Examples with Keccak256 co.rsk.crypto.Keccak256 used on opensource projects

Example 16 with Keccak256

use of co.rsk.crypto.Keccak256 in project rskj by rsksmart.

the class PrevMinGasPriceValidatorTest method validMGPInNewBlock.

@Test
public void validMGPInNewBlock() {
    Block block = Mockito.mock(Block.class);
    Block parent = Mockito.mock(Block.class);
    BlockStore blockStore = Mockito.mock(BlockStore.class);
    Mockito.when(block.getParentHash()).thenReturn(new Keccak256(PARENT_HASH));
    Mockito.when(block.getMinimumGasPrice()).thenReturn(BLOCK_MGP);
    Mockito.when(parent.getMinimumGasPrice()).thenReturn(PARENT_BLOCK_MGP);
    PrevMinGasPriceRule pmgpv = new PrevMinGasPriceRule();
    Assert.assertFalse(pmgpv.isValid(block, parent));
}

Example 17 with Keccak256

use of co.rsk.crypto.Keccak256 in project rskj by rsksmart.

the class StateTest method test2.

@Ignore
// calc state after applying first tx on genesis
@Test
public void test2() {
    // explanation:
    // 0) create genesis
    // 1) apply cost of tx to cd2a3d9f938e13cd947ec05abc7fe734df8dd826
    // 2) create AccountState for 77045e71a7a2c50903d88e564cd72fab11e82051
    // 3) minner gets the gas + coinbase ==> 6260000000000000 + 1500000000000000000
    // 4) calc the root
    Trie trie = generateGenesisState();
    Keccak256 expected = new Keccak256("c12b4d771fbcc0d56ec106f8d465d24b9d4c36d60275bbafa7d69694d6708660");
    // Get and update sender in world state
    byte[] cowAddress = Hex.decode("cd2a3d9f938e13cd947ec05abc7fe734df8dd826");
    byte[] rlpEncodedState = trie.get(cowAddress);
    AccountState account_1 = new AccountState(rlpEncodedState);
    final BigInteger value = new BigInteger("-6260000000001000");
    account_1.addToBalance(new Coin(value));
    account_1.incrementNonce();
    trie = trie.put(cowAddress, account_1.getEncoded());
    // Add contract to world state
    byte[] codeData = Hex.decode("61778e600054");
    AccountState account_2 = new AccountState(BigInteger.ZERO, Coin.valueOf(1000));
    account_2.setCodeHash(HashUtil.keccak256(codeData));
    // generated based on sender + nonce
    byte[] contractAddress = Hex.decode("77045e71a7a2c50903d88e564cd72fab11e82051");
    trie = trie.put(contractAddress, account_2.getEncoded());
    // this is saved in the db
    // trie.update(HashUtil.sha3(codeData), codeData);
    // Update miner in world state
    byte[] minerAddress = Hex.decode("4c5f4d519dff3c16f0d54b6866e256fbbbc1a600");
    final BigInteger bigInteger = new BigInteger("1506260000000000000");
    AccountState account_3 = new AccountState(BigInteger.ZERO, new Coin(bigInteger));
    trie = trie.put(minerAddress, account_3.getEncoded());
    assertEquals(expected, trie.getHash());
    /* *** GROSS DATA ***

        BlockData [
          hash=22cf863ab836a6f5c29389d2e77f4792a3b3b52908c98ed14b1cbe91491a3e36
          parentHash=77ef4fdaf389dca53236bcf7f72698e154eab2828f86fbc4fc6cd9225d285c89
          unclesHash=1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347
          coinbase=4c5f4d519dff3c16f0d54b6866e256fbbbc1a600
          stateHash=69c21ff84a5af0b53b11c61110a16d6ad43dad37b3eb29ae8e88c936eb06456a
          txTrieHash=a77691cf47bec9021d3f027fc8ef2d51b758b600a79967154354b8e37108896f
          difficulty=3ff000
          number=1
          minGasPrice=10000000000000
          gasLimit=999023
          gasUsed=626
          timestamp=1401979976 (2014.06.05 15:52:56)
          extraData=null
          nonce=0000000000000000000000000000000000000000000000005d439960040e4505

        TransactionReceipt[
           TransactionData [ hash=1ee6fa3149a5e9c09b54009eb6e108aaa7ecd79483d57eedcf2dff93a1505588  nonce=null,
               gasPrice=09184e72a000, gas=03e8, receiveAddress=0000000000000000000000000000000000000000, value=03e8,
               data=60016000546006601160003960066000f261778e600054, signatureV=27,
               signatureR=2b379f22050e3554c3fa5423d9040bb28dcc7f905300db4e67c03bcf9b27003c,
               signatureS=59f47793e050974e6b5fca2848b19925637b883a012693b54d712f1c4f74def5
          ]
          , postTxState=7fa5bd00f6e03b5a5718560f1e25179b227167585a3c3da06a48f554365fb527
          , cumulativeGas=0272]
        ]

        +++  4c5f4d519dff3c16f0d54b6866e256fbbbc1a600:
        +++  77045e71a7a2c50903d88e564cd72fab11e82051: $[61,77,8e,60,0,54] ([])
         *   cd2a3d9f938e13cd947ec05abc7fe734df8dd826: #1 1606938044258990275541962092341162602522202987522792835300376 (-6260000000001000)
          */
    assertEquals(expected, trie.getHash());
}

