Top 10 Examples of "web3-utils in functional component" in JavaScript

it('Authentic Submission Happy Path - SubmitBlock()', async () => {
    const ion = await Ion.new(DEPLOYEDCHAINID);
    const validation = await Validation.new(ion.address);
   
    await validation.RegisterChain(TESTCHAINID, VALIDATORS, GENESIS_HASH);

    // Fetch block 1 from testrpc
    const block = web3.eth.getBlock(1);

    const rlpHeaders = encoder.encodeBlockHeader(block);
    const signedHeaderHash = Web3Utils.sha3(rlpHeaders.signed);
    assert.equal(block.hash, signedHeaderHash);

    // Submit block should succeed
    const validationReceipt = await validation.SubmitBlock(TESTCHAINID, rlpHeaders.unsigned, rlpHeaders.signed);
    const recoveredBlockHash = await validation.getLatestBlockHash.call(TESTCHAINID);
    assert.equal(signedHeaderHash, recoveredBlockHash);
    console.log("\tGas used to submit block = " + validationReceipt.receipt.gasUsed.toString() + " gas");

    let blockHash = await validation.m_blockhashes(TESTCHAINID, block.hash);
    assert.equal(blockHash, true);

    let header = await validation.m_blockheaders(TESTCHAINID, block.hash);

    // Separate fetched header info
    parentHash = header[2];

await goodClient.resetDB();
      await goodClient.addLogContentsToReputationTree();
      await advanceMiningCycleNoContest({ colonyNetwork, test: this, client: goodClient });
      await goodClient.saveCurrentState();

      // The update log should contain the person being rewarded for the previous
      // update cycle, and reputation updates for one task completion (manager, worker (skill and domain), evaluator);
      // That's five in total.
      const repCycle = await getActiveRepCycle(colonyNetwork);
      const nLogEntries = await repCycle.getReputationUpdateLogLength();
      expect(nLogEntries).to.eq.BN(5);

      const badClient = new MaliciousReputationMinerExtraRep(
        { loader, realProviderPort, useJsTree, minerAddress: MINER2 },
        17,
        toBN("170141183460469231731687302715884105727").mul(toBN(-1))
      );
      await badClient.initialise(colonyNetwork.address);

      // Moving the state to the bad client
      const currentGoodClientState = await goodClient.getRootHash();
      await badClient.loadState(currentGoodClientState);

      await submitAndForwardTimeToDispute([goodClient, badClient], this);

      await accommodateChallengeAndInvalidateHash(colonyNetwork, this, goodClient, badClient, {
        client2: { respondToChallenge: "colony-reputation-mining-reputation-not-max-int128" }
      });
      await repCycle.confirmNewHash(1);
    });
  });

