@toruslabs/ethereum-controllers 4.1.0

package/src/Network/createEthereumMiddleware.ts

@@ -0,0 +1,307 @@
+import { InPageWalletProviderState, PROVIDER_JRPC_METHODS } from "@toruslabs/base-controllers";
+import {
+  createAsyncMiddleware,
+  createScaffoldMiddleware,
+  JRPCEngineEndCallback,
+  JRPCEngineNextCallback,
+  JRPCMiddleware,
+  JRPCRequest,
+  JRPCResponse,
+  mergeMiddleware,
+} from "@toruslabs/openlogin-jrpc";
+
+import { METHOD_TYPES, TRANSACTION_ENVELOPE_TYPES } from "../utils/constants";
+import {
+  BlockParams,
+  EthereumTransactionMeta,
+  MessageParams,
+  TransactionParams,
+  TransactionRPCMeta,
+  TypedMessageParams,
+  UserRequestApprovalParams,
+} from "../utils/interfaces";
+
+export interface IProviderHandlers {
+  version: string;
+  requestAccounts?: (req: JRPCRequest<string[]>) => Promise<string[]>;
+  getAccounts: (req: JRPCRequest<string[]>) => Promise<string[]>;
+
+  // All operations which open popup window or modal should operate with a windowId parameter
+  processTransaction?: (txParams: TransactionParams, req: JRPCRequest<TransactionParams> & UserRequestApprovalParams) => Promise<string>;
+
+  processEthSignMessage?: (msgParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams) => Promise<string>;
+  processTypedMessage?: (msgParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams) => Promise<string>;
+  processTypedMessageV3?: (msgParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams) => Promise<string>;
+  processTypedMessageV4?: (msgParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams) => Promise<string>;
+  processPersonalMessage?: (msgParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams) => Promise<string>;
+
+  processEncryptionPublicKey?: (address: string, req: JRPCRequest<string> & UserRequestApprovalParams) => Promise<string>;
+  processDecryptMessage?: (msgParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams) => Promise<string>;
+
+  getPendingNonce?: (
+    nonceParams: { address: string; blockReference: string },
+    req: JRPCRequest<{ address: string; blockReference: string }>
+  ) => Promise<string>;
+  getPendingTransactionByHash?: (hash: string, req: JRPCRequest<string>) => Promise<EthereumTransactionMeta>;
+
+  getProviderState: (
+    req: JRPCRequest<[]>,
+    res: JRPCResponse<InPageWalletProviderState>,
+    next: JRPCEngineNextCallback,
+    end: JRPCEngineEndCallback
+  ) => void;
+}
+
+export function createGetAccountsMiddleware({ getAccounts }: { getAccounts: IProviderHandlers["getAccounts"] }): JRPCMiddleware<never, string[]> {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const { method } = request;
+    if (method !== METHOD_TYPES.GET_ACCOUNTS) return next();
+
+    if (!getAccounts) throw new Error("WalletMiddleware - opts.getAccounts not provided");
+
+    const accounts = await getAccounts(request);
+    response.result = accounts;
+  });
+}
+
+export function createProcessTransactionMiddleware({
+  processTransaction,
+}: {
+  processTransaction: IProviderHandlers["processTransaction"];
+}): JRPCMiddleware<TransactionParams, string> {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const { method } = request;
+    if (method !== METHOD_TYPES.ETH_TRANSACTION) return next();
+
+    if (!processTransaction) throw new Error("WalletMiddleware - opts.processTransaction not provided");
+
+    response.result = await processTransaction(request.params, request);
+  });
+}
+
+export function createProcessEthSignMessage({
+  processEthSignMessage,
+}: {
+  processEthSignMessage: IProviderHandlers["processEthSignMessage"];
+}): JRPCMiddleware<MessageParams, string> {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const { method } = request;
+    if (method !== METHOD_TYPES.ETH_SIGN) return next();
+
+    if (!processEthSignMessage) throw new Error("WalletMiddleware - opts.processEthSignMessage not provided");
+
+    response.result = await processEthSignMessage(request.params, request);
+  });
+}
+
+export function createProcessTypedMessage({
+  processTypedMessage,
+}: {
+  processTypedMessage: IProviderHandlers["processTypedMessage"];
+}): JRPCMiddleware<MessageParams, string> {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const { method } = request;
+    if (method !== METHOD_TYPES.ETH_SIGN_TYPED_DATA) return next();
+
+    if (!processTypedMessage) throw new Error("WalletMiddleware - opts.processTypedMessage not  provided");
+    response.result = await processTypedMessage(request.params, request);
+  });
+}
+
+export function createProcessTypedMessageV3({
+  processTypedMessageV3,
+}: {
+  processTypedMessageV3: IProviderHandlers["processTypedMessageV3"];
+}): JRPCMiddleware<TypedMessageParams, string> {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const { method } = request;
+    if (method !== METHOD_TYPES.ETH_SIGN_TYPED_DATA_V3) return next();
+
+    if (!processTypedMessageV3) throw new Error("WalletMiddleware - opts.processTypedMessageV3 is not provided");
+
+    response.result = await processTypedMessageV3(request.params, request);
+  });
+}
+
+export function createProcessTypedMessageV4({
+  processTypedMessageV4,
+}: {
+  processTypedMessageV4: IProviderHandlers["processTypedMessageV4"];
+}): JRPCMiddleware<TypedMessageParams, string> {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const { method } = request;
+    if (method !== METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4) return next();
+
+    if (!processTypedMessageV4) throw new Error("WalletMiddleware - opts.processTypedMessageV4 is not provided");
+
+    response.result = await processTypedMessageV4(request.params, request);
+  });
+}
+
+export function createProcessPersonalMessage({
+  processPersonalMessage,
+}: {
+  processPersonalMessage: IProviderHandlers["processPersonalMessage"];
+}): JRPCMiddleware<MessageParams, string> {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const { method } = request;
+    if (method !== METHOD_TYPES.PERSONAL_SIGN) return next();
+
+    if (!processPersonalMessage) throw new Error("WalletMiddleware - opts.processPersonalMessage is not provided");
+
+    response.result = await processPersonalMessage(request.params, request);
+  });
+}
+
+export function createPendingNonceMiddleware({
+  getPendingNonce,
+}: {
+  getPendingNonce: IProviderHandlers["getPendingNonce"];
+}): JRPCMiddleware<{ address: string; blockReference: BlockParams }, string> {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const { params, method } = request;
+    if (method !== METHOD_TYPES.ETH_GET_TRANSACTION_COUNT) return next();
+
+    const { blockReference } = params;
+    if (blockReference !== "pending") return next();
+    response.result = await getPendingNonce(params, request);
+  });
+}
+
+export function formatTxMetaForRpcResult(txMeta: EthereumTransactionMeta): TransactionRPCMeta {
+  const { r, s, v, txReceipt, transaction, transactionHash, accessList } = txMeta;
+  const { to, data, nonce, gas, from, value, gasPrice, maxFeePerGas, maxPriorityFeePerGas } = transaction;
+
+  const formattedTxMeta: TransactionRPCMeta = {
+    v,
+    r,
+    s,
+    to,
+    gas,
+    from,
+    hash: transactionHash,
+    nonce,
+    input: data || "0x",
+    value: value || "0x0",
+    accessList: accessList || null,
+    blockHash: txReceipt?.blockHash || null,
+    blockNumber: txReceipt?.blockNumber || null,
+    transactionIndex: txReceipt?.transactionIndex || null,
+    type: null,
+  };
+
+  if (maxFeePerGas && maxPriorityFeePerGas) {
+    formattedTxMeta.maxFeePerGas = maxFeePerGas;
+    formattedTxMeta.maxPriorityFeePerGas = maxPriorityFeePerGas;
+    formattedTxMeta.type = TRANSACTION_ENVELOPE_TYPES.FEE_MARKET;
+  } else {
+    formattedTxMeta.gasPrice = gasPrice;
+    formattedTxMeta.type = TRANSACTION_ENVELOPE_TYPES.LEGACY;
+  }
+
+  return formattedTxMeta;
+}
+
+export function createPendingTxMiddleware({
+  getPendingTransactionByHash,
+}: {
+  getPendingTransactionByHash: IProviderHandlers["getPendingTransactionByHash"];
+}): JRPCMiddleware<string, TransactionRPCMeta> {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const { params, method } = request;
+    if (method !== 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;
+  });
+}
+
+export function createProcessEncryptionPublicKeyMiddleware({
+  processEncryptionPublicKey,
+}: {
+  processEncryptionPublicKey: IProviderHandlers["processEncryptionPublicKey"];
+}): JRPCMiddleware<string, string> {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const { params, method } = request;
+    if (method !== METHOD_TYPES.ETH_GET_ENCRYPTION_PUBLIC_KEY) return next();
+
+    if (!processEncryptionPublicKey) throw new Error("WalletMiddleware - opts.processEncryptionPublicKey not provided");
+
+    response.result = await processEncryptionPublicKey(params, request);
+  });
+}
+
+export function createProcessDecryptMessageMiddleware({
+  processDecryptMessage,
+}: {
+  processDecryptMessage: IProviderHandlers["processDecryptMessage"];
+}): JRPCMiddleware<MessageParams, string> {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const { params, method } = request;
+    if (method !== METHOD_TYPES.ETH_DECRYPT) return next();
+
+    if (!processDecryptMessage) throw new Error("WalletMiddleware - opts.processDecryptMessage not provided");
+
+    response.result = await processDecryptMessage(params, request);
+  });
+}
+
+export function createRequestAccountsMiddleware({
+  requestAccounts,
+}: {
+  requestAccounts: IProviderHandlers["requestAccounts"];
+}): JRPCMiddleware<string[], unknown> {
+  return 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;
+  });
+}
+
+export function createEthereumMiddleware(providerHandlers: IProviderHandlers): JRPCMiddleware<unknown, unknown> {
+  const {
+    requestAccounts,
+    getAccounts,
+    processTransaction,
+    processEthSignMessage,
+    processTypedMessage,
+    processTypedMessageV3,
+    processTypedMessageV4,
+    processPersonalMessage,
+    getPendingNonce,
+    getPendingTransactionByHash,
+    processEncryptionPublicKey,
+    processDecryptMessage,
+    getProviderState,
+    version,
+  } = providerHandlers;
+  return mergeMiddleware([
+    createScaffoldMiddleware({
+      version,
+      [PROVIDER_JRPC_METHODS.GET_PROVIDER_STATE]: getProviderState as JRPCMiddleware<unknown, unknown>,
+    }),
+    createRequestAccountsMiddleware({ requestAccounts }) as JRPCMiddleware<unknown, unknown>,
+    createGetAccountsMiddleware({ getAccounts }) as JRPCMiddleware<unknown, unknown>,
+    createProcessTransactionMiddleware({ processTransaction }) as JRPCMiddleware<unknown, unknown>,
+    createProcessEthSignMessage({ processEthSignMessage }) as JRPCMiddleware<unknown, unknown>,
+    createProcessTypedMessage({ processTypedMessage }) as JRPCMiddleware<unknown, unknown>,
+    createProcessTypedMessageV3({ processTypedMessageV3 }) as JRPCMiddleware<unknown, unknown>,
+    createProcessTypedMessageV4({ processTypedMessageV4 }) as JRPCMiddleware<unknown, unknown>,
+    createProcessPersonalMessage({ processPersonalMessage }) as JRPCMiddleware<unknown, unknown>,
+    createPendingNonceMiddleware({ getPendingNonce }) as JRPCMiddleware<unknown, unknown>,
+    createPendingTxMiddleware({ getPendingTransactionByHash }) as JRPCMiddleware<unknown, unknown>,
+    createProcessEncryptionPublicKeyMiddleware({ processEncryptionPublicKey }) as JRPCMiddleware<unknown, unknown>,
+    createProcessDecryptMessageMiddleware({ processDecryptMessage }) as JRPCMiddleware<unknown, unknown>,
+  ]);
+}

