webchain/src/chain/ChainManager.ts

import { Chain } from "../chain/Chain";
import { AVAILABLE_CHAINS, IChainData } from "../configs/config_chain";
import { AllChains } from "../configs/allchain";
import {
  ACTIVATE_PROXY_ABI,
  MYSTERY_BOX_ABI,
  MYSTERY_PROXY_ABI,
} from "../configs/contracts";
import { singleton } from "../decorator/singleton.decorator";
import { Blockchain } from "./blockchain";
import { UserModule } from "../module/UserModule";
import { getNonce } from "../api/User";
import { EventBus, SHOW_ERR_MSG } from "../utils/event-bus";

@singleton
export default class ChainManager {
  bc: Blockchain;
  instanceMap: Map<string, any>;
  public chainMap: Map<number, IChainData> = new Map();
  private _availableChains: Map<number, IChainData> = new Map();

  constructor() {
    this.bc = new Blockchain();
    this.instanceMap = new Map();
    for (const data of AllChains) {
      this.chainMap.set(data.id, data);
    }
  }

  get availableChains() {
    if (this._availableChains.size === 0) {
      for (const id of AVAILABLE_CHAINS) {
        const d = this.chainMap.get(id);
        if (d) {
          this._availableChains.set(id, d);
        }
      }
    }
    return this._availableChains;
  }

  public async init() {
    if (this.bc.isWalletConnect) {
      try {
        await this.bc.connect();
        await this.getNance();
      } catch (err) {
        console.log("connect chain error: ", err);
      }
    }
  }

  get isLogined() {
    return !!UserModule.token && !!UserModule.step;
  }

  public async logout() {
    await this.bc.disconnect();
  }

  public get currentChain() {
    return this.bc.currentChain;
  }

  public get currentAccount() {
    return UserModule.accountId;
  }

  public async login() {
    if (!UserModule.step) {
      try {
        await this.bc.connect(true);
        await this.checkNance();
      } catch (err) {
        EventBus.$emit(SHOW_ERR_MSG, err.message);
        await Promise.reject(err);
      }
    }
  }

  public async checkNance() {
    try {
      let nonce = UserModule.nonce;
      if (!nonce) {
        const preRequest: any = await getNonce({
          account: UserModule.accountId,
          net_id: UserModule.chainId,
        });
        nonce = preRequest.nonce + "";
        UserModule.updateNonce(nonce);
      }

      await UserModule.Login({
        bcInstance: this.bc,
        account: UserModule.accountId,
        chainId: UserModule.chainId,
        nonce,
      });
      UserModule.updateStep(1);
    } catch (err) {
      console.log(err);
      await Promise.reject(err);
    }
  }

  public async getNance() {
    console.log("need get nance");
    try {
      const preRequest: any = await getNonce({
        account: UserModule.accountId,
        net_id: UserModule.chainId,
      });
      console.log("success get nonce: ", preRequest);
      // if need check sign and has nonce val, store it
      if (preRequest.state) {
        UserModule.updateStep(1);
      } else if (!preRequest.state && preRequest.nonce) {
        if (UserModule.token) {
          await UserModule.LogOut();
        }
        UserModule.updateStep(0);
      }
      if (preRequest.nonce) {
        UserModule.updateNonce(preRequest.nonce + "");
      }
    } catch (err) {
      EventBus.$emit(SHOW_ERR_MSG, "Error get login nonce");
    }
  }

  public async getInstance(address: string, chainId: number, abi?: any) {
    const key = `${chainId}_${address}`;
    if (!this.instanceMap.has(key)) {
      const chain = new Chain(this.chainMap.get(chainId)!.rpc);
      const coinInstance = await chain.initContractInstance(address, abi);
      this.instanceMap.set(key, coinInstance);
    }
    return this.instanceMap.get(key);
  }

  public async getBalance(address: string, chainId: number) {
    const coinInstance = await this.getInstance(address, chainId);
    const balance = await coinInstance.methods
      .balanceOf(UserModule.accountId)
      .call();
    console.log("balance: ", balance);
    return balance;
  }

