Examples with PeginInstructionsProvider co.rsk.peg.pegininstructions.PeginInstructionsProvider used on opensource projects

Example 6 with PeginInstructionsProvider

use of co.rsk.peg.pegininstructions.PeginInstructionsProvider in project rskj by rsksmart.

the class PeginInformationTest method parse_withBtcLockSender_withPeginInstructions_preIris.

@Test
public void parse_withBtcLockSender_withPeginInstructions_preIris() throws PeginInstructionsException {
    // Arrange
    BtcECKey address1Key = new BtcECKey();
    RskAddress rskDestinationAddressFromBtcLockSender = new RskAddress(ECKey.fromPublicOnly(address1Key.getPubKey()).getAddress());
    Address btcRefundAddressFromBtcLockSender = address1Key.toAddress(networkParameters);
    TxSenderAddressType senderBtcAddressType = TxSenderAddressType.P2PKH;
    BtcTransaction btcTx = new BtcTransaction(networkParameters);
    BtcLockSender btcLockSenderMock = mock(P2pkhBtcLockSender.class);
    when(btcLockSenderMock.getRskAddress()).thenReturn(rskDestinationAddressFromBtcLockSender);
    when(btcLockSenderMock.getBTCAddress()).thenReturn(btcRefundAddressFromBtcLockSender);
    when(btcLockSenderMock.getTxSenderAddressType()).thenReturn(senderBtcAddressType);
    BtcLockSenderProvider btcLockSenderProviderMock = mock(BtcLockSenderProvider.class);
    when(btcLockSenderProviderMock.tryGetBtcLockSender(btcTx)).thenReturn(Optional.of(btcLockSenderMock));
    BtcECKey address2Key = new BtcECKey();
    RskAddress rskDestinationAddressFromPeginInstructions = new RskAddress(ECKey.fromPublicOnly(address2Key.getPubKey()).getAddress());
    Address btcRefundAddressFromPeginInstructions = address2Key.toAddress(networkParameters);
    PeginInstructionsVersion1 peginInstructionsMock = mock(PeginInstructionsVersion1.class);
    when(peginInstructionsMock.getProtocolVersion()).thenReturn(1);
    when(peginInstructionsMock.getRskDestinationAddress()).thenReturn(rskDestinationAddressFromPeginInstructions);
    when(peginInstructionsMock.getBtcRefundAddress()).thenReturn(Optional.of(btcRefundAddressFromPeginInstructions));
    PeginInstructionsProvider peginInstructionsProviderMock = mock(PeginInstructionsProvider.class);
    when(peginInstructionsProviderMock.buildPeginInstructions(btcTx)).thenReturn(Optional.of(peginInstructionsMock));
    ActivationConfig.ForBlock activationsMock = mock(ActivationConfig.ForBlock.class);
    when(activationsMock.isActive(ConsensusRule.RSKIP170)).thenReturn(false);
    // Act
    PeginInformation peginInformation = new PeginInformation(btcLockSenderProviderMock, peginInstructionsProviderMock, activationsMock);
    peginInformation.parse(btcTx);
    // Assert
    Assert.assertEquals(0, peginInformation.getProtocolVersion());
    Assert.assertEquals(rskDestinationAddressFromBtcLockSender, peginInformation.getRskDestinationAddress());
    Assert.assertEquals(btcRefundAddressFromBtcLockSender, peginInformation.getBtcRefundAddress());
    Assert.assertEquals(btcRefundAddressFromBtcLockSender, peginInformation.getSenderBtcAddress());
    Assert.assertEquals(senderBtcAddressType, peginInformation.getSenderBtcAddressType());
    Assert.assertNotEquals(rskDestinationAddressFromPeginInstructions, peginInformation.getRskDestinationAddress());
    Assert.assertNotEquals(btcRefundAddressFromPeginInstructions, peginInformation.getBtcRefundAddress());
}

Example 7 with PeginInstructionsProvider

use of co.rsk.peg.pegininstructions.PeginInstructionsProvider in project rskj by rsksmart.

the class BridgeSupportTest method getPeginInstructionsProviderForVersion1.

