target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void testToString() { Assert.assertEquals("6 signatures pending federation (complete)", pendingFederation.toString()); PendingFederation otherPendingFederation = new PendingFederation(FederationTestUtils.getFederationMembersFromPks(100)); Assert.assertEquals("1 signatures pending federation (incomplete)", otherPendingFederation.toString()); }
|
@Override public String toString() { return String.format("%d signatures pending federation (%s)", members.size(), isComplete() ? "complete" : "incomplete"); }
|
PendingFederation { @Override public String toString() { return String.format("%d signatures pending federation (%s)", members.size(), isComplete() ? "complete" : "incomplete"); } }
|
PendingFederation { @Override public String toString() { return String.format("%d signatures pending federation (%s)", members.size(), isComplete() ? "complete" : "incomplete"); } PendingFederation(List<FederationMember> members); }
|
PendingFederation { @Override public String toString() { return String.format("%d signatures pending federation (%s)", members.size(), isComplete() ? "complete" : "incomplete"); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
PendingFederation { @Override public String toString() { return String.format("%d signatures pending federation (%s)", members.size(), isComplete() ? "complete" : "incomplete"); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
@Test public void buildFederation_ok_a() { PendingFederation otherPendingFederation = new PendingFederation(FederationTestUtils.getFederationMembersFromPks(100, 200, 300, 400, 500, 600)); Federation expectedFederation = new Federation( FederationTestUtils.getFederationMembersFromPks(100, 200, 300, 400, 500, 600), Instant.ofEpochMilli(1234L), 0L, NetworkParameters.fromID(NetworkParameters.ID_REGTEST) ); Assert.assertEquals( expectedFederation, otherPendingFederation.buildFederation( Instant.ofEpochMilli(1234L), 0L, NetworkParameters.fromID(NetworkParameters.ID_REGTEST) ) ); }
|
public Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams) { if (!this.isComplete()) { throw new IllegalStateException("PendingFederation is incomplete"); } return new Federation( members, creationTime, blockNumber, btcParams ); }
|
PendingFederation { public Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams) { if (!this.isComplete()) { throw new IllegalStateException("PendingFederation is incomplete"); } return new Federation( members, creationTime, blockNumber, btcParams ); } }
|
PendingFederation { public Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams) { if (!this.isComplete()) { throw new IllegalStateException("PendingFederation is incomplete"); } return new Federation( members, creationTime, blockNumber, btcParams ); } PendingFederation(List<FederationMember> members); }
|
PendingFederation { public Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams) { if (!this.isComplete()) { throw new IllegalStateException("PendingFederation is incomplete"); } return new Federation( members, creationTime, blockNumber, btcParams ); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
PendingFederation { public Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams) { if (!this.isComplete()) { throw new IllegalStateException("PendingFederation is incomplete"); } return new Federation( members, creationTime, blockNumber, btcParams ); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
@Test public void buildFederation_ok_b() { PendingFederation otherPendingFederation = new PendingFederation(FederationTestUtils.getFederationMembersFromPks( 100, 200, 300, 400, 500, 600, 700, 800, 900 )); Federation expectedFederation = new Federation( FederationTestUtils.getFederationMembersFromPks(100, 200, 300, 400, 500, 600, 700, 800, 900), Instant.ofEpochMilli(1234L), 0L, NetworkParameters.fromID(NetworkParameters.ID_REGTEST) ); Assert.assertEquals( expectedFederation, otherPendingFederation.buildFederation( Instant.ofEpochMilli(1234L), 0L, NetworkParameters.fromID(NetworkParameters.ID_REGTEST) ) ); }
|
public Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams) { if (!this.isComplete()) { throw new IllegalStateException("PendingFederation is incomplete"); } return new Federation( members, creationTime, blockNumber, btcParams ); }
|
PendingFederation { public Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams) { if (!this.isComplete()) { throw new IllegalStateException("PendingFederation is incomplete"); } return new Federation( members, creationTime, blockNumber, btcParams ); } }
|
PendingFederation { public Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams) { if (!this.isComplete()) { throw new IllegalStateException("PendingFederation is incomplete"); } return new Federation( members, creationTime, blockNumber, btcParams ); } PendingFederation(List<FederationMember> members); }
|
PendingFederation { public Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams) { if (!this.isComplete()) { throw new IllegalStateException("PendingFederation is incomplete"); } return new Federation( members, creationTime, blockNumber, btcParams ); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
PendingFederation { public Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams) { if (!this.isComplete()) { throw new IllegalStateException("PendingFederation is incomplete"); } return new Federation( members, creationTime, blockNumber, btcParams ); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
@Test public void testGetPrivKeyBytes() { ECKey key = new ECKey(); assertNotNull(key.getPrivKeyBytes()); assertEquals(32, key.getPrivKeyBytes().length); }
|
@Nullable public byte[] getPrivKeyBytes() { return bigIntegerToBytes(priv, 32); }
|
ECKey { @Nullable public byte[] getPrivKeyBytes() { return bigIntegerToBytes(priv, 32); } }
|
ECKey { @Nullable public byte[] getPrivKeyBytes() { return bigIntegerToBytes(priv, 32); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); }
|
ECKey { @Nullable public byte[] getPrivKeyBytes() { return bigIntegerToBytes(priv, 32); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); }
|
ECKey { @Nullable public byte[] getPrivKeyBytes() { return bigIntegerToBytes(priv, 32); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); static final ECDomainParameters CURVE; static final BigInteger HALF_CURVE_ORDER; }
|
@Test public void buildFederation_incomplete() { PendingFederation otherPendingFederation = new PendingFederation(FederationTestUtils.getFederationMembersFromPks(100)); try { otherPendingFederation.buildFederation(Instant.ofEpochMilli(12L), 0L, NetworkParameters.fromID(NetworkParameters.ID_REGTEST)); } catch (Exception e) { Assert.assertEquals("PendingFederation is incomplete", e.getMessage()); return; } Assert.fail(); }
|
public Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams) { if (!this.isComplete()) { throw new IllegalStateException("PendingFederation is incomplete"); } return new Federation( members, creationTime, blockNumber, btcParams ); }
|
PendingFederation { public Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams) { if (!this.isComplete()) { throw new IllegalStateException("PendingFederation is incomplete"); } return new Federation( members, creationTime, blockNumber, btcParams ); } }
|
PendingFederation { public Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams) { if (!this.isComplete()) { throw new IllegalStateException("PendingFederation is incomplete"); } return new Federation( members, creationTime, blockNumber, btcParams ); } PendingFederation(List<FederationMember> members); }
|
PendingFederation { public Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams) { if (!this.isComplete()) { throw new IllegalStateException("PendingFederation is incomplete"); } return new Federation( members, creationTime, blockNumber, btcParams ); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
PendingFederation { public Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams) { if (!this.isComplete()) { throw new IllegalStateException("PendingFederation is incomplete"); } return new Federation( members, creationTime, blockNumber, btcParams ); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
@PrepareForTest({ BridgeSerializationUtils.class }) @Test public void getHash() { PowerMockito.mockStatic(BridgeSerializationUtils.class); PowerMockito.when(BridgeSerializationUtils.serializePendingFederationOnlyBtcKeys(pendingFederation)).thenReturn(new byte[] { (byte) 0xaa }); Keccak256 expectedHash = new Keccak256(HashUtil.keccak256(new byte[] { (byte) 0xaa })); Assert.assertEquals(expectedHash, pendingFederation.getHash()); }
|
public Keccak256 getHash() { byte[] encoded = BridgeSerializationUtils.serializePendingFederationOnlyBtcKeys(this); return new Keccak256(HashUtil.keccak256(encoded)); }
|
PendingFederation { public Keccak256 getHash() { byte[] encoded = BridgeSerializationUtils.serializePendingFederationOnlyBtcKeys(this); return new Keccak256(HashUtil.keccak256(encoded)); } }
|
PendingFederation { public Keccak256 getHash() { byte[] encoded = BridgeSerializationUtils.serializePendingFederationOnlyBtcKeys(this); return new Keccak256(HashUtil.keccak256(encoded)); } PendingFederation(List<FederationMember> members); }
|
PendingFederation { public Keccak256 getHash() { byte[] encoded = BridgeSerializationUtils.serializePendingFederationOnlyBtcKeys(this); return new Keccak256(HashUtil.keccak256(encoded)); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
PendingFederation { public Keccak256 getHash() { byte[] encoded = BridgeSerializationUtils.serializePendingFederationOnlyBtcKeys(this); return new Keccak256(HashUtil.keccak256(encoded)); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
@Test public void activations_is_set() { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP124)).thenReturn(true); BridgeSupport bridgeSupport = getBridgeSupport( mock(BridgeConstants.class), mock(BridgeStorageProvider.class), mock(Repository.class), mock(BridgeEventLogger.class), mock(BtcLockSenderProvider.class), mock(Block.class), mock(BtcBlockStoreWithCache.Factory.class), activations); Assert.assertTrue(bridgeSupport.getActivations().isActive(ConsensusRule.RSKIP124)); }
|
@VisibleForTesting ActivationConfig.ForBlock getActivations() { return this.activations; }
|
BridgeSupport { @VisibleForTesting ActivationConfig.ForBlock getActivations() { return this.activations; } }
|
BridgeSupport { @VisibleForTesting ActivationConfig.ForBlock getActivations() { return this.activations; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { @VisibleForTesting ActivationConfig.ForBlock getActivations() { return this.activations; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { @VisibleForTesting ActivationConfig.ForBlock getActivations() { return this.activations; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test(expected = NullPointerException.class) public void voteFeePerKbChange_nullFeeThrows() { BridgeStorageProvider provider = mock(BridgeStorageProvider.class); Transaction tx = mock(Transaction.class); BridgeConstants constants = mock(BridgeConstants.class); AddressBasedAuthorizer authorizer = mock(AddressBasedAuthorizer.class); when(provider.getFeePerKbElection(any())) .thenReturn(new ABICallElection(null)); when(tx.getSender()) .thenReturn(new RskAddress(ByteUtil.leftPadBytes(new byte[]{0x43}, 20))); when(constants.getFeePerKbChangeAuthorizer()) .thenReturn(authorizer); when(authorizer.isAuthorized(tx)) .thenReturn(true); BridgeSupport bridgeSupport = getBridgeSupport(constants, provider); bridgeSupport.voteFeePerKbChange(tx, null); verify(provider, never()).setFeePerKb(any()); }
|
public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void voteFeePerKbChange_unsuccessfulVote_unauthorized() { BridgeStorageProvider provider = mock(BridgeStorageProvider.class); Transaction tx = mock(Transaction.class); BridgeConstants constants = mock(BridgeConstants.class); AddressBasedAuthorizer authorizer = mock(AddressBasedAuthorizer.class); byte[] senderBytes = ByteUtil.leftPadBytes(new byte[]{0x43}, 20); when(provider.getFeePerKbElection(any())) .thenReturn(new ABICallElection(authorizer)); when(tx.getSender()) .thenReturn(new RskAddress(senderBytes)); when(constants.getFeePerKbChangeAuthorizer()) .thenReturn(authorizer); when(authorizer.isAuthorized(tx)) .thenReturn(false); BridgeSupport bridgeSupport = getBridgeSupport(constants, provider); assertThat(bridgeSupport.voteFeePerKbChange(tx, Coin.CENT), is(-10)); verify(provider, never()).setFeePerKb(any()); }
|
public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void voteFeePerKbChange_unsuccessfulVote_negativeFeePerKb() { BridgeStorageProvider provider = mock(BridgeStorageProvider.class); Transaction tx = mock(Transaction.class); BridgeConstants constants = mock(BridgeConstants.class); AddressBasedAuthorizer authorizer = mock(AddressBasedAuthorizer.class); byte[] senderBytes = ByteUtil.leftPadBytes(new byte[]{0x43}, 20); when(provider.getFeePerKbElection(any())) .thenReturn(new ABICallElection(authorizer)); when(tx.getSender()) .thenReturn(new RskAddress(senderBytes)); when(constants.getFeePerKbChangeAuthorizer()) .thenReturn(authorizer); when(authorizer.isAuthorized(tx)) .thenReturn(true); when(authorizer.isAuthorized(tx.getSender())) .thenReturn(true); when(authorizer.getRequiredAuthorizedKeys()) .thenReturn(2); BridgeSupport bridgeSupport = getBridgeSupport(constants, provider); assertThat(bridgeSupport.voteFeePerKbChange(tx, Coin.NEGATIVE_SATOSHI), is(-1)); assertThat(bridgeSupport.voteFeePerKbChange(tx, Coin.ZERO), is(-1)); verify(provider, never()).setFeePerKb(any()); }
|
public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void voteFeePerKbChange_unsuccessfulVote_excessiveFeePerKb() { final long MAX_FEE_PER_KB = 5_000_000L; BridgeStorageProvider provider = mock(BridgeStorageProvider.class); Transaction tx = mock(Transaction.class); BridgeConstants constants = mock(BridgeConstants.class); AddressBasedAuthorizer authorizer = mock(AddressBasedAuthorizer.class); byte[] senderBytes = ByteUtil.leftPadBytes(new byte[]{0x43}, 20); when(provider.getFeePerKbElection(any())) .thenReturn(new ABICallElection(authorizer)); when(tx.getSender()) .thenReturn(new RskAddress(senderBytes)); when(constants.getFeePerKbChangeAuthorizer()) .thenReturn(authorizer); when(authorizer.isAuthorized(tx)) .thenReturn(true); when(authorizer.isAuthorized(tx.getSender())) .thenReturn(true); when(authorizer.getRequiredAuthorizedKeys()) .thenReturn(2); when(constants.getMaxFeePerKb()) .thenReturn(Coin.valueOf(MAX_FEE_PER_KB)); BridgeSupport bridgeSupport = getBridgeSupport(constants, provider); assertThat(bridgeSupport.voteFeePerKbChange(tx, Coin.valueOf(MAX_FEE_PER_KB)), is(1)); assertThat(bridgeSupport.voteFeePerKbChange(tx, Coin.valueOf(MAX_FEE_PER_KB + 1)), is(-2)); verify(provider, never()).setFeePerKb(any()); }
|
public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void voteFeePerKbChange_successfulVote() { final long MAX_FEE_PER_KB = 5_000_000L; BridgeStorageProvider provider = mock(BridgeStorageProvider.class); Transaction tx = mock(Transaction.class); BridgeConstants constants = mock(BridgeConstants.class); AddressBasedAuthorizer authorizer = mock(AddressBasedAuthorizer.class); byte[] senderBytes = ByteUtil.leftPadBytes(new byte[]{0x43}, 20); when(provider.getFeePerKbElection(any())) .thenReturn(new ABICallElection(authorizer)); when(tx.getSender()) .thenReturn(new RskAddress(senderBytes)); when(constants.getFeePerKbChangeAuthorizer()) .thenReturn(authorizer); when(authorizer.isAuthorized(tx)) .thenReturn(true); when(authorizer.isAuthorized(tx.getSender())) .thenReturn(true); when(authorizer.getRequiredAuthorizedKeys()) .thenReturn(2); when(constants.getMaxFeePerKb()) .thenReturn(Coin.valueOf(MAX_FEE_PER_KB)); BridgeSupport bridgeSupport = getBridgeSupport(constants, provider); assertThat(bridgeSupport.voteFeePerKbChange(tx, Coin.CENT), is(1)); verify(provider, never()).setFeePerKb(any()); }
|
public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void voteFeePerKbChange_successfulVoteWithFeeChange() { final long MAX_FEE_PER_KB = 5_000_000L; BridgeStorageProvider provider = mock(BridgeStorageProvider.class); Transaction tx = mock(Transaction.class); BridgeConstants constants = mock(BridgeConstants.class); AddressBasedAuthorizer authorizer = mock(AddressBasedAuthorizer.class); byte[] senderBytes = ByteUtil.leftPadBytes(new byte[]{0x43}, 20); when(provider.getFeePerKbElection(any())) .thenReturn(new ABICallElection(authorizer)); when(tx.getSender()) .thenReturn(new RskAddress(senderBytes)); when(constants.getFeePerKbChangeAuthorizer()) .thenReturn(authorizer); when(authorizer.isAuthorized(tx)) .thenReturn(true); when(authorizer.isAuthorized(tx.getSender())) .thenReturn(true); when(authorizer.getRequiredAuthorizedKeys()) .thenReturn(1); when(constants.getMaxFeePerKb()) .thenReturn(Coin.valueOf(MAX_FEE_PER_KB)); BridgeSupport bridgeSupport = getBridgeSupport(constants, provider); assertThat(bridgeSupport.voteFeePerKbChange(tx, Coin.CENT), is(1)); verify(provider).setFeePerKb(Coin.CENT); }
|
public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public Integer voteFeePerKbChange(Transaction tx, Coin feePerKb) { AddressBasedAuthorizer authorizer = bridgeConstants.getFeePerKbChangeAuthorizer(); if (!authorizer.isAuthorized(tx)) { return FEE_PER_KB_GENERIC_ERROR_CODE; } if(!feePerKb.isPositive()){ return NEGATIVE_FEE_PER_KB_ERROR_CODE; } if(feePerKb.isGreaterThan(bridgeConstants.getMaxFeePerKb())) { return EXCESSIVE_FEE_PER_KB_ERROR_CODE; } ABICallElection feePerKbElection = provider.getFeePerKbElection(authorizer); ABICallSpec feeVote = new ABICallSpec("setFeePerKb", new byte[][]{BridgeSerializationUtils.serializeCoin(feePerKb)}); boolean successfulVote = feePerKbElection.vote(feeVote, tx.getSender()); if (!successfulVote) { return -1; } ABICallSpec winner = feePerKbElection.getWinner(); if (winner == null) { logger.info("Successful fee per kb vote for {}", feePerKb); return 1; } Coin winnerFee; try { winnerFee = BridgeSerializationUtils.deserializeCoin(winner.getArguments()[0]); } catch (Exception e) { logger.warn("Exception deserializing winner feePerKb", e); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (winnerFee == null) { logger.warn("Invalid winner feePerKb: feePerKb can't be null"); return FEE_PER_KB_GENERIC_ERROR_CODE; } if (!winnerFee.equals(feePerKb)) { logger.debug("Winner fee is different than the last vote: maybe you forgot to clear winners"); } logger.info("Fee per kb changed to {}", winnerFee); provider.setFeePerKb(winnerFee); feePerKbElection.clear(); return 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void getLockingCap() { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP134)).thenReturn(true); BridgeConstants constants = mock(BridgeConstants.class); when(constants.getInitialLockingCap()).thenReturn(Coin.SATOSHI); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); when(provider.getLockingCap()).thenReturn(null).thenReturn(constants.getInitialLockingCap()); BridgeSupport bridgeSupport = getBridgeSupport( constants, provider, mock(Repository.class), mock(BridgeEventLogger.class), null, null, activations ); assertEquals(constants.getInitialLockingCap(), bridgeSupport.getLockingCap()); assertEquals(constants.getInitialLockingCap(), bridgeSupport.getLockingCap()); verify(provider, times(1)).setLockingCap(constants.getInitialLockingCap()); }
|
public Coin getLockingCap() { if (activations.isActive(ConsensusRule.RSKIP134) && this.provider.getLockingCap() == null) { logger.debug("Setting initial locking cap value"); this.provider.setLockingCap(bridgeConstants.getInitialLockingCap()); } return this.provider.getLockingCap(); }
|
BridgeSupport { public Coin getLockingCap() { if (activations.isActive(ConsensusRule.RSKIP134) && this.provider.getLockingCap() == null) { logger.debug("Setting initial locking cap value"); this.provider.setLockingCap(bridgeConstants.getInitialLockingCap()); } return this.provider.getLockingCap(); } }
|
BridgeSupport { public Coin getLockingCap() { if (activations.isActive(ConsensusRule.RSKIP134) && this.provider.getLockingCap() == null) { logger.debug("Setting initial locking cap value"); this.provider.setLockingCap(bridgeConstants.getInitialLockingCap()); } return this.provider.getLockingCap(); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public Coin getLockingCap() { if (activations.isActive(ConsensusRule.RSKIP134) && this.provider.getLockingCap() == null) { logger.debug("Setting initial locking cap value"); this.provider.setLockingCap(bridgeConstants.getInitialLockingCap()); } return this.provider.getLockingCap(); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public Coin getLockingCap() { if (activations.isActive(ConsensusRule.RSKIP134) && this.provider.getLockingCap() == null) { logger.debug("Setting initial locking cap value"); this.provider.setLockingCap(bridgeConstants.getInitialLockingCap()); } return this.provider.getLockingCap(); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void testIsIn20PercentRange() { assertTrue(isIn20PercentRange(BigInteger.valueOf(20000), BigInteger.valueOf(24000))); assertTrue(isIn20PercentRange(BigInteger.valueOf(24000), BigInteger.valueOf(20000))); assertFalse(isIn20PercentRange(BigInteger.valueOf(20000), BigInteger.valueOf(25000))); assertTrue(isIn20PercentRange(BigInteger.valueOf(20), BigInteger.valueOf(24))); assertTrue(isIn20PercentRange(BigInteger.valueOf(24), BigInteger.valueOf(20))); assertFalse(isIn20PercentRange(BigInteger.valueOf(20), BigInteger.valueOf(25))); assertTrue(isIn20PercentRange(BigInteger.ZERO, BigInteger.ZERO)); assertFalse(isIn20PercentRange(BigInteger.ZERO, BigInteger.ONE)); assertTrue(isIn20PercentRange(BigInteger.ONE, BigInteger.ZERO)); }
|
public static boolean isIn20PercentRange(BigInteger first, BigInteger second) { BigInteger five = BigInteger.valueOf(5); BigInteger limit = first.add(first.divide(five)); return !isMoreThan(second, limit); }
|
BIUtil { public static boolean isIn20PercentRange(BigInteger first, BigInteger second) { BigInteger five = BigInteger.valueOf(5); BigInteger limit = first.add(first.divide(five)); return !isMoreThan(second, limit); } }
|
BIUtil { public static boolean isIn20PercentRange(BigInteger first, BigInteger second) { BigInteger five = BigInteger.valueOf(5); BigInteger limit = first.add(first.divide(five)); return !isMoreThan(second, limit); } }
|
BIUtil { public static boolean isIn20PercentRange(BigInteger first, BigInteger second) { BigInteger five = BigInteger.valueOf(5); BigInteger limit = first.add(first.divide(five)); return !isMoreThan(second, limit); } static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBI(byte[] data); static BigInteger toBI(long data); static boolean isPositive(BigInteger value); static boolean isCovers(Coin covers, Coin value); static boolean isNotCovers(Coin covers, Coin value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); }
|
BIUtil { public static boolean isIn20PercentRange(BigInteger first, BigInteger second) { BigInteger five = BigInteger.valueOf(5); BigInteger limit = first.add(first.divide(five)); return !isMoreThan(second, limit); } static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBI(byte[] data); static BigInteger toBI(long data); static boolean isPositive(BigInteger value); static boolean isCovers(Coin covers, Coin value); static boolean isNotCovers(Coin covers, Coin value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); }
|
@Test public void increaseLockingCap_unauthorized() { AddressBasedAuthorizer authorizer = mock(AddressBasedAuthorizer.class); when(authorizer.isAuthorized(any(Transaction.class))).thenReturn(false); BridgeConstants constants = mock(BridgeConstants.class); when(constants.getIncreaseLockingCapAuthorizer()).thenReturn(authorizer); BridgeSupport bridgeSupport = getBridgeSupport(constants, mock(BridgeStorageProvider.class), ActivationConfigsForTest.all().forBlock(0)); assertFalse(bridgeSupport.increaseLockingCap(mock(Transaction.class), Coin.SATOSHI)); }
|
public boolean increaseLockingCap(Transaction tx, Coin newCap) { AddressBasedAuthorizer authorizer = bridgeConstants.getIncreaseLockingCapAuthorizer(); if (!authorizer.isAuthorized(tx)) { logger.warn("not authorized address tried to increase locking cap. Address: {}", tx.getSender()); return false; } Coin currentLockingCap = this.getLockingCap(); if (newCap.compareTo(currentLockingCap) < 0) { logger.warn("attempted value doesn't increase locking cap. Attempted: {}", newCap.value); return false; } Coin maxLockingCap = currentLockingCap.multiply(bridgeConstants.getLockingCapIncrementsMultiplier()); if (newCap.compareTo(maxLockingCap) > 0) { logger.warn("attempted value increases locking cap above its limit. Attempted: {}", newCap.value); return false; } logger.info("increased locking cap: {}", newCap.value); this.provider.setLockingCap(newCap); return true; }
|
BridgeSupport { public boolean increaseLockingCap(Transaction tx, Coin newCap) { AddressBasedAuthorizer authorizer = bridgeConstants.getIncreaseLockingCapAuthorizer(); if (!authorizer.isAuthorized(tx)) { logger.warn("not authorized address tried to increase locking cap. Address: {}", tx.getSender()); return false; } Coin currentLockingCap = this.getLockingCap(); if (newCap.compareTo(currentLockingCap) < 0) { logger.warn("attempted value doesn't increase locking cap. Attempted: {}", newCap.value); return false; } Coin maxLockingCap = currentLockingCap.multiply(bridgeConstants.getLockingCapIncrementsMultiplier()); if (newCap.compareTo(maxLockingCap) > 0) { logger.warn("attempted value increases locking cap above its limit. Attempted: {}", newCap.value); return false; } logger.info("increased locking cap: {}", newCap.value); this.provider.setLockingCap(newCap); return true; } }
|
BridgeSupport { public boolean increaseLockingCap(Transaction tx, Coin newCap) { AddressBasedAuthorizer authorizer = bridgeConstants.getIncreaseLockingCapAuthorizer(); if (!authorizer.isAuthorized(tx)) { logger.warn("not authorized address tried to increase locking cap. Address: {}", tx.getSender()); return false; } Coin currentLockingCap = this.getLockingCap(); if (newCap.compareTo(currentLockingCap) < 0) { logger.warn("attempted value doesn't increase locking cap. Attempted: {}", newCap.value); return false; } Coin maxLockingCap = currentLockingCap.multiply(bridgeConstants.getLockingCapIncrementsMultiplier()); if (newCap.compareTo(maxLockingCap) > 0) { logger.warn("attempted value increases locking cap above its limit. Attempted: {}", newCap.value); return false; } logger.info("increased locking cap: {}", newCap.value); this.provider.setLockingCap(newCap); return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public boolean increaseLockingCap(Transaction tx, Coin newCap) { AddressBasedAuthorizer authorizer = bridgeConstants.getIncreaseLockingCapAuthorizer(); if (!authorizer.isAuthorized(tx)) { logger.warn("not authorized address tried to increase locking cap. Address: {}", tx.getSender()); return false; } Coin currentLockingCap = this.getLockingCap(); if (newCap.compareTo(currentLockingCap) < 0) { logger.warn("attempted value doesn't increase locking cap. Attempted: {}", newCap.value); return false; } Coin maxLockingCap = currentLockingCap.multiply(bridgeConstants.getLockingCapIncrementsMultiplier()); if (newCap.compareTo(maxLockingCap) > 0) { logger.warn("attempted value increases locking cap above its limit. Attempted: {}", newCap.value); return false; } logger.info("increased locking cap: {}", newCap.value); this.provider.setLockingCap(newCap); return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public boolean increaseLockingCap(Transaction tx, Coin newCap) { AddressBasedAuthorizer authorizer = bridgeConstants.getIncreaseLockingCapAuthorizer(); if (!authorizer.isAuthorized(tx)) { logger.warn("not authorized address tried to increase locking cap. Address: {}", tx.getSender()); return false; } Coin currentLockingCap = this.getLockingCap(); if (newCap.compareTo(currentLockingCap) < 0) { logger.warn("attempted value doesn't increase locking cap. Attempted: {}", newCap.value); return false; } Coin maxLockingCap = currentLockingCap.multiply(bridgeConstants.getLockingCapIncrementsMultiplier()); if (newCap.compareTo(maxLockingCap) > 0) { logger.warn("attempted value increases locking cap above its limit. Attempted: {}", newCap.value); return false; } logger.info("increased locking cap: {}", newCap.value); this.provider.setLockingCap(newCap); return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void increaseLockingCap() { Coin lastValue = Coin.COIN; BridgeStorageProvider provider = mock(BridgeStorageProvider.class); when(provider.getLockingCap()).thenReturn(lastValue); AddressBasedAuthorizer authorizer = mock(AddressBasedAuthorizer.class); when(authorizer.isAuthorized(any(Transaction.class))).thenReturn(true); BridgeConstants constants = mock(BridgeConstants.class); when(constants.getIncreaseLockingCapAuthorizer()).thenReturn(authorizer); int multiplier = 2; when(constants.getLockingCapIncrementsMultiplier()).thenReturn(multiplier); BridgeSupport bridgeSupport = getBridgeSupport(constants, provider, ActivationConfigsForTest.all().forBlock(0)); assertTrue(bridgeSupport.increaseLockingCap(mock(Transaction.class), lastValue)); assertTrue(bridgeSupport.increaseLockingCap(mock(Transaction.class), lastValue.plus(Coin.SATOSHI))); assertTrue(bridgeSupport.increaseLockingCap(mock(Transaction.class), lastValue.plus(Coin.CENT))); assertTrue(bridgeSupport.increaseLockingCap(mock(Transaction.class), lastValue.multiply(multiplier))); }
|
public boolean increaseLockingCap(Transaction tx, Coin newCap) { AddressBasedAuthorizer authorizer = bridgeConstants.getIncreaseLockingCapAuthorizer(); if (!authorizer.isAuthorized(tx)) { logger.warn("not authorized address tried to increase locking cap. Address: {}", tx.getSender()); return false; } Coin currentLockingCap = this.getLockingCap(); if (newCap.compareTo(currentLockingCap) < 0) { logger.warn("attempted value doesn't increase locking cap. Attempted: {}", newCap.value); return false; } Coin maxLockingCap = currentLockingCap.multiply(bridgeConstants.getLockingCapIncrementsMultiplier()); if (newCap.compareTo(maxLockingCap) > 0) { logger.warn("attempted value increases locking cap above its limit. Attempted: {}", newCap.value); return false; } logger.info("increased locking cap: {}", newCap.value); this.provider.setLockingCap(newCap); return true; }
|
BridgeSupport { public boolean increaseLockingCap(Transaction tx, Coin newCap) { AddressBasedAuthorizer authorizer = bridgeConstants.getIncreaseLockingCapAuthorizer(); if (!authorizer.isAuthorized(tx)) { logger.warn("not authorized address tried to increase locking cap. Address: {}", tx.getSender()); return false; } Coin currentLockingCap = this.getLockingCap(); if (newCap.compareTo(currentLockingCap) < 0) { logger.warn("attempted value doesn't increase locking cap. Attempted: {}", newCap.value); return false; } Coin maxLockingCap = currentLockingCap.multiply(bridgeConstants.getLockingCapIncrementsMultiplier()); if (newCap.compareTo(maxLockingCap) > 0) { logger.warn("attempted value increases locking cap above its limit. Attempted: {}", newCap.value); return false; } logger.info("increased locking cap: {}", newCap.value); this.provider.setLockingCap(newCap); return true; } }
|
BridgeSupport { public boolean increaseLockingCap(Transaction tx, Coin newCap) { AddressBasedAuthorizer authorizer = bridgeConstants.getIncreaseLockingCapAuthorizer(); if (!authorizer.isAuthorized(tx)) { logger.warn("not authorized address tried to increase locking cap. Address: {}", tx.getSender()); return false; } Coin currentLockingCap = this.getLockingCap(); if (newCap.compareTo(currentLockingCap) < 0) { logger.warn("attempted value doesn't increase locking cap. Attempted: {}", newCap.value); return false; } Coin maxLockingCap = currentLockingCap.multiply(bridgeConstants.getLockingCapIncrementsMultiplier()); if (newCap.compareTo(maxLockingCap) > 0) { logger.warn("attempted value increases locking cap above its limit. Attempted: {}", newCap.value); return false; } logger.info("increased locking cap: {}", newCap.value); this.provider.setLockingCap(newCap); return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public boolean increaseLockingCap(Transaction tx, Coin newCap) { AddressBasedAuthorizer authorizer = bridgeConstants.getIncreaseLockingCapAuthorizer(); if (!authorizer.isAuthorized(tx)) { logger.warn("not authorized address tried to increase locking cap. Address: {}", tx.getSender()); return false; } Coin currentLockingCap = this.getLockingCap(); if (newCap.compareTo(currentLockingCap) < 0) { logger.warn("attempted value doesn't increase locking cap. Attempted: {}", newCap.value); return false; } Coin maxLockingCap = currentLockingCap.multiply(bridgeConstants.getLockingCapIncrementsMultiplier()); if (newCap.compareTo(maxLockingCap) > 0) { logger.warn("attempted value increases locking cap above its limit. Attempted: {}", newCap.value); return false; } logger.info("increased locking cap: {}", newCap.value); this.provider.setLockingCap(newCap); return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public boolean increaseLockingCap(Transaction tx, Coin newCap) { AddressBasedAuthorizer authorizer = bridgeConstants.getIncreaseLockingCapAuthorizer(); if (!authorizer.isAuthorized(tx)) { logger.warn("not authorized address tried to increase locking cap. Address: {}", tx.getSender()); return false; } Coin currentLockingCap = this.getLockingCap(); if (newCap.compareTo(currentLockingCap) < 0) { logger.warn("attempted value doesn't increase locking cap. Attempted: {}", newCap.value); return false; } Coin maxLockingCap = currentLockingCap.multiply(bridgeConstants.getLockingCapIncrementsMultiplier()); if (newCap.compareTo(maxLockingCap) > 0) { logger.warn("attempted value increases locking cap above its limit. Attempted: {}", newCap.value); return false; } logger.info("increased locking cap: {}", newCap.value); this.provider.setLockingCap(newCap); return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void isBtcTxHashAlreadyProcessed() throws IOException { BridgeConstants bridgeConstants = BridgeRegTestConstants.getInstance(); ActivationConfig.ForBlock activations = ActivationConfigsForTest.all().forBlock(0l); Sha256Hash hash1 = Sha256Hash.ZERO_HASH; Sha256Hash hash2 = Sha256Hash.wrap("0000000000000000000000000000000000000000000000000000000000000001"); BridgeStorageProvider bridgeStorageProvider = mock(BridgeStorageProvider.class); when(bridgeStorageProvider.getHeightIfBtcTxhashIsAlreadyProcessed(hash1)).thenReturn(Optional.of(1l)); BridgeSupport bridgeSupport = getBridgeSupport(bridgeConstants, bridgeStorageProvider, activations); assertTrue(bridgeSupport.isBtcTxHashAlreadyProcessed(hash1)); assertFalse(bridgeSupport.isBtcTxHashAlreadyProcessed(hash2)); }
|
public Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash) throws IOException { return provider.getHeightIfBtcTxhashIsAlreadyProcessed(btcTxHash).isPresent(); }
|
BridgeSupport { public Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash) throws IOException { return provider.getHeightIfBtcTxhashIsAlreadyProcessed(btcTxHash).isPresent(); } }
|
BridgeSupport { public Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash) throws IOException { return provider.getHeightIfBtcTxhashIsAlreadyProcessed(btcTxHash).isPresent(); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash) throws IOException { return provider.getHeightIfBtcTxhashIsAlreadyProcessed(btcTxHash).isPresent(); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash) throws IOException { return provider.getHeightIfBtcTxhashIsAlreadyProcessed(btcTxHash).isPresent(); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void getBtcTxHashProcessedHeight() throws IOException { BridgeConstants bridgeConstants = BridgeRegTestConstants.getInstance(); ActivationConfig.ForBlock activations = ActivationConfigsForTest.all().forBlock(0l); Sha256Hash hash1 = Sha256Hash.ZERO_HASH; Sha256Hash hash2 = Sha256Hash.wrap("0000000000000000000000000000000000000000000000000000000000000001"); BridgeStorageProvider bridgeStorageProvider = mock(BridgeStorageProvider.class); when(bridgeStorageProvider.getHeightIfBtcTxhashIsAlreadyProcessed(hash1)).thenReturn(Optional.of(1l)); BridgeSupport bridgeSupport = getBridgeSupport(bridgeConstants, bridgeStorageProvider, activations); assertEquals(Long.valueOf(1), bridgeSupport.getBtcTxHashProcessedHeight(hash1)); assertEquals(Long.valueOf(-1), bridgeSupport.getBtcTxHashProcessedHeight(hash2)); }
|
public Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash) throws IOException { return provider.getHeightIfBtcTxhashIsAlreadyProcessed(btcTxHash).orElse(-1L); }
|
BridgeSupport { public Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash) throws IOException { return provider.getHeightIfBtcTxhashIsAlreadyProcessed(btcTxHash).orElse(-1L); } }
|
BridgeSupport { public Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash) throws IOException { return provider.getHeightIfBtcTxhashIsAlreadyProcessed(btcTxHash).orElse(-1L); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash) throws IOException { return provider.getHeightIfBtcTxhashIsAlreadyProcessed(btcTxHash).orElse(-1L); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash) throws IOException { return provider.getHeightIfBtcTxhashIsAlreadyProcessed(btcTxHash).orElse(-1L); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void eventLoggerLogLockBtc_before_rskip_146_activation() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP146)).thenReturn(false); BridgeEventLogger mockedEventLogger = mock(BridgeEventLogger.class); BridgeStorageProvider mockBridgeStorageProvider = mock(BridgeStorageProvider.class); when(mockBridgeStorageProvider.getHeightIfBtcTxhashIsAlreadyProcessed(any(Sha256Hash.class))).thenReturn(Optional.empty()); LockWhitelist lockWhitelist = mock(LockWhitelist.class); when(lockWhitelist.isWhitelistedFor(any(Address.class), any(Coin.class), any(int.class))).thenReturn(true); when(mockBridgeStorageProvider.getLockWhitelist()).thenReturn(lockWhitelist); when(mockBridgeStorageProvider.getNewFederation()).thenReturn(bridgeConstants.getGenesisFederation()); Block executionBlock = mock(Block.class); NetworkParameters params = RegTestParams.get(); Context btcContext = new Context(params); FederationSupport federationSupport = new FederationSupport(bridgeConstants, mockBridgeStorageProvider, executionBlock); BtcBlockStoreWithCache.Factory btcBlockStoreFactory = mock(BtcBlockStoreWithCache.Factory.class); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); when(btcBlockStoreFactory.newInstance(any(Repository.class))).thenReturn(btcBlockStore); Coin lockValue = Coin.COIN; BtcTransaction tx = new BtcTransaction(bridgeConstants.getBtcParams()); tx.addOutput(lockValue, mockBridgeStorageProvider.getNewFederation().getAddress()); BtcECKey srcKey = new BtcECKey(); tx.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey)); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), bits, hashes, 1); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(new ArrayList<>()); co.rsk.bitcoinj.core.BtcBlock btcBlock = new co.rsk.bitcoinj.core.BtcBlock(bridgeConstants.getBtcParams(), 1, PegTestUtils.createHash(), merkleRoot, 1, 1, 1, new ArrayList<>()); int height = 1; mockChainOfStoredBlocks(btcBlockStore, btcBlock, height + bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(), height); BridgeSupport bridgeSupport = new BridgeSupport( bridgeConstants, mockBridgeStorageProvider, mockedEventLogger, new BtcLockSenderProvider(), mock(Repository.class), executionBlock, btcContext, federationSupport, btcBlockStoreFactory, activations ); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx.bitcoinSerialize(), height, pmt.bitcoinSerialize()); verify(mockedEventLogger, never()).logLockBtc(any(RskAddress.class), any(BtcTransaction.class), any(Address.class), any(Coin.class)); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void eventLoggerLogLockBtc_after_rskip_146_activation() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP146)).thenReturn(true); BridgeEventLogger mockedEventLogger = mock(BridgeEventLogger.class); BridgeStorageProvider mockBridgeStorageProvider = mock(BridgeStorageProvider.class); when(mockBridgeStorageProvider.getHeightIfBtcTxhashIsAlreadyProcessed(any(Sha256Hash.class))).thenReturn(Optional.empty()); LockWhitelist lockWhitelist = mock(LockWhitelist.class); when(lockWhitelist.isWhitelistedFor(any(Address.class), any(Coin.class), any(int.class))).thenReturn(true); when(mockBridgeStorageProvider.getLockWhitelist()).thenReturn(lockWhitelist); when(mockBridgeStorageProvider.getNewFederation()).thenReturn(bridgeConstants.getGenesisFederation()); Block executionBlock = mock(Block.class); NetworkParameters params = RegTestParams.get(); Context btcContext = new Context(params); FederationSupport federationSupport = new FederationSupport(bridgeConstants, mockBridgeStorageProvider, executionBlock); BtcBlockStoreWithCache.Factory btcBlockStoreFactory = mock(BtcBlockStoreWithCache.Factory.class); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); when(btcBlockStoreFactory.newInstance(any(Repository.class))).thenReturn(btcBlockStore); Coin lockValue = Coin.COIN; BtcTransaction tx = new BtcTransaction(bridgeConstants.getBtcParams()); tx.addOutput(lockValue, mockBridgeStorageProvider.getNewFederation().getAddress()); BtcECKey srcKey = new BtcECKey(); tx.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey)); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), bits, hashes, 1); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(new ArrayList<>()); co.rsk.bitcoinj.core.BtcBlock btcBlock = new co.rsk.bitcoinj.core.BtcBlock(bridgeConstants.getBtcParams(), 1, PegTestUtils.createHash(), merkleRoot, 1, 1, 1, new ArrayList<>()); int height = 1; mockChainOfStoredBlocks(btcBlockStore, btcBlock, height + bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(), height); BridgeSupport bridgeSupport = new BridgeSupport( bridgeConstants, mockBridgeStorageProvider, mockedEventLogger, new BtcLockSenderProvider(), mock(Repository.class), executionBlock, btcContext, federationSupport, btcBlockStoreFactory, activations ); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx.bitcoinSerialize(), height, pmt.bitcoinSerialize()); verify(mockedEventLogger, atLeastOnce()).logLockBtc(any(RskAddress.class), any(BtcTransaction.class), any(Address.class), any(Coin.class)); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void rskTxWaitingForSignature_uses_updateCollection_rskTxHash_before_rskip_146_activation() throws IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP146)).thenReturn(false); BridgeConstants spiedBridgeConstants = spy(BridgeRegTestConstants.getInstance()); doReturn(1).when(spiedBridgeConstants).getRsk2BtcMinimumAcceptableConfirmations(); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); BtcTransaction btcTx = mock(BtcTransaction.class); Set<ReleaseTransactionSet.Entry> set = new HashSet<>(); set.add(new ReleaseTransactionSet.Entry(btcTx, 1L)); when(provider.getReleaseTransactionSet()).thenReturn(new ReleaseTransactionSet(set)); when(provider.getReleaseRequestQueue()).thenReturn(new ReleaseRequestQueue(Collections.emptyList())); when(provider.getRskTxsWaitingForSignatures()).thenReturn(new TreeMap<>()); Block executionBlock = mock(Block.class); when(executionBlock.getNumber()).thenReturn(2L); BridgeSupport bridgeSupport = getBridgeSupport(spiedBridgeConstants, provider, mock(Repository.class), mock(BridgeEventLogger.class), executionBlock, null, activations ); Transaction tx = new Transaction(TO_ADDRESS, DUST_AMOUNT, NONCE, GAS_PRICE, GAS_LIMIT, DATA, Constants.REGTEST_CHAIN_ID); bridgeSupport.updateCollections(tx); assertEquals(btcTx, provider.getRskTxsWaitingForSignatures().get(tx.getHash())); assertEquals(0, provider.getReleaseTransactionSet().getEntries().size()); }
|
public void updateCollections(Transaction rskTx) throws IOException { Context.propagate(btcContext); eventLogger.logUpdateCollections(rskTx); processFundsMigration(rskTx); processReleaseRequests(); processReleaseTransactions(rskTx); }
|
BridgeSupport { public void updateCollections(Transaction rskTx) throws IOException { Context.propagate(btcContext); eventLogger.logUpdateCollections(rskTx); processFundsMigration(rskTx); processReleaseRequests(); processReleaseTransactions(rskTx); } }
|
BridgeSupport { public void updateCollections(Transaction rskTx) throws IOException { Context.propagate(btcContext); eventLogger.logUpdateCollections(rskTx); processFundsMigration(rskTx); processReleaseRequests(); processReleaseTransactions(rskTx); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void updateCollections(Transaction rskTx) throws IOException { Context.propagate(btcContext); eventLogger.logUpdateCollections(rskTx); processFundsMigration(rskTx); processReleaseRequests(); processReleaseTransactions(rskTx); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void updateCollections(Transaction rskTx) throws IOException { Context.propagate(btcContext); eventLogger.logUpdateCollections(rskTx); processFundsMigration(rskTx); processReleaseRequests(); processReleaseTransactions(rskTx); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void rskTxWaitingForSignature_uses_updateCollection_rskTxHash_after_rskip_146_activation_if_release_transaction_doesnt_have_rstTxHash() throws IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP146)).thenReturn(true); BridgeConstants spiedBridgeConstants = spy(BridgeRegTestConstants.getInstance()); doReturn(1).when(spiedBridgeConstants).getRsk2BtcMinimumAcceptableConfirmations(); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); BtcTransaction btcTx = mock(BtcTransaction.class); Set<ReleaseTransactionSet.Entry> set = new HashSet<>(); set.add(new ReleaseTransactionSet.Entry(btcTx, 1L)); when(provider.getReleaseTransactionSet()).thenReturn(new ReleaseTransactionSet(set)); when(provider.getReleaseRequestQueue()).thenReturn(new ReleaseRequestQueue(Collections.emptyList())); when(provider.getRskTxsWaitingForSignatures()).thenReturn(new TreeMap<>()); Block executionBlock = mock(Block.class); when(executionBlock.getNumber()).thenReturn(2L); BridgeSupport bridgeSupport = getBridgeSupport(spiedBridgeConstants, provider, mock(Repository.class), mock(BridgeEventLogger.class), executionBlock, null, activations ); Transaction tx = new Transaction(TO_ADDRESS, DUST_AMOUNT, NONCE, GAS_PRICE, GAS_LIMIT, DATA, Constants.REGTEST_CHAIN_ID); bridgeSupport.updateCollections(tx); assertEquals(btcTx, provider.getRskTxsWaitingForSignatures().get(tx.getHash())); assertEquals(0, provider.getReleaseTransactionSet().getEntries().size()); }
|
public void updateCollections(Transaction rskTx) throws IOException { Context.propagate(btcContext); eventLogger.logUpdateCollections(rskTx); processFundsMigration(rskTx); processReleaseRequests(); processReleaseTransactions(rskTx); }
|
BridgeSupport { public void updateCollections(Transaction rskTx) throws IOException { Context.propagate(btcContext); eventLogger.logUpdateCollections(rskTx); processFundsMigration(rskTx); processReleaseRequests(); processReleaseTransactions(rskTx); } }
|
BridgeSupport { public void updateCollections(Transaction rskTx) throws IOException { Context.propagate(btcContext); eventLogger.logUpdateCollections(rskTx); processFundsMigration(rskTx); processReleaseRequests(); processReleaseTransactions(rskTx); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void updateCollections(Transaction rskTx) throws IOException { Context.propagate(btcContext); eventLogger.logUpdateCollections(rskTx); processFundsMigration(rskTx); processReleaseRequests(); processReleaseTransactions(rskTx); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void updateCollections(Transaction rskTx) throws IOException { Context.propagate(btcContext); eventLogger.logUpdateCollections(rskTx); processFundsMigration(rskTx); processReleaseRequests(); processReleaseTransactions(rskTx); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void rskTxWaitingForSignature_uses_release_transaction_rstTxHash_after_rskip_146_activation() throws IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP146)).thenReturn(true); BridgeConstants spiedBridgeConstants = spy(BridgeRegTestConstants.getInstance()); doReturn(1).when(spiedBridgeConstants).getRsk2BtcMinimumAcceptableConfirmations(); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); BtcTransaction btcTx = mock(BtcTransaction.class); Set<ReleaseTransactionSet.Entry> set = new HashSet<>(); Keccak256 rskTxHash = Keccak256.ZERO_HASH; set.add(new ReleaseTransactionSet.Entry(btcTx, 1L, rskTxHash)); when(provider.getReleaseTransactionSet()).thenReturn(new ReleaseTransactionSet(set)); when(provider.getReleaseRequestQueue()).thenReturn(new ReleaseRequestQueue(Collections.emptyList())); when(provider.getRskTxsWaitingForSignatures()).thenReturn(new TreeMap<>()); Block executionBlock = mock(Block.class); when(executionBlock.getNumber()).thenReturn(2L); BridgeSupport bridgeSupport = getBridgeSupport(spiedBridgeConstants, provider, mock(Repository.class), mock(BridgeEventLogger.class), executionBlock, null, activations ); Transaction tx = new Transaction(TO_ADDRESS, DUST_AMOUNT, NONCE, GAS_PRICE, GAS_LIMIT, DATA, Constants.REGTEST_CHAIN_ID); bridgeSupport.updateCollections(tx); assertEquals(btcTx, provider.getRskTxsWaitingForSignatures().get(rskTxHash)); assertEquals(0, provider.getReleaseTransactionSet().getEntries().size()); }
|
public void updateCollections(Transaction rskTx) throws IOException { Context.propagate(btcContext); eventLogger.logUpdateCollections(rskTx); processFundsMigration(rskTx); processReleaseRequests(); processReleaseTransactions(rskTx); }
|
BridgeSupport { public void updateCollections(Transaction rskTx) throws IOException { Context.propagate(btcContext); eventLogger.logUpdateCollections(rskTx); processFundsMigration(rskTx); processReleaseRequests(); processReleaseTransactions(rskTx); } }
|
BridgeSupport { public void updateCollections(Transaction rskTx) throws IOException { Context.propagate(btcContext); eventLogger.logUpdateCollections(rskTx); processFundsMigration(rskTx); processReleaseRequests(); processReleaseTransactions(rskTx); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void updateCollections(Transaction rskTx) throws IOException { Context.propagate(btcContext); eventLogger.logUpdateCollections(rskTx); processFundsMigration(rskTx); processReleaseRequests(); processReleaseTransactions(rskTx); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void updateCollections(Transaction rskTx) throws IOException { Context.propagate(btcContext); eventLogger.logUpdateCollections(rskTx); processFundsMigration(rskTx); processReleaseRequests(); processReleaseTransactions(rskTx); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void when_registerBtcTransaction_sender_not_recognized_no_lock_and_no_refund() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); List<BtcECKey> federation1Keys = Arrays.asList( BtcECKey.fromPrivate(Hex.decode("fa01")), BtcECKey.fromPrivate(Hex.decode("fa02")) ); federation1Keys.sort(BtcECKey.PUBKEY_COMPARATOR); Federation federation1 = new Federation( FederationTestUtils.getFederationMembersWithBtcKeys(federation1Keys), Instant.ofEpochMilli(1000L), 0L, btcParams ); Repository repository = createRepository(); repository.addBalance(PrecompiledContracts.BRIDGE_ADDR, LIMIT_MONETARY_BASE); Block executionBlock = mock(Block.class); when(executionBlock.getNumber()).thenReturn(10L); BtcECKey srcKey1 = new BtcECKey(); ECKey key = ECKey.fromPublicOnly(srcKey1.getPubKey()); RskAddress rskAddress = new RskAddress(key.getAddress()); Coin amountToLock = Coin.COIN.multiply(5); BtcTransaction tx1 = new BtcTransaction(btcParams); tx1.addOutput(amountToLock, federation1.getAddress()); tx1.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey1)); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BridgeStorageProvider provider = new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations); provider.setNewFederation(federation1); BtcLockSenderProvider btcLockSenderProvider = mock(BtcLockSenderProvider.class); when(btcLockSenderProvider.tryGetBtcLockSender(any())).thenReturn(Optional.empty()); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, btcLockSenderProvider, executionBlock, mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 30; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 35, height); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmt.bitcoinSerialize()); Assert.assertEquals(co.rsk.core.Coin.ZERO, repository.getBalance(rskAddress)); Assert.assertEquals(LIMIT_MONETARY_BASE, repository.getBalance(PrecompiledContracts.BRIDGE_ADDR)); Assert.assertEquals(0, provider.getNewFederationBtcUTXOs().size()); Assert.assertEquals(0, provider.getReleaseRequestQueue().getEntries().size()); Assert.assertEquals(0, provider.getReleaseTransactionSet().getEntries().size()); Assert.assertTrue(provider.getRskTxsWaitingForSignatures().isEmpty()); Assert.assertFalse(provider.getHeightIfBtcTxhashIsAlreadyProcessed(tx1.getHash()).isPresent()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void test1() { assertFalse(isIn20PercentRange(BigInteger.ONE, BigInteger.valueOf(5))); assertTrue(isIn20PercentRange(BigInteger.valueOf(5), BigInteger.ONE)); assertTrue(isIn20PercentRange(BigInteger.valueOf(5), BigInteger.valueOf(6))); assertFalse(isIn20PercentRange(BigInteger.valueOf(5), BigInteger.valueOf(7))); }
|
public static boolean isIn20PercentRange(BigInteger first, BigInteger second) { BigInteger five = BigInteger.valueOf(5); BigInteger limit = first.add(first.divide(five)); return !isMoreThan(second, limit); }
|
BIUtil { public static boolean isIn20PercentRange(BigInteger first, BigInteger second) { BigInteger five = BigInteger.valueOf(5); BigInteger limit = first.add(first.divide(five)); return !isMoreThan(second, limit); } }
|
BIUtil { public static boolean isIn20PercentRange(BigInteger first, BigInteger second) { BigInteger five = BigInteger.valueOf(5); BigInteger limit = first.add(first.divide(five)); return !isMoreThan(second, limit); } }
|
BIUtil { public static boolean isIn20PercentRange(BigInteger first, BigInteger second) { BigInteger five = BigInteger.valueOf(5); BigInteger limit = first.add(first.divide(five)); return !isMoreThan(second, limit); } static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBI(byte[] data); static BigInteger toBI(long data); static boolean isPositive(BigInteger value); static boolean isCovers(Coin covers, Coin value); static boolean isNotCovers(Coin covers, Coin value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); }
|
BIUtil { public static boolean isIn20PercentRange(BigInteger first, BigInteger second) { BigInteger five = BigInteger.valueOf(5); BigInteger limit = first.add(first.divide(five)); return !isMoreThan(second, limit); } static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBI(byte[] data); static BigInteger toBI(long data); static boolean isPositive(BigInteger value); static boolean isCovers(Coin covers, Coin value); static boolean isNotCovers(Coin covers, Coin value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); }
|
@Test public void when_registerBtcTransaction_usesLegacyType_beforeFork_lock_and_no_refund() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(false); List<BtcECKey> federation1Keys = Arrays.asList( BtcECKey.fromPrivate(Hex.decode("fa01")), BtcECKey.fromPrivate(Hex.decode("fa02")) ); federation1Keys.sort(BtcECKey.PUBKEY_COMPARATOR); Federation federation1 = new Federation( FederationTestUtils.getFederationMembersWithBtcKeys(federation1Keys), Instant.ofEpochMilli(1000L), 0L, btcParams ); Repository repository = createRepository(); repository.addBalance(PrecompiledContracts.BRIDGE_ADDR, LIMIT_MONETARY_BASE); Block executionBlock = mock(Block.class); when(executionBlock.getNumber()).thenReturn(10L); BtcECKey srcKey1 = new BtcECKey(); ECKey key = ECKey.fromPublicOnly(srcKey1.getPubKey()); Address btcAddress = srcKey1.toAddress(btcParams); RskAddress rskAddress = new RskAddress(key.getAddress()); Coin amountToLock = Coin.COIN.multiply(5); BtcTransaction tx1 = new BtcTransaction(btcParams); tx1.addOutput(amountToLock, federation1.getAddress()); tx1.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey1)); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BridgeStorageProvider provider = new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations); provider.setNewFederation(federation1); LockWhitelist whitelist = provider.getLockWhitelist(); whitelist.put(btcAddress, new OneOffWhiteListEntry(btcAddress, Coin.COIN.multiply(5))); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BtcLockSenderProvider btcLockSenderProvider = getBtcLockSenderProvider(BtcLockSender.TxType.P2PKH, btcAddress, rskAddress); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, btcLockSenderProvider, executionBlock, mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 30; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 35, height); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmt.bitcoinSerialize()); co.rsk.core.Coin totalAmountExpectedToHaveBeenLocked = co.rsk.core.Coin.fromBitcoin(Coin.valueOf(5, 0)); Assert.assertThat(whitelist.isWhitelisted(btcAddress), is(false)); Assert.assertEquals(totalAmountExpectedToHaveBeenLocked, repository.getBalance(rskAddress)); Assert.assertEquals(LIMIT_MONETARY_BASE.subtract(totalAmountExpectedToHaveBeenLocked), repository.getBalance(PrecompiledContracts.BRIDGE_ADDR)); Assert.assertEquals(1, provider.getNewFederationBtcUTXOs().size()); Assert.assertEquals(amountToLock, provider.getNewFederationBtcUTXOs().get(0).getValue()); Assert.assertEquals(0, provider.getReleaseRequestQueue().getEntries().size()); Assert.assertEquals(0, provider.getReleaseTransactionSet().getEntries().size()); Assert.assertTrue(provider.getRskTxsWaitingForSignatures().isEmpty()); Assert.assertTrue(provider.getHeightIfBtcTxhashIsAlreadyProcessed(tx1.getHash()).isPresent()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void when_registerBtcTransaction_usesLegacyType_afterFork_notWhitelisted_no_lock_and_refund() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); List<BtcECKey> federation1Keys = Arrays.asList( BtcECKey.fromPrivate(Hex.decode("fa01")), BtcECKey.fromPrivate(Hex.decode("fa02")) ); federation1Keys.sort(BtcECKey.PUBKEY_COMPARATOR); Federation federation1 = new Federation( FederationTestUtils.getFederationMembersWithBtcKeys(federation1Keys), Instant.ofEpochMilli(1000L), 0L, btcParams ); Repository repository = createRepository(); repository.addBalance(PrecompiledContracts.BRIDGE_ADDR, LIMIT_MONETARY_BASE); Block executionBlock = mock(Block.class); when(executionBlock.getNumber()).thenReturn(10L); BtcTransaction tx1 = new BtcTransaction(btcParams); BtcECKey srcKey1 = new BtcECKey(); ECKey key = ECKey.fromPublicOnly(srcKey1.getPubKey()); Address btcAddress = srcKey1.toAddress(btcParams); RskAddress rskAddress = new RskAddress(key.getAddress()); Coin amountToLock = Coin.COIN.multiply(5); tx1.addOutput(amountToLock, federation1.getAddress()); tx1.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey1)); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BridgeStorageProvider provider = new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations); provider.setNewFederation(federation1); LockWhitelist whitelist = provider.getLockWhitelist(); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BtcLockSenderProvider btcLockSenderProvider = getBtcLockSenderProvider(BtcLockSender.TxType.P2PKH, btcAddress, rskAddress); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, btcLockSenderProvider, executionBlock, mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 30; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 35, height); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmt.bitcoinSerialize()); Assert.assertThat(whitelist.isWhitelisted(btcAddress), is(false)); Assert.assertEquals(co.rsk.core.Coin.ZERO, repository.getBalance(rskAddress)); Assert.assertEquals(LIMIT_MONETARY_BASE, repository.getBalance(PrecompiledContracts.BRIDGE_ADDR)); Assert.assertEquals(0, provider.getNewFederationBtcUTXOs().size()); Assert.assertEquals(1, provider.getReleaseTransactionSet().getEntries().size()); List<BtcTransaction> releaseTxs = provider.getReleaseTransactionSet().getEntries() .stream() .map(ReleaseTransactionSet.Entry::getTransaction) .sorted(Comparator.comparing(BtcTransaction::getOutputSum)) .collect(Collectors.toList()); BtcTransaction releaseTx = releaseTxs.get(0); Assert.assertEquals(1, releaseTx.getOutputs().size()); Assert.assertThat(amountToLock.subtract(releaseTx.getOutput(0).getValue()), is(lessThanOrEqualTo(Coin.MILLICOIN))); Assert.assertEquals(btcAddress, releaseTx.getOutput(0).getAddressFromP2PKHScript(btcParams)); Assert.assertEquals(1, releaseTx.getInputs().size()); Assert.assertEquals(tx1.getHash(), releaseTx.getInput(0).getOutpoint().getHash()); Assert.assertEquals(0, releaseTx.getInput(0).getOutpoint().getIndex()); Assert.assertTrue(provider.getRskTxsWaitingForSignatures().isEmpty()); Assert.assertTrue(provider.getHeightIfBtcTxhashIsAlreadyProcessed(tx1.getHash()).isPresent()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void when_registerBtcTransaction_usesLegacyType_afterFork_lock_and_no_refund() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); List<BtcECKey> federation1Keys = Arrays.asList( BtcECKey.fromPrivate(Hex.decode("fa01")), BtcECKey.fromPrivate(Hex.decode("fa02")) ); federation1Keys.sort(BtcECKey.PUBKEY_COMPARATOR); Federation federation1 = new Federation( FederationTestUtils.getFederationMembersWithBtcKeys(federation1Keys), Instant.ofEpochMilli(1000L), 0L, btcParams ); Repository repository = createRepository(); repository.addBalance(PrecompiledContracts.BRIDGE_ADDR, LIMIT_MONETARY_BASE); Block executionBlock = mock(Block.class); when(executionBlock.getNumber()).thenReturn(10L); BtcECKey srcKey1 = new BtcECKey(); ECKey key = ECKey.fromPublicOnly(srcKey1.getPubKey()); Address btcAddress = srcKey1.toAddress(btcParams); RskAddress rskAddress = new RskAddress(key.getAddress()); BtcTransaction tx1 = new BtcTransaction(btcParams); tx1.addOutput(Coin.COIN.multiply(5), federation1.getAddress()); tx1.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey1)); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BridgeStorageProvider provider = new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations); provider.setNewFederation(federation1); LockWhitelist whitelist = provider.getLockWhitelist(); whitelist.put(btcAddress, new OneOffWhiteListEntry(btcAddress, Coin.COIN.multiply(5))); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BtcLockSenderProvider btcLockSenderProvider = getBtcLockSenderProvider(BtcLockSender.TxType.P2PKH, btcAddress, rskAddress); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, btcLockSenderProvider, executionBlock, mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 30; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 35, height); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmt.bitcoinSerialize()); co.rsk.core.Coin totalAmountExpectedToHaveBeenLocked = co.rsk.core.Coin.fromBitcoin(Coin.valueOf(5, 0)); Assert.assertThat(whitelist.isWhitelisted(btcAddress), is(false)); Assert.assertEquals(totalAmountExpectedToHaveBeenLocked, repository.getBalance(rskAddress)); Assert.assertEquals(LIMIT_MONETARY_BASE.subtract(totalAmountExpectedToHaveBeenLocked), repository.getBalance(PrecompiledContracts.BRIDGE_ADDR)); Assert.assertEquals(1, provider.getNewFederationBtcUTXOs().size()); Assert.assertEquals(Coin.COIN.multiply(5), provider.getNewFederationBtcUTXOs().get(0).getValue()); Assert.assertEquals(0, provider.getReleaseRequestQueue().getEntries().size()); Assert.assertEquals(0, provider.getReleaseTransactionSet().getEntries().size()); Assert.assertTrue(provider.getRskTxsWaitingForSignatures().isEmpty()); Assert.assertTrue(provider.getHeightIfBtcTxhashIsAlreadyProcessed(tx1.getHash()).isPresent()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void when_registerBtcTransaction_usesSegCompatibilityType_beforeFork_no_lock_and_no_refund() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(false); List<BtcECKey> federation1Keys = Arrays.asList( BtcECKey.fromPrivate(Hex.decode("fa01")), BtcECKey.fromPrivate(Hex.decode("fa02")) ); federation1Keys.sort(BtcECKey.PUBKEY_COMPARATOR); Federation federation1 = new Federation( FederationTestUtils.getFederationMembersWithBtcKeys(federation1Keys), Instant.ofEpochMilli(1000L), 0L, btcParams ); Repository repository = createRepository(); repository.addBalance(PrecompiledContracts.BRIDGE_ADDR, LIMIT_MONETARY_BASE); Block executionBlock = mock(Block.class); when(executionBlock.getNumber()).thenReturn(10L); BtcECKey srcKey1 = new BtcECKey(); ECKey key = ECKey.fromPublicOnly(srcKey1.getPubKey()); Address btcAddress = srcKey1.toAddress(btcParams); RskAddress rskAddress = new RskAddress(key.getAddress()); BtcTransaction tx1 = new BtcTransaction(btcParams); tx1.addOutput(Coin.COIN.multiply(5), federation1.getAddress()); tx1.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey1)); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BridgeStorageProvider provider = new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations); provider.setNewFederation(federation1); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BtcLockSenderProvider btcLockSenderProvider = getBtcLockSenderProvider(BtcLockSender.TxType.P2SHP2WPKH, btcAddress, rskAddress); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, btcLockSenderProvider, executionBlock, mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 30; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 35, height); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmt.bitcoinSerialize()); Assert.assertEquals(co.rsk.core.Coin.ZERO, repository.getBalance(rskAddress)); Assert.assertEquals(LIMIT_MONETARY_BASE, repository.getBalance(PrecompiledContracts.BRIDGE_ADDR)); Assert.assertEquals(0, provider.getNewFederationBtcUTXOs().size()); Assert.assertEquals(0, provider.getReleaseRequestQueue().getEntries().size()); Assert.assertEquals(0, provider.getReleaseTransactionSet().getEntries().size()); Assert.assertTrue(provider.getRskTxsWaitingForSignatures().isEmpty()); Assert.assertFalse(provider.getHeightIfBtcTxhashIsAlreadyProcessed(tx1.getHash()).isPresent()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void when_registerBtcTransaction_usesSegCompatibilityType_afterFork_lock_and_no_refund() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); List<BtcECKey> federation1Keys = Arrays.asList( BtcECKey.fromPrivate(Hex.decode("fa01")), BtcECKey.fromPrivate(Hex.decode("fa02")) ); federation1Keys.sort(BtcECKey.PUBKEY_COMPARATOR); Federation federation1 = new Federation( FederationTestUtils.getFederationMembersWithBtcKeys(federation1Keys), Instant.ofEpochMilli(1000L), 0L, btcParams ); Repository repository = createRepository(); repository.addBalance(PrecompiledContracts.BRIDGE_ADDR, LIMIT_MONETARY_BASE); Block executionBlock = mock(Block.class); when(executionBlock.getNumber()).thenReturn(10L); BtcTransaction tx1 = new BtcTransaction(btcParams); BtcECKey srcKey1 = new BtcECKey(); ECKey key = ECKey.fromPublicOnly(srcKey1.getPubKey()); Address btcAddress = srcKey1.toAddress(btcParams); RskAddress rskAddress = new RskAddress(key.getAddress()); Coin amountToLock = Coin.COIN.multiply(5); tx1.addOutput(amountToLock, federation1.getAddress()); tx1.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey1)); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BridgeStorageProvider provider = new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations); provider.setNewFederation(federation1); LockWhitelist whitelist = provider.getLockWhitelist(); whitelist.put(btcAddress, new OneOffWhiteListEntry(btcAddress, amountToLock)); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BtcLockSenderProvider btcLockSenderProvider = getBtcLockSenderProvider(BtcLockSender.TxType.P2SHP2WPKH, btcAddress, rskAddress); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, btcLockSenderProvider, executionBlock, mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 30; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 35, height); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmt.bitcoinSerialize()); co.rsk.core.Coin totalAmountExpectedToHaveBeenLocked = co.rsk.core.Coin.fromBitcoin(Coin.valueOf(5, 0)); Assert.assertThat(whitelist.isWhitelisted(btcAddress), is(false)); Assert.assertEquals(totalAmountExpectedToHaveBeenLocked, repository.getBalance(rskAddress)); Assert.assertEquals(LIMIT_MONETARY_BASE.subtract(totalAmountExpectedToHaveBeenLocked), repository.getBalance(PrecompiledContracts.BRIDGE_ADDR)); Assert.assertEquals(1, provider.getNewFederationBtcUTXOs().size()); Assert.assertEquals(amountToLock, provider.getNewFederationBtcUTXOs().get(0).getValue()); Assert.assertEquals(0, provider.getReleaseRequestQueue().getEntries().size()); Assert.assertEquals(0, provider.getReleaseTransactionSet().getEntries().size()); Assert.assertTrue(provider.getRskTxsWaitingForSignatures().isEmpty()); Assert.assertTrue(provider.getHeightIfBtcTxhashIsAlreadyProcessed(tx1.getHash()).isPresent()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void when_registerBtcTransaction_usesSegCompatibilityType_afterFork_notWhitelisted_no_lock_and_refund() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); List<BtcECKey> federation1Keys = Arrays.asList( BtcECKey.fromPrivate(Hex.decode("fa01")), BtcECKey.fromPrivate(Hex.decode("fa02")) ); federation1Keys.sort(BtcECKey.PUBKEY_COMPARATOR); Federation federation1 = new Federation( FederationTestUtils.getFederationMembersWithBtcKeys(federation1Keys), Instant.ofEpochMilli(1000L), 0L, btcParams ); Repository repository = createRepository(); repository.addBalance(PrecompiledContracts.BRIDGE_ADDR, LIMIT_MONETARY_BASE); Block executionBlock = mock(Block.class); when(executionBlock.getNumber()).thenReturn(10L); BtcTransaction tx1 = new BtcTransaction(btcParams); BtcECKey srcKey1 = new BtcECKey(); ECKey key = ECKey.fromPublicOnly(srcKey1.getPubKey()); Address btcAddress = srcKey1.toAddress(btcParams); RskAddress rskAddress = new RskAddress(key.getAddress()); Coin amountToLock = Coin.COIN.multiply(5); tx1.addOutput(amountToLock, federation1.getAddress()); tx1.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey1)); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BridgeStorageProvider provider = new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations); provider.setNewFederation(federation1); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, getBtcLockSenderProvider(BtcLockSender.TxType.P2SHP2WPKH, btcAddress, rskAddress), executionBlock, mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 30; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 35, height); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmt.bitcoinSerialize()); Assert.assertEquals(co.rsk.core.Coin.ZERO, repository.getBalance(rskAddress)); Assert.assertEquals(LIMIT_MONETARY_BASE, repository.getBalance(PrecompiledContracts.BRIDGE_ADDR)); Assert.assertEquals(0, provider.getNewFederationBtcUTXOs().size()); Assert.assertEquals(1, provider.getReleaseTransactionSet().getEntries().size()); List<BtcTransaction> releaseTxs = provider.getReleaseTransactionSet().getEntries() .stream() .map(ReleaseTransactionSet.Entry::getTransaction) .sorted(Comparator.comparing(BtcTransaction::getOutputSum)) .collect(Collectors.toList()); BtcTransaction releaseTx = releaseTxs.get(0); Assert.assertEquals(1, releaseTx.getOutputs().size()); Assert.assertThat(amountToLock.subtract(releaseTx.getOutput(0).getValue()), is(lessThanOrEqualTo(Coin.MILLICOIN))); Assert.assertEquals(btcAddress, releaseTx.getOutput(0).getAddressFromP2PKHScript(btcParams)); Assert.assertEquals(1, releaseTx.getInputs().size()); Assert.assertEquals(tx1.getHash(), releaseTx.getInput(0).getOutpoint().getHash()); Assert.assertEquals(0, releaseTx.getInput(0).getOutpoint().getIndex()); Assert.assertTrue(provider.getRskTxsWaitingForSignatures().isEmpty()); Assert.assertTrue(provider.getHeightIfBtcTxhashIsAlreadyProcessed(tx1.getHash()).isPresent()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void when_registerBtcTransaction_usesMultisigType_beforeFork_no_lock_and_no_refund() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(false); List<BtcECKey> federation1Keys = Arrays.asList( BtcECKey.fromPrivate(Hex.decode("fa01")), BtcECKey.fromPrivate(Hex.decode("fa02")) ); federation1Keys.sort(BtcECKey.PUBKEY_COMPARATOR); Federation federation1 = new Federation( FederationTestUtils.getFederationMembersWithBtcKeys(federation1Keys), Instant.ofEpochMilli(1000L), 0L, btcParams ); Repository repository = createRepository(); repository.addBalance(PrecompiledContracts.BRIDGE_ADDR, LIMIT_MONETARY_BASE); Block executionBlock = mock(Block.class); when(executionBlock.getNumber()).thenReturn(10L); BtcECKey srcKey1 = new BtcECKey(); ECKey key = ECKey.fromPublicOnly(srcKey1.getPubKey()); Address btcAddress = srcKey1.toAddress(btcParams); RskAddress rskAddress = new RskAddress(key.getAddress()); BtcTransaction tx1 = new BtcTransaction(btcParams); tx1.addOutput(Coin.COIN.multiply(5), federation1.getAddress()); tx1.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey1)); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BridgeStorageProvider provider = new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations); provider.setNewFederation(federation1); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BtcLockSenderProvider btcLockSenderProvider = getBtcLockSenderProvider(BtcLockSender.TxType.P2SHMULTISIG, btcAddress, rskAddress); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, btcLockSenderProvider, executionBlock, mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 30; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 35, height); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmt.bitcoinSerialize()); Assert.assertEquals(co.rsk.core.Coin.ZERO, repository.getBalance(rskAddress)); Assert.assertEquals(LIMIT_MONETARY_BASE, repository.getBalance(PrecompiledContracts.BRIDGE_ADDR)); Assert.assertEquals(0, provider.getNewFederationBtcUTXOs().size()); Assert.assertEquals(0, provider.getReleaseRequestQueue().getEntries().size()); Assert.assertEquals(0, provider.getReleaseTransactionSet().getEntries().size()); Assert.assertTrue(provider.getRskTxsWaitingForSignatures().isEmpty()); Assert.assertFalse(provider.getHeightIfBtcTxhashIsAlreadyProcessed(tx1.getHash()).isPresent()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void when_registerBtcTransaction_usesMultisigType_afterFork_no_lock_and_refund() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); List<BtcECKey> federation1Keys = Arrays.asList( BtcECKey.fromPrivate(Hex.decode("fa01")), BtcECKey.fromPrivate(Hex.decode("fa02")) ); federation1Keys.sort(BtcECKey.PUBKEY_COMPARATOR); Federation federation1 = new Federation( FederationTestUtils.getFederationMembersWithBtcKeys(federation1Keys), Instant.ofEpochMilli(1000L), 0L, btcParams ); Repository repository = createRepository(); repository.addBalance(PrecompiledContracts.BRIDGE_ADDR, LIMIT_MONETARY_BASE); Block executionBlock = mock(Block.class); when(executionBlock.getNumber()).thenReturn(10L); BtcECKey srcKey1 = new BtcECKey(); Address btcAddress = srcKey1.toAddress(btcParams); Coin amountToLock = Coin.COIN.multiply(5); BtcTransaction tx1 = new BtcTransaction(btcParams); tx1.addOutput(amountToLock, federation1.getAddress()); tx1.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey1)); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BridgeStorageProvider provider = new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations); provider.setNewFederation(federation1); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BtcLockSenderProvider btcLockSenderProvider = getBtcLockSenderProvider(BtcLockSender.TxType.P2SHMULTISIG, btcAddress, null); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, btcLockSenderProvider, executionBlock, mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 30; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 35, height); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmt.bitcoinSerialize()); Assert.assertEquals(LIMIT_MONETARY_BASE, repository.getBalance(PrecompiledContracts.BRIDGE_ADDR)); Assert.assertEquals(0, provider.getNewFederationBtcUTXOs().size()); Assert.assertEquals(0, provider.getReleaseRequestQueue().getEntries().size()); Assert.assertEquals(1, provider.getReleaseTransactionSet().getEntries().size()); List<BtcTransaction> releaseTxs = provider.getReleaseTransactionSet().getEntries() .stream() .map(ReleaseTransactionSet.Entry::getTransaction) .collect(Collectors.toList()); BtcTransaction releaseTx = releaseTxs.get(0); Assert.assertEquals(1, releaseTx.getOutputs().size()); Assert.assertThat(amountToLock.subtract(releaseTx.getOutput(0).getValue()), is(lessThanOrEqualTo(Coin.MILLICOIN))); Assert.assertEquals(btcAddress, releaseTx.getOutput(0).getScriptPubKey().getToAddress(btcParams)); Assert.assertEquals(1, releaseTx.getInputs().size()); Assert.assertEquals(tx1.getHash(), releaseTx.getInput(0).getOutpoint().getHash()); Assert.assertEquals(0, releaseTx.getInput(0).getOutpoint().getIndex()); Assert.assertTrue(provider.getRskTxsWaitingForSignatures().isEmpty()); Assert.assertTrue(provider.getHeightIfBtcTxhashIsAlreadyProcessed(tx1.getHash()).isPresent()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void when_registerBtcTransaction_usesMultisigWithWitnessType_beforeFork_no_lock_and_no_refund() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(false); List<BtcECKey> federation1Keys = Arrays.asList( BtcECKey.fromPrivate(Hex.decode("fa01")), BtcECKey.fromPrivate(Hex.decode("fa02")) ); federation1Keys.sort(BtcECKey.PUBKEY_COMPARATOR); Federation federation1 = new Federation( FederationTestUtils.getFederationMembersWithBtcKeys(federation1Keys), Instant.ofEpochMilli(1000L), 0L, btcParams ); Repository repository = createRepository(); repository.addBalance(PrecompiledContracts.BRIDGE_ADDR, LIMIT_MONETARY_BASE); Block executionBlock = mock(Block.class); when(executionBlock.getNumber()).thenReturn(10L); BtcECKey srcKey1 = new BtcECKey(); ECKey key = ECKey.fromPublicOnly(srcKey1.getPubKey()); Address btcAddress = srcKey1.toAddress(btcParams); RskAddress rskAddress = new RskAddress(key.getAddress()); Coin amountToLock = Coin.COIN.multiply(5); BtcTransaction tx1 = new BtcTransaction(btcParams); tx1.addOutput(amountToLock, federation1.getAddress()); tx1.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey1)); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BridgeStorageProvider provider = new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations); provider.setNewFederation(federation1); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BtcLockSenderProvider btcLockSenderProvider = getBtcLockSenderProvider(BtcLockSender.TxType.P2SHP2WSH, btcAddress, rskAddress); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, btcLockSenderProvider, executionBlock, mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 30; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 35, height); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmt.bitcoinSerialize()); Assert.assertEquals(co.rsk.core.Coin.ZERO, repository.getBalance(rskAddress)); Assert.assertEquals(LIMIT_MONETARY_BASE, repository.getBalance(PrecompiledContracts.BRIDGE_ADDR)); Assert.assertEquals(0, provider.getNewFederationBtcUTXOs().size()); Assert.assertEquals(0, provider.getReleaseRequestQueue().getEntries().size()); Assert.assertEquals(0, provider.getReleaseTransactionSet().getEntries().size()); Assert.assertTrue(provider.getRskTxsWaitingForSignatures().isEmpty()); Assert.assertFalse(provider.getHeightIfBtcTxhashIsAlreadyProcessed(tx1.getHash()).isPresent()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void when_registerBtcTransaction_usesMultisigWithWitnessType_afterFork_no_lock_and_refund() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); List<BtcECKey> federation1Keys = Arrays.asList( BtcECKey.fromPrivate(Hex.decode("fa01")), BtcECKey.fromPrivate(Hex.decode("fa02")) ); federation1Keys.sort(BtcECKey.PUBKEY_COMPARATOR); Federation federation1 = new Federation( FederationTestUtils.getFederationMembersWithBtcKeys(federation1Keys), Instant.ofEpochMilli(1000L), 0L, btcParams ); Repository repository = createRepository(); repository.addBalance(PrecompiledContracts.BRIDGE_ADDR, LIMIT_MONETARY_BASE); Block executionBlock = mock(Block.class); when(executionBlock.getNumber()).thenReturn(10L); BtcECKey srcKey1 = new BtcECKey(); Address btcAddress = srcKey1.toAddress(btcParams); Coin amountToLock = Coin.COIN.multiply(5); BtcTransaction tx1 = new BtcTransaction(btcParams); tx1.addOutput(amountToLock, federation1.getAddress()); tx1.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey1)); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BridgeStorageProvider provider = new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations); provider.setNewFederation(federation1); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BtcLockSenderProvider btcLockSenderProvider = getBtcLockSenderProvider(BtcLockSender.TxType.P2SHP2WSH, btcAddress, null); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, btcLockSenderProvider, executionBlock, mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 30; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 35, height); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmt.bitcoinSerialize()); Assert.assertEquals(LIMIT_MONETARY_BASE, repository.getBalance(PrecompiledContracts.BRIDGE_ADDR)); Assert.assertEquals(0, provider.getNewFederationBtcUTXOs().size()); Assert.assertEquals(0, provider.getReleaseRequestQueue().getEntries().size()); Assert.assertEquals(1, provider.getReleaseTransactionSet().getEntries().size()); List<BtcTransaction> releaseTxs = provider.getReleaseTransactionSet().getEntries() .stream() .map(ReleaseTransactionSet.Entry::getTransaction) .collect(Collectors.toList()); BtcTransaction releaseTx = releaseTxs.get(0); Assert.assertEquals(1, releaseTx.getOutputs().size()); Assert.assertThat(amountToLock.subtract(releaseTx.getOutput(0).getValue()), is(lessThanOrEqualTo(Coin.MILLICOIN))); Assert.assertEquals(btcAddress, releaseTx.getOutput(0).getScriptPubKey().getToAddress(btcParams)); Assert.assertEquals(1, releaseTx.getInputs().size()); Assert.assertEquals(tx1.getHash(), releaseTx.getInput(0).getOutpoint().getHash()); Assert.assertEquals(0, releaseTx.getInput(0).getOutpoint().getIndex()); Assert.assertTrue(provider.getRskTxsWaitingForSignatures().isEmpty()); Assert.assertTrue(provider.getHeightIfBtcTxhashIsAlreadyProcessed(tx1.getHash()).isPresent()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void toString_Empty() { Value val = new Value(null); String str = val.toString(); assertEquals("", str); }
|
public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } Value(); Value(Object obj); }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); void init(byte[] rlp); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); String getHex(); byte[] getData(); int[] asSlice(); Value get(int index); byte[] encode(); byte[] hash(); boolean isList(); boolean isString(); boolean isInt(); boolean isLong(); boolean isBigInt(); boolean isBytes(); boolean isReadableString(); boolean isHexString(); boolean isHashCode(); boolean isNull(); boolean isEmpty(); int length(); String toString(); }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); void init(byte[] rlp); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); String getHex(); byte[] getData(); int[] asSlice(); Value get(int index); byte[] encode(); byte[] hash(); boolean isList(); boolean isString(); boolean isInt(); boolean isLong(); boolean isBigInt(); boolean isBytes(); boolean isReadableString(); boolean isHexString(); boolean isHashCode(); boolean isNull(); boolean isEmpty(); int length(); String toString(); }
|
@Test(expected = VerificationException.EmptyInputsOrOutputs.class) public void registerBtcTransaction_rejects_tx_with_witness_before_rskip_143_activation() throws BlockStoreException, IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(false); Repository repository = createRepository(); BtcTransaction tx1 = new BtcTransaction(btcParams); tx1.addInput(Sha256Hash.ZERO_HASH, 0, new Script(new byte[]{})); TransactionWitness txWit = new TransactionWitness(1); txWit.setPush(0, new byte[]{}); tx1.setWitness(0, txWit); tx1.addOutput(Coin.COIN, Address.fromBase58(BridgeRegTestConstants.getInstance().getBtcParams(), "mvbnrCX3bg1cDRUu8pkecrvP6vQkSLDSou")); byte[] bits = new byte[1]; bits[0] = 0x3f; co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), Sha256Hash.ZERO_HASH, 1, 1, 1, new ArrayList<>() ); List<Sha256Hash> hashes2 = new ArrayList<>(); hashes2.add(tx1.getHash(true)); PartialMerkleTree pmtWithWitness = new PartialMerkleTree(btcParams, bits, hashes2, 1); int height = 50; StoredBlock block = new StoredBlock(registerHeader, new BigInteger("0"), height); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); when(btcBlockStore.getFromCache(registerHeader.getHash())).thenReturn(block); co.rsk.bitcoinj.core.BtcBlock headBlock = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(2), Sha256Hash.of(new byte[]{1}), 1, 1, 1, new ArrayList<>() ); StoredBlock chainHead = new StoredBlock(headBlock, new BigInteger("0"), 132); when(btcBlockStore.getChainHead()).thenReturn(chainHead); when(btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight())).thenReturn(block); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); BridgeSupport bridgeSupport = getBridgeSupport(provider, repository, mockFactory); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmtWithWitness.bitcoinSerialize()); verify(btcBlockStore, never()).getStoredBlockAtMainChainHeight(height); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void registerBtcTransaction_accepts_lock_tx_with_witness_after_rskip_143_activation() throws BlockStoreException, IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); List<BtcECKey> federation1Keys = Arrays.asList( BtcECKey.fromPrivate(Hex.decode("fa01")), BtcECKey.fromPrivate(Hex.decode("fa02")) ); federation1Keys.sort(BtcECKey.PUBKEY_COMPARATOR); Federation federation1 = new Federation( FederationTestUtils.getFederationMembersWithBtcKeys(federation1Keys), Instant.ofEpochMilli(1000L), 0L, btcParams ); Repository repository = createRepository(); BtcTransaction tx1 = new BtcTransaction(btcParams); BtcECKey srcKey1 = new BtcECKey(); ECKey key = ECKey.fromPublicOnly(srcKey1.getPubKey()); Address btcAddress = srcKey1.toAddress(btcParams); RskAddress rskAddress = new RskAddress(key.getAddress()); Coin amountToLock = Coin.COIN.multiply(10); tx1.addOutput(amountToLock, federation1.getAddress()); tx1.addInput(PegTestUtils.createHash(1), 0, new Script(new byte[]{})); TransactionWitness txWit = new TransactionWitness(1); txWit.setPush(0, new byte[]{}); tx1.setWitness(0, txWit); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmtWithoutWitness = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash blockMerkleRoot = pmtWithoutWitness.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), blockMerkleRoot, 1, 1, 1, new ArrayList<>() ); List<Sha256Hash> hashes2 = new ArrayList<>(); hashes2.add(tx1.getHash(true)); PartialMerkleTree pmtWithWitness = new PartialMerkleTree(btcParams, bits, hashes2, 1); List<Sha256Hash> hashlist2 = new ArrayList<>(); Sha256Hash witnessMerkleRoot = pmtWithWitness.getTxnHashAndMerkleRoot(hashlist2); int height = 50; StoredBlock block = new StoredBlock(registerHeader, new BigInteger("0"), height); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); co.rsk.bitcoinj.core.BtcBlock headBlock = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(2), Sha256Hash.of(new byte[]{1}), 1, 1, 1, new ArrayList<>() ); StoredBlock chainHead = new StoredBlock(headBlock, new BigInteger("0"), 132); when(btcBlockStore.getChainHead()).thenReturn(chainHead); when(btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight())).thenReturn(block); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeStorageProvider provider = new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations); provider.setNewFederation(federation1); LockWhitelist whitelist = provider.getLockWhitelist(); whitelist.put(btcAddress, new OneOffWhiteListEntry(btcAddress, Coin.COIN.multiply(10))); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, getBtcLockSenderProvider(BtcLockSender.TxType.P2SHP2WPKH, btcAddress, rskAddress), mock(Block.class), mockFactory, activations ); CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(registerHeader.getHash(), coinbaseInformation); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmtWithWitness.bitcoinSerialize()); co.rsk.core.Coin totalAmountExpectedToHaveBeenLocked = co.rsk.core.Coin.fromBitcoin(amountToLock); Assert.assertEquals(totalAmountExpectedToHaveBeenLocked, repository.getBalance(rskAddress)); Assert.assertEquals(1, provider.getNewFederationBtcUTXOs().size()); Assert.assertEquals(amountToLock, provider.getNewFederationBtcUTXOs().get(0).getValue()); Assert.assertEquals(0, provider.getReleaseRequestQueue().getEntries().size()); Assert.assertEquals(0, provider.getReleaseTransactionSet().getEntries().size()); Assert.assertTrue(provider.getRskTxsWaitingForSignatures().isEmpty()); Assert.assertTrue(provider.getHeightIfBtcTxhashIsAlreadyProcessed(tx1.getHash(false)).isPresent()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void registerBtcTransaction_rejects_tx_with_witness_and_unregistered_coinbase_after_rskip_143_activation() throws BlockStoreException, IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); BtcTransaction tx1 = new BtcTransaction(btcParams); BtcECKey srcKey1 = new BtcECKey(); ECKey key = ECKey.fromPublicOnly(srcKey1.getPubKey()); Address btcAddress = srcKey1.toAddress(btcParams); RskAddress rskAddress = new RskAddress(key.getAddress()); Coin amountToLock = Coin.COIN.multiply(10); tx1.addOutput(amountToLock, Address.fromBase58(BridgeRegTestConstants.getInstance().getBtcParams(), "mvbnrCX3bg1cDRUu8pkecrvP6vQkSLDSou")); tx1.addInput(PegTestUtils.createHash(1), 0, new Script(new byte[]{})); TransactionWitness txWit = new TransactionWitness(1); txWit.setPush(0, new byte[]{}); tx1.setWitness(0, txWit); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmtWithoutWitness = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash blockMerkleRoot = pmtWithoutWitness.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), blockMerkleRoot, 1, 1, 1, new ArrayList<>() ); List<Sha256Hash> hashes2 = new ArrayList<>(); hashes2.add(tx1.getHash(true)); PartialMerkleTree pmtWithWitness = new PartialMerkleTree(btcParams, bits, hashes2, 1); int height = 50; StoredBlock block = new StoredBlock(registerHeader, new BigInteger("0"), height); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); co.rsk.bitcoinj.core.BtcBlock headBlock = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(2), Sha256Hash.of(new byte[]{1}), 1, 1, 1, new ArrayList<>() ); StoredBlock chainHead = new StoredBlock(headBlock, new BigInteger("0"), 132); when(btcBlockStore.getChainHead()).thenReturn(chainHead); when(btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight())).thenReturn(block); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeStorageProvider provider = spy(new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations)); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, getBtcLockSenderProvider(BtcLockSender.TxType.P2SHP2WPKH, btcAddress, rskAddress), mock(Block.class), mockFactory, activations ); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmtWithWitness.bitcoinSerialize()); verify(provider, never()).setHeightBtcTxhashAlreadyProcessed(tx1.getHash(true), height); verify(provider, never()).setHeightBtcTxhashAlreadyProcessed(any(Sha256Hash.class), anyLong()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void registerBtcTransaction_rejects_tx_with_witness_and_unqual_witness_root_after_rskip_143_activation() throws BlockStoreException, IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); BtcTransaction tx1 = new BtcTransaction(btcParams); BtcECKey srcKey1 = new BtcECKey(); ECKey key = ECKey.fromPublicOnly(srcKey1.getPubKey()); Address btcAddress = srcKey1.toAddress(btcParams); RskAddress rskAddress = new RskAddress(key.getAddress()); Coin amountToLock = Coin.COIN.multiply(10); tx1.addOutput(amountToLock, Address.fromBase58(BridgeRegTestConstants.getInstance().getBtcParams(), "mvbnrCX3bg1cDRUu8pkecrvP6vQkSLDSou")); tx1.addInput(PegTestUtils.createHash(1), 0, new Script(new byte[]{})); TransactionWitness txWit = new TransactionWitness(1); txWit.setPush(0, new byte[]{}); tx1.setWitness(0, txWit); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmtWithoutWitness = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash blockMerkleRoot = pmtWithoutWitness.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), blockMerkleRoot, 1, 1, 1, new ArrayList<>() ); List<Sha256Hash> hashes2 = new ArrayList<>(); hashes2.add(tx1.getHash(true)); PartialMerkleTree pmtWithWitness = new PartialMerkleTree(btcParams, bits, hashes2, 1); int height = 50; StoredBlock block = new StoredBlock(registerHeader, new BigInteger("0"), height); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); co.rsk.bitcoinj.core.BtcBlock headBlock = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(2), Sha256Hash.of(new byte[]{1}), 1, 1, 1, new ArrayList<>() ); StoredBlock chainHead = new StoredBlock(headBlock, new BigInteger("0"), 132); when(btcBlockStore.getChainHead()).thenReturn(chainHead); when(btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight())).thenReturn(block); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeStorageProvider provider = spy(new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations)); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, getBtcLockSenderProvider(BtcLockSender.TxType.P2SHP2WPKH, btcAddress, rskAddress), mock(Block.class), mockFactory, activations ); CoinbaseInformation coinbaseInformation = new CoinbaseInformation(Sha256Hash.ZERO_HASH); provider.setCoinbaseInformation(registerHeader.getHash(), coinbaseInformation); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmtWithWitness.bitcoinSerialize()); verify(provider, never()).setHeightBtcTxhashAlreadyProcessed(tx1.getHash(true), height); verify(provider, never()).setHeightBtcTxhashAlreadyProcessed(any(Sha256Hash.class), anyLong()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void registerBtcTransaction_rejects_tx_without_witness_unequal_roots_after_rskip_143() throws BlockStoreException, IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); BtcTransaction tx1 = new BtcTransaction(btcParams); BtcECKey srcKey1 = new BtcECKey(); ECKey key = ECKey.fromPublicOnly(srcKey1.getPubKey()); Address btcAddress = srcKey1.toAddress(btcParams); RskAddress rskAddress = new RskAddress(key.getAddress()); Coin amountToLock = Coin.COIN.multiply(10); tx1.addOutput(amountToLock, Address.fromBase58(BridgeRegTestConstants.getInstance().getBtcParams(), "mvbnrCX3bg1cDRUu8pkecrvP6vQkSLDSou")); tx1.addInput(PegTestUtils.createHash(1), 0, new Script(new byte[]{})); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmtWithoutWitness = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash blockMerkleRoot = pmtWithoutWitness.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), blockMerkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 50; StoredBlock block = new StoredBlock(registerHeader, new BigInteger("0"), height); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); co.rsk.bitcoinj.core.BtcBlock headBlock = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(2), Sha256Hash.of(new byte[]{1}), 1, 1, 1, new ArrayList<>() ); StoredBlock chainHead = new StoredBlock(headBlock, new BigInteger("0"), 132); when(btcBlockStore.getChainHead()).thenReturn(chainHead); when(btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight())).thenReturn(block); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeStorageProvider provider = spy(new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations)); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, getBtcLockSenderProvider(BtcLockSender.TxType.P2PKH, btcAddress, rskAddress), mock(Block.class), mockFactory, activations ); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmtWithoutWitness.bitcoinSerialize()); verify(provider, never()).setHeightBtcTxhashAlreadyProcessed(tx1.getHash(), height); verify(provider, never()).setHeightBtcTxhashAlreadyProcessed(any(Sha256Hash.class), anyLong()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void registerBtcTransaction_accepts_lock_tx_without_witness_after_rskip_143_activation() throws BlockStoreException, IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); List<BtcECKey> federation1Keys = Arrays.asList( BtcECKey.fromPrivate(Hex.decode("fa01")), BtcECKey.fromPrivate(Hex.decode("fa02")) ); federation1Keys.sort(BtcECKey.PUBKEY_COMPARATOR); Federation federation1 = new Federation( FederationTestUtils.getFederationMembersWithBtcKeys(federation1Keys), Instant.ofEpochMilli(1000L), 0L, btcParams ); Repository repository = createRepository(); BtcTransaction tx1 = new BtcTransaction(btcParams); BtcECKey srcKey1 = new BtcECKey(); ECKey key = ECKey.fromPublicOnly(srcKey1.getPubKey()); Address btcAddress = srcKey1.toAddress(btcParams); RskAddress rskAddress = new RskAddress(key.getAddress()); Coin amountToLock = Coin.COIN.multiply(10); tx1.addOutput(amountToLock, federation1.getAddress()); tx1.addInput(PegTestUtils.createHash(1), 0, new Script(new byte[]{})); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmtWithoutWitness = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash blockMerkleRoot = pmtWithoutWitness.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), blockMerkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 50; StoredBlock block = new StoredBlock(registerHeader, new BigInteger("0"), height); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); co.rsk.bitcoinj.core.BtcBlock headBlock = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(2), Sha256Hash.of(new byte[]{1}), 1, 1, 1, new ArrayList<>() ); StoredBlock chainHead = new StoredBlock(headBlock, new BigInteger("0"), 132); when(btcBlockStore.getChainHead()).thenReturn(chainHead); when(btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight())).thenReturn(block); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeStorageProvider provider = new BridgeStorageProvider(repository, contractAddress, bridgeConstants, activations); provider.setNewFederation(federation1); LockWhitelist whitelist = provider.getLockWhitelist(); whitelist.put(btcAddress, new OneOffWhiteListEntry(btcAddress, Coin.COIN.multiply(10))); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, getBtcLockSenderProvider(BtcLockSender.TxType.P2PKH, btcAddress, rskAddress), mock(Block.class), mockFactory, activations ); bridgeSupport.registerBtcTransaction(mock(Transaction.class), tx1.bitcoinSerialize(), height, pmtWithoutWitness.bitcoinSerialize()); co.rsk.core.Coin totalAmountExpectedToHaveBeenLocked = co.rsk.core.Coin.fromBitcoin(amountToLock); Assert.assertEquals(totalAmountExpectedToHaveBeenLocked, repository.getBalance(rskAddress)); Assert.assertEquals(1, provider.getNewFederationBtcUTXOs().size()); Assert.assertEquals(amountToLock, provider.getNewFederationBtcUTXOs().get(0).getValue()); Assert.assertEquals(0, provider.getReleaseRequestQueue().getEntries().size()); Assert.assertEquals(0, provider.getReleaseTransactionSet().getEntries().size()); Assert.assertTrue(provider.getRskTxsWaitingForSignatures().isEmpty()); Assert.assertTrue(provider.getHeightIfBtcTxhashIsAlreadyProcessed(tx1.getHash(true)).isPresent()); }
|
public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized) throws IOException, BlockStoreException { Context.propagate(btcContext); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); try { if (isAlreadyBtcTxHashProcessed(btcTxHash)) { throw new RegisterBtcTransactionException("Transaction already processed"); } if (!validationsForRegisterBtcTransaction(btcTxHash, height, pmtSerialized, btcTxSerialized)) { throw new RegisterBtcTransactionException("Could not validate transaction"); } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); if (isAlreadyBtcTxHashProcessed(btcTx.getHash(false))) { throw new RegisterBtcTransactionException("Transaction already processed"); } switch (getTransactionType(btcTx)) { case PEGIN: processPegIn(btcTx, rskTx, height, btcTxHash); break; case PEGOUT: processRelease(btcTx, btcTxHash); break; case MIGRATION: processMigration(btcTx, btcTxHash); break; default: logger.warn("[registerBtcTransaction] This is not a lock, a release nor a migration tx {}", btcTx); panicProcessor.panic("btclock", "This is not a lock, a release nor a migration tx " + btcTx); } } catch (RegisterBtcTransactionException e) { logger.warn("[registerBtcTransaction] Could not register transaction {}. Message: {}", btcTxHash, e.getMessage()); } } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void isBlockMerkleRootValid_equal_merkle_roots() { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(false); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, mock(BridgeStorageProvider.class), mock(Repository.class), mock(BtcLockSenderProvider.class), mock(Block.class), mock(BtcBlockStoreWithCache.Factory.class), activations ); Sha256Hash merkleRoot = PegTestUtils.createHash(1); BtcBlock btcBlock = mock(BtcBlock.class); when(btcBlock.getMerkleRoot()).thenReturn(merkleRoot); Assert.assertTrue(bridgeSupport.isBlockMerkleRootValid(merkleRoot, btcBlock)); }
|
@VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void isBlockMerkleRootValid_unequal_merkle_roots_before_rskip_143() { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(false); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, mock(BridgeStorageProvider.class), mock(Repository.class), mock(BtcLockSenderProvider.class), mock(Block.class), mock(BtcBlockStoreWithCache.Factory.class), activations ); Sha256Hash merkleRoot = PegTestUtils.createHash(1); BtcBlock btcBlock = mock(BtcBlock.class); when(btcBlock.getMerkleRoot()).thenReturn(Sha256Hash.ZERO_HASH); Assert.assertFalse(bridgeSupport.isBlockMerkleRootValid(merkleRoot, btcBlock)); }
|
@VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void isBlockMerkleRootValid_coinbase_information_null_after_rskip_143() { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); when(provider.getCoinbaseInformation(Sha256Hash.ZERO_HASH)).thenReturn(null); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, mock(Repository.class), mock(BtcLockSenderProvider.class), mock(Block.class), mock(BtcBlockStoreWithCache.Factory.class), activations ); BtcBlock btcBlock = mock(BtcBlock.class); when(btcBlock.getMerkleRoot()).thenReturn(Sha256Hash.ZERO_HASH); when(btcBlock.getHash()).thenReturn(Sha256Hash.ZERO_HASH); Assert.assertFalse(bridgeSupport.isBlockMerkleRootValid(PegTestUtils.createHash(1), btcBlock)); }
|
@VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void isBlockMerkleRootValid_coinbase_information_not_null_and_unequal_mroots_after_rskip_143() { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); CoinbaseInformation coinbaseInformation = new CoinbaseInformation(PegTestUtils.createHash(1)); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); when(provider.getCoinbaseInformation(Sha256Hash.ZERO_HASH)).thenReturn(coinbaseInformation); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, mock(Repository.class), mock(BtcLockSenderProvider.class), mock(Block.class), mock(BtcBlockStoreWithCache.Factory.class), activations ); BtcBlock btcBlock = mock(BtcBlock.class); when(btcBlock.getMerkleRoot()).thenReturn(Sha256Hash.ZERO_HASH); when(btcBlock.getHash()).thenReturn(Sha256Hash.ZERO_HASH); Assert.assertFalse(bridgeSupport.isBlockMerkleRootValid(PegTestUtils.createHash(2), btcBlock)); }
|
@VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void toString_SameString() { Value val = new Value("hello"); String str = val.toString(); assertEquals("hello", str); }
|
public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } Value(); Value(Object obj); }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); void init(byte[] rlp); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); String getHex(); byte[] getData(); int[] asSlice(); Value get(int index); byte[] encode(); byte[] hash(); boolean isList(); boolean isString(); boolean isInt(); boolean isLong(); boolean isBigInt(); boolean isBytes(); boolean isReadableString(); boolean isHexString(); boolean isHashCode(); boolean isNull(); boolean isEmpty(); int length(); String toString(); }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); void init(byte[] rlp); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); String getHex(); byte[] getData(); int[] asSlice(); Value get(int index); byte[] encode(); byte[] hash(); boolean isList(); boolean isString(); boolean isInt(); boolean isLong(); boolean isBigInt(); boolean isBytes(); boolean isReadableString(); boolean isHexString(); boolean isHashCode(); boolean isNull(); boolean isEmpty(); int length(); String toString(); }
|
@Test public void isBlockMerkleRootValid_coinbase_information_not_null_and_equal_mroots_after_rskip_143() { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Sha256Hash merkleRoot = PegTestUtils.createHash(1); CoinbaseInformation coinbaseInformation = new CoinbaseInformation(merkleRoot); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); when(provider.getCoinbaseInformation(Sha256Hash.ZERO_HASH)).thenReturn(coinbaseInformation); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, mock(Repository.class), mock(BtcLockSenderProvider.class), mock(Block.class), mock(BtcBlockStoreWithCache.Factory.class), activations ); BtcBlock btcBlock = mock(BtcBlock.class); when(btcBlock.getMerkleRoot()).thenReturn(Sha256Hash.ZERO_HASH); when(btcBlock.getHash()).thenReturn(Sha256Hash.ZERO_HASH); Assert.assertTrue(bridgeSupport.isBlockMerkleRootValid(merkleRoot, btcBlock)); }
|
@VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { @VisibleForTesting protected boolean isBlockMerkleRootValid(Sha256Hash merkleRoot, BtcBlock blockHeader) { boolean isValid = false; if (blockHeader.getMerkleRoot().equals(merkleRoot)) { logger.trace("block merkle root is valid"); isValid = true; } else { if (activations.isActive(ConsensusRule.RSKIP143)) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHeader.getHash()); if (coinbaseInformation == null) { logger.trace("coinbase information for block {} is not yet registered", blockHeader.getHash()); } isValid = coinbaseInformation != null && coinbaseInformation.getWitnessMerkleRoot().equals(merkleRoot); logger.trace("witness merkle root is {} valid", (isValid ? "":"NOT")); } else { logger.trace("RSKIP143 is not active, avoid checking witness merkle root"); } } return isValid; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void getBtcTransactionConfirmations_rejects_tx_with_witness_before_rskip_143() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(false); BtcTransaction tx1 = new BtcTransaction(btcParams); tx1.addOutput(Coin.COIN.multiply(10), Address.fromBase58(BridgeRegTestConstants.getInstance().getBtcParams(), "mvbnrCX3bg1cDRUu8pkecrvP6vQkSLDSou")); tx1.addInput(PegTestUtils.createHash(1), 0, new Script(new byte[]{})); TransactionWitness txWit = new TransactionWitness(1); txWit.setPush(0, new byte[]{}); tx1.setWitness(0, txWit); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash blockMerkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), blockMerkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 50; StoredBlock block = new StoredBlock(registerHeader, new BigInteger("0"), height); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); when(btcBlockStore.getFromCache(registerHeader.getHash())).thenReturn(block); StoredBlock chainHead = new StoredBlock(registerHeader, new BigInteger("0"), 132); when(btcBlockStore.getChainHead()).thenReturn(chainHead); when(btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight())).thenReturn(block); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); BridgeSupport bridgeSupport = getBridgeSupport(provider, mock(Repository.class), mockFactory); MerkleBranch merkleBranch = mock(MerkleBranch.class); int confirmations = bridgeSupport.getBtcTransactionConfirmations(tx1.getHash(true), registerHeader.getHash(), merkleBranch); Assert.assertEquals(-5, confirmations); }
|
public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void getBtcTransactionConfirmations_accepts_tx_with_witness_after_rskip_143() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); BtcTransaction tx1 = new BtcTransaction(btcParams); tx1.addOutput(Coin.COIN.multiply(10), Address.fromBase58(BridgeRegTestConstants.getInstance().getBtcParams(), "mvbnrCX3bg1cDRUu8pkecrvP6vQkSLDSou")); tx1.addInput(PegTestUtils.createHash(1), 0, new Script(new byte[]{})); TransactionWitness txWit = new TransactionWitness(1); txWit.setPush(0, new byte[]{}); tx1.setWitness(0, txWit); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash blockMerkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), blockMerkleRoot, 1, 1, 1, new ArrayList<>() ); List<Sha256Hash> hashes2 = new ArrayList<>(); hashes2.add(tx1.getHash(true)); PartialMerkleTree pmt2 = new PartialMerkleTree(btcParams, bits, hashes2, 1); List<Sha256Hash> hashlist2 = new ArrayList<>(); Sha256Hash witnessMerkleRoot = pmt2.getTxnHashAndMerkleRoot(hashlist2); int height = 50; StoredBlock block = new StoredBlock(registerHeader, new BigInteger("0"), height); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); when(btcBlockStore.getFromCache(registerHeader.getHash())).thenReturn(block); StoredBlock chainHead = new StoredBlock(registerHeader, new BigInteger("0"), 132); when(btcBlockStore.getChainHead()).thenReturn(chainHead); when(btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight())).thenReturn(block); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeStorageProvider provider = spy(new BridgeStorageProvider(repository, PrecompiledContracts.BRIDGE_ADDR, bridgeConstants, activations)); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), mockFactory, activations ); MerkleBranch merkleBranch = mock(MerkleBranch.class); when(merkleBranch.reduceFrom(tx1.getHash(true))).thenReturn(witnessMerkleRoot); CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(registerHeader.getHash(), coinbaseInformation); int confirmations = bridgeSupport.getBtcTransactionConfirmations(tx1.getHash(true), registerHeader.getHash(), merkleBranch); Assert.assertEquals(chainHead.getHeight() - block.getHeight() + 1, confirmations); }
|
public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void getBtcTransactionConfirmations_unregistered_coinbase_after_rskip_143() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); BtcTransaction tx1 = new BtcTransaction(btcParams); tx1.addOutput(Coin.COIN.multiply(10), Address.fromBase58(BridgeRegTestConstants.getInstance().getBtcParams(), "mvbnrCX3bg1cDRUu8pkecrvP6vQkSLDSou")); tx1.addInput(PegTestUtils.createHash(1), 0, new Script(new byte[]{})); TransactionWitness txWit = new TransactionWitness(1); txWit.setPush(0, new byte[]{}); tx1.setWitness(0, txWit); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash blockMerkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), blockMerkleRoot, 1, 1, 1, new ArrayList<>() ); List<Sha256Hash> hashes2 = new ArrayList<>(); hashes2.add(tx1.getHash(true)); PartialMerkleTree pmt2 = new PartialMerkleTree(btcParams, bits, hashes2, 1); List<Sha256Hash> hashlist2 = new ArrayList<>(); Sha256Hash witnessMerkleRoot = pmt2.getTxnHashAndMerkleRoot(hashlist2); int height = 50; StoredBlock block = new StoredBlock(registerHeader, new BigInteger("0"), height); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); when(btcBlockStore.getFromCache(registerHeader.getHash())).thenReturn(block); StoredBlock chainHead = new StoredBlock(registerHeader, new BigInteger("0"), 132); when(btcBlockStore.getChainHead()).thenReturn(chainHead); when(btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight())).thenReturn(block); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeStorageProvider provider = spy(new BridgeStorageProvider(repository, PrecompiledContracts.BRIDGE_ADDR, bridgeConstants, activations)); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), mockFactory, activations ); MerkleBranch merkleBranch = mock(MerkleBranch.class); when(merkleBranch.reduceFrom(tx1.getHash(true))).thenReturn(witnessMerkleRoot); int confirmations = bridgeSupport.getBtcTransactionConfirmations(tx1.getHash(true), registerHeader.getHash(), merkleBranch); Assert.assertEquals(-5, confirmations); }
|
public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void getBtcTransactionConfirmations_registered_coinbase_unequal_witnessroot_after_rskip_143() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); BtcTransaction tx1 = new BtcTransaction(btcParams); tx1.addOutput(Coin.COIN.multiply(10), Address.fromBase58(BridgeRegTestConstants.getInstance().getBtcParams(), "mvbnrCX3bg1cDRUu8pkecrvP6vQkSLDSou")); tx1.addInput(PegTestUtils.createHash(1), 0, new Script(new byte[]{})); TransactionWitness txWit = new TransactionWitness(1); txWit.setPush(0, new byte[]{}); tx1.setWitness(0, txWit); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash blockMerkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), blockMerkleRoot, 1, 1, 1, new ArrayList<>() ); List<Sha256Hash> hashes2 = new ArrayList<>(); hashes2.add(tx1.getHash(true)); PartialMerkleTree pmt2 = new PartialMerkleTree(btcParams, bits, hashes2, 1); List<Sha256Hash> hashlist2 = new ArrayList<>(); Sha256Hash witnessMerkleRoot = pmt2.getTxnHashAndMerkleRoot(hashlist2); int height = 50; StoredBlock block = new StoredBlock(registerHeader, new BigInteger("0"), height); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); when(btcBlockStore.getFromCache(registerHeader.getHash())).thenReturn(block); StoredBlock chainHead = new StoredBlock(registerHeader, new BigInteger("0"), 132); when(btcBlockStore.getChainHead()).thenReturn(chainHead); when(btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight())).thenReturn(block); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeStorageProvider provider = spy(new BridgeStorageProvider(repository, PrecompiledContracts.BRIDGE_ADDR, bridgeConstants, activations)); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), mockFactory, activations ); MerkleBranch merkleBranch = mock(MerkleBranch.class); when(merkleBranch.reduceFrom(tx1.getHash(true))).thenReturn(witnessMerkleRoot); CoinbaseInformation coinbaseInformation = new CoinbaseInformation(Sha256Hash.ZERO_HASH); provider.setCoinbaseInformation(registerHeader.getHash(), coinbaseInformation); int confirmations = bridgeSupport.getBtcTransactionConfirmations(tx1.getHash(true), registerHeader.getHash(), merkleBranch); Assert.assertEquals(-5, confirmations); }
|
public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void getBtcTransactionConfirmations_tx_without_witness_unequal_roots_after_rskip_143() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); BtcTransaction tx1 = new BtcTransaction(btcParams); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), Sha256Hash.ZERO_HASH, 1, 1, 1, new ArrayList<>() ); int height = 50; StoredBlock block = new StoredBlock(registerHeader, new BigInteger("0"), height); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); when(btcBlockStore.getFromCache(registerHeader.getHash())).thenReturn(block); StoredBlock chainHead = new StoredBlock(registerHeader, new BigInteger("0"), 132); when(btcBlockStore.getChainHead()).thenReturn(chainHead); when(btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight())).thenReturn(block); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeStorageProvider provider = spy(new BridgeStorageProvider(repository, PrecompiledContracts.BRIDGE_ADDR, bridgeConstants, activations)); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), mockFactory, activations ); MerkleBranch merkleBranch = mock(MerkleBranch.class); when(merkleBranch.reduceFrom(tx1.getHash())).thenReturn(PegTestUtils.createHash(5)); CoinbaseInformation coinbaseInformation = new CoinbaseInformation(Sha256Hash.ZERO_HASH); doReturn(coinbaseInformation).when(provider).getCoinbaseInformation(registerHeader.getHash()); int confirmations = bridgeSupport.getBtcTransactionConfirmations(tx1.getHash(), registerHeader.getHash(), merkleBranch); Assert.assertEquals(-5, confirmations); }
|
public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void getBtcTransactionConfirmations_accepts_tx_without_witness_after_rskip_143() throws Exception { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); BtcTransaction tx1 = new BtcTransaction(btcParams); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash blockMerkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), blockMerkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 50; StoredBlock block = new StoredBlock(registerHeader, new BigInteger("0"), height); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); when(btcBlockStore.getFromCache(registerHeader.getHash())).thenReturn(block); StoredBlock chainHead = new StoredBlock(registerHeader, new BigInteger("0"), 132); when(btcBlockStore.getChainHead()).thenReturn(chainHead); when(btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight())).thenReturn(block); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeStorageProvider provider = spy(new BridgeStorageProvider(repository, PrecompiledContracts.BRIDGE_ADDR, bridgeConstants, activations)); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), mockFactory, activations ); MerkleBranch merkleBranch = mock(MerkleBranch.class); when(merkleBranch.reduceFrom(tx1.getHash())).thenReturn(blockMerkleRoot); BtcBlock btcBlock = mock(BtcBlock.class); when(btcBlock.getMerkleRoot()).thenReturn(blockMerkleRoot); int confirmations = bridgeSupport.getBtcTransactionConfirmations(tx1.getHash(), registerHeader.getHash(), merkleBranch); Assert.assertEquals(chainHead.getHeight() - block.getHeight() + 1, confirmations); }
|
public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch) throws BlockStoreException, IOException { Context.propagate(btcContext); this.ensureBtcBlockChain(); StoredBlock block = btcBlockStore.getFromCache(btcBlockHash); if (block == null) { return BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; } final int bestChainHeight = getBtcBlockchainBestChainHeight(); final int blockDepth = Math.max(0, bestChainHeight - block.getHeight()); if (blockDepth > BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH) { return BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; } try { StoredBlock storedBlock = btcBlockStore.getStoredBlockAtMainChainHeight(block.getHeight()); if (storedBlock == null || !storedBlock.equals(block)){ return BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; } } catch (BlockStoreException e) { logger.warn(String.format( "Illegal state trying to get block with hash %s", btcBlockHash ), e); return BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; } Sha256Hash merkleRoot = merkleBranch.reduceFrom(btcTxHash); if (!isBlockMerkleRootValid(merkleRoot, block.getHeader())) { return BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; } return bestChainHeight - block.getHeight() + 1; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test(expected = BridgeIllegalArgumentException.class) public void when_RegisterBtcCoinbaseTransaction_wrong_witnessReservedValue_noSent() throws BlockStoreException, AddressFormatException, IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); byte[] rawTx = Hex.decode("020000000001010000000000000000000000000000000000000000000000000000000000000000fff" + "fffff0502cc000101ffffffff029c070395000000002321036d6b5bc8c0e902f296b5bdf3dfd4b6f095d8d0987818a557e1766e" + "a25c664524ac0000000000000000266a24aa21a9edfeb3b9170ae765cc6586edd67229eaa8bc19f9674d64cb10ee8a205f4ccf0" + "bc60120000000000000000000000000000000000000000000000000000000000000000000000000"); BtcTransaction txWithoutWitness = new BtcTransaction(btcParams, rawTx); byte[] witnessReservedValue = new byte[10]; BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x01; List<Sha256Hash> hashes = new ArrayList<>(); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); int height = 5; mockChainOfStoredBlocks(btcBlockStore, mock(BtcBlock.class), 5, height); when(btcBlockStore.getFromCache(mock(Sha256Hash.class))).thenReturn(new StoredBlock(mock(BtcBlock.class), BigInteger.ZERO, 0)); bridgeSupport.registerBtcCoinbaseTransaction(txWithoutWitness.bitcoinSerialize(), mock(Sha256Hash.class), pmt.bitcoinSerialize(), mock(Sha256Hash.class), witnessReservedValue); verify(mock(BridgeStorageProvider.class), never()).setCoinbaseInformation(any(Sha256Hash.class), any(CoinbaseInformation.class)); }
|
public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test(expected = BridgeIllegalArgumentException.class) public void when_RegisterBtcCoinbaseTransaction_MerkleTreeWrongFormat_noSent() throws BlockStoreException, AddressFormatException, IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); byte[] rawTx = Hex.decode("020000000001010000000000000000000000000000000000000000000000000000000000000000fff" + "fffff0502cc000101ffffffff029c070395000000002321036d6b5bc8c0e902f296b5bdf3dfd4b6f095d8d0987818a557e1766e" + "a25c664524ac0000000000000000266a24aa21a9edfeb3b9170ae765cc6586edd67229eaa8bc19f9674d64cb10ee8a205f4ccf0" + "bc60120000000000000000000000000000000000000000000000000000000000000000000000000"); BtcTransaction tx1 = new BtcTransaction(btcParams, rawTx); BtcTransaction txWithoutWitness = new BtcTransaction(btcParams, rawTx); byte[] witnessReservedValue = tx1.getWitness(0).getPush(0); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), mockFactory, activations ); int height = 5; mockChainOfStoredBlocks(btcBlockStore, mock(BtcBlock.class), 5, height); when(btcBlockStore.getFromCache(mock(Sha256Hash.class))).thenReturn(new StoredBlock(mock(BtcBlock.class), BigInteger.ZERO, 0)); bridgeSupport.registerBtcCoinbaseTransaction(txWithoutWitness.bitcoinSerialize(), mock(Sha256Hash.class), new byte[]{6,6,6}, mock(Sha256Hash.class), witnessReservedValue); verify(mock(BridgeStorageProvider.class), never()).setCoinbaseInformation(any(Sha256Hash.class), any(CoinbaseInformation.class)); }
|
public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void when_RegisterBtcCoinbaseTransaction_HashNotInPmt_noSent() throws BlockStoreException, AddressFormatException, IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); byte[] rawTx = Hex.decode("020000000001010000000000000000000000000000000000000000000000000000000000000000fff" + "fffff0502cc000101ffffffff029c070395000000002321036d6b5bc8c0e902f296b5bdf3dfd4b6f095d8d0987818a557e1766e" + "a25c664524ac0000000000000000266a24aa21a9edfeb3b9170ae765cc6586edd67229eaa8bc19f9674d64cb10ee8a205f4ccf0" + "bc60120000000000000000000000000000000000000000000000000000000000000000000000000"); BtcTransaction tx1 = new BtcTransaction(btcParams, rawTx); BtcTransaction txWithoutWitness = new BtcTransaction(btcParams, rawTx); Sha256Hash secondHashTx = Sha256Hash.wrap(Hex.decode("e3d0840a0825fb7d880e5cb8306745352920a8c7e8a30fac882b275e26c6bb65")); byte[] witnessReservedValue = tx1.getWitness(0).getPush(0); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(secondHashTx); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 5; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 5, height); when(btcBlockStore.getFromCache(registerHeader.getHash())).thenReturn(new StoredBlock(registerHeader, BigInteger.ZERO, 0)); bridgeSupport.registerBtcCoinbaseTransaction(txWithoutWitness.bitcoinSerialize(), mock(Sha256Hash.class), pmt.bitcoinSerialize(), mock(Sha256Hash.class), witnessReservedValue); verify(mock(BridgeStorageProvider.class), never()).setCoinbaseInformation(any(Sha256Hash.class), any(CoinbaseInformation.class)); }
|
public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void toString_Array() { Value val = new Value(new String[] {"hello", "world", "!"}); String str = val.toString(); assertEquals(" ['hello', 'world', '!'] ", str); }
|
public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } Value(); Value(Object obj); }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); void init(byte[] rlp); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); String getHex(); byte[] getData(); int[] asSlice(); Value get(int index); byte[] encode(); byte[] hash(); boolean isList(); boolean isString(); boolean isInt(); boolean isLong(); boolean isBigInt(); boolean isBytes(); boolean isReadableString(); boolean isHexString(); boolean isHashCode(); boolean isNull(); boolean isEmpty(); int length(); String toString(); }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); void init(byte[] rlp); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); String getHex(); byte[] getData(); int[] asSlice(); Value get(int index); byte[] encode(); byte[] hash(); boolean isList(); boolean isString(); boolean isInt(); boolean isLong(); boolean isBigInt(); boolean isBytes(); boolean isReadableString(); boolean isHexString(); boolean isHashCode(); boolean isNull(); boolean isEmpty(); int length(); String toString(); }
|
@Test(expected = VerificationException.class) public void when_RegisterBtcCoinbaseTransaction_notVerify_noSent() throws BlockStoreException, AddressFormatException, IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); BtcTransaction tx = new BtcTransaction(btcParams); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 5; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 5, height); when(btcBlockStore.getFromCache(registerHeader.getHash())).thenReturn(new StoredBlock(registerHeader, BigInteger.ZERO, 0)); bridgeSupport.registerBtcCoinbaseTransaction(tx.bitcoinSerialize(), registerHeader.getHash(), pmt.bitcoinSerialize(), mock(Sha256Hash.class), Sha256Hash.ZERO_HASH.getBytes()); verify(mock(BridgeStorageProvider.class), never()).setCoinbaseInformation(any(Sha256Hash.class), any(CoinbaseInformation.class)); }
|
public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void when_RegisterBtcCoinbaseTransaction_not_equal_merkle_root_noSent() throws BlockStoreException, AddressFormatException, IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); byte[] rawTx = Hex.decode("020000000001010000000000000000000000000000000000000000000000000000000000000000fff" + "fffff0502cc000101ffffffff029c070395000000002321036d6b5bc8c0e902f296b5bdf3dfd4b6f095d8d0987818a557e1766e" + "a25c664524ac0000000000000000266a24aa21a9edfeb3b9170ae765cc6586edd67229eaa8bc19f9674d64cb10ee8a205f4ccf0" + "bc60120000000000000000000000000000000000000000000000000000000000000000000000000"); BtcTransaction tx1 = new BtcTransaction(btcParams, rawTx); BtcTransaction txWithoutWitness = new BtcTransaction(btcParams, rawTx); txWithoutWitness.setWitness(0, null); byte[] witnessReservedValue = tx1.getWitness(0).getPush(0); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(txWithoutWitness.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), Sha256Hash.ZERO_HASH, 1, 1, 1, new ArrayList<>() ); int height = 5; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 5, height); BtcBlock btcBlock = mock(BtcBlock.class); StoredBlock storedBlock = mock(StoredBlock.class); when(btcBlock.getMerkleRoot()).thenReturn(Sha256Hash.ZERO_HASH); when(storedBlock.getHeader()).thenReturn(btcBlock); when(btcBlockStore.getFromCache(registerHeader.getHash())).thenReturn(storedBlock); bridgeSupport.registerBtcCoinbaseTransaction(txWithoutWitness.bitcoinSerialize(), registerHeader.getHash(), pmt.bitcoinSerialize(), mock(Sha256Hash.class), witnessReservedValue); verify(mock(BridgeStorageProvider.class), never()).setCoinbaseInformation(any(Sha256Hash.class), any(CoinbaseInformation.class)); }
|
public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test(expected = BridgeIllegalArgumentException.class) public void when_RegisterBtcCoinbaseTransaction_null_stored_block_noSent() throws BlockStoreException, AddressFormatException, IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); byte[] rawTx = Hex.decode("020000000001010000000000000000000000000000000000000000000000000000000000000000fff" + "fffff0502cc000101ffffffff029c070395000000002321036d6b5bc8c0e902f296b5bdf3dfd4b6f095d8d0987818a557e1766e" + "a25c664524ac0000000000000000266a24aa21a9edfeb3b9170ae765cc6586edd67229eaa8bc19f9674d64cb10ee8a205f4ccf0" + "bc60120000000000000000000000000000000000000000000000000000000000000000000000000"); BtcTransaction tx1 = new BtcTransaction(btcParams, rawTx); BtcTransaction txWithoutWitness = new BtcTransaction(btcParams, rawTx); Sha256Hash secondHashTx = Sha256Hash.wrap(Hex.decode("e3d0840a0825fb7d880e5cb8306745352920a8c7e8a30fac882b275e26c6bb65")); txWithoutWitness.setWitness(0, null); byte[] witnessReservedValue = tx1.getWitness(0).getPush(0); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); hashes.add(secondHashTx); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 2); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 5; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 5, height); when(btcBlockStore.getFromCache(registerHeader.getHash())).thenReturn(null); bridgeSupport.registerBtcCoinbaseTransaction(txWithoutWitness.bitcoinSerialize(), mock(Sha256Hash.class), pmt.bitcoinSerialize(), mock(Sha256Hash.class), witnessReservedValue); verify(mock(BridgeStorageProvider.class), never()).setCoinbaseInformation(any(Sha256Hash.class), any(CoinbaseInformation.class)); }
|
public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void registerBtcCoinbaseTransaction() throws BlockStoreException, AddressFormatException, IOException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); byte[] rawTx = Hex.decode("020000000001010000000000000000000000000000000000000000000000000000000000000000fff" + "fffff0502cc000101ffffffff029c070395000000002321036d6b5bc8c0e902f296b5bdf3dfd4b6f095d8d0987818a557e1766e" + "a25c664524ac0000000000000000266a24aa21a9edfeb3b9170ae765cc6586edd67229eaa8bc19f9674d64cb10ee8a205f4ccf0" + "bc60120000000000000000000000000000000000000000000000000000000000000000000000000"); BtcTransaction tx1 = new BtcTransaction(btcParams, rawTx); BtcTransaction txWithoutWitness = new BtcTransaction(btcParams, rawTx); Sha256Hash secondHashTx = Sha256Hash.wrap(Hex.decode("e3d0840a0825fb7d880e5cb8306745352920a8c7e8a30fac882b275e26c6bb65")); Sha256Hash mRoot = MerkleTreeUtils.combineLeftRight(tx1.getHash(), secondHashTx); txWithoutWitness.setWitness(0, null); byte[] witnessReservedValue = tx1.getWitness(0).getPush(0); Sha256Hash witnessRoot = MerkleTreeUtils.combineLeftRight(Sha256Hash.ZERO_HASH, secondHashTx); byte[] witnessRootBytes = witnessRoot.getReversedBytes(); byte[] wc = tx1.getOutputs().stream().filter(t -> t.getValue().getValue() == 0).collect(Collectors.toList()).get(0).getScriptPubKey().getChunks().get(1).data; wc = Arrays.copyOfRange(wc,4, 36); Sha256Hash witCom = Sha256Hash.wrap(wc); Assert.assertEquals(Sha256Hash.twiceOf(witnessRootBytes, witnessReservedValue), witCom); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(repository)).thenReturn(btcBlockStore); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), mockFactory, activations ); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx1.getHash()); hashes.add(secondHashTx); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 2); List<Sha256Hash> hashlist = new ArrayList<>(); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(hashlist); Assert.assertEquals(merkleRoot, mRoot); co.rsk.bitcoinj.core.BtcBlock registerHeader = new co.rsk.bitcoinj.core.BtcBlock( btcParams, 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<>() ); int height = 5; mockChainOfStoredBlocks(btcBlockStore, registerHeader, 5, height); when(btcBlockStore.getFromCache(registerHeader.getHash())).thenReturn(new StoredBlock(registerHeader, BigInteger.ZERO, 0)); bridgeSupport.registerBtcCoinbaseTransaction(txWithoutWitness.bitcoinSerialize(), registerHeader.getHash(), pmt.bitcoinSerialize(), witnessRoot, witnessReservedValue); ArgumentCaptor<CoinbaseInformation> argumentCaptor = ArgumentCaptor.forClass(CoinbaseInformation.class); verify(provider).setCoinbaseInformation(eq(registerHeader.getHash()), argumentCaptor.capture()); assertEquals(witnessRoot, argumentCaptor.getValue().getWitnessMerkleRoot()); }
|
public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue) throws IOException, BlockStoreException { Context.propagate(btcContext); this.ensureBtcBlockStore(); Sha256Hash btcTxHash = BtcTransactionFormatUtils.calculateBtcTxHash(btcTxSerialized); if (witnessReservedValue.length != 32) { logger.warn("[btcTx:{}] WitnessResevedValue length can't be different than 32 bytes", btcTxHash); throw new BridgeIllegalArgumentException("WitnessResevedValue length can't be different than 32 bytes"); } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { logger.warn("[btcTx:{}] PartialMerkleTree doesn't have expected size", btcTxHash); throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), pmtSerialized, 0); List<Sha256Hash> hashesInPmt = new ArrayList<>(); merkleRoot = pmt.getTxnHashAndMerkleRoot(hashesInPmt); if (!hashesInPmt.contains(btcTxHash)) { logger.warn("Supplied Btc Tx {} is not in the supplied partial merkle tree", btcTxHash); return; } } catch (VerificationException e) { logger.warn("[btcTx:{}] PartialMerkleTree could not be parsed", btcTxHash); throw new BridgeIllegalArgumentException(String.format("PartialMerkleTree could not be parsed %s", ByteUtil.toHexString(pmtSerialized)), e); } StoredBlock storedBlock = btcBlockStore.getFromCache(blockHash); if (storedBlock == null) { logger.warn("[btcTx:{}] Block not registered", btcTxHash); throw new BridgeIllegalArgumentException(String.format("Block not registered %s", blockHash.toString())); } BtcBlock blockHeader = storedBlock.getHeader(); if (!blockHeader.getMerkleRoot().equals(merkleRoot)) { String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return; } BtcTransaction btcTx = new BtcTransaction(bridgeConstants.getBtcParams(), btcTxSerialized); btcTx.verify(); Sha256Hash witnessCommitment = Sha256Hash.twiceOf(witnessMerkleRoot.getReversedBytes(), witnessReservedValue); if(!witnessCommitment.equals(btcTx.findWitnessCommitment())){ logger.warn("[btcTx:{}] WitnessCommitment does not match", btcTxHash); throw new BridgeIllegalArgumentException("WitnessCommitment does not match"); } CoinbaseInformation coinbaseInformation = new CoinbaseInformation(witnessMerkleRoot); provider.setCoinbaseInformation(blockHeader.getHash(), coinbaseInformation); logger.warn("[btcTx:{}] Registered coinbase information", btcTxHash); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void hasBtcCoinbaseTransaction_before_rskip_143_activation() throws AddressFormatException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(false); Repository repository = createRepository(); BridgeStorageProvider provider = new BridgeStorageProvider(repository, PrecompiledContracts.BRIDGE_ADDR, bridgeConstants, activations); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), mock(BtcBlockStoreWithCache.Factory.class), activations ); CoinbaseInformation coinbaseInformation = new CoinbaseInformation(Sha256Hash.ZERO_HASH); provider.setCoinbaseInformation(Sha256Hash.ZERO_HASH, coinbaseInformation); Assert.assertFalse(bridgeSupport.hasBtcBlockCoinbaseTransactionInformation(Sha256Hash.ZERO_HASH)); }
|
public boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHash); return coinbaseInformation != null; }
|
BridgeSupport { public boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHash); return coinbaseInformation != null; } }
|
BridgeSupport { public boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHash); return coinbaseInformation != null; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHash); return coinbaseInformation != null; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHash); return coinbaseInformation != null; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void hasBtcCoinbaseTransaction_after_rskip_143_activation() throws AddressFormatException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); BridgeStorageProvider provider = new BridgeStorageProvider(repository, PrecompiledContracts.BRIDGE_ADDR, bridgeConstants, activations); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), mock(BtcBlockStoreWithCache.Factory.class), activations ); CoinbaseInformation coinbaseInformation = new CoinbaseInformation(Sha256Hash.ZERO_HASH); provider.setCoinbaseInformation(Sha256Hash.ZERO_HASH, coinbaseInformation); Assert.assertTrue(bridgeSupport.hasBtcBlockCoinbaseTransactionInformation(Sha256Hash.ZERO_HASH)); }
|
public boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHash); return coinbaseInformation != null; }
|
BridgeSupport { public boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHash); return coinbaseInformation != null; } }
|
BridgeSupport { public boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHash); return coinbaseInformation != null; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHash); return coinbaseInformation != null; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHash); return coinbaseInformation != null; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void hasBtcCoinbaseTransaction_fails_with_null_coinbase_information_after_rskip_143_activation() throws AddressFormatException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); Repository repository = createRepository(); BridgeStorageProvider provider = mock(BridgeStorageProvider.class); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), mock(BtcBlockStoreWithCache.Factory.class), activations ); Assert.assertFalse(bridgeSupport.hasBtcBlockCoinbaseTransactionInformation(Sha256Hash.ZERO_HASH)); }
|
public boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHash); return coinbaseInformation != null; }
|
BridgeSupport { public boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHash); return coinbaseInformation != null; } }
|
BridgeSupport { public boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHash); return coinbaseInformation != null; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHash); return coinbaseInformation != null; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash) { CoinbaseInformation coinbaseInformation = provider.getCoinbaseInformation(blockHash); return coinbaseInformation != null; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void isAlreadyBtcTxHashProcessedHeight_true() throws IOException { Repository repository = createRepository(); BtcTransaction btcTransaction = new BtcTransaction(btcParams); BridgeStorageProvider provider = new BridgeStorageProvider(repository, PrecompiledContracts.BRIDGE_ADDR, bridgeConstants, activationsBeforeForks); provider.setHeightBtcTxhashAlreadyProcessed(btcTransaction.getHash(), 1L); BridgeSupport bridgeSupport = getBridgeSupport(bridgeConstants, provider); Assert.assertTrue(bridgeSupport.isAlreadyBtcTxHashProcessed(btcTransaction.getHash())); }
|
public boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash) throws IOException { if (getBtcTxHashProcessedHeight(btcTxHash) > -1L) { logger.warn("Supplied Btc Tx {} was already processed", btcTxHash); return true; } return false; }
|
BridgeSupport { public boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash) throws IOException { if (getBtcTxHashProcessedHeight(btcTxHash) > -1L) { logger.warn("Supplied Btc Tx {} was already processed", btcTxHash); return true; } return false; } }
|
BridgeSupport { public boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash) throws IOException { if (getBtcTxHashProcessedHeight(btcTxHash) > -1L) { logger.warn("Supplied Btc Tx {} was already processed", btcTxHash); return true; } return false; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash) throws IOException { if (getBtcTxHashProcessedHeight(btcTxHash) > -1L) { logger.warn("Supplied Btc Tx {} was already processed", btcTxHash); return true; } return false; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash) throws IOException { if (getBtcTxHashProcessedHeight(btcTxHash) > -1L) { logger.warn("Supplied Btc Tx {} was already processed", btcTxHash); return true; } return false; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void isAlreadyBtcTxHashProcessedHeight_false() throws IOException { BtcTransaction btcTransaction = new BtcTransaction(btcParams); BridgeSupport bridgeSupport = getBridgeSupport(bridgeConstants, mock(BridgeStorageProvider.class)); Assert.assertFalse(bridgeSupport.isAlreadyBtcTxHashProcessed(btcTransaction.getHash())); }
|
public boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash) throws IOException { if (getBtcTxHashProcessedHeight(btcTxHash) > -1L) { logger.warn("Supplied Btc Tx {} was already processed", btcTxHash); return true; } return false; }
|
BridgeSupport { public boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash) throws IOException { if (getBtcTxHashProcessedHeight(btcTxHash) > -1L) { logger.warn("Supplied Btc Tx {} was already processed", btcTxHash); return true; } return false; } }
|
BridgeSupport { public boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash) throws IOException { if (getBtcTxHashProcessedHeight(btcTxHash) > -1L) { logger.warn("Supplied Btc Tx {} was already processed", btcTxHash); return true; } return false; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash) throws IOException { if (getBtcTxHashProcessedHeight(btcTxHash) > -1L) { logger.warn("Supplied Btc Tx {} was already processed", btcTxHash); return true; } return false; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash) throws IOException { if (getBtcTxHashProcessedHeight(btcTxHash) > -1L) { logger.warn("Supplied Btc Tx {} was already processed", btcTxHash); return true; } return false; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void validationsForRegisterBtcTransaction_negative_height() throws BlockStoreException { BtcTransaction tx = new BtcTransaction(btcParams); Repository repository = createRepository(); BridgeStorageProvider provider = new BridgeStorageProvider(repository, PrecompiledContracts.BRIDGE_ADDR, bridgeConstants, activationsBeforeForks); BridgeSupport bridgeSupport = getBridgeSupport(bridgeConstants, provider); byte[] data = Hex.decode("ab"); Assert.assertFalse(bridgeSupport.validationsForRegisterBtcTransaction(tx.getHash(), -1, data, data)); }
|
@VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void toString_UnsupportedType() { Value val = new Value('a'); String str = val.toString(); assertEquals("Unexpected type", str); }
|
public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } Value(); Value(Object obj); }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); void init(byte[] rlp); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); String getHex(); byte[] getData(); int[] asSlice(); Value get(int index); byte[] encode(); byte[] hash(); boolean isList(); boolean isString(); boolean isInt(); boolean isLong(); boolean isBigInt(); boolean isBytes(); boolean isReadableString(); boolean isHexString(); boolean isHashCode(); boolean isNull(); boolean isEmpty(); int length(); String toString(); }
|
Value { public String toString() { StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) { stringBuilder.append(", "); } } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(ByteUtil.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return ByteUtil.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); void init(byte[] rlp); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); String getHex(); byte[] getData(); int[] asSlice(); Value get(int index); byte[] encode(); byte[] hash(); boolean isList(); boolean isString(); boolean isInt(); boolean isLong(); boolean isBigInt(); boolean isBytes(); boolean isReadableString(); boolean isHexString(); boolean isHashCode(); boolean isNull(); boolean isEmpty(); int length(); String toString(); }
|
@Test public void validationsForRegisterBtcTransaction_insufficient_confirmations() throws IOException, BlockStoreException { BtcTransaction tx = new BtcTransaction(btcParams); BtcBlockStoreWithCache.Factory btcBlockStoreFactory = new RepositoryBtcBlockStoreWithCache.Factory(bridgeConstants.getBtcParams()); Repository repository = createRepository(); BridgeStorageProvider provider = new BridgeStorageProvider(repository, PrecompiledContracts.BRIDGE_ADDR, bridgeConstants, activationsBeforeForks); BridgeSupport bridgeSupport = getBridgeSupport(bridgeConstants, provider, repository, mock(BtcLockSenderProvider.class), mock(Block.class), btcBlockStoreFactory); byte[] data = Hex.decode("ab"); Assert.assertFalse(bridgeSupport.validationsForRegisterBtcTransaction(tx.getHash(), 100, data, data)); }
|
@VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test(expected = BridgeIllegalArgumentException.class) public void validationsForRegisterBtcTransaction_invalid_pmt() throws IOException, BlockStoreException { BtcTransaction btcTx = new BtcTransaction(btcParams); BridgeConstants bridgeConstants = mock(BridgeConstants.class); String pmtSerializedEncoded = "030000000279e7c0da739df8a00f12c0bff55e5438f530aa5859ff9874258cd7bad3fe709746aff89" + "7e6a851faa80120d6ae99db30883699ac0428fc7192d6c3fec0ca64010d"; byte[] pmtSerialized = Hex.decode(pmtSerializedEncoded); int btcTxHeight = 2; doReturn(btcParams).when(bridgeConstants).getBtcParams(); doReturn(0).when(bridgeConstants).getBtc2RskMinimumAcceptableConfirmations(); StoredBlock storedBlock = mock(StoredBlock.class); doReturn(btcTxHeight - 1).when(storedBlock).getHeight(); BtcBlock btcBlock = mock(BtcBlock.class); doReturn(Sha256Hash.of(Hex.decode("aa"))).when(btcBlock).getHash(); doReturn(btcBlock).when(storedBlock).getHeader(); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); doReturn(storedBlock).when(btcBlockStore).getChainHead(); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, mock(BridgeStorageProvider.class), mock(Repository.class), mock(BridgeEventLogger.class), null, mockFactory ); bridgeSupport.validationsForRegisterBtcTransaction(btcTx.getHash(), btcTxHeight, pmtSerialized, btcTx.bitcoinSerialize()); }
|
@VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void validationsForRegisterBtcTransaction_hash_not_in_pmt() throws BlockStoreException, AddressFormatException, IOException { BtcTransaction btcTx = new BtcTransaction(btcParams); BridgeConstants bridgeConstants = mock(BridgeConstants.class); byte[] bits = new byte[1]; bits[0] = 0x01; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(PegTestUtils.createHash(0)); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); int btcTxHeight = 2; doReturn(btcParams).when(bridgeConstants).getBtcParams(); doReturn(0).when(bridgeConstants).getBtc2RskMinimumAcceptableConfirmations(); StoredBlock storedBlock = mock(StoredBlock.class); doReturn(btcTxHeight - 1).when(storedBlock).getHeight(); BtcBlock btcBlock = mock(BtcBlock.class); doReturn(Sha256Hash.of(Hex.decode("aa"))).when(btcBlock).getHash(); doReturn(btcBlock).when(storedBlock).getHeader(); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); doReturn(storedBlock).when(btcBlockStore).getChainHead(); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, mock(BridgeStorageProvider.class), mock(Repository.class), mock(BridgeEventLogger.class), null, mockFactory ); Assert.assertFalse(bridgeSupport.validationsForRegisterBtcTransaction(btcTx.getHash(), 0, pmt.bitcoinSerialize(), btcTx.bitcoinSerialize())); }
|
@VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test(expected = VerificationException.class) public void validationsForRegisterBtcTransaction_tx_without_inputs_before_rskip_143() throws BlockStoreException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(false); BtcTransaction btcTx = new BtcTransaction(btcParams); BridgeConstants bridgeConstants = mock(BridgeConstants.class); byte[] bits = new byte[1]; bits[0] = 0x01; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(btcTx.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); int btcTxHeight = 2; doReturn(btcParams).when(bridgeConstants).getBtcParams(); doReturn(0).when(bridgeConstants).getBtc2RskMinimumAcceptableConfirmations(); StoredBlock storedBlock = mock(StoredBlock.class); doReturn(btcTxHeight - 1).when(storedBlock).getHeight(); BtcBlock btcBlock = mock(BtcBlock.class); doReturn(Sha256Hash.of(Hex.decode("aa"))).when(btcBlock).getHash(); doReturn(btcBlock).when(storedBlock).getHeader(); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); doReturn(storedBlock).when(btcBlockStore).getChainHead(); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, mock(BridgeStorageProvider.class), mock(Repository.class), mock(BridgeEventLogger.class), null, mockFactory, activations ); bridgeSupport.validationsForRegisterBtcTransaction(btcTx.getHash(), btcTxHeight, pmt.bitcoinSerialize(), btcTx.bitcoinSerialize()); }
|
@VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test(expected = VerificationException.class) public void validationsForRegisterBtcTransaction_tx_without_inputs_after_rskip_143() throws BlockStoreException { ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class); when(activations.isActive(ConsensusRule.RSKIP143)).thenReturn(true); BtcTransaction btcTx = new BtcTransaction(btcParams); BridgeConstants bridgeConstants = mock(BridgeConstants.class); byte[] bits = new byte[1]; bits[0] = 0x01; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(btcTx.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(btcParams, bits, hashes, 1); int btcTxHeight = 2; doReturn(btcParams).when(bridgeConstants).getBtcParams(); doReturn(0).when(bridgeConstants).getBtc2RskMinimumAcceptableConfirmations(); StoredBlock storedBlock = mock(StoredBlock.class); doReturn(btcTxHeight - 1).when(storedBlock).getHeight(); BtcBlock btcBlock = mock(BtcBlock.class); doReturn(Sha256Hash.of(Hex.decode("aa"))).when(btcBlock).getHash(); doReturn(btcBlock).when(storedBlock).getHeader(); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); doReturn(storedBlock).when(btcBlockStore).getChainHead(); BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class); when(mockFactory.newInstance(any())).thenReturn(btcBlockStore); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, mock(BridgeStorageProvider.class), mock(Repository.class), mock(BridgeEventLogger.class), null, mockFactory, activations ); bridgeSupport.validationsForRegisterBtcTransaction(btcTx.getHash(), 0, pmt.bitcoinSerialize(), Hex.decode("00000000000100")); }
|
@VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void validationsForRegisterBtcTransaction_invalid_block_merkle_root() throws IOException, BlockStoreException { BridgeStorageProvider mockBridgeStorageProvider = mock(BridgeStorageProvider.class); when(mockBridgeStorageProvider.getHeightIfBtcTxhashIsAlreadyProcessed(any(Sha256Hash.class))).thenReturn(Optional.empty()); BtcBlockStoreWithCache.Factory btcBlockStoreFactory = mock(BtcBlockStoreWithCache.Factory.class); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); when(btcBlockStoreFactory.newInstance(any(Repository.class))).thenReturn(btcBlockStore); BtcTransaction tx = new BtcTransaction(bridgeConstants.getBtcParams()); BtcECKey srcKey = new BtcECKey(); tx.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey)); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), bits, hashes, 1); co.rsk.bitcoinj.core.BtcBlock btcBlock = new co.rsk.bitcoinj.core.BtcBlock(bridgeConstants.getBtcParams(), 1, PegTestUtils.createHash(), Sha256Hash.ZERO_HASH, 1, 1, 1, new ArrayList<>()); int height = 1; mockChainOfStoredBlocks(btcBlockStore, btcBlock, height + bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(), height); BridgeSupport bridgeSupport = new BridgeSupport( bridgeConstants, mockBridgeStorageProvider, mock(BridgeEventLogger.class), new BtcLockSenderProvider(), mock(Repository.class), mock(Block.class), mock(Context.class), mock(FederationSupport.class), btcBlockStoreFactory, mock(ActivationConfig.ForBlock.class) ); Assert.assertFalse(bridgeSupport.validationsForRegisterBtcTransaction(tx.getHash(), height, pmt.bitcoinSerialize(), tx.bitcoinSerialize())); }
|
@VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void validationsForRegisterBtcTransaction_successful() throws IOException, BlockStoreException { BridgeStorageProvider mockBridgeStorageProvider = mock(BridgeStorageProvider.class); when(mockBridgeStorageProvider.getHeightIfBtcTxhashIsAlreadyProcessed(any(Sha256Hash.class))).thenReturn(Optional.empty()); when(mockBridgeStorageProvider.getNewFederation()).thenReturn(bridgeConstants.getGenesisFederation()); BtcBlockStoreWithCache.Factory btcBlockStoreFactory = mock(BtcBlockStoreWithCache.Factory.class); BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class); when(btcBlockStoreFactory.newInstance(any(Repository.class))).thenReturn(btcBlockStore); Coin lockValue = Coin.COIN; BtcTransaction tx = new BtcTransaction(bridgeConstants.getBtcParams()); tx.addOutput(lockValue, mockBridgeStorageProvider.getNewFederation().getAddress()); BtcECKey srcKey = new BtcECKey(); tx.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey)); byte[] bits = new byte[1]; bits[0] = 0x3f; List<Sha256Hash> hashes = new ArrayList<>(); hashes.add(tx.getHash()); PartialMerkleTree pmt = new PartialMerkleTree(bridgeConstants.getBtcParams(), bits, hashes, 1); Sha256Hash merkleRoot = pmt.getTxnHashAndMerkleRoot(new ArrayList<>()); co.rsk.bitcoinj.core.BtcBlock btcBlock = new co.rsk.bitcoinj.core.BtcBlock(bridgeConstants.getBtcParams(), 1, PegTestUtils.createHash(), merkleRoot, 1, 1, 1, new ArrayList<>()); int height = 1; mockChainOfStoredBlocks(btcBlockStore, btcBlock, height + bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(), height); BridgeSupport bridgeSupport = new BridgeSupport( bridgeConstants, mockBridgeStorageProvider, mock(BridgeEventLogger.class), new BtcLockSenderProvider(), mock(Repository.class), mock(Block.class), mock(Context.class), mock(FederationSupport.class), btcBlockStoreFactory, mock(ActivationConfig.ForBlock.class) ); Assert.assertTrue(bridgeSupport.validationsForRegisterBtcTransaction(tx.getHash(), height, pmt.bitcoinSerialize(), tx.bitcoinSerialize())); }
|
@VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { @VisibleForTesting protected boolean validationsForRegisterBtcTransaction(Sha256Hash btcTxHash, int height, byte[] pmtSerialized, byte[] btcTxSerialized) throws BlockStoreException, VerificationException.EmptyInputsOrOutputs, BridgeIllegalArgumentException { try { int acceptableConfirmationsAmount = bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(); if (!BridgeUtils.validateHeightAndConfirmations(height, getBtcBlockchainBestChainHeight(), acceptableConfirmationsAmount, btcTxHash)) { return false; } } catch (Exception e) { String panicMessage = String.format("Btc Tx %s Supplied Height is %d but should be greater than 0", btcTxHash, height); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } if (!PartialMerkleTreeFormatUtils.hasExpectedSize(pmtSerialized)) { throw new BridgeIllegalArgumentException("PartialMerkleTree doesn't have expected size"); } Sha256Hash merkleRoot; try { NetworkParameters networkParameters = bridgeConstants.getBtcParams(); merkleRoot = BridgeUtils.calculateMerkleRoot(networkParameters, pmtSerialized, btcTxHash); if (merkleRoot == null) { return false; } } catch (VerificationException e) { throw new BridgeIllegalArgumentException(e.getMessage(), e); } logger.info("Going to validate inputs for btc tx {}", btcTxHash); BridgeUtils.validateInputsCount(btcTxSerialized, activations.isActive(ConsensusRule.RSKIP143)); BtcBlock blockHeader = btcBlockStore.getStoredBlockAtMainChainHeight(height).getHeader(); if (!isBlockMerkleRootValid(merkleRoot, blockHeader)){ String panicMessage = String.format( "Btc Tx %s Supplied merkle root %s does not match block's merkle root %s", btcTxHash.toString(), merkleRoot, blockHeader.getMerkleRoot() ); logger.warn(panicMessage); panicProcessor.panic("btclock", panicMessage); return false; } return true; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void addSignature_fedPubKey_no_belong_to_active_federation_no_existing_retiring_fed() throws Exception { BridgeStorageProvider provider = mock(BridgeStorageProvider.class); BridgeSupport bridgeSupport = getBridgeSupport( bridgeConstants, provider, mock(Repository.class), mock(BridgeEventLogger.class), mock(Block.class), null ); bridgeSupport.addSignature(BtcECKey.fromPrivate(Hex.decode("fa03")), null, PegTestUtils.createHash3(1).getBytes()); verify(provider, times(0)).getRskTxsWaitingForSignatures(); }
|
public void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash) throws Exception { Context.propagate(btcContext); Federation retiringFederation = getRetiringFederation(); Federation activeFederation = getActiveFederation(); Federation federation = activeFederation.hasBtcPublicKey(federatorPublicKey) ? activeFederation : (retiringFederation != null && retiringFederation.hasBtcPublicKey(federatorPublicKey) ? retiringFederation: null); if (federation == null) { logger.warn("Supplied federator public key {} does not belong to any of the federators.", federatorPublicKey); return; } BtcTransaction btcTx = provider.getRskTxsWaitingForSignatures().get(new Keccak256(rskTxHash)); if (btcTx == null) { logger.warn("No tx waiting for signature for hash {}. Probably fully signed already.", new Keccak256(rskTxHash)); return; } if (btcTx.getInputs().size() != signatures.size()) { logger.warn("Expected {} signatures but received {}.", btcTx.getInputs().size(), signatures.size()); return; } eventLogger.logAddSignature(federatorPublicKey, btcTx, rskTxHash); processSigning(federatorPublicKey, signatures, rskTxHash, btcTx, federation); }
|
BridgeSupport { public void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash) throws Exception { Context.propagate(btcContext); Federation retiringFederation = getRetiringFederation(); Federation activeFederation = getActiveFederation(); Federation federation = activeFederation.hasBtcPublicKey(federatorPublicKey) ? activeFederation : (retiringFederation != null && retiringFederation.hasBtcPublicKey(federatorPublicKey) ? retiringFederation: null); if (federation == null) { logger.warn("Supplied federator public key {} does not belong to any of the federators.", federatorPublicKey); return; } BtcTransaction btcTx = provider.getRskTxsWaitingForSignatures().get(new Keccak256(rskTxHash)); if (btcTx == null) { logger.warn("No tx waiting for signature for hash {}. Probably fully signed already.", new Keccak256(rskTxHash)); return; } if (btcTx.getInputs().size() != signatures.size()) { logger.warn("Expected {} signatures but received {}.", btcTx.getInputs().size(), signatures.size()); return; } eventLogger.logAddSignature(federatorPublicKey, btcTx, rskTxHash); processSigning(federatorPublicKey, signatures, rskTxHash, btcTx, federation); } }
|
BridgeSupport { public void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash) throws Exception { Context.propagate(btcContext); Federation retiringFederation = getRetiringFederation(); Federation activeFederation = getActiveFederation(); Federation federation = activeFederation.hasBtcPublicKey(federatorPublicKey) ? activeFederation : (retiringFederation != null && retiringFederation.hasBtcPublicKey(federatorPublicKey) ? retiringFederation: null); if (federation == null) { logger.warn("Supplied federator public key {} does not belong to any of the federators.", federatorPublicKey); return; } BtcTransaction btcTx = provider.getRskTxsWaitingForSignatures().get(new Keccak256(rskTxHash)); if (btcTx == null) { logger.warn("No tx waiting for signature for hash {}. Probably fully signed already.", new Keccak256(rskTxHash)); return; } if (btcTx.getInputs().size() != signatures.size()) { logger.warn("Expected {} signatures but received {}.", btcTx.getInputs().size(), signatures.size()); return; } eventLogger.logAddSignature(federatorPublicKey, btcTx, rskTxHash); processSigning(federatorPublicKey, signatures, rskTxHash, btcTx, federation); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { public void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash) throws Exception { Context.propagate(btcContext); Federation retiringFederation = getRetiringFederation(); Federation activeFederation = getActiveFederation(); Federation federation = activeFederation.hasBtcPublicKey(federatorPublicKey) ? activeFederation : (retiringFederation != null && retiringFederation.hasBtcPublicKey(federatorPublicKey) ? retiringFederation: null); if (federation == null) { logger.warn("Supplied federator public key {} does not belong to any of the federators.", federatorPublicKey); return; } BtcTransaction btcTx = provider.getRskTxsWaitingForSignatures().get(new Keccak256(rskTxHash)); if (btcTx == null) { logger.warn("No tx waiting for signature for hash {}. Probably fully signed already.", new Keccak256(rskTxHash)); return; } if (btcTx.getInputs().size() != signatures.size()) { logger.warn("Expected {} signatures but received {}.", btcTx.getInputs().size(), signatures.size()); return; } eventLogger.logAddSignature(federatorPublicKey, btcTx, rskTxHash); processSigning(federatorPublicKey, signatures, rskTxHash, btcTx, federation); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { public void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash) throws Exception { Context.propagate(btcContext); Federation retiringFederation = getRetiringFederation(); Federation activeFederation = getActiveFederation(); Federation federation = activeFederation.hasBtcPublicKey(federatorPublicKey) ? activeFederation : (retiringFederation != null && retiringFederation.hasBtcPublicKey(federatorPublicKey) ? retiringFederation: null); if (federation == null) { logger.warn("Supplied federator public key {} does not belong to any of the federators.", federatorPublicKey); return; } BtcTransaction btcTx = provider.getRskTxsWaitingForSignatures().get(new Keccak256(rskTxHash)); if (btcTx == null) { logger.warn("No tx waiting for signature for hash {}. Probably fully signed already.", new Keccak256(rskTxHash)); return; } if (btcTx.getInputs().size() != signatures.size()) { logger.warn("Expected {} signatures but received {}.", btcTx.getInputs().size(), signatures.size()); return; } eventLogger.logAddSignature(federatorPublicKey, btcTx, rskTxHash); processSigning(federatorPublicKey, signatures, rskTxHash, btcTx, federation); } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void getTransactionType_lock_tx() { BridgeSupport bridgeSupport = getBridgeSupport(bridgeConstants, mock(BridgeStorageProvider.class)); BtcTransaction btcTx = new BtcTransaction(btcParams); btcTx.addOutput(Coin.COIN.multiply(10), bridgeConstants.getGenesisFederation().getAddress()); btcTx.addInput(PegTestUtils.createHash(1), 0, new Script(new byte[]{})); Assert.assertEquals(BridgeSupport.TxType.PEGIN, bridgeSupport.getTransactionType(btcTx)); }
|
protected TxType getTransactionType(BtcTransaction btcTx) { if (BridgeUtils.isLockTx(btcTx, getLiveFederations(), btcContext, bridgeConstants)) { return TxType.PEGIN; } if (BridgeUtils.isMigrationTx(btcTx, getActiveFederation(), getRetiringFederation(), btcContext, bridgeConstants)) { return TxType.MIGRATION; } if (BridgeUtils.isReleaseTx(btcTx, getLiveFederations())) { return TxType.PEGOUT; } return TxType.UNKNOWN; }
|
BridgeSupport { protected TxType getTransactionType(BtcTransaction btcTx) { if (BridgeUtils.isLockTx(btcTx, getLiveFederations(), btcContext, bridgeConstants)) { return TxType.PEGIN; } if (BridgeUtils.isMigrationTx(btcTx, getActiveFederation(), getRetiringFederation(), btcContext, bridgeConstants)) { return TxType.MIGRATION; } if (BridgeUtils.isReleaseTx(btcTx, getLiveFederations())) { return TxType.PEGOUT; } return TxType.UNKNOWN; } }
|
BridgeSupport { protected TxType getTransactionType(BtcTransaction btcTx) { if (BridgeUtils.isLockTx(btcTx, getLiveFederations(), btcContext, bridgeConstants)) { return TxType.PEGIN; } if (BridgeUtils.isMigrationTx(btcTx, getActiveFederation(), getRetiringFederation(), btcContext, bridgeConstants)) { return TxType.MIGRATION; } if (BridgeUtils.isReleaseTx(btcTx, getLiveFederations())) { return TxType.PEGOUT; } return TxType.UNKNOWN; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { protected TxType getTransactionType(BtcTransaction btcTx) { if (BridgeUtils.isLockTx(btcTx, getLiveFederations(), btcContext, bridgeConstants)) { return TxType.PEGIN; } if (BridgeUtils.isMigrationTx(btcTx, getActiveFederation(), getRetiringFederation(), btcContext, bridgeConstants)) { return TxType.MIGRATION; } if (BridgeUtils.isReleaseTx(btcTx, getLiveFederations())) { return TxType.PEGOUT; } return TxType.UNKNOWN; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { protected TxType getTransactionType(BtcTransaction btcTx) { if (BridgeUtils.isLockTx(btcTx, getLiveFederations(), btcContext, bridgeConstants)) { return TxType.PEGIN; } if (BridgeUtils.isMigrationTx(btcTx, getActiveFederation(), getRetiringFederation(), btcContext, bridgeConstants)) { return TxType.MIGRATION; } if (BridgeUtils.isReleaseTx(btcTx, getLiveFederations())) { return TxType.PEGOUT; } return TxType.UNKNOWN; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void getTransactionType_release_tx() { BridgeSupport bridgeSupport = getBridgeSupport(bridgeConstants, mock(BridgeStorageProvider.class)); Federation federation = bridgeConstants.getGenesisFederation(); List<BtcECKey> federationPrivateKeys = BridgeRegTestConstants.REGTEST_FEDERATION_PRIVATE_KEYS; co.rsk.bitcoinj.core.Address randomAddress = new co.rsk.bitcoinj.core.Address( btcParams, org.bouncycastle.util.encoders.Hex.decode("4a22c3c4cbb31e4d03b15550636762bda0baf85a")); BtcTransaction releaseTx1 = new BtcTransaction(btcParams); releaseTx1.addOutput(co.rsk.bitcoinj.core.Coin.COIN, randomAddress); co.rsk.bitcoinj.core.TransactionInput releaseInput1 = new co.rsk.bitcoinj.core.TransactionInput(btcParams, releaseTx1, new byte[]{}, new co.rsk.bitcoinj.core.TransactionOutPoint( btcParams, 0, co.rsk.bitcoinj.core.Sha256Hash.ZERO_HASH) ); releaseTx1.addInput(releaseInput1); co.rsk.bitcoinj.script.Script redeemScript = createBaseRedeemScriptThatSpendsFromTheFederation(federation); co.rsk.bitcoinj.script.Script inputScript = createBaseInputScriptThatSpendsFromTheFederation(federation); releaseInput1.setScriptSig(inputScript); co.rsk.bitcoinj.core.Sha256Hash sighash = releaseTx1.hashForSignature( 0, redeemScript, BtcTransaction.SigHash.ALL, false); for (int i = 0; i < federation.getNumberOfSignaturesRequired(); i++) { BtcECKey federatorPrivKey = federationPrivateKeys.get(i); BtcECKey federatorPublicKey = federation.getBtcPublicKeys().get(i); BtcECKey.ECDSASignature sig = federatorPrivKey.sign(sighash); TransactionSignature txSig = new TransactionSignature(sig, BtcTransaction.SigHash.ALL, false); int sigIndex = inputScript.getSigInsertionIndex(sighash, federatorPublicKey); inputScript = ScriptBuilder.updateScriptWithSignature(inputScript, txSig.encodeToBitcoin(), sigIndex, 1, 1); } releaseInput1.setScriptSig(inputScript); Assert.assertEquals(BridgeSupport.TxType.PEGOUT, bridgeSupport.getTransactionType(releaseTx1)); }
|
protected TxType getTransactionType(BtcTransaction btcTx) { if (BridgeUtils.isLockTx(btcTx, getLiveFederations(), btcContext, bridgeConstants)) { return TxType.PEGIN; } if (BridgeUtils.isMigrationTx(btcTx, getActiveFederation(), getRetiringFederation(), btcContext, bridgeConstants)) { return TxType.MIGRATION; } if (BridgeUtils.isReleaseTx(btcTx, getLiveFederations())) { return TxType.PEGOUT; } return TxType.UNKNOWN; }
|
BridgeSupport { protected TxType getTransactionType(BtcTransaction btcTx) { if (BridgeUtils.isLockTx(btcTx, getLiveFederations(), btcContext, bridgeConstants)) { return TxType.PEGIN; } if (BridgeUtils.isMigrationTx(btcTx, getActiveFederation(), getRetiringFederation(), btcContext, bridgeConstants)) { return TxType.MIGRATION; } if (BridgeUtils.isReleaseTx(btcTx, getLiveFederations())) { return TxType.PEGOUT; } return TxType.UNKNOWN; } }
|
BridgeSupport { protected TxType getTransactionType(BtcTransaction btcTx) { if (BridgeUtils.isLockTx(btcTx, getLiveFederations(), btcContext, bridgeConstants)) { return TxType.PEGIN; } if (BridgeUtils.isMigrationTx(btcTx, getActiveFederation(), getRetiringFederation(), btcContext, bridgeConstants)) { return TxType.MIGRATION; } if (BridgeUtils.isReleaseTx(btcTx, getLiveFederations())) { return TxType.PEGOUT; } return TxType.UNKNOWN; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { protected TxType getTransactionType(BtcTransaction btcTx) { if (BridgeUtils.isLockTx(btcTx, getLiveFederations(), btcContext, bridgeConstants)) { return TxType.PEGIN; } if (BridgeUtils.isMigrationTx(btcTx, getActiveFederation(), getRetiringFederation(), btcContext, bridgeConstants)) { return TxType.MIGRATION; } if (BridgeUtils.isReleaseTx(btcTx, getLiveFederations())) { return TxType.PEGOUT; } return TxType.UNKNOWN; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { protected TxType getTransactionType(BtcTransaction btcTx) { if (BridgeUtils.isLockTx(btcTx, getLiveFederations(), btcContext, bridgeConstants)) { return TxType.PEGIN; } if (BridgeUtils.isMigrationTx(btcTx, getActiveFederation(), getRetiringFederation(), btcContext, bridgeConstants)) { return TxType.MIGRATION; } if (BridgeUtils.isReleaseTx(btcTx, getLiveFederations())) { return TxType.PEGOUT; } return TxType.UNKNOWN; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void isEmpty_Null() { Value val = new Value(null); assertTrue(val.isEmpty()); }
|
public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; }
|
Value { public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; } }
|
Value { public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; } Value(); Value(Object obj); }
|
Value { public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; } Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); void init(byte[] rlp); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); String getHex(); byte[] getData(); int[] asSlice(); Value get(int index); byte[] encode(); byte[] hash(); boolean isList(); boolean isString(); boolean isInt(); boolean isLong(); boolean isBigInt(); boolean isBytes(); boolean isReadableString(); boolean isHexString(); boolean isHashCode(); boolean isNull(); boolean isEmpty(); int length(); String toString(); }
|
Value { public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; } Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); void init(byte[] rlp); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); String getHex(); byte[] getData(); int[] asSlice(); Value get(int index); byte[] encode(); byte[] hash(); boolean isList(); boolean isString(); boolean isInt(); boolean isLong(); boolean isBigInt(); boolean isBytes(); boolean isReadableString(); boolean isHexString(); boolean isHashCode(); boolean isNull(); boolean isEmpty(); int length(); String toString(); }
|
@Test public void getTransactionType_unknown_tx() { BridgeSupport bridgeSupport = getBridgeSupport(bridgeConstants, mock(BridgeStorageProvider.class)); BtcTransaction btcTx = new BtcTransaction(btcParams); Assert.assertEquals(BridgeSupport.TxType.UNKNOWN, bridgeSupport.getTransactionType(btcTx)); }
|
protected TxType getTransactionType(BtcTransaction btcTx) { if (BridgeUtils.isLockTx(btcTx, getLiveFederations(), btcContext, bridgeConstants)) { return TxType.PEGIN; } if (BridgeUtils.isMigrationTx(btcTx, getActiveFederation(), getRetiringFederation(), btcContext, bridgeConstants)) { return TxType.MIGRATION; } if (BridgeUtils.isReleaseTx(btcTx, getLiveFederations())) { return TxType.PEGOUT; } return TxType.UNKNOWN; }
|
BridgeSupport { protected TxType getTransactionType(BtcTransaction btcTx) { if (BridgeUtils.isLockTx(btcTx, getLiveFederations(), btcContext, bridgeConstants)) { return TxType.PEGIN; } if (BridgeUtils.isMigrationTx(btcTx, getActiveFederation(), getRetiringFederation(), btcContext, bridgeConstants)) { return TxType.MIGRATION; } if (BridgeUtils.isReleaseTx(btcTx, getLiveFederations())) { return TxType.PEGOUT; } return TxType.UNKNOWN; } }
|
BridgeSupport { protected TxType getTransactionType(BtcTransaction btcTx) { if (BridgeUtils.isLockTx(btcTx, getLiveFederations(), btcContext, bridgeConstants)) { return TxType.PEGIN; } if (BridgeUtils.isMigrationTx(btcTx, getActiveFederation(), getRetiringFederation(), btcContext, bridgeConstants)) { return TxType.MIGRATION; } if (BridgeUtils.isReleaseTx(btcTx, getLiveFederations())) { return TxType.PEGOUT; } return TxType.UNKNOWN; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); }
|
BridgeSupport { protected TxType getTransactionType(BtcTransaction btcTx) { if (BridgeUtils.isLockTx(btcTx, getLiveFederations(), btcContext, bridgeConstants)) { return TxType.PEGIN; } if (BridgeUtils.isMigrationTx(btcTx, getActiveFederation(), getRetiringFederation(), btcContext, bridgeConstants)) { return TxType.MIGRATION; } if (BridgeUtils.isReleaseTx(btcTx, getLiveFederations())) { return TxType.PEGOUT; } return TxType.UNKNOWN; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); }
|
BridgeSupport { protected TxType getTransactionType(BtcTransaction btcTx) { if (BridgeUtils.isLockTx(btcTx, getLiveFederations(), btcContext, bridgeConstants)) { return TxType.PEGIN; } if (BridgeUtils.isMigrationTx(btcTx, getActiveFederation(), getRetiringFederation(), btcContext, bridgeConstants)) { return TxType.MIGRATION; } if (BridgeUtils.isReleaseTx(btcTx, getLiveFederations())) { return TxType.PEGOUT; } return TxType.UNKNOWN; } BridgeSupport(
BridgeConstants bridgeConstants,
BridgeStorageProvider provider,
BridgeEventLogger eventLogger,
BtcLockSenderProvider btcLockSenderProvider,
Repository repository,
Block executionBlock,
Context btcContext,
FederationSupport federationSupport,
BtcBlockStoreWithCache.Factory btcBlockStoreFactory,
ActivationConfig.ForBlock activations); List<ProgramSubtrace> getSubtraces(); void save(); void receiveHeaders(BtcBlock[] headers); Wallet getActiveFederationWallet(); Wallet getRetiringFederationWallet(); Wallet getUTXOBasedWalletForLiveFederations(List<UTXO> utxos); Wallet getNoSpendWalletForLiveFederations(); void registerBtcTransaction(Transaction rskTx, byte[] btcTxSerialized, int height, byte[] pmtSerialized); void releaseBtc(Transaction rskTx); Coin getFeePerKb(); void updateCollections(Transaction rskTx); void addSignature(BtcECKey federatorPublicKey, List<byte[]> signatures, byte[] rskTxHash); byte[] getStateForBtcReleaseClient(); byte[] getStateForDebugging(); int getBtcBlockchainBestChainHeight(); int getBtcBlockchainInitialBlockHeight(); @Deprecated List<Sha256Hash> getBtcBlockchainBlockLocator(); Sha256Hash getBtcBlockchainBlockHashAtDepth(int depth); Long getBtcTransactionConfirmationsGetCost(Object[] args); Integer getBtcTransactionConfirmations(Sha256Hash btcTxHash, Sha256Hash btcBlockHash, MerkleBranch merkleBranch); Boolean isBtcTxHashAlreadyProcessed(Sha256Hash btcTxHash); Long getBtcTxHashProcessedHeight(Sha256Hash btcTxHash); boolean isAlreadyBtcTxHashProcessed(Sha256Hash btcTxHash); Federation getActiveFederation(); @Nullable Federation getRetiringFederation(); Address getFederationAddress(); Integer getFederationSize(); Integer getFederationThreshold(); byte[] getFederatorPublicKey(int index); byte[] getFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getFederationCreationTime(); long getFederationCreationBlockNumber(); Address getRetiringFederationAddress(); Integer getRetiringFederationSize(); Integer getRetiringFederationThreshold(); byte[] getRetiringFederatorPublicKey(int index); byte[] getRetiringFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Instant getRetiringFederationCreationTime(); long getRetiringFederationCreationBlockNumber(); Integer voteFederationChange(Transaction tx, ABICallSpec callSpec); byte[] getPendingFederationHash(); Integer getPendingFederationSize(); byte[] getPendingFederatorPublicKey(int index); byte[] getPendingFederatorPublicKeyOfType(int index, FederationMember.KeyType keyType); Integer getLockWhitelistSize(); LockWhitelistEntry getLockWhitelistEntryByIndex(int index); LockWhitelistEntry getLockWhitelistEntryByAddress(String addressBase58); Integer addOneOffLockWhitelistAddress(Transaction tx, String addressBase58, BigInteger maxTransferValue); Integer addUnlimitedLockWhitelistAddress(Transaction tx, String addressBase58); Integer removeLockWhitelistAddress(Transaction tx, String addressBase58); Coin getMinimumLockTxValue(); Integer voteFeePerKbChange(Transaction tx, Coin feePerKb); Integer setLockWhitelistDisableBlockDelay(Transaction tx, BigInteger disableBlockDelayBI); Coin getLockingCap(); boolean increaseLockingCap(Transaction tx, Coin newCap); void registerBtcCoinbaseTransaction(byte[] btcTxSerialized, Sha256Hash blockHash, byte[] pmtSerialized, Sha256Hash witnessMerkleRoot, byte[] witnessReservedValue); boolean hasBtcBlockCoinbaseTransactionInformation(Sha256Hash blockHash); static final RskAddress BURN_ADDRESS; static final int MAX_RELEASE_ITERATIONS; static final Integer FEDERATION_CHANGE_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_GENERIC_ERROR_CODE; static final Integer LOCK_WHITELIST_INVALID_ADDRESS_FORMAT_ERROR_CODE; static final Integer LOCK_WHITELIST_ALREADY_EXISTS_ERROR_CODE; static final Integer LOCK_WHITELIST_UNKNOWN_ERROR_CODE; static final Integer LOCK_WHITELIST_SUCCESS_CODE; static final Integer FEE_PER_KB_GENERIC_ERROR_CODE; static final Integer NEGATIVE_FEE_PER_KB_ERROR_CODE; static final Integer EXCESSIVE_FEE_PER_KB_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INEXISTENT_BLOCK_HASH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_NOT_IN_BEST_CHAIN_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INCONSISTENT_BLOCK_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_BLOCK_TOO_OLD_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_INVALID_MERKLE_BRANCH_ERROR_CODE; static final Integer BTC_TRANSACTION_CONFIRMATION_MAX_DEPTH; }
|
@Test public void isAuthorized() { AddressBasedAuthorizer auth = new AddressBasedAuthorizer(Arrays.asList( ECKey.fromPrivate(BigInteger.valueOf(100L)), ECKey.fromPrivate(BigInteger.valueOf(101L)), ECKey.fromPrivate(BigInteger.valueOf(102L)) ), AddressBasedAuthorizer.MinimumRequiredCalculation.MAJORITY); for (long n = 100L; n <= 102L; n++) { Transaction mockedTx = mock(Transaction.class); when(mockedTx.getSender()).thenReturn(new RskAddress(ECKey.fromPrivate(BigInteger.valueOf(n)).getAddress())); Assert.assertTrue(auth.isAuthorized(new RskAddress(ECKey.fromPrivate(BigInteger.valueOf(n)).getAddress()))); Assert.assertTrue(auth.isAuthorized(mockedTx)); } Assert.assertFalse(auth.isAuthorized(new RskAddress(ECKey.fromPrivate(BigInteger.valueOf(50L)).getAddress()))); Transaction mockedTx = mock(Transaction.class); when(mockedTx.getSender()).thenReturn(new RskAddress(ECKey.fromPrivate(BigInteger.valueOf(50L)).getAddress())); Assert.assertFalse(auth.isAuthorized(mockedTx)); }
|
public boolean isAuthorized(RskAddress sender) { return authorizedAddresses.stream() .anyMatch(address -> Arrays.equals(address, sender.getBytes())); }
|
AddressBasedAuthorizer { public boolean isAuthorized(RskAddress sender) { return authorizedAddresses.stream() .anyMatch(address -> Arrays.equals(address, sender.getBytes())); } }
|
AddressBasedAuthorizer { public boolean isAuthorized(RskAddress sender) { return authorizedAddresses.stream() .anyMatch(address -> Arrays.equals(address, sender.getBytes())); } AddressBasedAuthorizer(List<ECKey> authorizedKeys, MinimumRequiredCalculation requiredCalculation); }
|
AddressBasedAuthorizer { public boolean isAuthorized(RskAddress sender) { return authorizedAddresses.stream() .anyMatch(address -> Arrays.equals(address, sender.getBytes())); } AddressBasedAuthorizer(List<ECKey> authorizedKeys, MinimumRequiredCalculation requiredCalculation); boolean isAuthorized(RskAddress sender); boolean isAuthorized(Transaction tx); int getNumberOfAuthorizedKeys(); int getRequiredAuthorizedKeys(); }
|
AddressBasedAuthorizer { public boolean isAuthorized(RskAddress sender) { return authorizedAddresses.stream() .anyMatch(address -> Arrays.equals(address, sender.getBytes())); } AddressBasedAuthorizer(List<ECKey> authorizedKeys, MinimumRequiredCalculation requiredCalculation); boolean isAuthorized(RskAddress sender); boolean isAuthorized(Transaction tx); int getNumberOfAuthorizedKeys(); int getRequiredAuthorizedKeys(); }
|
@Test public void serializeMapOfHashesToLong() throws Exception { Map<Sha256Hash, Long> sample = new HashMap<>(); sample.put(Sha256Hash.wrap(charNTimes('b', 64)), 1L); sample.put(Sha256Hash.wrap(charNTimes('d', 64)), 2L); sample.put(Sha256Hash.wrap(charNTimes('a', 64)), 3L); sample.put(Sha256Hash.wrap(charNTimes('c', 64)), 4L); byte[] result = BridgeSerializationUtils.serializeMapOfHashesToLong(sample); String hexResult = ByteUtil.toHexString(result); StringBuilder expectedBuilder = new StringBuilder(); expectedBuilder.append("f888"); char[] sorted = new char[]{'a','b','c','d'}; for (char c : sorted) { String key = charNTimes(c, 64); expectedBuilder.append("a0"); expectedBuilder.append(key); expectedBuilder.append("0" + String.valueOf(sample.get(Sha256Hash.wrap(key)).longValue())); } assertEquals(expectedBuilder.toString(), hexResult); }
|
public static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map) { byte[][] bytes = new byte[map.size() * 2][]; int n = 0; List<Sha256Hash> sortedHashes = new ArrayList<>(map.keySet()); Collections.sort(sortedHashes); for (Sha256Hash hash : sortedHashes) { Long value = map.get(hash); bytes[n++] = RLP.encodeElement(hash.getBytes()); bytes[n++] = RLP.encodeBigInteger(BigInteger.valueOf(value)); } return RLP.encodeList(bytes); }
|
BridgeSerializationUtils { public static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map) { byte[][] bytes = new byte[map.size() * 2][]; int n = 0; List<Sha256Hash> sortedHashes = new ArrayList<>(map.keySet()); Collections.sort(sortedHashes); for (Sha256Hash hash : sortedHashes) { Long value = map.get(hash); bytes[n++] = RLP.encodeElement(hash.getBytes()); bytes[n++] = RLP.encodeBigInteger(BigInteger.valueOf(value)); } return RLP.encodeList(bytes); } }
|
BridgeSerializationUtils { public static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map) { byte[][] bytes = new byte[map.size() * 2][]; int n = 0; List<Sha256Hash> sortedHashes = new ArrayList<>(map.keySet()); Collections.sort(sortedHashes); for (Sha256Hash hash : sortedHashes) { Long value = map.get(hash); bytes[n++] = RLP.encodeElement(hash.getBytes()); bytes[n++] = RLP.encodeBigInteger(BigInteger.valueOf(value)); } return RLP.encodeList(bytes); } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map) { byte[][] bytes = new byte[map.size() * 2][]; int n = 0; List<Sha256Hash> sortedHashes = new ArrayList<>(map.keySet()); Collections.sort(sortedHashes); for (Sha256Hash hash : sortedHashes) { Long value = map.get(hash); bytes[n++] = RLP.encodeElement(hash.getBytes()); bytes[n++] = RLP.encodeBigInteger(BigInteger.valueOf(value)); } return RLP.encodeList(bytes); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map) { byte[][] bytes = new byte[map.size() * 2][]; int n = 0; List<Sha256Hash> sortedHashes = new ArrayList<>(map.keySet()); Collections.sort(sortedHashes); for (Sha256Hash hash : sortedHashes) { Long value = map.get(hash); bytes[n++] = RLP.encodeElement(hash.getBytes()); bytes[n++] = RLP.encodeBigInteger(BigInteger.valueOf(value)); } return RLP.encodeList(bytes); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void deserializeMapOfHashesToLong_emptyOrNull() throws Exception { assertEquals(BridgeSerializationUtils.deserializeMapOfHashesToLong(null), new HashMap<>()); assertEquals(BridgeSerializationUtils.deserializeMapOfHashesToLong(new byte[]{}), new HashMap<>()); }
|
public static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data) { Map<Sha256Hash, Long> map = new HashMap<>(); if (data == null || data.length == 0) { return map; } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeMapOfHashesToLong: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; for (int k = 0; k < numEntries; k++) { Sha256Hash hash = Sha256Hash.wrap(rlpList.get(k * 2).getRLPData()); long number = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 2 + 1).getRLPData()).longValue(); map.put(hash, number); } return map; }
|
BridgeSerializationUtils { public static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data) { Map<Sha256Hash, Long> map = new HashMap<>(); if (data == null || data.length == 0) { return map; } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeMapOfHashesToLong: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; for (int k = 0; k < numEntries; k++) { Sha256Hash hash = Sha256Hash.wrap(rlpList.get(k * 2).getRLPData()); long number = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 2 + 1).getRLPData()).longValue(); map.put(hash, number); } return map; } }
|
BridgeSerializationUtils { public static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data) { Map<Sha256Hash, Long> map = new HashMap<>(); if (data == null || data.length == 0) { return map; } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeMapOfHashesToLong: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; for (int k = 0; k < numEntries; k++) { Sha256Hash hash = Sha256Hash.wrap(rlpList.get(k * 2).getRLPData()); long number = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 2 + 1).getRLPData()).longValue(); map.put(hash, number); } return map; } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data) { Map<Sha256Hash, Long> map = new HashMap<>(); if (data == null || data.length == 0) { return map; } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeMapOfHashesToLong: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; for (int k = 0; k < numEntries; k++) { Sha256Hash hash = Sha256Hash.wrap(rlpList.get(k * 2).getRLPData()); long number = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 2 + 1).getRLPData()).longValue(); map.put(hash, number); } return map; } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data) { Map<Sha256Hash, Long> map = new HashMap<>(); if (data == null || data.length == 0) { return map; } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeMapOfHashesToLong: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; for (int k = 0; k < numEntries; k++) { Sha256Hash hash = Sha256Hash.wrap(rlpList.get(k * 2).getRLPData()); long number = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 2 + 1).getRLPData()).longValue(); map.put(hash, number); } return map; } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void deserializeMapOfHashesToLong_nonEmpty() throws Exception { byte[] rlpFirstKey = RLP.encodeElement(Hex.decode(charNTimes('b', 64))); byte[] rlpSecondKey = RLP.encodeElement(Hex.decode(charNTimes('d', 64))); byte[] rlpThirdKey = RLP.encodeElement(Hex.decode(charNTimes('a', 64))); byte[] rlpFirstValue = RLP.encodeBigInteger(BigInteger.valueOf(7)); byte[] rlpSecondValue = RLP.encodeBigInteger(BigInteger.valueOf(76)); byte[] rlpThirdValue = RLP.encodeBigInteger(BigInteger.valueOf(123)); byte[] data = RLP.encodeList(rlpFirstKey, rlpFirstValue, rlpSecondKey, rlpSecondValue, rlpThirdKey, rlpThirdValue); Map<Sha256Hash, Long> result = BridgeSerializationUtils.deserializeMapOfHashesToLong(data); assertEquals(3, result.size()); assertEquals(7L, result.get(Sha256Hash.wrap(charNTimes('b', 64))).longValue()); assertEquals(76L, result.get(Sha256Hash.wrap(charNTimes('d', 64))).longValue()); assertEquals(123L, result.get(Sha256Hash.wrap(charNTimes('a', 64))).longValue()); }
|
public static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data) { Map<Sha256Hash, Long> map = new HashMap<>(); if (data == null || data.length == 0) { return map; } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeMapOfHashesToLong: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; for (int k = 0; k < numEntries; k++) { Sha256Hash hash = Sha256Hash.wrap(rlpList.get(k * 2).getRLPData()); long number = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 2 + 1).getRLPData()).longValue(); map.put(hash, number); } return map; }
|
BridgeSerializationUtils { public static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data) { Map<Sha256Hash, Long> map = new HashMap<>(); if (data == null || data.length == 0) { return map; } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeMapOfHashesToLong: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; for (int k = 0; k < numEntries; k++) { Sha256Hash hash = Sha256Hash.wrap(rlpList.get(k * 2).getRLPData()); long number = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 2 + 1).getRLPData()).longValue(); map.put(hash, number); } return map; } }
|
BridgeSerializationUtils { public static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data) { Map<Sha256Hash, Long> map = new HashMap<>(); if (data == null || data.length == 0) { return map; } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeMapOfHashesToLong: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; for (int k = 0; k < numEntries; k++) { Sha256Hash hash = Sha256Hash.wrap(rlpList.get(k * 2).getRLPData()); long number = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 2 + 1).getRLPData()).longValue(); map.put(hash, number); } return map; } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data) { Map<Sha256Hash, Long> map = new HashMap<>(); if (data == null || data.length == 0) { return map; } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeMapOfHashesToLong: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; for (int k = 0; k < numEntries; k++) { Sha256Hash hash = Sha256Hash.wrap(rlpList.get(k * 2).getRLPData()); long number = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 2 + 1).getRLPData()).longValue(); map.put(hash, number); } return map; } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data) { Map<Sha256Hash, Long> map = new HashMap<>(); if (data == null || data.length == 0) { return map; } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeMapOfHashesToLong: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; for (int k = 0; k < numEntries; k++) { Sha256Hash hash = Sha256Hash.wrap(rlpList.get(k * 2).getRLPData()); long number = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 2 + 1).getRLPData()).longValue(); map.put(hash, number); } return map; } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void deserializeMapOfHashesToLong_nonEmptyOddSize() throws Exception { byte[] rlpFirstKey = RLP.encodeElement(Hex.decode(charNTimes('b', 64))); byte[] rlpSecondKey = RLP.encodeElement(Hex.decode(charNTimes('d', 64))); byte[] rlpThirdKey = RLP.encodeElement(Hex.decode(charNTimes('a', 64))); byte[] rlpFourthKey = RLP.encodeElement(Hex.decode(charNTimes('e', 64))); byte[] rlpFirstValue = RLP.encodeBigInteger(BigInteger.valueOf(7)); byte[] rlpSecondValue = RLP.encodeBigInteger(BigInteger.valueOf(76)); byte[] rlpThirdValue = RLP.encodeBigInteger(BigInteger.valueOf(123)); byte[] data = RLP.encodeList(rlpFirstKey, rlpFirstValue, rlpSecondKey, rlpSecondValue, rlpThirdKey, rlpThirdValue, rlpFourthKey); boolean thrown = false; try { BridgeSerializationUtils.deserializeMapOfHashesToLong(data); } catch (RuntimeException e) { thrown = true; } Assert.assertTrue(thrown); }
|
public static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data) { Map<Sha256Hash, Long> map = new HashMap<>(); if (data == null || data.length == 0) { return map; } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeMapOfHashesToLong: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; for (int k = 0; k < numEntries; k++) { Sha256Hash hash = Sha256Hash.wrap(rlpList.get(k * 2).getRLPData()); long number = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 2 + 1).getRLPData()).longValue(); map.put(hash, number); } return map; }
|
BridgeSerializationUtils { public static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data) { Map<Sha256Hash, Long> map = new HashMap<>(); if (data == null || data.length == 0) { return map; } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeMapOfHashesToLong: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; for (int k = 0; k < numEntries; k++) { Sha256Hash hash = Sha256Hash.wrap(rlpList.get(k * 2).getRLPData()); long number = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 2 + 1).getRLPData()).longValue(); map.put(hash, number); } return map; } }
|
BridgeSerializationUtils { public static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data) { Map<Sha256Hash, Long> map = new HashMap<>(); if (data == null || data.length == 0) { return map; } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeMapOfHashesToLong: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; for (int k = 0; k < numEntries; k++) { Sha256Hash hash = Sha256Hash.wrap(rlpList.get(k * 2).getRLPData()); long number = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 2 + 1).getRLPData()).longValue(); map.put(hash, number); } return map; } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data) { Map<Sha256Hash, Long> map = new HashMap<>(); if (data == null || data.length == 0) { return map; } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeMapOfHashesToLong: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; for (int k = 0; k < numEntries; k++) { Sha256Hash hash = Sha256Hash.wrap(rlpList.get(k * 2).getRLPData()); long number = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 2 + 1).getRLPData()).longValue(); map.put(hash, number); } return map; } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data) { Map<Sha256Hash, Long> map = new HashMap<>(); if (data == null || data.length == 0) { return map; } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeMapOfHashesToLong: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; for (int k = 0; k < numEntries; k++) { Sha256Hash hash = Sha256Hash.wrap(rlpList.get(k * 2).getRLPData()); long number = BigIntegers.fromUnsignedByteArray(rlpList.get(k * 2 + 1).getRLPData()).longValue(); map.put(hash, number); } return map; } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void serializeFederationOnlyBtcKeys() throws Exception { byte[][] publicKeyBytes = new byte[][]{ BtcECKey.fromPrivate(BigInteger.valueOf(100)).getPubKey(), BtcECKey.fromPrivate(BigInteger.valueOf(200)).getPubKey(), BtcECKey.fromPrivate(BigInteger.valueOf(300)).getPubKey(), BtcECKey.fromPrivate(BigInteger.valueOf(400)).getPubKey(), BtcECKey.fromPrivate(BigInteger.valueOf(500)).getPubKey(), BtcECKey.fromPrivate(BigInteger.valueOf(600)).getPubKey(), }; Federation federation = new Federation( FederationTestUtils.getFederationMembersWithBtcKeys(Arrays.asList(new BtcECKey[]{ BtcECKey.fromPublicOnly(publicKeyBytes[0]), BtcECKey.fromPublicOnly(publicKeyBytes[1]), BtcECKey.fromPublicOnly(publicKeyBytes[2]), BtcECKey.fromPublicOnly(publicKeyBytes[3]), BtcECKey.fromPublicOnly(publicKeyBytes[4]), BtcECKey.fromPublicOnly(publicKeyBytes[5]), })), Instant.ofEpochMilli(0xabcdef), 42L, NetworkParameters.fromID(NetworkParameters.ID_REGTEST) ); byte[] result = BridgeSerializationUtils.serializeFederationOnlyBtcKeys(federation); StringBuilder expectedBuilder = new StringBuilder(); expectedBuilder.append("f8d3"); expectedBuilder.append("83abcdef"); expectedBuilder.append("2a"); expectedBuilder.append("f8cc"); federation.getBtcPublicKeys().stream().sorted(BtcECKey.PUBKEY_COMPARATOR).forEach(key -> { expectedBuilder.append("a1"); expectedBuilder.append(ByteUtil.toHexString(key.getPubKey())); }); String expected = expectedBuilder.toString(); Assert.assertEquals(expected, ByteUtil.toHexString(result)); }
|
public static byte[] serializeFederationOnlyBtcKeys(Federation federation) { return serializeFederationWithSerializer(federation, federationMember -> federationMember.getBtcPublicKey().getPubKeyPoint().getEncoded(true)); }
|
BridgeSerializationUtils { public static byte[] serializeFederationOnlyBtcKeys(Federation federation) { return serializeFederationWithSerializer(federation, federationMember -> federationMember.getBtcPublicKey().getPubKeyPoint().getEncoded(true)); } }
|
BridgeSerializationUtils { public static byte[] serializeFederationOnlyBtcKeys(Federation federation) { return serializeFederationWithSerializer(federation, federationMember -> federationMember.getBtcPublicKey().getPubKeyPoint().getEncoded(true)); } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static byte[] serializeFederationOnlyBtcKeys(Federation federation) { return serializeFederationWithSerializer(federation, federationMember -> federationMember.getBtcPublicKey().getPubKeyPoint().getEncoded(true)); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static byte[] serializeFederationOnlyBtcKeys(Federation federation) { return serializeFederationWithSerializer(federation, federationMember -> federationMember.getBtcPublicKey().getPubKeyPoint().getEncoded(true)); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void deserializeFederationOnlyBtcKeys_ok() throws Exception { byte[][] publicKeyBytes = Arrays.asList(100, 200, 300, 400, 500, 600).stream() .map(k -> BtcECKey.fromPrivate(BigInteger.valueOf(k))) .sorted(BtcECKey.PUBKEY_COMPARATOR) .map(k -> k.getPubKey()) .toArray(byte[][]::new); byte[][] rlpKeys = new byte[publicKeyBytes.length][]; for (int k = 0; k < publicKeyBytes.length; k++) { rlpKeys[k] = RLP.encodeElement(publicKeyBytes[k]); } byte[] rlpFirstElement = RLP.encodeElement(Hex.decode("1388")); byte[] rlpSecondElement = RLP.encodeElement(Hex.decode("002a")); byte[] rlpKeyList = RLP.encodeList(rlpKeys); byte[] data = RLP.encodeList(rlpFirstElement, rlpSecondElement, rlpKeyList); Federation deserializedFederation = BridgeSerializationUtils.deserializeFederationOnlyBtcKeys(data, NetworkParameters.fromID(NetworkParameters.ID_REGTEST)); Assert.assertEquals(5000, deserializedFederation.getCreationTime().toEpochMilli()); Assert.assertEquals(4, deserializedFederation.getNumberOfSignaturesRequired()); Assert.assertEquals(6, deserializedFederation.getBtcPublicKeys().size()); Assert.assertThat(deserializedFederation.getCreationBlockNumber(), is(42L)); for (int i = 0; i < 6; i++) { Assert.assertTrue(Arrays.equals(publicKeyBytes[i], deserializedFederation.getBtcPublicKeys().get(i).getPubKey())); } Assert.assertEquals(NetworkParameters.fromID(NetworkParameters.ID_REGTEST), deserializedFederation.getBtcParams()); }
|
public static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, (pubKeyBytes -> FederationMember.getFederationMemberFromKey(BtcECKey.fromPublicOnly(pubKeyBytes)))); }
|
BridgeSerializationUtils { public static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, (pubKeyBytes -> FederationMember.getFederationMemberFromKey(BtcECKey.fromPublicOnly(pubKeyBytes)))); } }
|
BridgeSerializationUtils { public static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, (pubKeyBytes -> FederationMember.getFederationMemberFromKey(BtcECKey.fromPublicOnly(pubKeyBytes)))); } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, (pubKeyBytes -> FederationMember.getFederationMemberFromKey(BtcECKey.fromPublicOnly(pubKeyBytes)))); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, (pubKeyBytes -> FederationMember.getFederationMemberFromKey(BtcECKey.fromPublicOnly(pubKeyBytes)))); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void deserializeFederationOnlyBtcKeys_wrongListSize() throws Exception { byte[] rlpFirstElement = RLP.encodeElement(Hex.decode("1388")); byte[] rlpSecondElement = RLP.encodeElement(Hex.decode("03")); byte[] rlpThirdElement = RLP.encodeElement(Hex.decode("03")); byte[] rlpFourthElement = RLP.encodeElement(Hex.decode("aabbccdd")); byte[] data = RLP.encodeList(rlpFirstElement, rlpSecondElement, rlpThirdElement, rlpFourthElement); boolean thrown = false; try { BridgeSerializationUtils.deserializeFederationOnlyBtcKeys(data, NetworkParameters.fromID(NetworkParameters.ID_REGTEST)); } catch (Exception e) { Assert.assertTrue(e.getMessage().contains("Expected 3 elements")); thrown = true; } Assert.assertTrue(thrown); }
|
public static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, (pubKeyBytes -> FederationMember.getFederationMemberFromKey(BtcECKey.fromPublicOnly(pubKeyBytes)))); }
|
BridgeSerializationUtils { public static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, (pubKeyBytes -> FederationMember.getFederationMemberFromKey(BtcECKey.fromPublicOnly(pubKeyBytes)))); } }
|
BridgeSerializationUtils { public static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, (pubKeyBytes -> FederationMember.getFederationMemberFromKey(BtcECKey.fromPublicOnly(pubKeyBytes)))); } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, (pubKeyBytes -> FederationMember.getFederationMemberFromKey(BtcECKey.fromPublicOnly(pubKeyBytes)))); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, (pubKeyBytes -> FederationMember.getFederationMemberFromKey(BtcECKey.fromPublicOnly(pubKeyBytes)))); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void serializeFederation_serializedKeysAreCompressedAndThree() { final int NUM_MEMBERS = 10; final int EXPECTED_NUM_KEYS = 3; final int EXPECTED_PUBLICKEY_SIZE = 33; List<FederationMember> members = new ArrayList<>(); for (int j = 0; j < NUM_MEMBERS; j++) { members.add(new FederationMember(new BtcECKey(), new ECKey(), new ECKey())); } Federation testFederation = new Federation( members, Instant.now(), 123, NetworkParameters.fromID(NetworkParameters.ID_REGTEST) ); byte[] serializedFederation = BridgeSerializationUtils.serializeFederation(testFederation); RLPList serializedList = (RLPList) RLP.decode2(serializedFederation).get(0); Assert.assertEquals(3, serializedList.size()); RLPList memberList = (RLPList) serializedList.get(2); Assert.assertEquals(NUM_MEMBERS, memberList.size()); for (int i = 0; i < NUM_MEMBERS; i++) { RLPList memberKeys = (RLPList) RLP.decode2(memberList.get(i).getRLPData()).get(0); Assert.assertEquals(EXPECTED_NUM_KEYS, memberKeys.size()); for (int j = 0; j < EXPECTED_NUM_KEYS; j++) { Assert.assertEquals(EXPECTED_PUBLICKEY_SIZE, memberKeys.get(j).getRLPData().length); } } }
|
public static byte[] serializeFederation(Federation federation) { return serializeFederationWithSerializer(federation, BridgeSerializationUtils::serializeFederationMember); }
|
BridgeSerializationUtils { public static byte[] serializeFederation(Federation federation) { return serializeFederationWithSerializer(federation, BridgeSerializationUtils::serializeFederationMember); } }
|
BridgeSerializationUtils { public static byte[] serializeFederation(Federation federation) { return serializeFederationWithSerializer(federation, BridgeSerializationUtils::serializeFederationMember); } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static byte[] serializeFederation(Federation federation) { return serializeFederationWithSerializer(federation, BridgeSerializationUtils::serializeFederationMember); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static byte[] serializeFederation(Federation federation) { return serializeFederationWithSerializer(federation, BridgeSerializationUtils::serializeFederationMember); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void isEmpty_EmptyString() { Value val = new Value(""); assertTrue(val.isEmpty()); }
|
public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; }
|
Value { public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; } }
|
Value { public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; } Value(); Value(Object obj); }
|
Value { public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; } Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); void init(byte[] rlp); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); String getHex(); byte[] getData(); int[] asSlice(); Value get(int index); byte[] encode(); byte[] hash(); boolean isList(); boolean isString(); boolean isInt(); boolean isLong(); boolean isBigInt(); boolean isBytes(); boolean isReadableString(); boolean isHexString(); boolean isHashCode(); boolean isNull(); boolean isEmpty(); int length(); String toString(); }
|
Value { public boolean isEmpty() { if (isNull()) { return true; } if (isBytes() && asBytes().length == 0) { return true; } if (isList() && asList().isEmpty()) { return true; } if (isString() && asString().equals("")) { return true; } return false; } Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); void init(byte[] rlp); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); String getHex(); byte[] getData(); int[] asSlice(); Value get(int index); byte[] encode(); byte[] hash(); boolean isList(); boolean isString(); boolean isInt(); boolean isLong(); boolean isBigInt(); boolean isBytes(); boolean isReadableString(); boolean isHexString(); boolean isHashCode(); boolean isNull(); boolean isEmpty(); int length(); String toString(); }
|
@Test public void deserializeFederation_wrongListSize() { byte[] serialized = RLP.encodeList(RLP.encodeElement(new byte[0]), RLP.encodeElement(new byte[0])); try { BridgeSerializationUtils.deserializeFederation(serialized, NetworkParameters.fromID(NetworkParameters.ID_REGTEST)); Assert.fail(); } catch (RuntimeException e) { Assert.assertTrue(e.getMessage().contains("Invalid serialized Federation")); } }
|
public static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, BridgeSerializationUtils::deserializeFederationMember); }
|
BridgeSerializationUtils { public static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, BridgeSerializationUtils::deserializeFederationMember); } }
|
BridgeSerializationUtils { public static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, BridgeSerializationUtils::deserializeFederationMember); } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, BridgeSerializationUtils::deserializeFederationMember); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, BridgeSerializationUtils::deserializeFederationMember); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void deserializeFederation_invalidFederationMember() { byte[] serialized = RLP.encodeList( RLP.encodeElement(BigInteger.valueOf(1).toByteArray()), RLP.encodeElement(BigInteger.valueOf(1).toByteArray()), RLP.encodeList(RLP.encodeList(RLP.encodeElement(new byte[0]), RLP.encodeElement(new byte[0]))) ); try { BridgeSerializationUtils.deserializeFederation(serialized, NetworkParameters.fromID(NetworkParameters.ID_REGTEST)); Assert.fail(); } catch (RuntimeException e) { Assert.assertTrue(e.getMessage().contains("Invalid serialized FederationMember")); } }
|
public static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, BridgeSerializationUtils::deserializeFederationMember); }
|
BridgeSerializationUtils { public static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, BridgeSerializationUtils::deserializeFederationMember); } }
|
BridgeSerializationUtils { public static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, BridgeSerializationUtils::deserializeFederationMember); } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, BridgeSerializationUtils::deserializeFederationMember); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters) { return deserializeFederationWithDesserializer(data, networkParameters, BridgeSerializationUtils::deserializeFederationMember); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void serializePendingFederation_serializedKeysAreCompressedAndThree() { final int NUM_MEMBERS = 10; final int EXPECTED_NUM_KEYS = 3; final int EXPECTED_PUBLICKEY_SIZE = 33; List<FederationMember> members = new ArrayList<>(); for (int j = 0; j < NUM_MEMBERS; j++) { members.add(new FederationMember(new BtcECKey(), new ECKey(), new ECKey())); } PendingFederation testPendingFederation = new PendingFederation(members); byte[] serializedPendingFederation = BridgeSerializationUtils.serializePendingFederation(testPendingFederation); RLPList memberList = (RLPList) RLP.decode2(serializedPendingFederation).get(0); Assert.assertEquals(NUM_MEMBERS, memberList.size()); for (int i = 0; i < NUM_MEMBERS; i++) { RLPList memberKeys = (RLPList) RLP.decode2(memberList.get(i).getRLPData()).get(0); Assert.assertEquals(EXPECTED_NUM_KEYS, memberKeys.size()); for (int j = 0; j < EXPECTED_NUM_KEYS; j++) { Assert.assertEquals(EXPECTED_PUBLICKEY_SIZE, memberKeys.get(j).getRLPData().length); } } }
|
public static byte[] serializePendingFederation(PendingFederation pendingFederation) { List<byte[]> encodedMembers = pendingFederation.getMembers().stream() .sorted(FederationMember.BTC_RSK_MST_PUBKEYS_COMPARATOR) .map(BridgeSerializationUtils::serializeFederationMember) .collect(Collectors.toList()); return RLP.encodeList(encodedMembers.toArray(new byte[0][])); }
|
BridgeSerializationUtils { public static byte[] serializePendingFederation(PendingFederation pendingFederation) { List<byte[]> encodedMembers = pendingFederation.getMembers().stream() .sorted(FederationMember.BTC_RSK_MST_PUBKEYS_COMPARATOR) .map(BridgeSerializationUtils::serializeFederationMember) .collect(Collectors.toList()); return RLP.encodeList(encodedMembers.toArray(new byte[0][])); } }
|
BridgeSerializationUtils { public static byte[] serializePendingFederation(PendingFederation pendingFederation) { List<byte[]> encodedMembers = pendingFederation.getMembers().stream() .sorted(FederationMember.BTC_RSK_MST_PUBKEYS_COMPARATOR) .map(BridgeSerializationUtils::serializeFederationMember) .collect(Collectors.toList()); return RLP.encodeList(encodedMembers.toArray(new byte[0][])); } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static byte[] serializePendingFederation(PendingFederation pendingFederation) { List<byte[]> encodedMembers = pendingFederation.getMembers().stream() .sorted(FederationMember.BTC_RSK_MST_PUBKEYS_COMPARATOR) .map(BridgeSerializationUtils::serializeFederationMember) .collect(Collectors.toList()); return RLP.encodeList(encodedMembers.toArray(new byte[0][])); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static byte[] serializePendingFederation(PendingFederation pendingFederation) { List<byte[]> encodedMembers = pendingFederation.getMembers().stream() .sorted(FederationMember.BTC_RSK_MST_PUBKEYS_COMPARATOR) .map(BridgeSerializationUtils::serializeFederationMember) .collect(Collectors.toList()); return RLP.encodeList(encodedMembers.toArray(new byte[0][])); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void deserializePendingFederation_invalidFederationMember() { byte[] serialized = RLP.encodeList( RLP.encodeList(RLP.encodeElement(new byte[0]), RLP.encodeElement(new byte[0])) ); try { BridgeSerializationUtils.deserializePendingFederation(serialized); Assert.fail(); } catch (RuntimeException e) { Assert.assertTrue(e.getMessage().contains("Invalid serialized FederationMember")); } }
|
public static PendingFederation deserializePendingFederation(byte[] data) { RLPList rlpList = (RLPList)RLP.decode2(data).get(0); List<FederationMember> members = new ArrayList<>(); for (int k = 0; k < rlpList.size(); k++) { RLPElement element = rlpList.get(k); FederationMember member = deserializeFederationMember(element.getRLPData()); members.add(member); } return new PendingFederation(members); }
|
BridgeSerializationUtils { public static PendingFederation deserializePendingFederation(byte[] data) { RLPList rlpList = (RLPList)RLP.decode2(data).get(0); List<FederationMember> members = new ArrayList<>(); for (int k = 0; k < rlpList.size(); k++) { RLPElement element = rlpList.get(k); FederationMember member = deserializeFederationMember(element.getRLPData()); members.add(member); } return new PendingFederation(members); } }
|
BridgeSerializationUtils { public static PendingFederation deserializePendingFederation(byte[] data) { RLPList rlpList = (RLPList)RLP.decode2(data).get(0); List<FederationMember> members = new ArrayList<>(); for (int k = 0; k < rlpList.size(); k++) { RLPElement element = rlpList.get(k); FederationMember member = deserializeFederationMember(element.getRLPData()); members.add(member); } return new PendingFederation(members); } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static PendingFederation deserializePendingFederation(byte[] data) { RLPList rlpList = (RLPList)RLP.decode2(data).get(0); List<FederationMember> members = new ArrayList<>(); for (int k = 0; k < rlpList.size(); k++) { RLPElement element = rlpList.get(k); FederationMember member = deserializeFederationMember(element.getRLPData()); members.add(member); } return new PendingFederation(members); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static PendingFederation deserializePendingFederation(byte[] data) { RLPList rlpList = (RLPList)RLP.decode2(data).get(0); List<FederationMember> members = new ArrayList<>(); for (int k = 0; k < rlpList.size(); k++) { RLPElement element = rlpList.get(k); FederationMember member = deserializeFederationMember(element.getRLPData()); members.add(member); } return new PendingFederation(members); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void serializePendingFederationOnlyBtcKeys() throws Exception { byte[][] publicKeyBytes = new byte[][]{ BtcECKey.fromPrivate(BigInteger.valueOf(100)).getPubKey(), BtcECKey.fromPrivate(BigInteger.valueOf(200)).getPubKey(), BtcECKey.fromPrivate(BigInteger.valueOf(300)).getPubKey(), BtcECKey.fromPrivate(BigInteger.valueOf(400)).getPubKey(), BtcECKey.fromPrivate(BigInteger.valueOf(500)).getPubKey(), BtcECKey.fromPrivate(BigInteger.valueOf(600)).getPubKey(), }; PendingFederation pendingFederation = new PendingFederation( FederationTestUtils.getFederationMembersWithBtcKeys(Arrays.asList(new BtcECKey[]{ BtcECKey.fromPublicOnly(publicKeyBytes[0]), BtcECKey.fromPublicOnly(publicKeyBytes[1]), BtcECKey.fromPublicOnly(publicKeyBytes[2]), BtcECKey.fromPublicOnly(publicKeyBytes[3]), BtcECKey.fromPublicOnly(publicKeyBytes[4]), BtcECKey.fromPublicOnly(publicKeyBytes[5]), })) ); byte[] result = BridgeSerializationUtils.serializePendingFederationOnlyBtcKeys(pendingFederation); StringBuilder expectedBuilder = new StringBuilder(); expectedBuilder.append("f8cc"); pendingFederation.getBtcPublicKeys().stream().sorted(BtcECKey.PUBKEY_COMPARATOR).forEach(key -> { expectedBuilder.append("a1"); expectedBuilder.append(ByteUtil.toHexString(key.getPubKey())); }); String expected = expectedBuilder.toString(); Assert.assertEquals(expected, ByteUtil.toHexString(result)); }
|
public static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation) { return serializeBtcPublicKeys(pendingFederation.getBtcPublicKeys()); }
|
BridgeSerializationUtils { public static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation) { return serializeBtcPublicKeys(pendingFederation.getBtcPublicKeys()); } }
|
BridgeSerializationUtils { public static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation) { return serializeBtcPublicKeys(pendingFederation.getBtcPublicKeys()); } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation) { return serializeBtcPublicKeys(pendingFederation.getBtcPublicKeys()); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation) { return serializeBtcPublicKeys(pendingFederation.getBtcPublicKeys()); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void deserializePendingFederationOnlyBtcKeys() throws Exception { byte[][] publicKeyBytes = Arrays.asList(100, 200, 300, 400, 500, 600).stream() .map(k -> BtcECKey.fromPrivate(BigInteger.valueOf(k))) .sorted(BtcECKey.PUBKEY_COMPARATOR) .map(k -> k.getPubKey()) .toArray(byte[][]::new); byte[][] rlpBytes = new byte[publicKeyBytes.length][]; for (int k = 0; k < publicKeyBytes.length; k++) { rlpBytes[k] = RLP.encodeElement(publicKeyBytes[k]); } byte[] data = RLP.encodeList(rlpBytes); PendingFederation deserializedPendingFederation = BridgeSerializationUtils.deserializePendingFederationOnlyBtcKeys(data); Assert.assertEquals(6, deserializedPendingFederation.getBtcPublicKeys().size()); for (int i = 0; i < 6; i++) { Assert.assertTrue(Arrays.equals(publicKeyBytes[i], deserializedPendingFederation.getBtcPublicKeys().get(i).getPubKey())); } }
|
public static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data) { List<FederationMember> members = deserializeBtcPublicKeys(data).stream().map(pk -> FederationMember.getFederationMemberFromKey(pk) ).collect(Collectors.toList()); return new PendingFederation(members); }
|
BridgeSerializationUtils { public static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data) { List<FederationMember> members = deserializeBtcPublicKeys(data).stream().map(pk -> FederationMember.getFederationMemberFromKey(pk) ).collect(Collectors.toList()); return new PendingFederation(members); } }
|
BridgeSerializationUtils { public static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data) { List<FederationMember> members = deserializeBtcPublicKeys(data).stream().map(pk -> FederationMember.getFederationMemberFromKey(pk) ).collect(Collectors.toList()); return new PendingFederation(members); } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data) { List<FederationMember> members = deserializeBtcPublicKeys(data).stream().map(pk -> FederationMember.getFederationMemberFromKey(pk) ).collect(Collectors.toList()); return new PendingFederation(members); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data) { List<FederationMember> members = deserializeBtcPublicKeys(data).stream().map(pk -> FederationMember.getFederationMemberFromKey(pk) ).collect(Collectors.toList()); return new PendingFederation(members); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void serializeElection() throws Exception { AddressBasedAuthorizer authorizer = getTestingAddressBasedAuthorizer(); Map<ABICallSpec, List<RskAddress>> sampleVotes = new HashMap<>(); sampleVotes.put( new ABICallSpec("one-function", new byte[][]{}), Arrays.asList(createAddress("8899"), createAddress("aabb")) ); sampleVotes.put( new ABICallSpec("another-function", new byte[][]{ Hex.decode("01"), Hex.decode("0203") }), Arrays.asList(createAddress("ccdd"), createAddress("eeff"), createAddress("0011")) ); sampleVotes.put( new ABICallSpec("yet-another-function", new byte[][]{ Hex.decode("0405") }), Arrays.asList(createAddress("fa"), createAddress("ca")) ); ABICallElection sample = new ABICallElection(authorizer, sampleVotes); byte[] result = BridgeSerializationUtils.serializeElection(sample); String hexResult = ByteUtil.toHexString(result); StringBuilder expectedBuilder = new StringBuilder(); expectedBuilder.append("f8d7d6"); expectedBuilder.append("90"); expectedBuilder.append(ByteUtil.toHexString("another-function".getBytes(StandardCharsets.UTF_8))); expectedBuilder.append("c4"); expectedBuilder.append("01"); expectedBuilder.append("820203"); expectedBuilder.append("f83f"); expectedBuilder.append("94" + createAddress("0011").toString()); expectedBuilder.append("94" + createAddress("ccdd").toString()); expectedBuilder.append("94" + createAddress("eeff").toString()); expectedBuilder.append("ce"); expectedBuilder.append("8c"); expectedBuilder.append(ByteUtil.toHexString("one-function".getBytes(StandardCharsets.UTF_8))); expectedBuilder.append("c0"); expectedBuilder.append("ea"); expectedBuilder.append("94" + createAddress("8899").toString()); expectedBuilder.append("94" + createAddress("aabb").toString()); expectedBuilder.append("d9"); expectedBuilder.append("94"); expectedBuilder.append(ByteUtil.toHexString("yet-another-function".getBytes(StandardCharsets.UTF_8))); expectedBuilder.append("c3"); expectedBuilder.append("820405"); expectedBuilder.append("ea"); expectedBuilder.append("94" + createAddress("ca").toString() + "94" + createAddress("fa").toString()); Assert.assertEquals(expectedBuilder.toString(), hexResult); }
|
public static byte[] serializeElection(ABICallElection election) { byte[][] bytes = new byte[election.getVotes().size() * 2][]; int n = 0; Map<ABICallSpec, List<RskAddress>> votes = election.getVotes(); ABICallSpec[] specs = votes.keySet().toArray(new ABICallSpec[0]); Arrays.sort(specs, ABICallSpec.byBytesComparator); for (ABICallSpec spec : specs) { bytes[n++] = serializeABICallSpec(spec); bytes[n++] = serializeVoters(votes.get(spec)); } return RLP.encodeList(bytes); }
|
BridgeSerializationUtils { public static byte[] serializeElection(ABICallElection election) { byte[][] bytes = new byte[election.getVotes().size() * 2][]; int n = 0; Map<ABICallSpec, List<RskAddress>> votes = election.getVotes(); ABICallSpec[] specs = votes.keySet().toArray(new ABICallSpec[0]); Arrays.sort(specs, ABICallSpec.byBytesComparator); for (ABICallSpec spec : specs) { bytes[n++] = serializeABICallSpec(spec); bytes[n++] = serializeVoters(votes.get(spec)); } return RLP.encodeList(bytes); } }
|
BridgeSerializationUtils { public static byte[] serializeElection(ABICallElection election) { byte[][] bytes = new byte[election.getVotes().size() * 2][]; int n = 0; Map<ABICallSpec, List<RskAddress>> votes = election.getVotes(); ABICallSpec[] specs = votes.keySet().toArray(new ABICallSpec[0]); Arrays.sort(specs, ABICallSpec.byBytesComparator); for (ABICallSpec spec : specs) { bytes[n++] = serializeABICallSpec(spec); bytes[n++] = serializeVoters(votes.get(spec)); } return RLP.encodeList(bytes); } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static byte[] serializeElection(ABICallElection election) { byte[][] bytes = new byte[election.getVotes().size() * 2][]; int n = 0; Map<ABICallSpec, List<RskAddress>> votes = election.getVotes(); ABICallSpec[] specs = votes.keySet().toArray(new ABICallSpec[0]); Arrays.sort(specs, ABICallSpec.byBytesComparator); for (ABICallSpec spec : specs) { bytes[n++] = serializeABICallSpec(spec); bytes[n++] = serializeVoters(votes.get(spec)); } return RLP.encodeList(bytes); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static byte[] serializeElection(ABICallElection election) { byte[][] bytes = new byte[election.getVotes().size() * 2][]; int n = 0; Map<ABICallSpec, List<RskAddress>> votes = election.getVotes(); ABICallSpec[] specs = votes.keySet().toArray(new ABICallSpec[0]); Arrays.sort(specs, ABICallSpec.byBytesComparator); for (ABICallSpec spec : specs) { bytes[n++] = serializeABICallSpec(spec); bytes[n++] = serializeVoters(votes.get(spec)); } return RLP.encodeList(bytes); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
@Test public void deserializeElection_emptyOrNull() throws Exception { AddressBasedAuthorizer authorizer = getTestingAddressBasedAuthorizer(); ABICallElection election; election = BridgeSerializationUtils.deserializeElection(null, authorizer); Assert.assertEquals(0, election.getVotes().size()); election = BridgeSerializationUtils.deserializeElection(new byte[]{}, authorizer); Assert.assertEquals(0, election.getVotes().size()); }
|
public static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer) { if (data == null || data.length == 0) { return new ABICallElection(authorizer); } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeElection: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; Map<ABICallSpec, List<RskAddress>> votes = new HashMap<>(); for (int k = 0; k < numEntries; k++) { ABICallSpec spec = deserializeABICallSpec(rlpList.get(k * 2).getRLPData()); List<RskAddress> specVotes = deserializeVoters(rlpList.get(k * 2 + 1).getRLPData()); votes.put(spec, specVotes); } return new ABICallElection(authorizer, votes); }
|
BridgeSerializationUtils { public static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer) { if (data == null || data.length == 0) { return new ABICallElection(authorizer); } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeElection: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; Map<ABICallSpec, List<RskAddress>> votes = new HashMap<>(); for (int k = 0; k < numEntries; k++) { ABICallSpec spec = deserializeABICallSpec(rlpList.get(k * 2).getRLPData()); List<RskAddress> specVotes = deserializeVoters(rlpList.get(k * 2 + 1).getRLPData()); votes.put(spec, specVotes); } return new ABICallElection(authorizer, votes); } }
|
BridgeSerializationUtils { public static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer) { if (data == null || data.length == 0) { return new ABICallElection(authorizer); } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeElection: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; Map<ABICallSpec, List<RskAddress>> votes = new HashMap<>(); for (int k = 0; k < numEntries; k++) { ABICallSpec spec = deserializeABICallSpec(rlpList.get(k * 2).getRLPData()); List<RskAddress> specVotes = deserializeVoters(rlpList.get(k * 2 + 1).getRLPData()); votes.put(spec, specVotes); } return new ABICallElection(authorizer, votes); } private BridgeSerializationUtils(); }
|
BridgeSerializationUtils { public static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer) { if (data == null || data.length == 0) { return new ABICallElection(authorizer); } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeElection: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; Map<ABICallSpec, List<RskAddress>> votes = new HashMap<>(); for (int k = 0; k < numEntries; k++) { ABICallSpec spec = deserializeABICallSpec(rlpList.get(k * 2).getRLPData()); List<RskAddress> specVotes = deserializeVoters(rlpList.get(k * 2 + 1).getRLPData()); votes.put(spec, specVotes); } return new ABICallElection(authorizer, votes); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
BridgeSerializationUtils { public static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer) { if (data == null || data.length == 0) { return new ABICallElection(authorizer); } RLPList rlpList = (RLPList) RLP.decode2(data).get(0); if (rlpList.size() % 2 != 0) { throw new RuntimeException("deserializeElection: expected an even number of entries, but odd given"); } int numEntries = rlpList.size() / 2; Map<ABICallSpec, List<RskAddress>> votes = new HashMap<>(); for (int k = 0; k < numEntries; k++) { ABICallSpec spec = deserializeABICallSpec(rlpList.get(k * 2).getRLPData()); List<RskAddress> specVotes = deserializeVoters(rlpList.get(k * 2 + 1).getRLPData()); votes.put(spec, specVotes); } return new ABICallElection(authorizer, votes); } private BridgeSerializationUtils(); static byte[] serializeMap(SortedMap<Keccak256, BtcTransaction> map); static SortedMap<Keccak256, BtcTransaction> deserializeMap(byte[] data, NetworkParameters networkParameters, boolean noInputsTxs); static byte[] serializeUTXOList(List<UTXO> list); static List<UTXO> deserializeUTXOList(byte[] data); static byte[] serializeSet(SortedSet<Sha256Hash> set); static SortedSet<Sha256Hash> deserializeSet(byte[] data); static byte[] serializeMapOfHashesToLong(Map<Sha256Hash, Long> map); static Map<Sha256Hash, Long> deserializeMapOfHashesToLong(byte[] data); static byte[] serializeFederationOnlyBtcKeys(Federation federation); static Federation deserializeFederationOnlyBtcKeys(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederation(Federation federation); static Federation deserializeFederation(byte[] data, NetworkParameters networkParameters); static byte[] serializeFederationMember(FederationMember federationMember); static byte[] serializePendingFederationOnlyBtcKeys(PendingFederation pendingFederation); static PendingFederation deserializePendingFederationOnlyBtcKeys(byte[] data); static byte[] serializePendingFederation(PendingFederation pendingFederation); static PendingFederation deserializePendingFederation(byte[] data); static byte[] serializeElection(ABICallElection election); static ABICallElection deserializeElection(byte[] data, AddressBasedAuthorizer authorizer); static byte[] serializeOneOffLockWhitelist(Pair<List<OneOffWhiteListEntry>, Integer> data); static byte[] serializeUnlimitedLockWhitelist(List<UnlimitedWhiteListEntry> entries); static Pair<HashMap<Address, OneOffWhiteListEntry>, Integer> deserializeOneOffLockWhitelistAndDisableBlockHeight(byte[] data, NetworkParameters parameters); static Map<Address, UnlimitedWhiteListEntry> deserializeUnlimitedLockWhitelistEntries(byte[] data, NetworkParameters parameters); static byte[] serializeCoin(Coin coin); @Nullable static Coin deserializeCoin(byte[] data); static byte[] serializeReleaseRequestQueue(ReleaseRequestQueue queue); static byte[] serializeReleaseRequestQueueWithTxHash(ReleaseRequestQueue queue); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters); static List<ReleaseRequestQueue.Entry> deserializeReleaseRequestQueue(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeReleaseTransactionSet(ReleaseTransactionSet set); static byte[] serializeReleaseTransactionSetWithTxHash(ReleaseTransactionSet set); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters); static ReleaseTransactionSet deserializeReleaseTransactionSet(byte[] data, NetworkParameters networkParameters, boolean hasTxHash); static byte[] serializeInteger(Integer value); static Integer deserializeInteger(byte[] data); static byte[] serializeLong(long value); static Optional<Long> deserializeOptionalLong(byte[] data); static CoinbaseInformation deserializeCoinbaseInformation(byte[] data); static byte[] serializeCoinbaseInformation(CoinbaseInformation coinbaseInformation); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.