  /**
   * get amount of mystery boxes
   * this method can get amount of general erc721 also
   * @param {string} address
   * @param {number} chainId
   * @return {Promise<any>}
   */
  public async getNftBalance(address: string, chainId: number) {
    const coinInstance = await this.getInstance(
      address,
      chainId,
      MYSTERY_BOX_ABI
    );
    const balance = await coinInstance.methods
      .balanceOf(UserModule.accountId)
      .call();
    console.log("nft balance: ", balance);
    return balance;
  }

  /**
   *  Get NFT list of current user
   * @param {string} address  NFT address
   * @param {number} chainId  chain id
   * @param {number} start
   * @param {number} page
   */
  public async getNftList(
    address: string,
    chainId: number,
    start = 0,
    page = 8
  ) {
    const nftInstance = await this.getInstance(
      address,
      chainId,
      MYSTERY_BOX_ABI
    );
    return nftInstance.methods
      .userTokens(UserModule.accountId, start, page)
      .call();
  }

  /**
   * Get NFT of current user with index
   * @param {string} address
   * @param {number} chainId
   * @param {number} index
   * @return {Promise<any>}
   */
  public async getNftIdOfIndex(
    address: string,
    chainId: number,
    index: number
  ) {
    const nftInstance = await this.getInstance(
      address,
      chainId,
      MYSTERY_BOX_ABI
    );
    const nftId = await nftInstance.methods
      .tokenOfOwnerByIndex(UserModule.accountId, index)
      .call();
    console.log(
      `address: ${address}, chainId: ${chainId}, index: ${index}, token: ${nftId}`
    );
    return nftId;
  }

  /**
   * Open one mystery box
   * @param {string} address address of mystery box contract on current chain
   * @param {string} boxId  nftid of mystery box
   * @param {number[]} tokenIds
   * @param {string} nonce
   * @param {string} signature
   * @return {Promise<any>}
   */
  public async openMysteryBox(
    address: string,
    boxId: string,
    tokenIds: number[],
    nonce: string,
    signature: string
  ) {
    const proxyInstance = await this.bc.getContractInstance(
      address,
      MYSTERY_PROXY_ABI
    );
    // get transactionHash and upload to server for verify
    return proxyInstance.methods
      .openBox(boxId, tokenIds, nonce, signature)
      .send({ gas: 1000000 });
  }

  /**
   * activate one nft with 18 digital id
   * @param {string} address
   * @param {string} nftOld
   * @param {string} nftNew
   * @param {number} nftType
   * @param {string} nonce
   * @param {string} signature
   * @return {Promise<any>}
   */
  public async activateOneNft(
    address: string,
    nftOld: string,
    nftNew: string,
    nftType: number,
    nonce: string,
    signature: string
  ) {
    const nftProxyInstance = await this.bc.getContractInstance(
      address,
      ACTIVATE_PROXY_ABI
    );
    const gas = await nftProxyInstance.methods
      .activateOne(nftOld, nftNew, nftType, nonce, signature)
      .estimateGas({ gas: 1000000 });
    console.log("nftProxyInstance activateOne need gas: ", gas);
    return nftProxyInstance.methods
      .activateOne(nftOld, nftNew, nftType, nonce, signature)
      .send({ gas: (gas * 1.1) | 0 });
  }

  public async transferToAccount({
    to,
    amount,
    chainId,
    address,
  }: {
    to: string;
    amount: number;
    chainId: number;
    address: string;
  }) {
    const self = this;
    if (chainId !== this.bc.currentChain) {
      return new Promise((resolve, reject) => {
        this.bc.switchEthereumChain(chainId, function () {
          self.bc
            .transferToAccount(to, amount, address)
            .then((res) => {
              resolve && resolve(res);
            })
            .catch((err) => {
              reject && reject(err);
            });
        });
      });
    } else {
      return this.bc.transferToAccount(to, amount, address);
    }
  }
}