Pull latest bitcoinj upstream and reimplement PoW/SPV shit, as well as P2SH-P2WPKH

Author: pokkst

core/build.gradle

@@ -15,6 +15,7 @@ dependencies {
     api 'com.google.protobuf:protobuf-javalite:3.22.3'
     implementation 'org.slf4j:slf4j-api:2.0.7'
     implementation 'net.jcip:jcip-annotations:1.0'
+    implementation 'com.lambdaworks:scrypt:1.4.0'
     testImplementation 'junit:junit:4.13.2'
     testImplementation 'org.easymock:easymock:5.1.0'
     testImplementation 'com.fasterxml.jackson.core:jackson-databind:2.14.0'

core/src/main/java/org/bitcoinj/base/BitcoinNetwork.java

@@ -55,7 +55,7 @@ public enum BitcoinNetwork implements Network {
     /**
      * The maximum number of coins to be generated
      */
-    private static final long MAX_COINS = 21_000_000;
+    private static final long MAX_COINS = 84_000_000;
 
     /**
      * The maximum money to be generated
@@ -140,7 +140,12 @@ public int legacyAddressHeader() {
      * @see LegacyAddress.P2SHHeader
      */
     public int legacyP2SHHeader() {
-        return LegacyAddress.P2SHHeader.ofNetwork(this).headerByte();
+        return this == MAINNET ? LegacyAddress.P2SHHeader.X5.headerByte() : LegacyAddress.P2SHHeader.X196.headerByte();
+    }
+
+    @Override
+    public int legacyP2SHHeader2() {
+        return this == MAINNET ? LegacyAddress.P2SHHeader.X50.headerByte() : LegacyAddress.P2SHHeader.X58.headerByte();
     }
 
     /**

core/src/main/java/org/bitcoinj/base/DefaultAddressParser.java

@@ -141,7 +141,7 @@ private LegacyAddress parseBase58AnyNetwork(String base58)
             throws AddressFormatException, AddressFormatException.WrongNetwork {
         int version = Base58.decodeChecked(base58)[0] & 0xFF;
         return base58Networks.stream()
-                .filter(n -> version == n.legacyAddressHeader() || version == n.legacyP2SHHeader())
+                .filter(n -> version == n.legacyAddressHeader() || version == n.legacyP2SHHeader() || version == n.legacyP2SHHeader2())
                 .findFirst()
                 .map(n -> LegacyAddress.fromBase58(base58, n))
                 .orElseThrow(() -> new AddressFormatException.InvalidPrefix("No network found for " + base58));

core/src/main/java/org/bitcoinj/base/LegacyAddress.java

@@ -195,7 +195,7 @@ public static LegacyAddress fromBase58(String base58, @Nonnull Network network)
         byte[] bytes = Arrays.copyOfRange(versionAndDataBytes, 1, versionAndDataBytes.length);
         if (version == network.legacyAddressHeader())
             return new LegacyAddress(network, false, bytes);
-        else if (version == network.legacyP2SHHeader())
+        else if (version == network.legacyP2SHHeader() || version == network.legacyP2SHHeader2())
             return new LegacyAddress(network, true, bytes);
         throw new AddressFormatException.WrongNetwork(version);
     }
@@ -216,7 +216,7 @@ public Network network() {
      * @return version header as one byte
      */
     public int getVersion() {
-        return p2sh ? network.legacyP2SHHeader() : network.legacyAddressHeader();
+        return p2sh ? network.legacyP2SHHeader2() : network.legacyAddressHeader();
     }
 
     /**
@@ -331,7 +331,9 @@ public int headerByte() {
      */
     public enum P2SHHeader {
         X5(5, MAINNET),
-        X196(196, TESTNET, SIGNET, REGTEST);
+        X196(196, TESTNET, SIGNET, REGTEST),
+        X50(50, MAINNET),
+        X58(58, TESTNET, SIGNET, REGTEST);
 
         private final int headerByte;
         private final EnumSet<BitcoinNetwork> networks;

core/src/main/java/org/bitcoinj/base/Network.java

@@ -40,6 +40,8 @@ public interface Network {
      */
     int legacyP2SHHeader();
 
+    int legacyP2SHHeader2();
+
     /**
      * Human-readable part (HRP) of bech32 encoded segwit addresses for this network.
      * @return HRP (lowercase)

core/src/main/java/org/bitcoinj/base/ScriptType.java

@@ -36,7 +36,8 @@ public enum ScriptType {
     P2SH("sh", 3),      // pay to script hash
     P2WPKH("wpkh", 4),  // pay to witness pubkey hash
     P2WSH("wsh", 5),    // pay to witness script hash
-    P2TR("tr", 6);      // pay to taproot
+    P2TR("tr", 6),      // pay to taproot
+    P2SH_P2WPKH("p2sh-p2wpkh", 6);
 
     private final String scriptIdentifierString;
 

core/src/main/java/org/bitcoinj/base/internal/ByteUtils.java

@@ -17,6 +17,7 @@
 package org.bitcoinj.base.internal;
 
 import com.google.common.io.BaseEncoding;
+import com.lambdaworks.crypto.SCrypt;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -742,4 +743,12 @@ public static Comparator<byte[]> arrayUnsignedComparator() {
     private static int compareUnsigned(byte a, byte b) {
         return Byte.toUnsignedInt(a) - Byte.toUnsignedInt(b);
     }
+
+    public static byte[] scryptDigest(byte[] input) {
+        try {
+            return SCrypt.scrypt(input, input, 1024, 1, 1, 32);
+        } catch (Exception e) {
+            return null;
+        }
+    }
 }

core/src/main/java/org/bitcoinj/core/Block.java

@@ -133,6 +133,7 @@ public enum VerifyFlag {
 
     /** Stores the hash of the block. If null, getHash() will recalculate it. */
     private Sha256Hash hash;
+    private Sha256Hash scryptHash;
 
     /**
      * Deserialize this message from a given payload.
@@ -151,13 +152,20 @@ public static Block read(ByteBuffer payload) throws BufferUnderflowException, Pr
         long difficultyTarget = ByteUtils.readUint32(payload);
         long nonce = ByteUtils.readUint32(payload);
         payload.reset(); // read again from the mark for the hash
-        Sha256Hash hash = Sha256Hash.wrapReversed(Sha256Hash.hashTwice(Buffers.readBytes(payload, HEADER_SIZE)));
+        byte[] header = Buffers.readBytes(payload, HEADER_SIZE);
+        Sha256Hash hash = Sha256Hash.wrapReversed(Sha256Hash.hashTwice(header));
+        byte[] scryptDigest = ByteUtils.scryptDigest(header);
+        if(scryptDigest == null) {
+            throw new RuntimeException("Scrypt digest is null.");
+        }
+        Sha256Hash scryptHash = Sha256Hash.wrap(ByteUtils.reverseBytes(scryptDigest));
         // transactions
         List<Transaction> transactions = payload.hasRemaining() ? // otherwise this message is just a header
                 readTransactions(payload) :
                 null;
         Block block = new Block(version, prevBlockHash, merkleRoot, time, difficultyTarget, nonce, transactions);
         block.hash = hash;
+        block.scryptHash = scryptHash;
         return block;
     }
 
@@ -242,14 +250,14 @@ public static Block createGenesis() {
     //
     //   "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks"
     private static final byte[] genesisTxInputScriptBytes = ByteUtils.parseHex
-                ("04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73");
+                ("04ffff001d0104404e592054696d65732030352f4f63742f32303131205374657665204a6f62732c204170706c65e280997320566973696f6e6172792c2044696573206174203536");
 
     private static final byte[] genesisTxScriptPubKeyBytes;
     static {
         ByteArrayOutputStream scriptPubKeyBytes = new ByteArrayOutputStream();
         try {
             Script.writeBytes(scriptPubKeyBytes, ByteUtils.parseHex
-                    ("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"));
+                    ("040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9"));
         } catch (IOException e) {
             throw new RuntimeException(e); // Cannot happen.
         }
@@ -307,6 +315,7 @@ protected void unCache() {
 
     private void unCacheHeader() {
         hash = null;
+        scryptHash = null;
     }
 
     private void unCacheTransactions() {
@@ -318,6 +327,10 @@ private void unCacheTransactions() {
         merkleRoot = null;
     }
 
+    /**
+     * Calculates the block hash by serializing the block and hashing the
+     * resulting bytes.
+     */
     /**
      * Calculates the block hash by serializing the block and hashing the
      * resulting bytes.
@@ -332,6 +345,20 @@ private Sha256Hash calculateHash() {
         }
     }
 
+    private Sha256Hash calculateScryptHash() {
+        try {
+            ByteArrayOutputStream bos = new ByteArrayOutputStream(HEADER_SIZE);
+            writeHeader(bos);
+            byte[] scryptDigest = ByteUtils.scryptDigest(bos.toByteArray());
+            if(scryptDigest == null) {
+                throw new RuntimeException("Scrypt digest is null.");
+            }
+            return Sha256Hash.wrap(ByteUtils.reverseBytes(scryptDigest));
+        } catch (IOException e) {
+            throw new RuntimeException(e); // Cannot happen.
+        }
+    }
+
     /**
      * Returns the hash of the block (which for a valid, solved block should be below the target) in the form seen on
      * the block explorer. If you call this on block 1 in the mainnet chain
@@ -341,6 +368,10 @@ public String getHashAsString() {
         return getHash().toString();
     }
 
+    public String getScryptHashAsString() {
+        return getScryptHash().toString();
+    }
+
     /**
      * Returns the hash of the block (which for a valid, solved block should be
      * below the target). Big endian.
@@ -351,6 +382,12 @@ public Sha256Hash getHash() {
         return hash;
     }
 
+    public Sha256Hash getScryptHash() {
+        if (scryptHash == null)
+            scryptHash = calculateScryptHash();
+        return scryptHash;
+    }
+
     /**
      * The number that is one greater than the largest representable SHA-256
      * hash.
@@ -383,6 +420,7 @@ public Block cloneAsHeader() {
         block.merkleRoot = getMerkleRoot();
         block.hash = getHash();
         block.transactions = null;
+        block.scryptHash = getScryptHash();
         return block;
     }
 
@@ -456,10 +494,6 @@ public BigInteger getDifficultyTargetAsInteger() {
 
     /** Returns true if the hash of the block is OK (lower than difficulty target). */
     protected boolean checkProofOfWork(boolean throwException) throws VerificationException {
-        // shortcut for unit-testing
-        if (Context.get().isRelaxProofOfWork())
-            return true;
-
         // This part is key - it is what proves the block was as difficult to make as it claims
         // to be. Note however that in the context of this function, the block can claim to be
         // as difficult as it wants to be .... if somebody was able to take control of our network
@@ -470,11 +504,11 @@ protected boolean checkProofOfWork(boolean throwException) throws VerificationEx
         // field is of the right value. This requires us to have the preceding blocks.
         BigInteger target = getDifficultyTargetAsInteger();
 
-        BigInteger h = getHash().toBigInteger();
+        BigInteger h = getScryptHash().toBigInteger();
         if (h.compareTo(target) > 0) {
             // Proof of work check failed!
             if (throwException)
-                throw new VerificationException("Hash is higher than target: " + getHashAsString() + " vs "
+                throw new VerificationException("Hash is higher than target: " + getScryptHashAsString() + " vs "
                         + target.toString(16));
             else
                 return false;
@@ -659,6 +693,7 @@ void setMerkleRoot(Sha256Hash value) {
         unCacheHeader();
         merkleRoot = value;
         hash = null;
+        scryptHash = null;
     }
 
     /**
@@ -689,6 +724,7 @@ else if (runSanityChecks && transactions.size() > 0 && t.isCoinBase())
         // Force a recalculation next time the values are needed.
         merkleRoot = null;
         hash = null;
+        scryptHash = null;
     }
 
     /** Returns the version of the block data structure as defined by the Bitcoin protocol. */
@@ -708,6 +744,7 @@ void setPrevBlockHash(Sha256Hash prevBlockHash) {
         unCacheHeader();
         this.prevBlockHash = prevBlockHash;
         this.hash = null;
+        this.scryptHash = null;
     }
 
     /**
@@ -741,6 +778,7 @@ public void setTime(Instant time) {
         unCacheHeader();
         this.time = time.truncatedTo(ChronoUnit.SECONDS); // convert to Bitcoin time
         this.hash = null;
+        this.scryptHash = null;
     }
 
     /**
@@ -762,6 +800,7 @@ public void setDifficultyTarget(long compactForm) {
         unCacheHeader();
         this.difficultyTarget = compactForm;
         this.hash = null;
+        this.scryptHash = null;
     }
 
     /**
@@ -778,6 +817,7 @@ public void setNonce(long nonce) {
         unCacheHeader();
         this.nonce = nonce;
         this.hash = null;
+        this.scryptHash = null;
     }
 
     /** Returns an unmodifiable list of transactions held in this block, or null if this object represents just a header. */

core/src/main/java/org/bitcoinj/core/CheckpointManager.java

@@ -44,10 +44,7 @@
 import java.security.MessageDigest;
 import java.time.Instant;
 import java.time.temporal.ChronoUnit;
-import java.util.Arrays;
-import java.util.Map;
-import java.util.Objects;
-import java.util.TreeMap;
+import java.util.*;
 
 import static org.bitcoinj.base.internal.Preconditions.checkArgument;
 import static org.bitcoinj.base.internal.Preconditions.checkState;
@@ -216,6 +213,43 @@ public StoredBlock getCheckpointBefore(long timeSecs) {
          return getCheckpointBefore(Instant.ofEpochSecond(timeSecs));
     }
 
+    public List<StoredBlock> getCheckpointsBefore(Instant time) {
+        try {
+            ArrayList<StoredBlock> checkpointsBefore = new ArrayList<>();
+            checkArgument(time.isAfter(params.getGenesisBlock().time()));
+            // This is thread safe because the map never changes after creation.
+            Map.Entry<Instant, StoredBlock> entry = checkpoints.floorEntry(time);
+            if (entry != null) {
+                StoredBlock mostRecentCheckpointBlock = entry.getValue();
+                StoredBlock blockBefore = getBlockBefore(mostRecentCheckpointBlock, checkpoints);
+                checkpointsBefore.add(blockBefore);
+                checkpointsBefore.add(mostRecentCheckpointBlock);
+                return checkpointsBefore;
+            }
+            Block genesis = params.getGenesisBlock().cloneAsHeader();
+            checkpointsBefore.add(new StoredBlock(genesis, genesis.getWork(), 0));
+            return checkpointsBefore;
+        } catch (VerificationException e) {
+            throw new RuntimeException(e);  // Cannot happen.
+        }
+    }
+
+    public StoredBlock getBlockBefore(StoredBlock block, TreeMap<Instant, StoredBlock> checkpoints) {
+        /*
+        Litecoin does this weird thing with the difficulty adjustment algorithm.
+        In Bitcoin, upon time for the difficulty to adjust (every 2016 blocks), it actually goes back 2015 blocks to calculate.
+        In Litecoin, it goes a full 2016 blocks, so for the checkpoint manager to fully work in litecoinj, we need both the actual
+        block where the difficulty changes, and the block before it.
+         */
+        int heightToLookFor = block.getHeight()-1;
+        for(StoredBlock checkpoint : checkpoints.values()) {
+            if(checkpoint.getHeight() == heightToLookFor) {
+                return checkpoint;
+            }
+        }
+        return null;
+    }
+
     /** Returns the number of checkpoints that were loaded. */
     public int numCheckpoints() {
         return checkpoints.size();
@@ -247,9 +281,13 @@ public static void checkpoint(NetworkParameters params, InputStream checkpoints,
 
         BufferedInputStream stream = new BufferedInputStream(checkpoints);
         CheckpointManager manager = new CheckpointManager(params, stream);
-        StoredBlock checkpoint = manager.getCheckpointBefore(time);
-        store.put(checkpoint);
-        store.setChainHead(checkpoint);
+        List<StoredBlock> checkpointsBefore = manager.getCheckpointsBefore(time);
+        for(int i = 0; i < checkpointsBefore.size(); i++) {
+            store.put(checkpointsBefore.get(i));
+            if(i == checkpointsBefore.size()-1) {
+                store.setChainHead(checkpointsBefore.get(i));
+            }
+        }
     }
 
     /** @deprecated use {@link #checkpoint(NetworkParameters, InputStream, BlockStore, Instant)} */