dracoder-web3-package 1.0.0 → 2.0.0

package/index.js

@@ -1,322 +1,240 @@
-'use strict'
+"use strict";
 
-const Web3 = require('web3');
-const axios = require("axios");
-const { abiToken } = require('./helpers/factory_data');
+const {Web3} = require("web3");
+const {abiToken} = require("./helpers/factory_data");
 
-let walletConnectionUrl = 'wallet_connection';
-let tokenCreationUrl = 'token_creation';
-let tokenTransferUrl = 'token_transfer';
-let clientTokenTransferUrl = 'client_token_transfer';
-let getTokenTransactionUrl = 'get_token_transactions';
-let clientTokenOwnersBalanceUrl = 'token_owners_balance';
-let balanceUrl = 'balance';
-let deleteUrl = 'delete';
-let clientServerUrl = "";
-
-const setClientServerUrl = (url) => {
-    clientServerUrl = url;
-}
-
-const setEndpointsUrls = ({
-                              walletConnectionCustomUrl = walletConnectionUrl,
-                              tokenCreationCustomUrl = tokenCreationUrl,
-                              tokenTransferCustomUrl = tokenTransferUrl,
-                              clientTokenTransferCustomUrl = clientTokenTransferUrl,
-                              getTokenTransactionCustomUrl = getTokenTransactionUrl,
-                              clientTokenOwnersBalanceCustomUrl = clientTokenOwnersBalanceUrl,
-                              balanceCustomUrl = balanceUrl,
-                              deleteCustomUrl = deleteUrl,
-                          }) => {
-    walletConnectionUrl = walletConnectionCustomUrl;
-    tokenCreationUrl = tokenCreationCustomUrl;
-    tokenTransferUrl = tokenTransferCustomUrl;
-    clientTokenTransferUrl = clientTokenTransferCustomUrl;
-    getTokenTransactionUrl = getTokenTransactionCustomUrl;
-    clientTokenOwnersBalanceUrl = clientTokenOwnersBalanceCustomUrl;
-    balanceUrl = balanceCustomUrl;
-    deleteUrl = deleteCustomUrl;
-}
-
-const metamaskConnect = async () => {
-    // let walletConnectionResponse;
-
-    if (typeof window.ethereum !== 'undefined') {
-        const [account] = await ethereum.request({method: 'eth_requestAccounts'}).catch(async (error) => {
-
-            throw {
-                ok: false,
-                message: 'Something went wrong connecting to Metamask.',
-                metamaskMessage: error
-            };
-        });
-
-        if (!account) {
-            const message = "There is no account to connect to";
-
-            throw {
-                ok: false,
-                message: message
-            };
-        }
-
-        return {
-            ok: true,
-            message: "Connected successfully.",
-            account: account
-        };
-    }
-
-    const message = "There was a problem connecting to your Metamask wallet. Do you have Metamask installed?";
-
-    // walletConnection({walletAddress: null, response: message, ...extraParameters});
-
-    throw {
-        ok: false,
-        message: message
-    };
-}
-
-const tokenCreate = async ({
-                               nameOfToken,
-                               numberOfToken,
-                               symbolOfToken,
-                               numberOfDecimals,
-                               userWalletAddress,
-                               ...extraParameters
-                           }) => {
-    if (!userWalletAddress) {
-        return {
-            ok: false,
-            message: "Wallet address is required and needs to be valid."
-        }
-    }
-
-    return await axios.post(`${clientServerUrl}/${tokenCreationUrl}`, {
-        nameOfToken,
-        numberOfToken,
-        symbolOfToken,
-        numberOfDecimals,
-        userWalletAddress,
-        ...extraParameters
-    });
+const METAMASK_NOT_INSTALLED_MESSAGE = {
+  ok: false,
+  message: "You don't have Metamask installed.",
 }
 
-const tokenTransfer = async ({
-                                 walletAddressToTransferFrom,
-                                 walletAddressToTransferTo,
-                                 tokenAddress,
-                                 amount,
-                                 ...extraParameters
-                             }) => {
-    const {data} = await axios.post(`${clientServerUrl}/${tokenTransferUrl}`, {
-        walletAddressToTransferFrom: walletAddressToTransferFrom,
-        walletAddressToTransferTo: walletAddressToTransferTo,
-        tokenAddress: tokenAddress,
-        amount: amount,
-        ...extraParameters
-    });
-
-    return data;
-}
-
-const clientTokenTransfer = async ({walletAddressToTransferTo, tokenAddress, amount, ...extraParameters}) => {
-    const response = await metamaskConnect().catch(error => {
-        throw error;
-    });
-    const account = response.account;
-    let web3;
-
-    try {
-        web3 = new Web3(window.ethereum);
-    } catch (error) {
-        await tokenTransfer({
-            walletAddressToTransferFrom: null,
-            walletAddressToTransferTo: null,
-            tokenAddress: null,
-            amount: null,
-            response: error,
-            ...extraParameters
-        })
-    }
-    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.');
-    }
-
-    const MyTokenContractInstance = new web3.eth.Contract(abiToken, tokenAddress);
-    const decimals = await MyTokenContractInstance.methods.decimals().call();
-    const amountToTransfer = (amount * Number(`1e${decimals}`)).toString();
-
-    const pendingTokenTransfer = MyTokenContractInstance
-        .methods
-        .transfer(walletAddressToTransferTo, amountToTransfer)
+const Metamask = window.ethereum
 
-    return {account, pendingTokenTransfer};
+const checkIfMetamaskIsAvailable = () => {
+  return typeof Metamask !== "undefined"
 }
 
-const tokenTransferWithTokenAddressOnly = async ({tokenAddress, ...extraParameters}) => {
-    if (!tokenAddress) {
-        throw new Error('Is not a Token Address');
-    }
-
-    return await axios.post(`${clientServerUrl}/${clientTokenTransferUrl}`, {
-        tokenAddress: tokenAddress,
-        ...extraParameters
+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 getTokenOwnersBalance = async ({tokenAddress, ...extraParams}) => {
-    if (!tokenAddress) {
-        throw new Error('Is not a Token Address');
-    }
-
-    return await axios.post(`${clientServerUrl}/${clientTokenOwnersBalanceUrl}`, {
-        tokenAddress: tokenAddress,
-        ...extraParams
+  if (!account) {
+    throw {
+      ok: false,
+      message: "There is no account to connect to",
+    };
+  }
+  return {
+    ok: true,
+    message: "Connected successfully.",
+    account: account,
+  };
+};
+
+const clientTokenTransfer = async ({
+                                     walletAddressToTransferTo,
+                                     tokenAddress,
+                                     amount,
+                                   }) => {
+  if (!checkIfMetamaskIsAvailable()) {
+    return METAMASK_NOT_INSTALLED_MESSAGE
+  }
+  const response = await getMetamaskAccount().catch((error) => {
+    throw error;
+  });
+  const account = response.account;
+  let web3;
+
+  try {
+    web3 = new Web3(Metamask);
+  } catch (error) {
+    throw error;
+  }
+
+  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.");
+  }
+
+  const MyTokenContractInstance = new web3.eth.Contract(abiToken, tokenAddress);
+  const decimals = await MyTokenContractInstance.methods.decimals().call();
+  const amountToTransfer = (amount * Number(`1e${decimals}`)).toString();
+
+  const pendingTokenTransfer = MyTokenContractInstance.methods.transfer(
+    walletAddressToTransferTo,
+    amountToTransfer
+  );
+
+  try {
+    const transactionReceipt = await pendingTokenTransfer.send({
+      from: account,
     });
-}
 
-const sendTokenToWallet = async ({tokenAddress, ...extraParameters}) => {
-    await metamaskConnect().catch(error => {
-        throw error
+    return {
+      ok: true,
+      message: "Transfer successful",
+      transactionHash: transactionReceipt.transactionHash,
+    };
+  } catch (error) {
+    throw {
+      ok: false,
+      message: "Transfer failed",
+      error: error,
+    };
+  }
+};
+
+const sendTokenToWallet = async ({tokenAddress}) => {
+  if (!checkIfMetamaskIsAvailable()) {
+    return METAMASK_NOT_INSTALLED_MESSAGE
+  }
+
+  await getMetamaskAccount().catch((error) => {
+    throw error;
+  });
+
+  let web3 = new Web3(Metamask);
+  let tokenAdded = false;
+
+  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 response = await Metamask.request({
+      method: 'wallet_watchAsset',
+      params: {
+        type: 'ERC20',
+        options: {
+          address: tokenAddress,
+          symbol: symbol,
+          decimals: decimals,
+        },
+      },
     });
+    tokenAdded = !!response;
+  } catch (error) {
+    return error
+  }
+  return tokenAdded;
 
-    let web3 = new Web3(window.ethereum);
-    let tokenAdded = false;
-
-    if (typeof window.ethereum !== 'undefined') {
-        const MyTokenContractInstance = new web3.eth.Contract(abiToken, tokenAddress);
-
-        const symbol = await MyTokenContractInstance.methods.symbol().call();
-        const decimals = await MyTokenContractInstance.methods.decimals().call();
-        const response = await ethereum
-        .request({
-            method: 'wallet_watchAsset',
-            params: {
-                type: 'ERC20',
-                options: {
-                    address: tokenAddress,
-                    symbol: symbol,
-                    decimals: decimals,
-                },
-            },
-        });
-
-        tokenAdded = !!response;
-    }
-
-    return tokenAdded;
-}
+};
 
 const isMetamaskInstalled = () => {
-    if (typeof window.ethereum == 'undefined') {
-        return {
-            ok: false,
-            message: "You don't have Metamask installed."
-        }
-    }
+  if (!checkIfMetamaskIsAvailable()) {
+    return METAMASK_NOT_INSTALLED_MESSAGE
+  }
+  return {
+    ok: true,
+    message: "Metamask is installed",
+  };
 
-    return {
-        ok: true,
-        message: "Metamask is installed"
-    }
-}
+};
 
 const checkWalletFormat = (account) => {
-    let web3;
-
-    try {
-        web3 = new Web3(window.ethereum);
-    } catch (error) {
-        return {
-            ok: false,
-            message: "Web3 can not be loaded. Metamask must be installed",
-            error: error
-        }
-    }
-
-    if (!web3.utils.isAddress(account)) {
-        return {
-            ok: false,
-            message: "Wrong address format"
-        }
-    }
-
+  let web3;
+  if (!checkIfMetamaskIsAvailable()) {
+    return METAMASK_NOT_INSTALLED_MESSAGE
+  }
+  try {
+    web3 = new Web3(Metamask);
+  } catch (error) {
     return {
-        ok: true,
-        message: "Proper address format"
-    }
-}
+      ok: false,
+      message: "Web3 can not be loaded. Metamask must be installed",
+      error: error,
+    };
+  }
 
-const selectOrAddPolygonMainNetwork = async ({...extraParameters}) => {
-    await metamaskConnect().catch(error => {
-        throw error
+  if (!web3.utils.isAddress(account)) {
+    return {
+      ok: false,
+      message: "Wrong address format",
+    };
+  }
+
+  return {
+    ok: true,
+    message: "Proper address format",
+  };
+};
+
+const selectOrAddPolygonMainNetwork = async () => {
+  if (!checkIfMetamaskIsAvailable()) {
+    return METAMASK_NOT_INSTALLED_MESSAGE
+  }
+  await getMetamaskAccount().catch((error) => {
+    throw error;
+  });
+  try {
+    await Metamask.request({
+      method: "wallet_switchEthereumChain",
+      params: [{chainId: "0x89"}],
     });
-    if (typeof window.ethereum !== 'undefined') {
-        try {
-            await ethereum
-                .request({
-                    method: 'wallet_switchEthereumChain',
-                    params: [{chainId: '0x89'}],
-                });
-        } catch (switchError) {
-            if (switchError.code === 4902) {
-                // This error code indicates that the chain has not been added to MetaMask.
-                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 ethereum
-                        .request({
-                            method: 'wallet_addEthereumChain',
-                            params: params
-                        });
-                    return {
-                        ok: true,
-                        message: "Matic Mainnet added successfully",
-                        response: response
-                    }
-                } catch (error) {
-                    return {
-                        ok: false,
-                        message: "Matic Mainnet can not be added",
-                        response: error
-                    }
-                }
-            }
-        }
+    return {
+      ok: true,
+      message: "Already on polygon main network",
+    };
+  } catch (switchError) {
+    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,
+        });
+        return {
+          ok: true,
+          message: "Matic MainNet added successfully",
+          response: response,
+        };
+      } catch (error) {
+        return {
+          ok: false,
+          message: "Matic MainNet can not be added",
+          response: error,
+        };
+      }
     }
-
-}
+  }
+};
 
 module.exports = {
-    setClientServerUrl,
-    setEndpointsUrls,
-    metamaskConnect,
-    tokenCreate,
-    tokenTransfer,
-    clientTokenTransfer,
-    tokenTransferWithTokenAddressOnly,
-    getTokenOwnersBalance,
-    sendTokenToWallet,
-    isMetamaskInstalled,
-    checkWalletFormat,
-    selectOrAddPolygonMainNetwork
-}
+  clientTokenTransfer,
+  sendTokenToWallet,
+  isMetamaskInstalled,
+  checkWalletFormat,
+  selectOrAddPolygonMainNetwork,
+};