package/src/Network/createJsonRpcClient.ts

@@ -0,0 +1,59 @@
+import { createFetchMiddleware, ProviderConfig } from "@toruslabs/base-controllers";
+import {
+  JRPCEngineEndCallback,
+  JRPCEngineNextCallback,
+  JRPCMiddleware,
+  JRPCRequest,
+  JRPCResponse,
+  mergeMiddleware,
+  providerFromMiddleware,
+} from "@toruslabs/openlogin-jrpc";
+
+import PollingBlockTracker from "../Block/PollingBlockTracker";
+
+export function createChainIdMiddleware(chainId: string): JRPCMiddleware<unknown, string> {
+  return (req: JRPCRequest<unknown>, res: JRPCResponse<string>, next: JRPCEngineNextCallback, end: JRPCEngineEndCallback) => {
+    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();
+  };
+}
+
+export function createProviderConfigMiddleware(providerConfig: ProviderConfig): JRPCMiddleware<unknown, ProviderConfig> {
+  return (req: JRPCRequest<unknown>, res: JRPCResponse<ProviderConfig>, next: JRPCEngineNextCallback, end: JRPCEngineEndCallback) => {
+    if (req.method === "eth_provider_config") {
+      res.result = providerConfig;
+      return end();
+    }
+    return next();
+  };
+}
+
+export function createJsonRpcClient(providerConfig: ProviderConfig): {
+  networkMiddleware: JRPCMiddleware<unknown, unknown>;
+  blockTracker: PollingBlockTracker;
+} {
+  const { chainId, rpcTarget } = providerConfig;
+  const fetchMiddleware = createFetchMiddleware({ rpcTarget });
+  const blockProvider = providerFromMiddleware(fetchMiddleware as JRPCMiddleware<unknown, unknown>);
+  const blockTracker = new PollingBlockTracker({ config: { provider: blockProvider }, state: {} });
+
+  const networkMiddleware = mergeMiddleware([
+    createChainIdMiddleware(chainId) as JRPCMiddleware<unknown, unknown>,
+    createProviderConfigMiddleware(providerConfig) as JRPCMiddleware<unknown, unknown>,
+    // 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 }),
+    // createInflightCacheMiddleware(),
+    // createBlockTrackerInspectorMiddleware({ blockTracker }),
+    fetchMiddleware as JRPCMiddleware<unknown, unknown>,
+  ]);
+  return { networkMiddleware, blockTracker };
+}