Example 18 with Keccak256

use of co.rsk.crypto.Keccak256 in project rskj by rsksmart.

the class FamilyUtilsTest method getFamilyGetAncestorsWithUncles.

@Test
public void getFamilyGetAncestorsWithUncles() {
    BlockStore store = createBlockStore();
    BlockGenerator blockGenerator = new BlockGenerator();
    Block genesis = blockGenerator.getGenesisBlock();
    Block block1 = blockGenerator.createChildBlock(genesis);
    Block uncle11 = blockGenerator.createChildBlock(genesis);
    Block uncle12 = blockGenerator.createChildBlock(genesis);
    Block block2 = blockGenerator.createChildBlock(block1);
    Block uncle21 = blockGenerator.createChildBlock(block1);
    Block uncle22 = blockGenerator.createChildBlock(block1);
    Block block3 = blockGenerator.createChildBlock(block2);
    Block uncle31 = blockGenerator.createChildBlock(block2);
    Block uncle32 = blockGenerator.createChildBlock(block2);
    store.saveBlock(genesis, TEST_DIFFICULTY, true);
    store.saveBlock(block1, TEST_DIFFICULTY, true);
    store.saveBlock(uncle11, TEST_DIFFICULTY, false);
    store.saveBlock(uncle12, TEST_DIFFICULTY, false);
    store.saveBlock(block2, TEST_DIFFICULTY, true);
    store.saveBlock(uncle21, TEST_DIFFICULTY, false);
    store.saveBlock(uncle22, TEST_DIFFICULTY, false);
    store.saveBlock(block3, TEST_DIFFICULTY, true);
    store.saveBlock(uncle31, TEST_DIFFICULTY, false);
    store.saveBlock(uncle32, TEST_DIFFICULTY, false);
    Set<Keccak256> family = FamilyUtils.getFamily(store, block3, 2);
    Assert.assertNotNull(family);
    Assert.assertFalse(family.isEmpty());
    Assert.assertEquals(4, family.size());
    Assert.assertFalse(family.contains(genesis.getHash()));
    Assert.assertTrue(family.contains(block1.getHash()));
    Assert.assertFalse(family.contains(uncle11.getHash()));
    Assert.assertFalse(family.contains(uncle12.getHash()));
    Assert.assertTrue(family.contains(block2.getHash()));
    Assert.assertTrue(family.contains(uncle21.getHash()));
    Assert.assertTrue(family.contains(uncle22.getHash()));
    Assert.assertFalse(family.contains(block3.getHash()));
    Assert.assertFalse(family.contains(uncle31.getHash()));
    Assert.assertFalse(family.contains(uncle32.getHash()));
    family = FamilyUtils.getFamily(store, block3, 3);
    Assert.assertNotNull(family);
    Assert.assertFalse(family.isEmpty());
    Assert.assertEquals(7, family.size());
    Assert.assertTrue(family.contains(genesis.getHash()));
    Assert.assertTrue(family.contains(block1.getHash()));
    Assert.assertTrue(family.contains(uncle11.getHash()));
    Assert.assertTrue(family.contains(uncle12.getHash()));
    Assert.assertTrue(family.contains(block2.getHash()));
    Assert.assertTrue(family.contains(uncle21.getHash()));
    Assert.assertTrue(family.contains(uncle22.getHash()));
    Assert.assertFalse(family.contains(block3.getHash()));
    Assert.assertFalse(family.contains(uncle31.getHash()));
    Assert.assertFalse(family.contains(uncle32.getHash()));
}