package/package.json

@@ -1,21 +1,29 @@
 {
   "name": "dracoder-web3-package",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Dracoder package used for web3 provider integration.",
   "main": "index.js",
   "keywords": [
-    "rocketchain",
+    "dracoder",
     "web3",
     "api",
     "metamask"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "webpack",
+    "start": "webpack && node test/app.js"
   },
   "author": "Dracoder S.L.",
   "license": "MIT",
   "dependencies": {
-    "axios": "^1.6.7",
     "web3": "^4.4.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.15.0",
+    "@babel/preset-env": "^7.15.0",
+    "babel-loader": "^8.2.2",
+    "express": "^4.18.2",
+    "webpack": "^5.51.1",
+    "webpack-cli": "^4.8.0"
   }
 }

package/test/app.js

@@ -0,0 +1,16 @@
+const express = require('express');
+const  {join} = require("path");
+
+const port = 3000;
+const app = express();
+
+app.use('/static', express.static(join(__dirname+'/../lib/')));
+
+app.use(express.urlencoded({ extended: false }));
+app.use(express.json());
+
+app.get('/', (req, res) => {
+  res.sendFile(join(__dirname+'/test.html'))
+});
+
+app.listen(port, () => console.log(`Servidor iniciado en el puerto ${port}`));

package/test/test.html