it("should prohibit revealing at the right time but with too low a deposit", async function() {
    let instance = await MacroverseUniversalRegistry.deployed()
    let backend = await MacroverseRealEstate.deployed()

    // Remember our commitment from the last test?
    let to_claim = mv.keypathToToken('0.0.0.0')
    let nonce = 0xDEAD
    
    assert.equal(await backend.exists(to_claim), false, "Token exists too early")

    // We're also going to test price adjustments

    let since = web3.eth.getBlock('latest').number

    // Adjust the price up
    await instance.setMinimumSystemDeposit(Web3Utils.toWei("1001", "ether"))

    let saw_event = false
    let new_price = undefined
    for (let event_report of await instance.getPastEvents('DepositScaleChange', {fromBlock: since})) {
      if (event_report.event == 'DepositScaleChange') {
        // Remember we saw the change
        saw_event = true
        // And what we changed to
        new_price = event_report.args.new_min_system_deposit_in_atomic_units
      }
    }

    assert.equal(saw_event, true, "We got the first expected price change event")
    assert.equal(new_price, Web3Utils.toWei("1001", "ether"), "We got the first expected new price")

    await assert_throws(instance.reveal(to_claim, nonce), "Revealed with too small deposit")

register () {
        //***** Simulating the principal node
        console.log ('registering principal', this.custodian);
        const report = engUtils.encodeReport (
            this.params[1],
            this.params[2],
            this.params[3],
        );
        // Using the same artificial data for all workers
        return this.contract.register (
            this.params[0], report, {
                from: this.custodian,
                gas: 4712388,
                gasPrice: web3Utils.toWei (GAS_PRICE_GWEI, 'gwei')
            }
        );
    }

it("should prohibit revealing for a parent token of owned land", async function() {
    let instance = await MacroverseUniversalRegistry.deployed()
    let mrv = await MRVToken.deployed()

    // Approve the deposit tokens
    await mrv.approve(instance.address, await mrv.balanceOf.call(accounts[1]), {from: accounts[1]})

    // This is a parent of the land token we have been working with
    let to_claim = mv.keypathToToken('0.0.0.0.0.-1.7.2.2')
    let nonce = 0xDEADBEEF88
    let data_hash = mv.hashTokenAndNonce(to_claim, nonce)

    // Commit for it
    await instance.commit(data_hash, Web3Utils.toWei("1000", "ether"), {from: accounts[1]})

    // Advance time for 10 minutes to mature the commitment
    await mv.advanceTime(10)

    // Now try revealing. It should fail.
    await assert_throws(instance.reveal(to_claim, nonce), "Revealed land superplot")

    // Clean up
    await instance.cancel(data_hash, {from: accounts[1]})
  })

try{
        var txCount = await web3.eth.getTransactionCount(addressFrom);
        console.log('txCount',txCount)
       } catch(error) {  //here goes if someAsyncPromise() rejected}
        console.log(error);
         return error;    //this will result in a resolved promise.
       }


    const txOptions = {
      nonce: web3Utils.toHex(txCount),
      gasLimit: web3Utils.toHex(25000),
      gasPrice: web3Utils.toHex(2e9), // 2 Gwei
      to: addressTo,
      from: addressFrom,
      value: web3Utils.toHex(web3Utils.toWei('123', 'wei'))
    //  value: web3Utils.toHex(web3Utils.toWei('123', 'wei'))
    }

    // fire away!

    console.log('fire away ')
    await this.sendSignedRawTransaction(web3,txOptions,addressFrom,account, function(err, result) {
      if (err) return console.log('error', err)
      console.log('sent', result)
    })



  },

source: "With value: Send `@tokenAmount(token, msg.value)` from `msg.sender` to `receiver`",
    bindings: { token: address(ETH), receiver:  address('0x8401Eb5ff34cc943f096A32EF3d5113FEbE8D4Eb') },
    options: { from: '0xb4124cEB3451635DAcedd11767f004d8a28c6eE7', value: '1000000000000000000' },
  }, 'With value: Send 1 ETH from 0xb4124cEB3451635DAcedd11767f004d8a28c6eE7 to 0x8401Eb5ff34cc943f096A32EF3d5113FEbE8D4Eb'],

  [{
    source: "Sending tx with data `msg.data` to contract at `contract`",
    bindings: { contract: address('0x960b236A07cf122663c4303350609A66A7B288C0') },
    options: { data: '0xabcdef'}
  }, "Sending tx with data 0xabcdef to contract at 0x960b236A07cf122663c4303350609A66A7B288C0"],
  
  // using msg.data on a helper
  [{
    source: "Performs a call to `@radspec(contract, msg.data)`",
    bindings: { contract: address('0x960b236A07cf122663c4303350609A66A7B288C0') },
    options: { data: keccak256(Object.keys(knownFunctions)[3]).slice(0,10) }
  }, `Performs a call to ${Object.values(knownFunctions)[3]}`],

  ...comparisonCases,
  ...helperCases,
  ...dataDecodeCases
]

cases.forEach(([input, expected], index) => {
  test(`${index} - ${input.source}`, async (t) => {
    const { userHelpers } = input.options || {}
    const actual = await evaluateRaw(
      input.source,
      input.bindings,
      {
        ...input.options,
        availableHelpers: { ...defaultHelpers, ...userHelpers }

it("returns correct negative value", function() {
      let bytes = [0xf5, 0xe2, 0xc5, 0x17];  // starts with 0b1
      let raw = new BN("f5e2c517", 16);
      let bitfipped = new BN(
        raw.toString(2)
          .replace(/0/g, "x")
          .replace(/1/g, "0")
          .replace(/x/g, "1"),
        2
      );

      let expectedValue = bitfipped.add(new BN(1)).neg();

      let result = utils.toSignedBN(bytes);

      assert.equal(result.toString(), expectedValue.toString());
    });

//  console.log('digestBigNumber',digestBigNumber.toString())
              // console.log('miningTarget',miningTarget.toString())

                 if ( digestBigNumber.lt(miningTarget) )
                 {


                    console.log(minerEthAddress)
                     console.log('------')
                     console.log(solution_number)
                      console.log(challenge_number)
                        console.log(solution_number)
                    console.log('------')
                     console.log( web3utils.bytesToHex(digestBytes32))
                 }


             if ( digestBigNumber.lt(miningTarget)  )
             {
               //pass in digest bytes or trimmed ?

               if(this.testMode){
                 this.mining = false;

                 this.networkInterface.checkMiningSolution( minerEthAddress, solution_number , web3utils.bytesToHex( digestBytes32 ),challenge_number,miningTarget,
                   function(result){
                    console.log('checked mining soln:' ,result)
                  })
              }else {
                console.log('submit mined solution with challenge ', challenge_number)

    .map(methodSignature => soliditySha3(methodSignature)) // keccak256
    .map(h =>