blockchain.js

import Web3 from './web3.min.js';
import bip39 from './bip39.js';
import hdkeySpec from './hdkey.js';
const hdkey = hdkeySpec.default;
import ethereumJsTx from './ethereumjs-tx.js';
import {makePromise} from './util.js';
import {
  chainName,
  web3MainnetSidechainEndpoint,
  web3TestnetSidechainEndpoint,
  polygonVigilKey,
} from './constants.js';
const {Transaction, Common} = ethereumJsTx;
import addresses from 'https://contracts.webaverse.com/config/addresses.js';
import abis from 'https://contracts.webaverse.com/config/abi.js';

export const Networks = {
  mainnet: {
    displayName: 'Mainnet',
    transferOptions: ['mainnetsidechain'],
  },
  mainnetsidechain: {
    displayName: 'Webaverse',
    transferOptions: ['mainnet', 'polygon'],
  },
  polygon: {
    displayName: 'Polygon',
    transferOptions: ['mainnetsidechain'],
  },
  testnet: {
    displayName: 'Rinkeby Testnet',
    transferOptions: ['testnetsidechain', 'testnetpolygon'],
  },
  testnetsidechain: {
    displayName: 'Webaverse Testnet',
    transferOptions: ['testnet'],
  },
  testnetpolygon: {
    displayName: 'Polygon Testnet',
    transferOptions: ['testnetsidechain'],
  },
};

const injectedWeb3 = new Web3(window.ethereum);
const web3 = {
  mainnet: injectedWeb3,
  mainnetsidechain: new Web3(
    new Web3.providers.HttpProvider(web3MainnetSidechainEndpoint),
  ),
  testnet: injectedWeb3,
  testnetsidechain: new Web3(
    new Web3.providers.HttpProvider(web3TestnetSidechainEndpoint),
  ),
  polygon: new Web3(
    new Web3.providers.HttpProvider(
      `https://rpc-mainnet.maticvigil.com/v1/${polygonVigilKey}`,
    ),
  ),
  testnetpolygon: new Web3(
    new Web3.providers.HttpProvider(
      `https://rpc-mumbai.maticvigil.com/v1/${polygonVigilKey}`,
    ),
  ),
};
let common = null;
let addressFront;
let addressBack;
let networkName = '';
function _setChain(nn) {
  addressFront = addresses[nn];
  addressBack = addresses[nn + 'sidechain'];
  networkName = nn;

  if (nn === 'mainnet') {
    common = Common.forCustomChain(
      'mainnet',
      {
        name: 'geth',
        networkId: 1,
        chainId: 1338,
      },
      'petersburg',
    );
  } else if (nn === 'testnet') {
    common = Common.forCustomChain(
      'mainnet',
      {
        name: 'geth',
        networkId: 1,
        chainId: 1337,
      },
      'petersburg',
    );
  } else if (nn === 'polygon') {
    // throw new Error('cannot set common properties for polygon yet');
  } else {
    throw new Error('unknown network name', nn);
  }
}
const _initSetChain = () => {
  _setChain(chainName);
};
_initSetChain();

const contracts = {};
Object.keys(Networks).forEach(network => {
  // console.log("*** Network is", network);
  contracts[network] = {
    Account: new web3[network].eth.Contract(
      abis.Account,
      addresses[network].Account,
    ),
    FT: new web3[network].eth.Contract(abis.FT, addresses[network].FT),
    FTProxy: new web3[network].eth.Contract(
      abis.FTProxy,
      addresses[network].FTProxy,
    ),
    NFT: new web3[network].eth.Contract(abis.NFT, addresses[network].NFT),
    NFTProxy: new web3[network].eth.Contract(
      abis.NFTProxy,
      addresses[network].NFTProxy,
    ),
    Trade: new web3[network].eth.Contract(abis.Trade, addresses[network].Trade),
    LAND: new web3[network].eth.Contract(abis.LAND, addresses[network].LAND),
    LANDProxy: new web3[network].eth.Contract(
      abis.LANDProxy,
      addresses[network].LANDProxy,
    ),
  };
});