private PeginInstructionsProvider getPeginInstructionsProviderForVersion1(RskAddress rskDestinationAddress, Optional<Address> btcRefundAddress) throws PeginInstructionsException {
    PeginInstructionsVersion1 peginInstructions = mock(PeginInstructionsVersion1.class);
    when(peginInstructions.getProtocolVersion()).thenReturn(1);
    when(peginInstructions.getRskDestinationAddress()).thenReturn(rskDestinationAddress);
    when(peginInstructions.getBtcRefundAddress()).thenReturn(btcRefundAddress);
    PeginInstructionsProvider peginInstructionsProvider = mock(PeginInstructionsProvider.class);
    when(peginInstructionsProvider.buildPeginInstructions(any())).thenReturn(Optional.of(peginInstructions));
    return peginInstructionsProvider;
}

Example 8 with PeginInstructionsProvider

use of co.rsk.peg.pegininstructions.PeginInstructionsProvider in project rskj by rsksmart.

the class BridgeSupportTest method when_registerBtcTransaction_usesSegCompatibilityType_afterFork_notWhitelisted_no_lock_and_refund.

@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);
    Federation federation1 = getFederation(bridgeConstants);
    Repository repository = createRepository();
    repository.addBalance(PrecompiledContracts.BRIDGE_ADDR, LIMIT_MONETARY_BASE);
    Block executionBlock = mock(Block.class);
    when(executionBlock.getNumber()).thenReturn(10L);
    // First transaction goes only to the first federation
    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, bridgeConstants, provider, activations)).thenReturn(btcBlockStore);
    BridgeSupport bridgeSupport = getBridgeSupport(bridgeConstants, provider, repository, getBtcLockSenderProvider(TxSenderAddressType.P2SHP2WPKH, btcAddress, rskAddress), new PeginInstructionsProvider(), 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());
    // First release tx should correspond to the 5 BTC lock tx
    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());
}

Example 9 with PeginInstructionsProvider

use of co.rsk.peg.pegininstructions.PeginInstructionsProvider in project rskj by rsksmart.

the class BridgeSupportTest method processPegIn_errorParsingPeginInstructions_afterRskip170_refundSender.

@Test
public void processPegIn_errorParsingPeginInstructions_afterRskip170_refundSender() throws IOException, PeginInstructionsException {
    // Arrange
    ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class);
    when(activations.isActive(ConsensusRule.RSKIP170)).thenReturn(true);
    Repository repository = createRepository();
    BtcECKey srcKey1 = new BtcECKey();
    ECKey key = ECKey.fromPublicOnly(srcKey1.getPubKey());
    RskAddress rskAddress = new RskAddress(key.getAddress());
    Address btcSenderAddress = srcKey1.toAddress(btcParams);
    BtcTransaction btcTx = new BtcTransaction(btcParams);
    btcTx.addOutput(Coin.COIN.multiply(10), bridgeConstants.getGenesisFederation().getAddress());
    btcTx.addInput(PegTestUtils.createHash(1), 0, new Script(new byte[] {}));
    BridgeStorageProvider provider = mock(BridgeStorageProvider.class);
    ReleaseTransactionSet releaseTransactionSet = new ReleaseTransactionSet(new HashSet<>());
    when(provider.getReleaseTransactionSet()).thenReturn(releaseTransactionSet);
    BtcLockSenderProvider btcLockSenderProvider = getBtcLockSenderProvider(TxSenderAddressType.P2PKH, btcSenderAddress, rskAddress);
    PeginInstructionsProvider peginInstructionsProvider = mock(PeginInstructionsProvider.class);
    when(peginInstructionsProvider.buildPeginInstructions(btcTx)).thenThrow(PeginInstructionsException.class);
    BridgeSupport bridgeSupport = getBridgeSupport(bridgeConstants, provider, repository, btcLockSenderProvider, peginInstructionsProvider, mock(Block.class), mock(BtcBlockStoreWithCache.Factory.class), activations);
    // Act
    try {
        bridgeSupport.processPegIn(btcTx, mock(Transaction.class), 0, mock(Sha256Hash.class));
        // Should have thrown a RegisterBtcTransactionException
        Assert.fail();
    } catch (Exception ex) {
        // Assert
        Assert.assertTrue(ex instanceof RegisterBtcTransactionException);
        Assert.assertEquals(1, releaseTransactionSet.getEntries().size());
        // Check rejection tx input was created from btc tx and sent to the btc refund address indicated by the user
        boolean successfulRejection = false;
        for (ReleaseTransactionSet.Entry e : releaseTransactionSet.getEntries()) {
            BtcTransaction refundTx = e.getTransaction();
            if (refundTx.getInput(0).getOutpoint().getHash() == btcTx.getHash() && refundTx.getOutput(0).getScriptPubKey().getToAddress(btcParams).equals(btcSenderAddress)) {
                successfulRejection = true;
                break;
            }
        }
        Assert.assertTrue(successfulRejection);
    }
}

