@Test public void orphanBlock() { // CREATE EMPTY MEMORY DATABASE DBSet databaseSet = DBSet.createEmptyDatabaseSet(); // PROCESS GENESISBLOCK GenesisBlock genesisBlock = new GenesisBlock(); genesisBlock.process(databaseSet); // CREATE KNOWN ACCOUNT byte[] seed = Crypto.getInstance().digest("test".getBytes()); byte[] privateKey = Crypto.getInstance().createKeyPair(seed).getA(); PrivateKeyAccount generator = new PrivateKeyAccount(privateKey); // PROCESS GENESIS TRANSACTION TO MAKE SURE GENERATOR HAS FUNDS Transaction transaction = new GenesisTransaction(generator, BigDecimal.valueOf(1000).setScale(8), NTP.getTime()); transaction.process(databaseSet); // GENERATE NEXT BLOCK BlockGenerator blockGenerator = new BlockGenerator(); Block block = blockGenerator.generateNextBlock(databaseSet, generator, genesisBlock); // FORK DBSet fork = databaseSet.fork(); // GENERATE PAYMENT 1 Account recipient = new Account("XUi2oga2pnGNcZ9es6pBqxydtRZKWdkL2g"); long timestamp = block.getTimestamp(); byte[] signature = PaymentTransaction.generateSignature( databaseSet, generator, recipient, BigDecimal.valueOf(100).setScale(8), BigDecimal.valueOf(1).setScale(8), timestamp); Transaction payment1 = new PaymentTransaction( generator, recipient, BigDecimal.valueOf(100).setScale(8), BigDecimal.valueOf(1).setScale(8), timestamp, generator.getLastReference(databaseSet), signature); payment1.process(fork); block.addTransaction(payment1); // GENERATE PAYMENT 2 Account recipient2 = new Account("XLPYYfxKEiDcybCkFA7jXcxSdePMMoyZLt"); signature = PaymentTransaction.generateSignature( fork, generator, recipient2, BigDecimal.valueOf(100).setScale(8), BigDecimal.valueOf(1).setScale(8), timestamp); Transaction payment2 = new PaymentTransaction( generator, recipient2, BigDecimal.valueOf(100).setScale(8), BigDecimal.valueOf(1).setScale(8), timestamp, generator.getLastReference(fork), signature); block.addTransaction(payment2); // ADD TRANSACTION SIGNATURE byte[] transactionsSignature = blockGenerator.calculateTransactionsSignature(block, generator); block.setTransactionsSignature(transactionsSignature); // CHECK VALID assertEquals(true, block.isSignatureValid()); assertEquals(true, block.isValid(databaseSet)); // PROCESS BLOCK block.process(databaseSet); // ORPHAN BLOCK block.orphan(databaseSet); // CHECK BALANCE GENERATOR assertEquals( true, generator.getConfirmedBalance(databaseSet).compareTo(BigDecimal.valueOf(1000)) == 0); // CHECK LAST REFERENCE GENERATOR assertEquals( true, Arrays.equals(generator.getLastReference(databaseSet), transaction.getSignature())); // CHECK BALANCE RECIPIENT assertEquals( true, recipient.getConfirmedBalance(databaseSet).compareTo(BigDecimal.valueOf(1000)) == 0); // CHECK LAST REFERENCE RECIPIENT assertEquals( false, Arrays.equals(recipient.getLastReference(databaseSet), payment1.getSignature())); // CHECK BALANCE RECIPIENT2 assertEquals( true, recipient2.getConfirmedBalance(databaseSet).compareTo(BigDecimal.valueOf(0)) == 0); // CHECK LAST REFERENCE RECIPIENT assertEquals(true, Arrays.equals(recipient2.getLastReference(databaseSet), new byte[0])); // CHECK LAST BLOCK assertEquals( true, Arrays.equals( genesisBlock.getSignature(), databaseSet.getBlockMap().getLastBlock().getSignature())); }
@Test public void validateBlock() { // CREATE EMPTY MEMORY DATABASE DBSet databaseSet = DBSet.createEmptyDatabaseSet(); // PROCESS GENESISBLOCK GenesisBlock genesisBlock = new GenesisBlock(); genesisBlock.process(databaseSet); // CREATE KNOWN ACCOUNT byte[] seed = Crypto.getInstance().digest("test".getBytes()); byte[] privateKey = Crypto.getInstance().createKeyPair(seed).getA(); PrivateKeyAccount generator = new PrivateKeyAccount(privateKey); // PROCESS GENESIS TRANSACTION TO MAKE SURE GENERATOR HAS FUNDS Transaction transaction = new GenesisTransaction(generator, BigDecimal.valueOf(1000).setScale(8), NTP.getTime()); transaction.process(databaseSet); // GENERATE NEXT BLOCK BlockGenerator blockGenerator = new BlockGenerator(); Block newBlock = blockGenerator.generateNextBlock(databaseSet, generator, genesisBlock); // ADD TRANSACTION SIGNATURE byte[] transactionsSignature = Crypto.getInstance().sign(generator, newBlock.getGeneratorSignature()); newBlock.setTransactionsSignature(transactionsSignature); // CHECK IF VALID assertEquals(true, newBlock.isValid(databaseSet)); // CHANGE REFERENCE Block invalidBlock = BlockFactory.getInstance() .create( newBlock.getVersion(), new byte[128], newBlock.getTimestamp(), newBlock.getGeneratingBalance(), newBlock.getGenerator(), newBlock.getGeneratorSignature()); // CHECK IF INVALID assertEquals(false, invalidBlock.isValid(databaseSet)); // CHANGE TIMESTAMP invalidBlock = BlockFactory.getInstance() .create( newBlock.getVersion(), newBlock.getReference(), 1L, newBlock.getGeneratingBalance(), newBlock.getGenerator(), newBlock.getGeneratorSignature()); // CHECK IF INVALID assertEquals(false, invalidBlock.isValid(databaseSet)); // CHANGE BASETARGET invalidBlock = BlockFactory.getInstance() .create( newBlock.getVersion(), newBlock.getReference(), newBlock.getTimestamp(), 1L, newBlock.getGenerator(), newBlock.getGeneratorSignature()); // CHECK IF INVALID assertEquals(false, invalidBlock.isValid(databaseSet)); // ADD INVALID TRANSACTION invalidBlock = blockGenerator.generateNextBlock(databaseSet, generator, genesisBlock); Account recipient = new Account("XUi2oga2pnGNcZ9es6pBqxydtRZKWdkL2g"); long timestamp = newBlock.getTimestamp(); byte[] signature = PaymentTransaction.generateSignature( databaseSet, generator, recipient, BigDecimal.valueOf(-100).setScale(8), BigDecimal.valueOf(1).setScale(8), timestamp); Transaction payment = new PaymentTransaction( generator, recipient, BigDecimal.valueOf(-100).setScale(8), BigDecimal.valueOf(1).setScale(8), timestamp, generator.getLastReference(databaseSet), signature); invalidBlock.addTransaction(payment); // CHECK IF INVALID assertEquals(false, invalidBlock.isValid(databaseSet)); // ADD GENESIS TRANSACTION invalidBlock = blockGenerator.generateNextBlock(databaseSet, generator, genesisBlock); transaction = new GenesisTransaction( generator, BigDecimal.valueOf(1000).setScale(8), newBlock.getTimestamp()); invalidBlock.addTransaction(transaction); // CHECK IF INVALID assertEquals(false, invalidBlock.isValid(databaseSet)); }
@Test public void parseBlock() { // CREATE EMPTY MEMORY DATABASE DBSet databaseSet = DBSet.createEmptyDatabaseSet(); // PROCESS GENESISBLOCK GenesisBlock genesisBlock = new GenesisBlock(); genesisBlock.process(databaseSet); // CREATE KNOWN ACCOUNT byte[] seed = Crypto.getInstance().digest("test".getBytes()); byte[] privateKey = Crypto.getInstance().createKeyPair(seed).getA(); PrivateKeyAccount generator = new PrivateKeyAccount(privateKey); // PROCESS GENESIS TRANSACTION TO MAKE SURE GENERATOR HAS FUNDS Transaction transaction = new GenesisTransaction(generator, BigDecimal.valueOf(1000).setScale(8), NTP.getTime()); transaction.process(databaseSet); // GENERATE NEXT BLOCK BlockGenerator blockGenerator = new BlockGenerator(); Block block = blockGenerator.generateNextBlock(databaseSet, generator, genesisBlock); // FORK DBSet fork = databaseSet.fork(); // GENERATE PAYMENT 1 Account recipient = new Account("XUi2oga2pnGNcZ9es6pBqxydtRZKWdkL2g"); long timestamp = block.getTimestamp(); byte[] signature = PaymentTransaction.generateSignature( databaseSet, generator, recipient, BigDecimal.valueOf(100).setScale(8), BigDecimal.valueOf(1).setScale(8), timestamp); Transaction payment1 = new PaymentTransaction( generator, recipient, BigDecimal.valueOf(100).setScale(8), BigDecimal.valueOf(1).setScale(8), timestamp, generator.getLastReference(databaseSet), signature); payment1.process(fork); block.addTransaction(payment1); // GENERATE PAYMENT 2 Account recipient2 = new Account("XLPYYfxKEiDcybCkFA7jXcxSdePMMoyZLt"); signature = PaymentTransaction.generateSignature( fork, generator, recipient2, BigDecimal.valueOf(100).setScale(8), BigDecimal.valueOf(1).setScale(8), timestamp); Transaction payment2 = new PaymentTransaction( generator, recipient2, BigDecimal.valueOf(100).setScale(8), BigDecimal.valueOf(1).setScale(8), timestamp, generator.getLastReference(fork), signature); block.addTransaction(payment2); // ADD TRANSACTION SIGNATURE byte[] transactionsSignature = Crypto.getInstance().sign(generator, block.getGeneratorSignature()); block.setTransactionsSignature(transactionsSignature); // CONVERT TO BYTES byte[] rawBlock = block.toBytes(); try { // PARSE FROM BYTES Block parsedBlock = BlockFactory.getInstance().parse(rawBlock); // CHECK INSTANCE assertEquals(false, parsedBlock instanceof GenesisBlock); // CHECK SIGNATURE assertEquals(true, Arrays.equals(block.getSignature(), parsedBlock.getSignature())); // CHECK GENERATOR assertEquals(block.getGenerator().getAddress(), parsedBlock.getGenerator().getAddress()); // CHECK BASE TARGET assertEquals(block.getGeneratingBalance(), parsedBlock.getGeneratingBalance()); // CHECK FEE assertEquals(block.getTotalFee(), parsedBlock.getTotalFee()); // CHECK REFERENCE assertEquals(true, Arrays.equals(block.getReference(), parsedBlock.getReference())); // CHECK TIMESTAMP assertEquals(block.getTimestamp(), parsedBlock.getTimestamp()); // CHECK TRANSACTIONS COUNT assertEquals(block.getTransactionCount(), parsedBlock.getTransactionCount()); } catch (Exception e) { fail("Exception while parsing transaction."); } // PARSE TRANSACTION FROM WRONG BYTES rawBlock = new byte[50]; try { // PARSE FROM BYTES BlockFactory.getInstance().parse(rawBlock); // FAIL fail("this should throw an exception"); } catch (Exception e) { // EXCEPTION IS THROWN OKE } }
public boolean isValid(DBSet db) { // CHECK IF PARENT EXISTS if (this.reference == null || this.getParent(db) == null) { return false; } // CHECK IF TIMESTAMP IS VALID -500 MS ERROR MARGIN TIME if (this.timestamp - 500 > NTP.getTime() || this.timestamp < this.getParent(db).timestamp) { return false; } // CHECK IF TIMESTAMP REST SAME AS PARENT TIMESTAMP REST if (this.timestamp % 1000 != this.getParent(db).timestamp % 1000) { return false; } // CHECK IF GENERATING BALANCE IS CORRECT if (this.generatingBalance != BlockGenerator.getNextBlockGeneratingBalance(db, this.getParent(db))) { return false; } // CHECK IF VERSION IS CORRECT if (this.version != this.getParent(db).getNextBlockVersion(db)) { return false; } if (this.version < 2 && (this.atBytes.length > 0 || this.atFees != 0)) { return false; } // CREATE TARGET byte[] targetBytes = new byte[32]; Arrays.fill(targetBytes, Byte.MAX_VALUE); BigInteger target = new BigInteger(1, targetBytes); // DIVIDE TARGET BY BASE TARGET BigInteger baseTarget = BigInteger.valueOf(BlockGenerator.getBaseTarget(this.generatingBalance)); target = target.divide(baseTarget); // MULTIPLY TARGET BY USER BALANCE target = target.multiply(this.generator.getGeneratingBalance(db).toBigInteger()); // MULTIPLE TARGET BY GUESSES long guesses = (this.timestamp - this.getParent(db).getTimestamp()) / 1000; BigInteger lowerTarget = target.multiply(BigInteger.valueOf(guesses - 1)); target = target.multiply(BigInteger.valueOf(guesses)); // CONVERT PROOF HASH TO BIGINT BigInteger hashValue = new BigInteger(1, getProofHash()); // CHECK IF HASH LOWER THEN TARGET if (hashValue.compareTo(target) >= 0) { return false; } // CHECK IF FIRST BLOCK OF USER if (hashValue.compareTo(lowerTarget) < 0) { return false; } if (this.atBytes != null && this.atBytes.length > 0) { try { AT_Block atBlock = AT_Controller.validateATs( this.getBlockATs(), db.getBlockMap().getLastBlock().getHeight(db) + 1, db); this.atFees = atBlock.getTotalFees(); } catch (NoSuchAlgorithmException | AT_Exception e) { e.printStackTrace(); return false; } } // CHECK TRANSACTIONS DBSet fork = db.fork(); for (Transaction transaction : this.getTransactions()) { // CHECK IF NOT GENESISTRANSACTION if (transaction instanceof GenesisTransaction) { return false; } Integer min = 0; if (db.getBlockMap().getParentList() != null) { min = AT_API_Platform_Impl.getForkHeight(db); } // CHECK IF VALID if (transaction instanceof DeployATTransaction) { DeployATTransaction atTx = (DeployATTransaction) transaction; if (atTx.isValid(fork, min) != Transaction.VALIDATE_OK) { return false; } } else if (transaction.isValid(fork) != Transaction.VALIDATE_OK) { return false; } // CHECK TIMESTAMP AND DEADLINE if (transaction.getTimestamp() > this.timestamp || transaction.getDeadline() <= this.timestamp) { return false; } // PROCESS TRANSACTION IN MEMORYDB TO MAKE SURE OTHER TRANSACTIONS VALIDATE PROPERLY transaction.process(fork); } // BLOCK IS VALID return true; }