1. Set up MetaMask
2. Open the browser's console
3. Use the console helpers
4. The ethernaut contract
5. Interact with the ABI
6. Get test ether
7. Getting a level instance
8. Inspecting the contract
9. Interact with the contract to complete the level 

await contract.info()
"You will find what you need in info1()."

await contract.info1()
"Try info2(), but with "hello" as a parameter."

await contract.info2("hello")
"The property infoNum holds the number of the next info method to call."

await contract.infoNum()
t {s: 1, e: 1, c: Array(1)}c: [42]e: 1s: 1__proto__: Object

await contract.info42()
"theMethodName is the name of the next method."

await contract.theMethodName()
"The method name is method7123949."

await contract.method7123949()
"If you know the password, submit it to authenticate()."

await contract.password()

ethernaut0

await contract.authenticate('ethernaut0')
{tx: "0x9f6c29c29b5397f6df441d4eddb6ae82b89818e57f40635f37eec6ac9153205d", receipt: {…}, logs: Array(0)} 

const TronWeb = require('../../dist/TronWeb.node.js');

const fullNode = 'https://api.shasta.trongrid.io';
const solidityNode = 'https://api.shasta.trongrid.io';
const eventServer = 'https://api.shasta.trongrid.io';
const privateKey = 'abc';

const app = async() => {
const tronWeb = new TronWeb(
    fullNode,
    solidityNode,
    eventServer,
    privateKey
);
tronWeb.setDefaultBlock('latest');

const nodes = await tronWeb.isConnected();
const connected = !Object.entries(nodes).map(([name, connected]) => {
    if (!connected)
        console.error(`Error: ${name} is not connected`);
        return connected;
    }).includes(false);

const transactions = [];

         let hasMoreTransactions = true;
         let offset = 0;

         while(hasMoreTransactions) {
             const newTransactions = (await tronWeb.trx.getTransactionsRelated("TS4AYYxrF38EA3fDw92mMWbWdFWRJ4VKih", 'all', 90, offset))
                 .map(transaction => {
                     transaction.offset = offset;
                     return transaction;
                 });

             if(!newTransactions.length)
                hasMoreTransactions = false;
             else offset += 90;

             transactions.push(...newTransactions);
         }
         console.log("transactions: ", transactions);

};
app();

async updateTransactions() {
 if(this.updatingTransactions) return;
 this.updatingTransactions = true;
 const transactions = await this.getTransactions();
 const filteredTransactions = transactions .filter(( {
  txID
 }) => ( !Object.keys(this.transactions).includes(txID) && !this.ignoredTransactions.includes(txID) ));
 const mappedTransactions = TransactionMapper.mapAll(filteredTransactions) .filter(( {
  type
 }) => SUPPORTED_CONTRACTS.includes(type));
 const newTransactions = [];
 const manuallyCached = [];
 for (const transaction of mappedTransactions) {
  if(transaction.timestamp) {
   transaction.cached = true;
   newTransactions.push(transaction);
   continue;
  }const txData = await NodeService.tronWeb.trx .getTransactionInfo(transaction.txID);
  if(!txData.id) {
   logger.warn(`Transaction $ {
    transaction.txID
   }has not been cached,
   skipping`);
   continue;
  }// if(!txData.id) {
   // logger.warn(`Transaction ${
    transaction.txID
   }has not been cached`);
 // // StorageService.addPendingTransaction(address,
   transaction.txID);
 // transaction.cached = false; // // this.transactions[
    transaction.txID
   ]= transaction;
 // continue; //
  }// logger.info(`Transaction ${
   transaction.txID
  }has been cached`,
  transaction);
transaction.cached = true;
transaction.timestamp = txData.blockTimeStamp;
transaction.receipt = txData.receipt || false;
transaction.result = txData.contractResult || false;
newTransactions.push(transaction);
manuallyCached.push(transaction.txID);
 }const sortedTransactions = [
  ...Object.values(this.transactions),
  ...newTransactions
 ].sort((a,
 b) => b.timestamp - a.timestamp);
this.transactions = sortedTransactions .slice(0,
 100) .reduce((transactions,
 transaction) => {
  transactions[
   transaction.txID
  ]= transaction;
return transactions;
 },
 {});
manuallyCached.forEach(txID => {
  if(txID in this.transactions) return;
// Transaction is now too old for TronLink (100+) this.ignoredTransactions.push(txID);
 });
this.updatingTransactions = false;
this.save();
}