@Test
public void testUpdateLength() {
NetworkParameters params = UnitTestParams.get();
Block block =
params
.getGenesisBlock()
.createNextBlockWithCoinbase(
Block.BLOCK_VERSION_GENESIS, new ECKey().getPubKey(), Block.BLOCK_HEIGHT_GENESIS);
assertEquals(block.bitcoinSerialize().length, block.length);
final int origBlockLen = block.length;
Transaction tx = new Transaction(params);
// this is broken until the transaction has > 1 input + output (which is required anyway...)
// assertTrue(tx.length == tx.bitcoinSerialize().length && tx.length == 8);
byte[] outputScript = new byte[10];
Arrays.fill(outputScript, (byte) ScriptOpCodes.OP_FALSE);
tx.addOutput(new TransactionOutput(params, null, Coin.SATOSHI, outputScript));
tx.addInput(
new TransactionInput(
params,
null,
new byte[] {(byte) ScriptOpCodes.OP_FALSE},
new TransactionOutPoint(params, 0, Sha256Hash.of(new byte[] {1}))));
int origTxLength = 8 + 2 + 8 + 1 + 10 + 40 + 1 + 1;
assertEquals(tx.bitcoinSerialize().length, tx.length);
assertEquals(origTxLength, tx.length);
block.addTransaction(tx);
assertEquals(block.bitcoinSerialize().length, block.length);
assertEquals(origBlockLen + tx.length, block.length);
block
.getTransactions()
.get(1)
.getInputs()
.get(0)
.setScriptBytes(new byte[] {(byte) ScriptOpCodes.OP_FALSE, (byte) ScriptOpCodes.OP_FALSE});
assertEquals(block.length, origBlockLen + tx.length);
assertEquals(tx.length, origTxLength + 1);
block.getTransactions().get(1).getInputs().get(0).setScriptBytes(new byte[] {});
assertEquals(block.length, block.bitcoinSerialize().length);
assertEquals(block.length, origBlockLen + tx.length);
assertEquals(tx.length, origTxLength - 1);
block
.getTransactions()
.get(1)
.addInput(
new TransactionInput(
params,
null,
new byte[] {(byte) ScriptOpCodes.OP_FALSE},
new TransactionOutPoint(params, 0, Sha256Hash.of(new byte[] {1}))));
assertEquals(block.length, origBlockLen + tx.length);
assertEquals(tx.length, origTxLength + 41); // - 1 + 40 + 1 + 1
}
@Test
public void testHeaderParse() throws Exception {
Block block = params.getDefaultSerializer().makeBlock(blockBytes);
Block header = block.cloneAsHeader();
Block reparsed = params.getDefaultSerializer().makeBlock(header.bitcoinSerialize());
assertEquals(reparsed, header);
}
@Test
public void testBitcoinSerialization() throws Exception {
// We have to be able to reserialize everything exactly as we found it for hashing to work. This
// test also
// proves that transaction serialization works, along with all its subobjects like scripts and
// in/outpoints.
//
// NB: This tests the bitcoin serialization protocol.
Block block = params.getDefaultSerializer().makeBlock(blockBytes);
assertTrue(Arrays.equals(blockBytes, block.bitcoinSerialize()));
}
@Before
public void setUp() throws Exception {
unitTestParams = UnitTestParams.get();
wallet = new Wallet(unitTestParams);
wallet.addKey(new ECKey());
resetBlockStore();
Transaction tx1 =
createFakeTx(
unitTestParams,
Utils.toNanoCoins(2, 0),
wallet.getKeys().get(0).toAddress(unitTestParams));
// add a second input so can test granularity of byte cache.
Transaction prevTx = new Transaction(unitTestParams);
TransactionOutput prevOut =
new TransactionOutput(
unitTestParams,
prevTx,
Utils.toNanoCoins(1, 0),
wallet.getKeys().get(0).toAddress(unitTestParams));
prevTx.addOutput(prevOut);
// Connect it.
tx1.addInput(prevOut);
Transaction tx2 =
createFakeTx(
unitTestParams, Utils.toNanoCoins(1, 0), new ECKey().toAddress(unitTestParams));
Block b1 = createFakeBlock(blockStore, tx1, tx2).block;
BitcoinSerializer bs = new BitcoinSerializer(unitTestParams);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
bs.serialize(tx1, bos);
tx1BytesWithHeader = bos.toByteArray();
tx1Bytes = tx1.bitcoinSerialize();
bos.reset();
bs.serialize(tx2, bos);
tx2BytesWithHeader = bos.toByteArray();
tx2Bytes = tx2.bitcoinSerialize();
bos.reset();
bs.serialize(b1, bos);
b1BytesWithHeader = bos.toByteArray();
b1Bytes = b1.bitcoinSerialize();
}