Example 10 with PeginInstructionsProvider

use of co.rsk.peg.pegininstructions.PeginInstructionsProvider in project rskj by rsksmart.

the class BridgeSupportTest method assertLockingCap.

private void assertLockingCap(boolean shouldLock, boolean isLockingCapEnabled, Coin lockingCap, Coin amountSentToNewFed, Coin amountSentToOldFed, Coin amountInNewFed, Coin amountInOldFed) throws BlockStoreException, IOException, BridgeIllegalArgumentException {
    // Configure if locking cap should be evaluated
    ActivationConfig.ForBlock activations = mock(ActivationConfig.ForBlock.class);
    when(activations.isActive(ConsensusRule.RSKIP134)).thenReturn(isLockingCapEnabled);
    BridgeConstants bridgeConstants = mock(BridgeConstants.class);
    when(bridgeConstants.getLegacyMinimumPeginTxValueInSatoshis()).thenReturn(Coin.SATOSHI);
    when(bridgeConstants.getBtcParams()).thenReturn(BridgeRegTestConstants.getInstance().getBtcParams());
    when(bridgeConstants.getBtc2RskMinimumAcceptableConfirmations()).thenReturn(1);
    when(bridgeConstants.getGenesisFeePerKb()).thenReturn(BridgeRegTestConstants.getInstance().getGenesisFeePerKb());
    when(bridgeConstants.getMaxRbtc()).thenReturn(BridgeRegTestConstants.getInstance().getMaxRbtc());
    // Configure locking cap
    when(bridgeConstants.getInitialLockingCap()).thenReturn(lockingCap);
    Repository repository = createRepository();
    Federation oldFederation = this.getFederation(bridgeConstants);
    BridgeStorageProvider provider = new BridgeStorageProvider(repository, PrecompiledContracts.BRIDGE_ADDR, bridgeConstants, activations);
    // We need a random new fed
    provider.setNewFederation(this.getFederation(bridgeConstants, Arrays.asList(BtcECKey.fromPrivate(Hex.decode("fb01")), BtcECKey.fromPrivate(Hex.decode("fb02")), BtcECKey.fromPrivate(Hex.decode("fb03")))));
    // Use genesis fed as old
    provider.setOldFederation(oldFederation);
    Coin currentFunds = Coin.ZERO;
    // Configure existing utxos in both federations
    if (amountInOldFed != null) {
        UTXO utxo = new UTXO(Sha256Hash.wrap(HashUtil.randomHash()), 0, amountInOldFed, 1, false, new Script(new byte[] {}));
        provider.getOldFederationBtcUTXOs().add(utxo);
        currentFunds = currentFunds.add(amountInOldFed);
    }
    if (amountInNewFed != null) {
        UTXO utxo = new UTXO(Sha256Hash.wrap(HashUtil.randomHash()), 0, amountInNewFed, 1, false, new Script(new byte[] {}));
        provider.getNewFederationBtcUTXOs().add(utxo);
        currentFunds = currentFunds.add(amountInNewFed);
    }
    // Fund bridge in RBTC, substracting the funds that we are indicating were locked in the federations (which means a user locked)
    co.rsk.core.Coin bridgeBalance = LIMIT_MONETARY_BASE.subtract(co.rsk.core.Coin.fromBitcoin(currentFunds));
    repository.addBalance(PrecompiledContracts.BRIDGE_ADDR, bridgeBalance);
    // The locking cap shouldn't be surpassed by the initial configuration
    Assert.assertFalse(isLockingCapEnabled && currentFunds.isGreaterThan(lockingCap));
    Coin lockValue = Coin.ZERO;
    int newUtxos = 0;
    // Create transaction setting the outputs to the configured values
    BtcTransaction tx = new BtcTransaction(bridgeConstants.getBtcParams());
    if (amountSentToOldFed != null) {
        tx.addOutput(amountSentToOldFed, provider.getOldFederation().getAddress());
        lockValue = lockValue.add(amountSentToOldFed);
        newUtxos++;
    }
    if (amountSentToNewFed != null) {
        tx.addOutput(amountSentToNewFed, provider.getNewFederation().getAddress());
        lockValue = lockValue.add(amountSentToNewFed);
        newUtxos++;
    }
    BtcECKey srcKey = new BtcECKey();
    tx.addInput(PegTestUtils.createHash(1), 0, ScriptBuilder.createInputScript(null, srcKey));
    // Create header and PMT
    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 registerHeader = new co.rsk.bitcoinj.core.BtcBlock(bridgeConstants.getBtcParams(), 1, PegTestUtils.createHash(1), merkleRoot, 1, 1, 1, new ArrayList<BtcTransaction>());
    BtcBlockStoreWithCache btcBlockStore = mock(BtcBlockStoreWithCache.class);
    BtcBlockStoreWithCache.Factory mockFactory = mock(BtcBlockStoreWithCache.Factory.class);
    when(mockFactory.newInstance(repository, bridgeConstants, provider, activations)).thenReturn(btcBlockStore);
    Block executionBlock = Mockito.mock(Block.class);
    when(executionBlock.getNumber()).thenReturn(10L);
    // Get the tx sender public key
    byte[] data = tx.getInput(0).getScriptSig().getChunks().get(1).data;
    BtcECKey senderBtcKey = BtcECKey.fromPublicOnly(data);
    // Whitelist the addresses
    LockWhitelist whitelist = provider.getLockWhitelist();
    Address address = senderBtcKey.toAddress(bridgeConstants.getBtcParams());
    whitelist.put(address, new OneOffWhiteListEntry(address, lockValue));
    // The address is whitelisted
    Assert.assertThat(whitelist.isWhitelisted(address), is(true));
    BridgeSupport bridgeSupport = getBridgeSupport(bridgeConstants, provider, repository, new BtcLockSenderProvider(), new PeginInstructionsProvider(), executionBlock, mockFactory, activations);
    // Simulate blockchain
    int height = 1;
    mockChainOfStoredBlocks(btcBlockStore, registerHeader, height + bridgeConstants.getBtc2RskMinimumAcceptableConfirmations(), height);
    Transaction rskTx = mock(Transaction.class);
    Keccak256 hash = new Keccak256(HashUtil.keccak256(new byte[] {}));
    when(rskTx.getHash()).thenReturn(hash);
    // Try to register tx
    bridgeSupport.registerBtcTransaction(rskTx, tx.bitcoinSerialize(), height, pmt.bitcoinSerialize());
    bridgeSupport.save();
    // If the address is no longer whitelisted, it means it was consumed, whether the lock was rejected by lockingCap or not
    Assert.assertThat(whitelist.isWhitelisted(address), is(false));
    // The Btc transaction should have been processed
    assertTrue(bridgeSupport.isBtcTxHashAlreadyProcessed(tx.getHash()));
    co.rsk.core.Coin totalAmountExpectedToHaveBeenLocked = co.rsk.core.Coin.fromBitcoin(shouldLock ? lockValue : Coin.ZERO);
    RskAddress srcKeyRskAddress = new RskAddress(org.ethereum.crypto.ECKey.fromPrivate(srcKey.getPrivKey()).getAddress());
    // Verify amount was locked
    Assert.assertEquals(totalAmountExpectedToHaveBeenLocked, repository.getBalance(srcKeyRskAddress));
    Assert.assertEquals(bridgeBalance.subtract(totalAmountExpectedToHaveBeenLocked), repository.getBalance(PrecompiledContracts.BRIDGE_ADDR));
    if (!shouldLock) {
        // Release tx should have been created directly to the signatures stack
        BtcTransaction releaseTx = provider.getReleaseTransactionSet().getEntries().iterator().next().getTransaction();
        Assert.assertNotNull(releaseTx);
        // returns the funds to the sender
        Assert.assertEquals(1, releaseTx.getOutputs().size());
        Assert.assertEquals(address, releaseTx.getOutputs().get(0).getAddressFromP2PKHScript(bridgeConstants.getBtcParams()));
        Assert.assertEquals(lockValue, releaseTx.getOutputs().get(0).getValue().add(releaseTx.getFee()));
        // Uses the same UTXO(s)
        Assert.assertEquals(newUtxos, releaseTx.getInputs().size());
        for (int i = 0; i < newUtxos; i++) {
            TransactionInput input = releaseTx.getInput(i);
            Assert.assertEquals(tx.getHash(), input.getOutpoint().getHash());
            Assert.assertEquals(i, input.getOutpoint().getIndex());
        }
    }
}