Example 19 with Keccak256

use of co.rsk.crypto.Keccak256 in project rskj by rsksmart.

the class HashRateCalculatorTest method init.

@Before
public void init() {
    blockStore = Mockito.mock(BlockStore.class);
    block = Mockito.mock(Block.class);
    blockHeader = Mockito.mock(BlockHeader.class);
    Mockito.when(block.getHeader()).thenReturn(blockHeader);
    Mockito.when(block.getHash()).thenReturn(new Keccak256(FAKE_GENERIC_HASH));
    Mockito.when(blockHeader.getParentHash()).thenReturn(new Keccak256(FAKE_GENERIC_HASH)).thenReturn(new Keccak256(OHTER_FAKE_GENERIC_HASH)).thenReturn(new Keccak256(FAKE_GENERIC_HASH)).thenReturn(null);
    Mockito.when(blockHeader.getHash()).thenReturn(new Keccak256(FAKE_GENERIC_HASH));
    Mockito.when(blockStore.getBlockByHash(Mockito.any())).thenReturn(block).thenReturn(block).thenReturn(block).thenReturn(null);
    Mockito.when(blockStore.getBestBlock()).thenReturn(block);
    Mockito.when(blockStore.getBlockByHash(Mockito.any())).thenReturn(block);
}

Example 20 with Keccak256

use of co.rsk.crypto.Keccak256 in project rskj by rsksmart.

the class StateForBtcReleaseClientTest method getInitializer.

private BridgeStorageProviderInitializer getInitializer() {
    final int minNumTxs = 1;
    final int maxNumTxs = 100;
    final int minNumInputs = 1;
    final int maxNumInputs = 10;
    return (BridgeStorageProvider provider, Repository repository, int executionIndex) -> {
        Map<Keccak256, BtcTransaction> txsWaitingForSignatures;
        try {
            txsWaitingForSignatures = provider.getRskTxsWaitingForSignatures();
        } catch (IOException e) {
            throw new RuntimeException("Exception while trying to gather txs waiting for signatures for storage initialization");
        }
        int numTxs = Helper.randomInRange(minNumTxs, maxNumTxs);
        for (int i = 0; i < numTxs; i++) {
            BtcTransaction releaseTx = new BtcTransaction(networkParameters);
            Federation federation = bridgeConstants.getGenesisFederation();
            // Receiver and amounts
            Address toAddress = new BtcECKey().toAddress(networkParameters);
            Coin releaseAmount = Coin.CENT.multiply(Helper.randomInRange(10, 100));
            releaseTx.addOutput(releaseAmount, toAddress);
            // Input generation
            int numInputs = Helper.randomInRange(minNumInputs, maxNumInputs);
            for (int j = 0; j < numInputs; j++) {
                Coin inputAmount = releaseAmount.divide(numInputs);
                BtcTransaction inputTx = new BtcTransaction(networkParameters);
                inputTx.addOutput(inputAmount, federation.getAddress());
                releaseTx.addInput(inputTx.getOutput(0)).setScriptSig(PegTestUtils.createBaseInputScriptThatSpendsFromTheFederation(federation));
            }
            Keccak256 rskTxHash = new Keccak256(HashUtil.keccak256(BigInteger.valueOf(new Random().nextLong()).toByteArray()));
            txsWaitingForSignatures.put(rskTxHash, releaseTx);
        }
    };
}