BitWasp\Bitcoin\RpcTest\RbfTransactionTest

Complexity

Total Complexity

9

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	15

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	assertSendRawTransaction()	0	8	1
A	assertBitcoindError()	0	10	1
B	createTransaction()	0	35	4
A	testCanReplaceTransactionOnce()	0	52	1

<?php

namespace BitWasp\Bitcoin\RpcTest;


use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PrivateKeyInterface;
use BitWasp\Bitcoin\Key\PrivateKeyFactory;
use BitWasp\Bitcoin\Script\ScriptFactory;
use BitWasp\Bitcoin\Transaction\Factory\Signer;
use BitWasp\Bitcoin\Transaction\Factory\TxBuilder;
use BitWasp\Bitcoin\Transaction\TransactionInterface;
use BitWasp\Bitcoin\Transaction\TransactionOutput;
use BitWasp\Bitcoin\Utxo\Utxo;

class RbfTransactionTest extends AbstractTestCase
{
    /**
     * @var RegtestBitcoinFactory
     */
    private $rpcFactory;

    public function __construct($name = null, array $data = [], $dataName = '')
    {
        parent::__construct($name, $data, $dataName);

        static $rpcFactory = null;
        if (null === $rpcFactory) {
            $rpcFactory = new RegtestBitcoinFactory();
        }
        $this->rpcFactory = $rpcFactory;
    }

    private function assertSendRawTransaction($result) {
        $this->assertInternalType('array', $result);
        $this->assertArrayHasKey('error', $result);
        $this->assertEquals(null, $result['error']);

        $this->assertArrayHasKey('result', $result);
        $this->assertEquals(64, strlen($result['result']));
    }

    private function assertBitcoindError($errorCode, $result)
    {
        $this->assertInternalType('array', $result);
        $this->assertArrayHasKey('error', $result);
        $this->assertInternalType('array', $result['error']);
        $this->assertEquals($errorCode, $result['error']['code']);

        $this->assertArrayHasKey('error', $result);
        $this->assertEquals(null, $result['result']);
    }

    /**
     * @param Utxo[] $utxos
     * @param PrivateKeyInterface[] $privKeys
     * @param TransactionOutput[] $outputs
     * @param array $sequences - sequence to set on inputs
     * @return TransactionInterface
     */
    private function createTransaction(array $utxos, array $privKeys, array $outputs, array $sequences)
    {
        $this->assertEquals(count($utxos), count($privKeys));
        $this->assertEquals(count($utxos), count($sequences));

        // First transaction, spends UTXO 0, to $destSPK 0.25 and $changeSPK 0.2499
        $txBuilder = new TxBuilder();

        $totalIn = 0;
        foreach ($utxos as $i => $utxo) {
            $txid = $utxo->getOutPoint()->getTxId();
            $vout= $utxo->getOutPoint()->getVout();
            $txBuilder->input($txid, $vout, null, $sequences[$i]);
            $totalIn += $utxo->getOutput()->getValue();
        }

        $totalOut = 0;
        foreach ($outputs as $output) {
            $txBuilder->output($output->getValue(), $output->getScript());
            $totalOut += $output->getValue();
        }

        $this->assertGreaterThanOrEqual($totalOut, $totalIn, "TotalIn should be greater than TotalOut");

        $signer = new Signer($txBuilder->get());
        foreach ($utxos as $i => $utxo) {
            $iSigner = $signer
                ->input($i, $utxo->getOutput())
                ->sign($privKeys[$i])
            ;
            $this->assertTrue($iSigner->isFullySigned());
        }

        return $signer->get();
    }

    public function testCanReplaceTransactionOnce()
    {
        $bitcoind = $this->rpcFactory->startBitcoind();

        $this->assertTrue($bitcoind->isRunning());

        $destKey = PrivateKeyFactory::create(true);
        $destSPK = ScriptFactory::scriptPubKey()->p2wkh($destKey->getPubKeyHash());

        $changeKey = PrivateKeyFactory::create(true);
        $changeSPK = ScriptFactory::scriptPubKey()->p2wkh($changeKey->getPubKeyHash());

        $privateKey = PrivateKeyFactory::create(true);
        $scriptPubKey = ScriptFactory::scriptPubKey()->p2wkh($privateKey->getPubKeyHash());
        $amount = 100000000;

        /** @var Utxo[] $utxos */
        $utxos = [
            $bitcoind->fundOutput($amount, $scriptPubKey),
            $bitcoind->fundOutput($amount, $scriptPubKey),
            $bitcoind->fundOutput($amount, $scriptPubKey),
        ];

        // replacable tx
        $tx = $this->createTransaction([$utxos[0]], [$privateKey], [
            new TransactionOutput(25000000, $destSPK),
            new TransactionOutput(74990000, $changeSPK),
        ], [TransactionInterface::MAX_LOCKTIME - 2]);

        $result = $bitcoind->makeRpcRequest('sendrawtransaction', [$tx->getHex()]);
        $this->assertSendRawTransaction($result);

        // replace tx
        $tx = $this->createTransaction([$utxos[0], $utxos[1]], [$privateKey, $privateKey], [
            new TransactionOutput(25000000, $destSPK),
            new TransactionOutput($utxos[1]->getOutput()->getValue() + 74950000, $changeSPK),
        ], [TransactionInterface::MAX_LOCKTIME - 1, TransactionInterface::MAX_LOCKTIME]);

        $result = $bitcoind->makeRpcRequest('sendrawtransaction', [$tx->getHex()]);
        $this->assertSendRawTransaction($result);

        // cant replace again, mempool tx has final input
        $tx = $this->createTransaction($utxos, [$privateKey, $privateKey, $privateKey], [
            new TransactionOutput(25000000, $destSPK),
            new TransactionOutput((2 * $utxos[1]->getOutput()->getValue()) + 74920000, $changeSPK),
        ], [TransactionInterface::MAX_LOCKTIME, TransactionInterface::MAX_LOCKTIME, TransactionInterface::MAX_LOCKTIME]);

        $result = $bitcoind->makeRpcRequest('sendrawtransaction', [$tx->getHex()]);
        $this->assertBitcoindError(RpcServer::ERROR_TX_MEMPOOL_CONFLICT, $result);

        $bitcoind->destroy();
    }
}