package/src/Nfts/INftsController.ts

@@ -0,0 +1,13 @@
+import { BaseConfig, BaseState } from "@toruslabs/base-controllers";
+
+import { CustomNftInfo } from "../utils/interfaces";
+
+export interface NftsControllerConfig extends BaseConfig {
+  interval?: number;
+  selectedAddress: string;
+  chainId: string;
+}
+
+export interface NftsControllerState extends BaseState {
+  nfts: Record<string, CustomNftInfo[]>;
+}

package/src/Nfts/NftHandler.ts

@@ -0,0 +1,191 @@
+import { get } from "@toruslabs/http-helpers";
+import { BrowserProvider, Contract } from "ethers";
+import log from "loglevel";
+
+import { erc721Abi, erc1155Abi } from "../utils/abis";
+import { CONTRACT_TYPE_ERC721, CONTRACT_TYPE_ERC1155, ERC721_INTERFACE_ID, ERC1155_INTERFACE_ID, OLD_ERC721_LIST } from "../utils/constants";
+import { sanitizeNftMetdataUrl } from "../utils/helpers";
+import { CustomNftInfo, CustomNftItemInfo, NftStandardType } from "../utils/interfaces";
+
+interface INftOptions {
+  contractAddress: string;
+  contractName?: string;
+  contractSymbol?: string;
+  contractImage?: string;
+  contractSupply?: string;
+  contractFallbackLogo?: string;
+  nftStandard?: "erc721" | "erc1155";
+  contractDescription?: string;
+  chainId: string;
+  provider: BrowserProvider;
+}
+
+export class NftHandler {
+  public contractAddress: string;
+
+  public contractName: string;
+
+  public contractSymbol: string;
+
+  public contractImage: string;
+
+  public contractSupply?: string;
+
+  public contractFallbackLogo?: string;
+
+  public nftStandard: "erc721" | "erc1155";
+
+  public contractDescription?: string;
+
+  public chainId: string;
+
+  public provider: BrowserProvider;
+
+  public isSpecial?: boolean;
+
+  constructor({
+    chainId,
+    contractAddress,
+    contractImage,
+    contractName,
+    contractSymbol,
+    nftStandard,
+    provider,
+    contractDescription,
+    contractFallbackLogo,
+    contractSupply,
+  }: INftOptions) {
+    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: string, tokenInfo: Partial<CustomNftItemInfo>): Promise<CustomNftItemInfo> {
+    const returnNftItem: CustomNftItemInfo = { 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 || 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 = 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 get<{ name: string; description: string; image: string; decimals?: string }>(finalTokenMetaUri);
+        returnNftItem.image = returnNftItem.image || 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(): Promise<Omit<CustomNftInfo, "assets">> {
+    const returnNft: Omit<CustomNftInfo, "assets"> = {
+      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 === CONTRACT_TYPE_ERC721 ? erc721Abi : erc1155Abi;
+      const contract = new 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: string, tokenId: string): Promise<string> {
+    const { standard } = await this.checkNftStandard();
+    const abi = standard === CONTRACT_TYPE_ERC721 ? erc721Abi : erc1155Abi;
+    const contract = new Contract(this.contractAddress, abi, this.provider);
+    if (standard === 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";
+  }
+
+  private async checkNftStandard(): Promise<{ isSpecial: boolean; standard: NftStandardType }> {
+    // For Cryptokitties
+    if (this.nftStandard && this.isSpecial !== undefined) return;
+    if (Object.prototype.hasOwnProperty.call(OLD_ERC721_LIST, this.contractAddress.toLowerCase())) {
+      this.nftStandard = CONTRACT_TYPE_ERC721;
+      this.isSpecial = true;
+      return { standard: CONTRACT_TYPE_ERC721, isSpecial: true };
+    }
+    const isErc721 = await this.contractSupportsInterface(CONTRACT_TYPE_ERC721, ERC721_INTERFACE_ID);
+    if (isErc721) {
+      this.nftStandard = CONTRACT_TYPE_ERC721;
+      this.isSpecial = false;
+      return { standard: CONTRACT_TYPE_ERC721, isSpecial: false };
+    }
+    const isErc1155 = await this.contractSupportsInterface(CONTRACT_TYPE_ERC1155, ERC1155_INTERFACE_ID);
+    if (isErc1155) {
+      this.nftStandard = CONTRACT_TYPE_ERC1155;
+      this.isSpecial = false;
+      return { standard: CONTRACT_TYPE_ERC1155, isSpecial: false };
+    }
+
+    throw new Error("Unsupported nft standard");
+  }
+
+  private async contractSupportsInterface(standard: NftStandardType, interfaceId: string): Promise<boolean> {
+    const abi = standard === CONTRACT_TYPE_ERC721 ? erc721Abi : erc1155Abi;
+    const contract = new Contract(this.contractAddress, abi, this.provider);
+    return contract.supportsInterface(interfaceId);
+  }
+
+  private async getCollectibleTokenURI(tokenId: string, standard: NftStandardType = CONTRACT_TYPE_ERC721): Promise<string> {
+    const method = standard === CONTRACT_TYPE_ERC721 ? "tokenURI" : "uri";
+    const abi = standard === CONTRACT_TYPE_ERC721 ? erc721Abi : erc1155Abi;
+    const contract = new Contract(this.contractAddress, abi, this.provider);
+    return contract[method](tokenId);
+  }
+}