@toruslabs/ethereum-controllers 5.10.1 → 6.0.0

package/dist/lib.cjs/Network/createEthereumMiddleware.js

@@ -0,0 +1,302 @@
+'use strict';
+
+var baseControllers = require('@toruslabs/base-controllers');
+var auth = require('@web3auth/auth');
+var constants = require('../utils/constants.js');
+
+function createGetAccountsMiddleware({
+  getAccounts
+}) {
+  return auth.createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== constants.METHOD_TYPES.GET_ACCOUNTS) return next();
+    if (!getAccounts) throw new Error("WalletMiddleware - opts.getAccounts not provided");
+    const accounts = await getAccounts(request);
+    response.result = accounts;
+  });
+}
+function createProcessTransactionMiddleware({
+  processTransaction
+}) {
+  return auth.createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== constants.METHOD_TYPES.ETH_TRANSACTION) return next();
+    if (!processTransaction) throw new Error("WalletMiddleware - opts.processTransaction not provided");
+    response.result = await processTransaction(request.params, request);
+  });
+}
+function createProcessEthSignMessage({
+  processEthSignMessage
+}) {
+  return auth.createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== constants.METHOD_TYPES.ETH_SIGN) return next();
+    if (!processEthSignMessage) throw new Error("WalletMiddleware - opts.processEthSignMessage not provided");
+    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
+    let msgParams = request.params;
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [address, message]`);
+      const params = request.params;
+      const address = params[0];
+      const message = params[1];
+      msgParams = {
+        from: address,
+        data: message
+      };
+    }
+    response.result = await processEthSignMessage(msgParams, request);
+  });
+}
+function createProcessTypedMessageV4({
+  processTypedMessageV4
+}) {
+  return auth.createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== constants.METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4) return next();
+    if (!processTypedMessageV4) throw new Error("WalletMiddleware - opts.processTypedMessageV4 is not provided");
+    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
+    let msgParams = request.params;
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [address, typedData]`);
+      const params = request.params;
+      const address = params[0];
+      const message = params[1];
+      msgParams = {
+        from: address,
+        data: message
+      };
+    }
+    response.result = await processTypedMessageV4(msgParams, request);
+  });
+}
+function createProcessPersonalMessage({
+  processPersonalMessage
+}) {
+  return auth.createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== constants.METHOD_TYPES.PERSONAL_SIGN) return next();
+    if (!processPersonalMessage) throw new Error("WalletMiddleware - opts.processPersonalMessage is not provided");
+    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
+    let msgParams = request.params;
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length >= 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [message, address]`);
+      const params = request.params;
+      if (typeof params[0] === "object") {
+        const {
+          challenge,
+          address
+        } = params[0];
+        msgParams = {
+          from: address,
+          data: challenge
+        };
+      } else {
+        const message = params[0];
+        const address = params[1];
+        msgParams = {
+          from: address,
+          data: message
+        };
+      }
+    }
+    response.result = await processPersonalMessage(msgParams, request);
+  });
+}
+function createPendingNonceMiddleware({
+  getPendingNonce
+}) {
+  return auth.createAsyncMiddleware(async (request, response, next) => {
+    const {
+      params,
+      method
+    } = request;
+    if (method !== constants.METHOD_TYPES.ETH_GET_TRANSACTION_COUNT) return next();
+    const {
+      blockReference
+    } = params;
+    if (blockReference !== "pending") return next();
+    response.result = await getPendingNonce(params, request);
+  });
+}
+function formatTxMetaForRpcResult(txMeta) {
+  const {
+    r,
+    s,
+    v,
+    txReceipt,
+    transaction,
+    transactionHash,
+    accessList
+  } = txMeta;
+  const {
+    to,
+    data,
+    nonce,
+    gas,
+    from,
+    value,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas
+  } = transaction;
+  const formattedTxMeta = {
+    v,
+    r,
+    s,
+    to,
+    gas,
+    from,
+    hash: transactionHash,
+    nonce,
+    input: data || "0x",
+    value: value || "0x0",
+    accessList: accessList || null,
+    blockHash: (txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.blockHash) || null,
+    blockNumber: (txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.blockNumber) || null,
+    transactionIndex: (txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.transactionIndex) || null,
+    type: null
+  };
+  if (maxFeePerGas && maxPriorityFeePerGas) {
+    formattedTxMeta.maxFeePerGas = maxFeePerGas;
+    formattedTxMeta.maxPriorityFeePerGas = maxPriorityFeePerGas;
+    formattedTxMeta.type = constants.TRANSACTION_ENVELOPE_TYPES.FEE_MARKET;
+  } else {
+    formattedTxMeta.gasPrice = gasPrice;
+    formattedTxMeta.type = constants.TRANSACTION_ENVELOPE_TYPES.LEGACY;
+  }
+  return formattedTxMeta;
+}
+function createPendingTxMiddleware({
+  getPendingTransactionByHash
+}) {
+  return auth.createAsyncMiddleware(async (request, response, next) => {
+    const {
+      params,
+      method
+    } = request;
+    if (method !== constants.METHOD_TYPES.ETH_GET_TRANSACTION_BY_HASH) return next();
+    if (!getPendingTransactionByHash) throw new Error("WalletMiddleware - opts.getPendingTransactionByHash not provided");
+    const txMeta = await getPendingTransactionByHash(params, request);
+    if (!txMeta) {
+      return next();
+    }
+    response.result = formatTxMetaForRpcResult(txMeta);
+    return undefined;
+  });
+}
+function createProcessSwitchEthereumChain({
+  processSwitchEthereumChain
+}) {
+  return auth.createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== constants.METHOD_TYPES.SWITCH_CHAIN) return next();
+    if (!processSwitchEthereumChain) throw new Error("WalletMiddleware - opts.processSwitchEthereumChain not provided");
+    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
+    let msgParams = request.params;
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 1)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [data]`);
+      const [message] = request.params;
+      msgParams = message;
+    }
+    response.result = await processSwitchEthereumChain(msgParams, request);
+  });
+}
+function createProcessAddEthereumChain({
+  processAddEthereumChain
+}) {
+  return auth.createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== constants.METHOD_TYPES.ADD_CHAIN) return next();
+    if (!processAddEthereumChain) throw new Error("WalletMiddleware - opts.processAddEthereumChain not provided");
+    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
+    let msgParams = request.params;
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 1)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [data]`);
+      const [message] = request.params;
+      msgParams = message;
+    }
+    response.result = await processAddEthereumChain(msgParams, request);
+  });
+}
+function createRequestAccountsMiddleware({
+  requestAccounts
+}) {
+  return auth.createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== "eth_requestAccounts") return next();
+    if (!requestAccounts) throw new Error("WalletMiddleware - opts.requestAccounts not provided");
+    // This calls the UI login function
+    const accounts = await requestAccounts(request);
+    response.result = accounts;
+    return undefined;
+  });
+}
+function createEthereumMiddleware(providerHandlers) {
+  const {
+    requestAccounts,
+    getAccounts,
+    processTransaction,
+    processEthSignMessage,
+    processTypedMessageV4,
+    processPersonalMessage,
+    getPendingNonce,
+    getPendingTransactionByHash,
+    processSwitchEthereumChain,
+    processAddEthereumChain,
+    getProviderState,
+    version
+  } = providerHandlers;
+  return auth.mergeMiddleware([auth.createScaffoldMiddleware({
+    version,
+    [baseControllers.PROVIDER_JRPC_METHODS.GET_PROVIDER_STATE]: getProviderState
+  }), createRequestAccountsMiddleware({
+    requestAccounts
+  }), createGetAccountsMiddleware({
+    getAccounts
+  }), createProcessTransactionMiddleware({
+    processTransaction
+  }), createProcessEthSignMessage({
+    processEthSignMessage
+  }), createProcessTypedMessageV4({
+    processTypedMessageV4
+  }), createProcessPersonalMessage({
+    processPersonalMessage
+  }), createPendingNonceMiddleware({
+    getPendingNonce
+  }), createPendingTxMiddleware({
+    getPendingTransactionByHash
+  }), createProcessSwitchEthereumChain({
+    processSwitchEthereumChain
+  }), createProcessAddEthereumChain({
+    processAddEthereumChain
+  })]);
+}
+
+exports.createEthereumMiddleware = createEthereumMiddleware;
+exports.createGetAccountsMiddleware = createGetAccountsMiddleware;
+exports.createPendingNonceMiddleware = createPendingNonceMiddleware;
+exports.createPendingTxMiddleware = createPendingTxMiddleware;
+exports.createProcessAddEthereumChain = createProcessAddEthereumChain;
+exports.createProcessEthSignMessage = createProcessEthSignMessage;
+exports.createProcessPersonalMessage = createProcessPersonalMessage;
+exports.createProcessSwitchEthereumChain = createProcessSwitchEthereumChain;
+exports.createProcessTransactionMiddleware = createProcessTransactionMiddleware;
+exports.createProcessTypedMessageV4 = createProcessTypedMessageV4;
+exports.createRequestAccountsMiddleware = createRequestAccountsMiddleware;
+exports.formatTxMetaForRpcResult = formatTxMetaForRpcResult;

package/dist/lib.cjs/Network/createJsonRpcClient.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var baseControllers = require('@toruslabs/base-controllers');
+var auth = require('@web3auth/auth');
+var PollingBlockTracker = require('../Block/PollingBlockTracker.js');
+var cacheIdentifier = require('./cacheIdentifier.js');
+
+function createChainIdMiddleware(chainId) {
+  return (req, res, next, end) => {
+    if (req.method === "eth_chainId") {
+      res.result = chainId;
+      return end();
+    }
+    if (req.method === "net_version") {
+      // convert to decimal
+      res.result = Number.parseInt(chainId, 16).toString(10);
+      return end();
+    }
+    return next();
+  };
+}
+function createProviderConfigMiddleware(providerConfig) {
+  return (req, res, next, end) => {
+    if (req.method === "eth_provider_config") {
+      res.result = providerConfig;
+      return end();
+    }
+    return next();
+  };
+}
+function createJsonRpcClient(providerConfig, networkConfig) {
+  const {
+    chainId,
+    rpcTarget
+  } = providerConfig;
+  const fetchMiddleware = baseControllers.createFetchMiddleware({
+    rpcTarget
+  });
+  const blockProvider = auth.providerFromMiddleware(fetchMiddleware);
+  const blockTracker = new PollingBlockTracker.PollingBlockTracker({
+    config: _objectSpread(_objectSpread({}, networkConfig), {}, {
+      provider: blockProvider
+    }),
+    state: {}
+  });
+  const networkMiddleware = auth.mergeMiddleware([createChainIdMiddleware(chainId), createProviderConfigMiddleware(providerConfig),
+  // No need for the following middlewares for web because all browser sessions are quite short lived and each session is limited to scope of a window/tab
+  // createBlockRefRewriteMiddleware({ blockTracker }),
+  // createBlockCacheMiddleware({ blockTracker }),
+  baseControllers.createInflightCacheMiddleware({
+    cacheIdentifierForRequest: cacheIdentifier.cacheIdentifierForRequest
+  }),
+  // createBlockTrackerInspectorMiddleware({ blockTracker }),
+  fetchMiddleware]);
+  return {
+    networkMiddleware,
+    blockTracker
+  };
+}
+
+exports.createChainIdMiddleware = createChainIdMiddleware;
+exports.createJsonRpcClient = createJsonRpcClient;
+exports.createProviderConfigMiddleware = createProviderConfigMiddleware;

package/dist/lib.cjs/Nfts/NftHandler.js

@@ -0,0 +1,180 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var httpHelpers = require('@toruslabs/http-helpers');
+var ethers = require('ethers');
+var log = require('loglevel');
+var abis = require('../utils/abis.js');
+var constants = require('../utils/constants.js');
+var helpers = require('../utils/helpers.js');
+
+class NftHandler {
+  constructor({
+    chainId,
+    contractAddress,
+    contractImage,
+    contractName,
+    contractSymbol,
+    nftStandard,
+    provider,
+    contractDescription,
+    contractFallbackLogo,
+    contractSupply
+  }) {
+    _defineProperty(this, "contractAddress", void 0);
+    _defineProperty(this, "contractName", void 0);
+    _defineProperty(this, "contractSymbol", void 0);
+    _defineProperty(this, "contractImage", void 0);
+    _defineProperty(this, "contractSupply", void 0);
+    _defineProperty(this, "contractFallbackLogo", void 0);
+    _defineProperty(this, "nftStandard", void 0);
+    _defineProperty(this, "contractDescription", void 0);
+    _defineProperty(this, "chainId", void 0);
+    _defineProperty(this, "provider", void 0);
+    _defineProperty(this, "isSpecial", void 0);
+    this.chainId = chainId;
+    this.contractAddress = contractAddress;
+    this.contractImage = contractImage;
+    this.contractName = contractName;
+    this.contractSymbol = contractSymbol;
+    this.nftStandard = nftStandard;
+    this.provider = provider;
+    this.contractDescription = contractDescription;
+    this.contractFallbackLogo = contractFallbackLogo;
+    this.contractSupply = contractSupply;
+  }
+  async getNftMetadata(userAddress, tokenInfo) {
+    const returnNftItem = _objectSpread({
+      description: "",
+      image: "",
+      name: "",
+      tokenBalance: "",
+      tokenId: "",
+      decimals: "1"
+    }, tokenInfo);
+    const [tokenURI, balance] = await Promise.all([this.getCollectibleTokenURI(returnNftItem.tokenId, this.nftStandard), !returnNftItem.tokenBalance ? this.fetchNftBalance(userAddress, returnNftItem.tokenId) : Promise.resolve("0")]);
+    returnNftItem.tokenBalance = returnNftItem.tokenBalance || balance;
+    // some people put full json object in uri
+    try {
+      const object = JSON.parse(tokenURI);
+      returnNftItem.image = returnNftItem.image || helpers.sanitizeNftMetdataUrl(object.image);
+      returnNftItem.name = returnNftItem.name || object.name;
+      returnNftItem.description = returnNftItem.description || object.description;
+      returnNftItem.decimals = returnNftItem.decimals || object.decimals;
+    } catch (error) {
+      log.warn("Token uri is not a valid json object", error);
+    }
+    const finalTokenMetaUri = helpers.sanitizeNftMetdataUrl(tokenURI);
+    try {
+      if (!returnNftItem.description || !returnNftItem.image || !returnNftItem.name) {
+        // this call might fail, if metadata url available in smart contract is not reachable
+        const object = await httpHelpers.get(finalTokenMetaUri);
+        returnNftItem.image = returnNftItem.image || helpers.sanitizeNftMetdataUrl(object.image);
+        returnNftItem.name = returnNftItem.name || object.name;
+        returnNftItem.description = returnNftItem.description || object.description;
+        returnNftItem.decimals = returnNftItem.decimals || object.decimals;
+      }
+    } catch (error) {
+      log.error("Failed to fetch nft metadata", error);
+    }
+    return returnNftItem;
+  }
+  async getContractMetadata() {
+    const returnNft = {
+      chainId: this.chainId,
+      contractAddress: this.contractAddress,
+      contractName: this.contractName,
+      contractSymbol: this.contractSymbol,
+      nftStandard: this.nftStandard,
+      contractImage: this.contractImage,
+      contractDescription: this.contractDescription,
+      contractFallbackLogo: this.contractFallbackLogo,
+      contractSupply: this.contractSupply
+    };
+    if (!this.nftStandard) {
+      const {
+        standard,
+        isSpecial
+      } = await this.checkNftStandard();
+      returnNft.nftStandard = standard;
+      this.nftStandard = standard;
+      this.isSpecial = isSpecial;
+    }
+    if (!this.contractName || !this.contractSymbol || !this.contractDescription) {
+      const abi = this.nftStandard === constants.CONTRACT_TYPE_ERC721 ? abis.erc721Abi : abis.erc1155Abi;
+      const contract = new ethers.Contract(this.contractAddress, abi, this.provider);
+      const [name, symbol] = await Promise.all([contract.name(), contract.symbol()]);
+      returnNft.contractName = name;
+      returnNft.contractSymbol = symbol;
+      if (!this.contractName) this.contractName = name;
+      if (!this.contractSymbol) this.contractSymbol = symbol;
+    }
+    return returnNft;
+  }
+  async fetchNftBalance(userAddress, tokenId) {
+    const {
+      standard
+    } = await this.checkNftStandard();
+    const abi = standard === constants.CONTRACT_TYPE_ERC721 ? abis.erc721Abi : abis.erc1155Abi;
+    const contract = new ethers.Contract(this.contractAddress, abi, this.provider);
+    if (standard === constants.CONTRACT_TYPE_ERC1155) {
+      const balance = await contract.balanceOf(userAddress, tokenId);
+      return balance;
+    }
+    let owner = "";
+    try {
+      owner = await contract.ownerOf(tokenId);
+    } catch {
+      throw new Error("Token id doesn't exists");
+    }
+    if (owner.toLowerCase() === userAddress.toLowerCase()) {
+      return "1";
+    }
+    return "0";
+  }
+  async checkNftStandard() {
+    // For Cryptokitties
+    if (this.nftStandard && this.isSpecial !== undefined) return;
+    if (Object.prototype.hasOwnProperty.call(constants.OLD_ERC721_LIST, this.contractAddress.toLowerCase())) {
+      this.nftStandard = constants.CONTRACT_TYPE_ERC721;
+      this.isSpecial = true;
+      return {
+        standard: constants.CONTRACT_TYPE_ERC721,
+        isSpecial: true
+      };
+    }
+    const isErc721 = await this.contractSupportsInterface(constants.CONTRACT_TYPE_ERC721, constants.ERC721_INTERFACE_ID);
+    if (isErc721) {
+      this.nftStandard = constants.CONTRACT_TYPE_ERC721;
+      this.isSpecial = false;
+      return {
+        standard: constants.CONTRACT_TYPE_ERC721,
+        isSpecial: false
+      };
+    }
+    const isErc1155 = await this.contractSupportsInterface(constants.CONTRACT_TYPE_ERC1155, constants.ERC1155_INTERFACE_ID);
+    if (isErc1155) {
+      this.nftStandard = constants.CONTRACT_TYPE_ERC1155;
+      this.isSpecial = false;
+      return {
+        standard: constants.CONTRACT_TYPE_ERC1155,
+        isSpecial: false
+      };
+    }
+    throw new Error("Unsupported nft standard");
+  }
+  async contractSupportsInterface(standard, interfaceId) {
+    const abi = standard === constants.CONTRACT_TYPE_ERC721 ? abis.erc721Abi : abis.erc1155Abi;
+    const contract = new ethers.Contract(this.contractAddress, abi, this.provider);
+    return contract.supportsInterface(interfaceId);
+  }
+  async getCollectibleTokenURI(tokenId, standard = constants.CONTRACT_TYPE_ERC721) {
+    const method = standard === constants.CONTRACT_TYPE_ERC721 ? "tokenURI" : "uri";
+    const abi = standard === constants.CONTRACT_TYPE_ERC721 ? abis.erc721Abi : abis.erc1155Abi;
+    const contract = new ethers.Contract(this.contractAddress, abi, this.provider);
+    return contract[method](tokenId);
+  }
+}
+
+exports.NftHandler = NftHandler;