const getNetworkName = () => chainName;

const getMainnetAddress = async () => {
  if (typeof window !== 'undefined' && window.ethereum) {
    const [address] = await window.ethereum.request({
      method: 'eth_requestAccounts',
    });
    return address || null;
  } else {
    return null;
  }
};

const transactionQueue = {
  running: false,
  queue: [],
  lock() {
    if (!this.running) {
      this.running = true;
      return Promise.resolve();
    } else {
      const promise = makePromise();
      this.queue.push(promise.accept);
      return promise;
    }
  },
  unlock() {
    this.running = false;
    if (this.queue.length > 0) {
      this.queue.shift()();
    }
  },
};
const runSidechainTransaction =
  mnemonic =>
  async (contractName, method, ...args) => {
    const wallet = hdkey
      .fromMasterSeed(bip39.mnemonicToSeedSync(mnemonic))
      .derivePath(`m/44'/60'/0'/0/0`)
      .getWallet();
    const address = wallet.getAddressString();
    const privateKey = wallet.getPrivateKeyString();
    const privateKeyBytes = Uint8Array.from(
      web3['mainnetsidechain'].utils.hexToBytes(privateKey),
    );

    const txData = contracts['mainnetsidechain'][contractName].methods[method](
      ...args,
    );
    const data = txData.encodeABI();
    const gas = await txData.estimateGas({
      from: address,
    });
    let gasPrice = await web3['mainnetsidechain'].eth.getGasPrice();
    gasPrice = parseInt(gasPrice, 10);

    await transactionQueue.lock();
    const nonce = await web3['mainnetsidechain'].eth.getTransactionCount(
      address,
    );
    let tx = Transaction.fromTxData(
      {
        to: contracts['mainnetsidechain'][contractName]._address,
        nonce: '0x' + new web3['mainnetsidechain'].utils.BN(nonce).toString(16),
        gas: '0x' + new web3['mainnetsidechain'].utils.BN(gas).toString(16),
        gasPrice:
          '0x' + new web3['mainnetsidechain'].utils.BN(gasPrice).toString(16),
        gasLimit:
          '0x' + new web3['mainnetsidechain'].utils.BN(8000000).toString(16),
        data,
      },
      {
        common,
      },
    ).sign(privateKeyBytes);
    const rawTx = '0x' + tx.serialize().toString('hex');
    // console.log('signed tx', tx, rawTx);
    const receipt = await web3['mainnetsidechain'].eth.sendSignedTransaction(
      rawTx,
    );
    transactionQueue.unlock();
    return receipt;
  };
const getTransactionSignature = async (
  chainName,
  contractName,
  transactionHash,
) => {
  const u = `https://sign.exokit.org/${chainName}/${contractName}/${transactionHash}`;
  for (let i = 0; i < 10; i++) {
    const signature = await fetch(u).then(res => res.json());
    // console.log('got sig', u, signature);
    if (signature) {
      return signature;
    } else {
      await new Promise((accept, reject) => {
        setTimeout(accept, 1000);
      });
    }
  }
  return null;
};

const runMainnetTransaction = async (contractName, method, ...args) => {
  const address = await getMainnetAddress();
  if (address) {
    const m = contracts.front[contractName].methods[method];
    m.apply(m, args).send({
      from: address,
    });
  } else {
    throw new Error('no addresses passed by web3');
  }
};

const _getWalletFromMnemonic = mnemonic =>
  hdkey
    .fromMasterSeed(bip39.mnemonicToSeedSync(mnemonic))
    .derivePath(`m/44'/60'/0'/0/0`)
    .getWallet();
const getAddressFromMnemonic = mnemonic =>
  _getWalletFromMnemonic(mnemonic).getAddressString();

const networkNameEl = document.getElementById('network-name');
const bindInterface = () => {
  if (networkNameEl) {
    networkNameEl.innerText = networkName;
  }
};

export {
  web3,
  contracts,
  bindInterface,
  getNetworkName,
  getMainnetAddress,
  runSidechainTransaction,
  runMainnetTransaction,
  getTransactionSignature,
  getAddressFromMnemonic,
};