const hre = require("hardhat");
const http = require ("http"); /* Change to require("https") if the URL below should use TLS */
const querystring = require ("querystring")

const BLOCKSCOUT_HOST = "127.0.0.1";
const BLOCKSCOUT_PORT = 4000;


/**
 * Verifies the contract's source code on the just deployed address
 */
async function blockscout_verify (contract_name, address, args = null) {

  const artifact =  await artifacts.readArtifact (contract_name);
  /* I'm assuming it exists, because I don't care enough to do proper error handling */
  const abi = artifact ["abi"];


  const debug_info = await artifacts.getBuildInfo(contract_name);
  /* Again, assuming they exist */
  const standard_input = debug_info ["input"];
  const compiler = debug_info ["solcLongVersion"];

  let post_data = {
        "module":"contract",
          "action": "verifysourcecode",
        "codeformat": "solidity-standard-json-input",
        "contractaddress": address,
        "contractname": contract_name,
        "compilerversion": "v" + compiler, /* Blockscout dies without further info if the compiler doesn't have the "v" */
        "sourceCode": JSON.stringify (standard_input)
  };


  if (args) {

    const iface = new hre.ethers.utils.Interface (abi);
    const encoded_args = iface.encodeDeploy (args);
    /* Yup, the typo is there in the API */
    post_data ["constructorArguements"] = encoded_args.replace (/^0x/, ""); /* The resulting string has a leading "0x", but Blockscout doesn't like that */
  }

  const data = querystring.stringify (post_data);

  const req = http.request (
    {
      "hostname": BLOCKSCOUT_HOST,
      "port": BLOCKSCOUT_PORT,
      "path": "/api",
      "method": "POST",
      "headers": {
        "Content-Type": "application/x-www-form-urlencoded",
        "Content-Length": Buffer.byteLength (data)
      }
    },
    res => {
      res.on ("data", d => {

        const response = JSON.parse (d);

        if (response ["status"] == "1" ) {
          /* The verification takes some time, so it makes no sense to keep polling for it */
          console.log ("Issued verification for " + contract_name);
        } else {
          console.log ("Verification of " + contract_name + " result: ", response ["result"]);
        }
      });
    }
  );

  req.on ("error", error => {
    console.error ("Error while verifying " + contract_name + " deployed at " + address + ":");
    console.error (error.message);
  });

  req.write (data);
  req.end ();
}



/**
 * Deploys the selected contract and starts the verification process, if the parameter "verify" is "true"
 * Since the contract's constructor may take one or more arguments, it's up to the caller to specify the
 * correct deployment function, which will get called after getContractFactory() is finished and returns
 * a contract. For example: `(contract, args) => { retur contract.deploy (args [0], args [1]) }`
 *
 * The constructor function can access the args through the "args" array, which is also passed to deploy()
 * and MUST return the result of contract.deploy()
 */
async function deploy (contract_name, verify = false, constructor, args) {

  const contract = await hre.ethers.getContractFactory (contract_name);
  const deployed = await constructor (contract, args);

  console.log (contract_name + " deployed to:", deployed.address);

  if (verify) {
    const timer = ms => new Promise( res => setTimeout(res, ms));
    console.log ("Waiting 60 seconds to allow transactions to be mined and Blockscout to ingest the new data");

    timer(60000).then(_=> blockscout_verify (contract_name, deployed.address, args));
  }
}





function main() {

  /* Dictionary of contracts and arguments
     Each element should contain the following information:
      - name: str -> full path to the contract (e.g.: "contracts/01-Fallback.sol:Fallback")
      - constructor: function -> Contract's constructor, to deploy it
      - args: array|null -> Arguments to pass to the constructor
      - verify: boolean -> "true" if the contract should be verified in Blockscout
  */
  const contracts = [
    {
      "name": "contracts/01-Fallback.sol:Fallback",
      "constructor": (contract, args) => { return contract.deploy (); },
      "args": null,
      "verify": true
    },
    {
      "name": "contracts/00-Hello Ethernaut.sol:Instance",
      "constructor": (contract, args) => { return contract.deploy (args [0]); },
      "args": [ "SuperSecurePassword!" ],
      "verify": true
    }
  ]

  const req = http.request (
    {
      "hostname": BLOCKSCOUT_HOST,
      "port": BLOCKSCOUT_PORT,
      "path": "/api",
      "method": "GET"
    },
    res => {
      /* If there's any reply at all, I assume that the server is running (instead of waiting for the data) */
      contracts.forEach (
        c => {
          deploy (c ["name"], c ["verify"], c ["constructor"], c ["args"]);
        }
      );
    }
  );

  req.on ("error", error => {
    console.log ("Error contacting blockscout: " + error.message);

    /* Just deploy the contracts, without verification */
    contracts.forEach (
      c => {
        deploy (c ["name"], false, c ["constructor"], c ["args"]);
      }
    );
  });

  req.end ();
}

main()
/*  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
})*/

>> ctf00_contract.methods.info ().call ( (err, res) => console.log (res));
You will find what you need in info1().

>> ctf00_contract.methods.info1 ().call ( (err, res) => console.log (res));
Try info2(), but with "hello" as a parameter.
>> ctf00_contract.methods.info2 ("hello").call ( (err, res) => console.log (res));
The property infoNum holds the number of the next info method to call.
>> ctf00_contract.methods.infoNum ().call ( (err, res) => console.log (res));
42
>> ctf00_contract.methods.info42 ().call ( (err, res) => console.log (res) );
theMethodName is the name of the next method.
>> ctf00_contract.methods.theMethodName ().call ( (err, res) => console.log (res) );
The method name is method7123949.
>> ctf00_contract.methods.method7123949 ().call ( (err, res) => console.log (res) );
If you know the password, submit it to authenticate().

>> ctf00_contract.methods.password ().call ( (err, res) => console.log (res) );
SuperSecurePassword!
>> ctf00_contract.methods.authenticate ("SuperSecurePassword!").call ( (err, res) => console.log (res) );
Object {  }
>> ctf00_contract.methods.getCleared ().call ( (err, res) => console.log (res) );
false

>> ctf00_contract.methods.authenticate ("asdf").send ({ "from": attackerAddress }, (err, res) => console.log (res) );
0x46da940b7eed9fb741015e5cf0d87d33d112bd2795f26fe9aea6e6458d6d5c0e
>> ctf00_contract.methods.getCleared ().call ( (err, res) => console.log (res) );
false
>> ctf00_contract.methods.authenticate ("SuperSecurePassword!").send ({ "from": attackerAddress }, (err, res) => console.log (res) );
0xb598659853e78ffaa0a4cf72b8f06733d07ce2ef2af9019dbbc486dd37e3f302
>> ctf00_contract.methods.getCleared ().call ( (err, res) => console.log (res) );
true