private void createNewStore(NetworkParameters params, File file) throws BlockStoreException {
   // Create a new block store if the file wasn't found or anything went wrong whilst reading.
   blockCache.clear();
   try {
     if (file.exists()) {
       if (!file.delete())
         throw new BlockStoreException("Could not delete old store in order to recreate it");
     }
     // Create fresh. The d makes writes synchronous.
     this.file = new RandomAccessFile(file, "rwd");
     this.channel = this.file.getChannel();
     lock();
     this.file.write(FILE_FORMAT_VERSION);
   } catch (IOException e1) {
     // We could not load a block store nor could we create a new one!
     throw new BlockStoreException(e1);
   }
   try {
     // Set up the genesis block. When we start out fresh, it is by definition the top of the
     // chain.
     Block genesis = params.genesisBlock.cloneAsHeader();
     StoredBlock storedGenesis = new StoredBlock(genesis, genesis.getWork(), 0);
     this.chainHead = storedGenesis.getHeader().getHash();
     this.file.write(this.chainHead.getBytes());
     put(storedGenesis);
   } catch (VerificationException e1) {
     throw new RuntimeException(e1); // Cannot happen.
   } catch (IOException e) {
     throw new BlockStoreException(e);
   }
 }
 public synchronized void setChainHead(StoredBlock chainHead) throws BlockStoreException {
   ensureOpen();
   try {
     this.chainHead = chainHead.getHeader().getHash();
     // Write out new hash to the first 32 bytes of the file past one (first byte is version
     // number).
     channel.write(ByteBuffer.wrap(this.chainHead.getBytes()), 1);
   } catch (IOException e) {
     throw new BlockStoreException(e);
   }
 }
 public synchronized void put(StoredBlock block) throws BlockStoreException {
   ensureOpen();
   try {
     Sha256Hash hash = block.getHeader().getHash();
     // Append to the end of the file.
     Record.write(channel, block);
     blockCache.put(hash, block);
   } catch (IOException e) {
     throw new BlockStoreException(e);
   }
 }
 public static void write(FileChannel channel, StoredBlock block) throws IOException {
   ByteBuffer buf = ByteBuffer.allocate(Record.SIZE);
   buf.putInt(block.getHeight());
   byte[] chainWorkBytes = block.getChainWork().toByteArray();
   checkState(
       chainWorkBytes.length <= CHAIN_WORK_BYTES, "Ran out of space to store chain work!");
   if (chainWorkBytes.length < CHAIN_WORK_BYTES) {
     // Pad to the right size.
     buf.put(EMPTY_BYTES, 0, CHAIN_WORK_BYTES - chainWorkBytes.length);
   }
   buf.put(chainWorkBytes);
   buf.put(block.getHeader().cloneAsHeader().feathercoinSerialize());
   buf.position(0);
   channel.position(channel.size());
   if (channel.write(buf) < Record.SIZE) throw new IOException("Failed to write record!");
   channel.position(channel.size() - Record.SIZE);
 }