@@ -0,0 +1,106 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <title>Test</title>
+</head>
+
+<body>
+
+<h1>Test web3 integration functionalities</h1>
+<div id="check-metamask-installed-functionality">
+    <h3>Check if metamask is installed</h3>
+    <button onclick="checkIfMetamaskIsInstalled()">Check</button>
+    <pre>Click "Check" button</pre>
+</div>
+
+<div id="check-add-polygon-network">
+    <h3>Check if can add polygon network</h3>
+    <button onclick="checkIfCanAddPolygon()">Check</button>
+    <pre>Click "Check" button</pre>
+</div>
+
+<div id="check-wallet-format">
+    <h3>Check wallet format</h3>
+    <input id="inputCheckWalletFormat" style="width: 25rem" type="text"
+           value="0x104d7e4b44F64c633Be6B099995eecb0Ac344611"/>
+    <button onclick="checkWalletFormat()">Check</button>
+    <pre>Click "Check" button</pre>
+</div>
+
+<div id="check-add-token-to-metamask">
+    <h3>Check add token to metamask</h3>
+    <input id="inputCheckAddTokenToMetamask" style="width: 25rem" type="text"
+           value="0xF516d5b66a954ae85aC08b33729dFe9BCF380207"/>
+    <button onclick="checkAddTokenToMetamask()">Check</button>
+    <pre>Click "Check" button</pre>
+</div>
+
+<div id="transfer-token">
+    <h3>Transfer Token</h3>
+    <input id="inputTokenAddress" style="width: 25rem" type="text" disabled
+           value="0xFdD0631B7B4a24efE135fDC816C3951cE2dB8854"/>
+    <input id="inputRecipientAddress" style="width: 25rem" type="text"  value="0x104d7e4b44F64c633Be6B099995eecb0Ac344611" placeholder="Recipient Address"/>
+    <input id="inputAmount" style="width: 25rem" type="number" value="1" disabled/>
+    <button onclick="transferToken()">Send</button>
+    <pre id="transferTokenResult">Click "Send" button</pre>
+</div>
+
+<script src="/static/dracoderWeb3Integration.js"></script>
+<script>
+  function checkIfMetamaskIsInstalled() {
+    const spanToPrintMessage = document.querySelector('#check-metamask-installed-functionality>pre')
+    spanToPrintMessage.innerHTML = JSON.stringify(dracoderWeb3Integration.isMetamaskInstalled())
+  }
+
+  async function checkIfCanAddPolygon() {
+    const spanToPrintMessage = document.querySelector('#check-add-polygon-network>pre')
+    try {
+      const response = await dracoderWeb3Integration.selectOrAddPolygonMainNetwork({})
+      spanToPrintMessage.innerHTML = JSON.stringify(response)
+    } catch (e) {
+      spanToPrintMessage.innerHTML = JSON.stringify(e)
+    }
+  }
+
+  function checkWalletFormat() {
+    const input = document.querySelector('#check-wallet-format>input')
+    const spanToPrintMessage = document.querySelector('#check-wallet-format>pre')
+    spanToPrintMessage.innerHTML = JSON.stringify(dracoderWeb3Integration.checkWalletFormat(input.value))
+  }
+
+  async function checkAddTokenToMetamask() {
+    const inputTokenAddress = document.querySelector('#inputCheckAddTokenToMetamask').value
+
+    const spanToPrintMessage = document.querySelector('#check-add-token-to-metamask>pre')
+    try {
+      const result = await dracoderWeb3Integration.sendTokenToWallet({tokenAddress: inputTokenAddress})
+      spanToPrintMessage.innerHTML = JSON.stringify(result)
+    } catch (error) {
+      spanToPrintMessage.innerHTML = JSON.stringify(error)
+    }
+  }
+
+  function transferToken() {
+    const inputRecipientAddress = document.getElementById("inputRecipientAddress").value;
+    const inputAmount = document.getElementById("inputAmount").value;
+    const transferTokenResult = document.getElementById("transferTokenResult");
+
+    dracoderWeb3Integration
+      .clientTokenTransfer({
+        walletAddressToTransferTo: inputRecipientAddress,
+        tokenAddress: "0xFdD0631B7B4a24efE135fDC816C3951cE2dB8854",
+        amount: inputAmount,
+      })
+      .then((response) => {
+        transferTokenResult.innerHTML = JSON.stringify(response);
+      })
+      .catch((error) => {
+        transferTokenResult.innerHTML = JSON.stringify(error);
+      });
+  }
+</script>
+</body>
+
+</html>

package/webpack.config.js

@@ -0,0 +1,29 @@
+const path = require("path");
+
+module.exports = {
+  entry: "./index.js",
+  output: {
+    path: path.resolve(__dirname, "lib"),
+    filename: "dracoderWeb3Integration.js",
+    library: {
+      name: "dracoderWeb3Integration",
+      type: "umd",
+    },
+    globalObject: "this",
+  },
+  mode: "development",
+  module: {
+    rules: [
+      {
+        test: /\.m?js$/,
+        exclude: /node_modules/,
+        use: {
+          loader: "babel-loader",
+          options: {
+            presets: ["@babel/preset-env"],
+          },
+        },
+      },
+    ],
+  },
+};