<?php
namespace App\Console\Commands;

use App\Models\Address;
use App\Models\Block;

use App\Models\Claim;
use App\Models\ClaimStream;
use App\Models\Input;
use App\Models\Output;
use App\Models\Transaction;
use Carbon\Carbon;
use DateTime;
use DateTimeZone;
use Exception;
use Illuminate\Console\Command;
use Illuminate\Support\Facades\Cache;

use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Redis;
use InvalidArgumentException;
use Mdanter\Ecc\EccFactory;
use PDO;
use RedisException;
use Throwable;

class BlockCommand extends Command{

    const mempooltxkey = 'lbc.mempooltx';

    const pubKeyAddress = [0, 85];

    const scriptAddress = [5, 122];

    protected static $redis;
    public static $rpcurl;

    /**
     * The console command description.
     * @var string
     */
    protected $description = 'LBRY Block Explorer - Block command';

    /**
     * The name and signature of the console command.
     * @var string
     */
    protected $signature = 'explorer:block {function?}';

    public function __construct(){
        parent::__construct();
        self::$redis = Redis::connection()->client();
        self::$rpcurl = config('lbry.rpc_url');
    }

    /**
     * Execute the console command.
     */
    public function handle(): void{
        $function = $this->argument('function');
        if($function){
            $this->$function();
        }else{
            $this->warn('No arguments specified');
        }
    }

    /**
     * @return void
     * @throws Throwable
     */
    public function fixscripthashtx(): void{
        $conn = DB::connection();
        $otxs = Output::query()->select(['TransactionId'])->distinct(['TransactionId'])->where('Type','scripthash')->get();
        foreach ($otxs as $otx) {
            $txid = $otx->TransactionId;
            $tx = Transaction::query()->select(['Hash'])->where('Id',$txid)->first();
            $req = ['method' => 'getrawtransaction', 'params' => [$tx->Hash],'id'=>rand()];
            $response = self::curl_json_post(self::$rpcurl, json_encode($req));
            $json = json_decode($response);
            $tx_result = $json->result;
            $raw_tx = $tx_result;
            $tx_data = self::decode_tx($raw_tx);
            $all_tx_data = $this->txdb_data_from_decoded($tx_data);

            foreach ($all_tx_data['outputs'] as $out) {
                if ($out['Type'] != 'scripthash') {
                    continue;
                }

                // get the old address
                $old_output = Output::query()->select(['Id', 'Addresses'])->where([
                    ['TransactionId',$txid],
                    ['Vout',$out['Vout']],
                ])->first();
                if ($old_output) {
                    $old_addresses = json_decode($old_output->Addresses);
                    $old_address = $old_addresses[0];
                    $new_addresses = json_decode($out['Addresses']);
                    $new_address = $new_addresses[0];

                    // update the output with new addresses array
                    $conn->beginTransaction();
                    $conn->statement('UPDATE Outputs SET Addresses = ? WHERE Id = ?', [$out['Addresses'], $old_output->Id]);

                    // update the old address with the new one
                    $conn->statement('UPDATE Addresses SET Address = ? WHERE Address = ?', [$new_address, $old_address]);
                    $conn->commit();

                    echo "$old_address => $new_address\n";
                }
            }
        }
    }

    public static function hex2str(string $hex): string{
        $string = '';
        for ($i = 0; $i < strlen($hex)-1; $i+=2){
            $string .= chr(hexdec($hex[$i].$hex[$i+1]));
        }
        return $string;
    }

    public function updateclaimfees(): void{
        self::lock('claimfees');

        $conn = DB::connection();
        try {
            $stmt = $conn->getPdo()->query('SELECT CS.Id, CS.Stream FROM ClaimStreams CS JOIN Claims C ON C.Id = CS.Id WHERE C.Fee = 0 AND C.Id <= 11462 ORDER BY Id ASC');
            $claims = $stmt->fetchAll(PDO::FETCH_OBJ);
            foreach ($claims as $claim) {
                $stream = json_decode($claim->Stream);
                if (isset($stream->metadata->fee) && $stream->metadata->fee->amount > 0) {
                    $fee = $stream->metadata->fee->amount;
                    $currency = $stream->metadata->fee->currency;

                    $conn->statement('UPDATE Claims SET Fee = ?, FeeCurrency = ? WHERE Id = ?', [$fee, $currency, $claim->Id]);
                    echo "Updated fee for claim ID: $claim->Id. Fee: $fee, Currency: $currency\n";
                }
            }
        } catch (Exception $e) {
            print_r($e);
        }

        self::unlock('claimfees');
    }

    /**
     * @return void
     * @throws RedisException
     * @throws Throwable
     */
    public function buildclaimindex(): void{
        self::lock('buildindex');

        // start with all txs
        $decoder_url = 'http://127.0.0.1:5000';
        $conn = DB::connection();
        $redis_key = 'claim.oid';
        $last_claim_oid = self::$redis->exists($redis_key) ? self::$redis->get($redis_key) : 0;
        try {
            $stmt = $conn->getPdo()->query('SELECT COUNT(Id) AS RecordCount FROM Outputs WHERE Id > ?', [$last_claim_oid]);
            $count = min(500000, $stmt->fetch(PDO::FETCH_OBJ)->RecordCount);

            $idx = 0;
            $stmt = $conn->getPdo()->query('SELECT O.Id, O.TransactionId, O.Vout, O.ScriptPubKeyAsm, T.Hash, IFNULL(T.TransactionTime, T.CreatedTime) AS TxTime FROM Outputs O ' .
                'JOIN Transactions T ON T.Id = O.TransactionId WHERE O.Id > ? ORDER BY O.Id ASC LIMIT 500000',
                [$last_claim_oid]);
            while ($out = $stmt->fetch(PDO::FETCH_OBJ)) {
                $idx++;
                $idx_str = str_pad($idx, strlen($count), '0', STR_PAD_LEFT);

                $txid = $out->TransactionId;
                $vout = $out->Vout;

                if (strpos($out->ScriptPubKeyAsm, 'OP_CLAIM_NAME') !== false) {
                    // check if the claim already exists in the claims table
                    $stmt2 = $conn->getPdo()->query('SELECT Id FROM Claims WHERE TransactionHash = ? AND Vout = ?', [$out->Hash, $out->Vout]);
                    $exist_claim = $stmt2->fetch(PDO::FETCH_OBJ);
                    if ($exist_claim) {
                        echo "[$idx_str/$count] claim already exists for [$out->Hash:$vout]. Skipping.\n";
                        continue;
                    }

                    $asm_parts = explode(' ', $out->ScriptPubKeyAsm, 4);
                    $name_hex = $asm_parts[1];
                    $claim_name = @pack('H*', $name_hex);

                    // decode claim
                    $url = sprintf("%s/claim_decode/%s", $decoder_url, $claim_name);
                    $json = null;
                    try {
                        $json = self::curl_json_get($url);
                    } catch (Exception $e) {
                        echo "[$idx_str/$count] claimdecode failed for [$out->Hash:$vout]. Skipping.\n";
                        continue;
                    }
                    $claim = json_decode($json);

                    if ($claim) {
                        $req = ['method' => 'getvalueforname', 'params' => [$claim_name],'id'=>rand()];
                        $json = null;
                        try {
                            $json = json_decode(self::curl_json_post(self::$rpcurl, json_encode($req)));
                            if (!$json) {
                                echo "[$idx_str/$count] getvalueforname failed for [$out->Hash:$vout]. Skipping.\n";
                                continue;
                            }
                        } catch (Exception $e) {
                            echo "[$idx_str/$count] getvalueforname failed for [$out->Hash:$vout]. Skipping.\n";
                            continue;
                        }

                        echo "[$idx_str/$count] claim found for [$out->Hash:$vout]. Processing claim... \n";
                        $claim_data = [];

                        $claim_id = $json->result->claimId;
                        $tx_dt = DateTime::createFromFormat('U', $out->TxTime);

                        $claim_stream_data = null;
                        if ($claim->claimType === 'streamType') {
                            // Build claim object to save
                            $claim_data = [
                                'ClaimId' => $claim_id,
                                'TransactionHash' => $out->Hash,
                                'Vout' => $out->Vout,
                                'Name' => $claim_name,
                                'Version' => $claim->version,
                                'ClaimType' => 2, // streamType
                                'ContentType' => isset($claim->stream->source->contentType) ? $claim->stream->source->contentType : null,
                                'Title' => isset($claim->stream->metadata->title) ? $claim->stream->metadata->title : null,
                                'Description' => isset($claim->stream->metadata->description) ? $claim->stream->metadata->description : null,
                                'Language' => isset($claim->stream->metadata->language) ? $claim->stream->metadata->language : null,
                                'Author' => isset($claim->stream->metadata->author) ? $claim->stream->metadata->author : null,
                                'ThumbnailUrl' => isset($claim->stream->metadata->thumbnail) ? $claim->stream->metadata->thumbnail : null,
                                'IsNSFW' => isset($claim->stream->metadata->nsfw) ? $claim->stream->metadata->nsfw : 0,
                                'Fee' => isset($claim->stream->metadata->fee) ? $claim->stream->metadata->fee->amount : 0,
                                'FeeCurrency' => isset($claim->stream->metadata->fee) ? $claim->stream->metadata->fee->currency : 0,
                                'Created' => $tx_dt->format('Y-m-d H:i:s'),
                                'Modified' => $tx_dt->format('Y-m-d H:i:s')
                            ];

                            $claim_stream_data = [
                                'Stream' => json_encode($claim->stream)
                            ];

                            if (isset($claim->publisherSignature)) {
                                $sig_claim = Claim::query()->select(['Id', 'ClaimId', 'Name'])->where('ClaimId',$claim->publisherSignature->certificateId)->first();
                                if ($sig_claim) {
                                    $claim_data['PublisherId'] = $sig_claim->ClaimId;
                                    $claim_data['PublisherName'] = $sig_claim->Name;
                                }
                            }
                        } else {
                            $claim_data = [
                                'ClaimId' => $claim_id,
                                'TransactionHash' => $out->Hash,
                                'Vout' => $out->Vout,
                                'Name' => $claim_name,
                                'Version' => $claim->version,
                                'ClaimType' => 1,
                                'Certificate' => json_encode($claim->certificate),
                                'Created' => $tx_dt->format('Y-m-d H:i:s'),
                                'Modified' => $tx_dt->format('Y-m-d H:i:s')
                            ];
                        }

                        $conn->beginTransaction();
                        $data_error = false;

                        $claim_entity = new Claim($claim_data);
                        $res = $claim_entity->save();

                        if (!$res) {
                            $data_error = true;
                            echo "[$idx_str/$count] claim for [$out->Hash:$vout] FAILED to save.\n";
                        }

                        if (!$data_error) {
                            if ($claim_stream_data) {
                                $claim_stream_data['Id'] = $claim_entity->Id;
                                $claim_stream_entity = new ClaimStream($claim_stream_data);

                                $res = $claim_stream_entity->save();
                                if (!$res) {
                                    $data_error = true;
                                }
                            }
                        }

                        if (!$data_error) {
                            $conn->commit();
                            echo "[$idx_str/$count] claim for [$out->Hash:$vout] indexed.\n";
                        } else {
                            $conn->rollback();
                            echo "[$idx_str/$count] claim for [$out->Hash:$vout] NOT indexed. Rolled back.\n";
                        }
                    } else {
                        echo "[$idx_str/$count] claim for [$out->Hash:$vout] could not be decoded. Skipping.\n";
                    }
                } else {
                    echo "[$idx_str/$count] no claim found for [$out->Hash:$vout]. Skipping.\n";
                }

                self::$redis->set($redis_key, $out->Id);
            }
        } catch (Exception $e) {
            // continue
            print_r($e);
        }

        self::unlock('buildindex');
    }

    // TODO: Refactor for unique claim identification by claim_id instead of using the claim name.
    protected function _getclaimfortxout($pubkeyasm, $tx_hash, $vout, $tx_time = null): array{
        $claim_data = null;
        $claim_stream_data = null;

        $asm_parts = explode(' ', $pubkeyasm, 4);
        $name_hex = $asm_parts[1];
        $claim_name = @pack('H*', $name_hex);

        // decode claim
        $decoder_url = 'http://127.0.0.1:5000';
        $url = sprintf("%s/claim_decode/%s", $decoder_url, $claim_name);
        $json = null;
        try {
            $json = self::curl_json_get($url);
        } catch (Exception $e) {
            echo "***claimdecode failed for [$tx_hash:$vout]. Skipping.\n";
        }

        if ($json) {
            $claim = json_decode($json);
            if ($claim) {
                if (strpos($claim_name, '#') !== false) {
                    $claim_name = substr($claim_name, 0, strpos($claim_name, '#'));
                }

                $req = ['method' => 'getvalueforname', 'params' => [$claim_name],'id'=>rand()];
                $json = null;
                try {
                    $json = json_decode(self::curl_json_post(self::$rpcurl, json_encode($req)));
                    if ($json) {
                        $claim_data = [];
                        $claim_id = $json->result->claimId;
                        $now = new DateTime('now', new DateTimeZone('UTC'));
                        $tx_dt = ($tx_time != null) ? $tx_time : $now;
                        if ($claim->claimType === 'streamType') {
                            // Build claim object to save
                            $claim_data = [
                                'ClaimId' => $claim_id,
                                'TransactionHash' => $tx_hash,
                                'Vout' => $vout,
                                'Name' => $claim_name,
                                'Version' => $claim->version,
                                'ClaimType' => 2, // streamType
                                'ContentType' => isset($claim->stream->source->contentType) ? $claim->stream->source->contentType : null,
                                'Title' => isset($claim->stream->metadata->title) ? $claim->stream->metadata->title : null,
                                'Description' => isset($claim->stream->metadata->description) ? $claim->stream->metadata->description : null,
                                'Language' => isset($claim->stream->metadata->language) ? $claim->stream->metadata->language : null,
                                'Author' => isset($claim->stream->metadata->author) ? $claim->stream->metadata->author : null,
                                'ThumbnailUrl' => isset($claim->stream->metadata->thumbnail) ? $claim->stream->metadata->thumbnail : null,
                                'IsNSFW' => isset($claim->stream->metadata->nsfw) ? $claim->stream->metadata->nsfw : 0,
                                'Fee' => isset($claim->stream->metadata->fee) ? $claim->stream->metadata->fee->amount : 0,
                                'FeeCurrency' => isset($claim->stream->metadata->fee) ? $claim->stream->metadata->fee->currency : 0,
                                'Created' => $tx_dt->format('Y-m-d H:i:s'),
                                'Modified' => $tx_dt->format('Y-m-d H:i:s')
                            ];

                            $claim_stream_data = [
                                'Stream' => json_encode($claim->stream)
                            ];

                            if (isset($claim->publisherSignature)) {
                                $sig_claim = Claim::query()->select(['Id', 'ClaimId', 'Name'])->where('ClaimId',$claim->publisherSignature->certificateId)->first();
                                if ($sig_claim) {
                                    $claim_data['PublisherId'] = $sig_claim->ClaimId;
                                    $claim_data['PublisherName'] = $sig_claim->Name;
                                }
                            }
                        } else {
                            $claim_data = [
                                'ClaimId' => $claim_id,
                                'TransactionHash' => $tx_hash,
                                'Vout' => $vout,
                                'Name' => $claim_name,
                                'Version' => $claim->version,
                                'ClaimType' => 1,
                                'Certificate' => json_encode($claim->certificate),
                                'Created' => $tx_dt->format('Y-m-d H:i:s'),
                                'Modified' => $tx_dt->format('Y-m-d H:i:s')
                            ];
                        }
                    }
                } catch (Exception $e) {
                    echo "***getvalueforname failed for [$out->Hash:$vout]. Skipping.\n";
                }
            }
        }

        return ['claim_data' => $claim_data, 'claim_stream_data' => $claim_stream_data];
    }

    public function fixzerooutputs(): void{
        self::lock('zerooutputs');

        $conn = DB::connection();

        /** 2017-06-12 21:38:07 **/
        //$last_fixed_txid = self::$redis->exists('fix.txid') ? self::$redis->get('fix.txid') : 0;
        try {
            $stmt = $conn->getPdo()->query('SELECT Id FROM Transactions WHERE Created >= ? AND Created <= ? LIMIT 1000000', ['2017-06-15 20:44:50', '2017-06-16 08:02:09']);
            $txids = $stmt->fetchAll(PDO::FETCH_OBJ);

            $count = count($txids);
            $idx = 0;
            foreach ($txids as $distincttx) {
                $idx++;
                $idx_str = str_pad($idx, strlen($count), '0', STR_PAD_LEFT);
                $txid = $distincttx->Id;
                echo "[$idx_str/$count] Processing txid: $txid... ";
                $total_diff = 0;

                // findtx
                $start_ms = round(microtime(true) * 1000);
                $tx = Transaction::query()->select(['Hash'])->where('Id',$txid)->first();
                $diff_ms = (round(microtime(true) * 1000)) - $start_ms;
                $total_diff += $diff_ms;
                echo "findtx took {$diff_ms}ms. ";

                // Get the inputs and outputs
                // Get the raw transaction (Use getrawtx daemon instead (for speed!!!)

                // getraw
                $req = ['method' => 'getrawtransaction', 'params' => [$tx->Hash],'id'=>rand()];
                $start_ms = round(microtime(true) * 1000);
                $response = self::curl_json_post(self::$rpcurl, json_encode($req));
                $diff_ms = (round(microtime(true) * 1000)) - $start_ms;
                $total_diff += $diff_ms;
                echo "getrawtx took {$diff_ms}ms. ";

                $start_ms = round(microtime(true) * 1000);
                $json = json_decode($response);
                $tx_result = $json->result;
                $raw_tx = $tx_result;
                $tx_data = self::decode_tx($raw_tx);

                $all_tx_data = $this->txdb_data_from_decoded($tx_data);

                $inputs = $all_tx_data['inputs'];
                $outputs = $all_tx_data['outputs'];

                $addr_id_map = [];
                $addr_id_drcr = []; // debits and credits grouped by address
                $total_tx_value = 0;

                $diff_ms = (round(microtime(true) * 1000)) - $start_ms;
                $total_diff += $diff_ms;
                echo "decodetx took {$diff_ms}ms. ";

                // Create / update addresses
                $addr_id_map = [];
                $new_addr_map = [];
                foreach($all_tx_data['addresses'] as $address => $addro) {
                    $prev_addr = Address::query()->select(['Id'])->where('Address',$address)->first();
                    if (!$prev_addr) {
                        $new_addr = [
                            'Address' => $address,
                            'FirstSeen' => $block_ts->format('Y-m-d H:i:s')
                        ];
                        $entity = new Address($new_addr);
                        $res = $entity->save();
                        if (!$res) {
                            $data_error = true;
                        } else {
                            $addr_id_map[$address] = $entity->Id;
                        }
                        $new_addr_map[$address] = 1;
                    } else {
                        $addr_id_map[$address] = $prev_addr->Id;
                    }
                }

                $start_ms = round(microtime(true) * 1000);
                $num_outputs = count($outputs);
                foreach ($outputs as $out) {
                    $vout = $out['Vout'];
                    $total_tx_value = bcadd($total_tx_value, $out['Value'], 8);

                    // check if the output exists
                    $stmt = $conn->getPdo()->query('SELECT Id FROM Outputs WHERE TransactionId = ? AND Vout = ?', [$txid, $vout]);
                    $exist_output = $stmt->fetch(PDO::FETCH_OBJ);

                    if (!$exist_output) {
                        $out['TransactionId'] = $txid;
                        $out_entity = new Output($out);

                        //$stmt->execute('INSERT INTO Outputs')
                        $conn->statement('INSERT INTO Outputs (TransactionId, Vout, Value, Type, ScriptPubKeyAsm, ScriptPubKeyHex, RequiredSignatures, Hash160, Addresses, Created, Modified) '.
                            'VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, UTC_TIMESTAMP(), UTC_TIMESTAMP())',
                            [$out['TransactionId'],
                                $out['Vout'],
                                $out['Value'],
                                $out['Type'],
                                $out['ScriptPubKeyAsm'],
                                $out['ScriptPubKeyHex'],
                                $out['RequiredSignatures'],
                                $out['Hash160'],
                                $out['Addresses']
                            ]);

                        // get the last insert id
                        $stmt = $conn->getPdo()->query('SELECT LAST_INSERT_ID() AS outputId');
                        $linsert = $stmt->fetch(PDO::FETCH_OBJ);
                        $out_entity->Id = $linsert->outputId;

                        if ($out_entity->Id === 0) {
                            $data_error = true;
                            break;
                        }

                        $json_addr = json_decode($out['Addresses']);
                        $address = $json_addr[0];

                        // Get the address ID
                        $addr_id = -1;
                        if (isset($addr_id_map[$address])) {
                            $addr_id = $addr_id_map[$address];
                        } else {
                            $src_addr = Address::query()->select(['Id'])->where('Address',$address)->first();
                            if ($src_addr) {
                                $addr_id = $src_addr->Id;
                                $addr_id_map[$address] = $addr_id;
                            }
                        }

                        if ($addr_id > -1) {
                            $conn->statement('INSERT INTO OutputsAddresses (OutputId, AddressId) VALUES (?, ?) ON DUPLICATE KEY UPDATE OutputId = OutputId', [$out_entity->Id, $addr_id]);
                            $conn->statement('INSERT INTO TransactionsAddresses (TransactionId, AddressId) VALUES (?, ?) ON DUPLICATE KEY UPDATE TransactionId = TransactionId', [$txid, $addr_id]);
                        }

                        if ($addr_id > -1 && isset($new_addr_map[$address])) {
                            if (!isset($addr_id_drcr[$addr_id])) {
                                $addr_id_drcr[$addr_id] = ['debit' => 0, 'credit' => 0];
                            }
                            $addr_id_drcr[$addr_id]['credit'] = bcadd($addr_id_drcr[$addr_id]['credit'], $out['Value'], 8);

                            // Update the Received amount for the address based on the output
                            $conn->statement('UPDATE Addresses SET TotalReceived = TotalReceived + ? WHERE Id = ?', [$out['Value'], $addr_id]);
                        }
                    }
                }
                $diff_ms = (round(microtime(true) * 1000)) - $start_ms;
                $total_diff += $diff_ms;
                echo "$num_outputs output(s) took {$diff_ms}ms. ";

                // Fix the input values
                $start_ms = round(microtime(true) * 1000);
                $num_inputs = count($inputs);
                foreach ($inputs as $in) {
                    if (isset($in['PrevoutHash'])) {
                        $prevout_hash = $in['PrevoutHash'];
                        $in_prevout = $in['PrevoutN'];
                        $prevout_tx_id = -1;
                        $prevout_tx = Transaction::query()->select(['Id'])->where('Hash',$prevout_hash)->first();
                        if (!$prevout_tx) {
                            continue;
                        }

                        $prevout_tx_id = $prevout_tx->Id;
                        $stmt = $conn->getPdo()->query('SELECT Value, Addresses FROM Outputs WHERE TransactionId = ? AND Vout = ?', [$prevout_tx_id, $in_prevout]);
                        $src_output = $stmt->fetch(PDO::FETCH_OBJ);
                        if ($src_output) {
                            $in['Value'] = $src_output->Value;
                            //$conn->execute('UPDATE Inputs SET Value = ? WHERE TransactionId = ? AND PrevoutHash = ? AND PrevoutN = ?', [$in['Value'], $txid, $prevout_hash, $in_prevout]);

                            // Check if the input exists
                            $stmt = $conn->getPdo()->query('SELECT Id FROM Inputs WHERE TransactionId = ? AND PrevoutHash = ? AND PrevoutN = ?', [$txid, $prevout_hash, $in_prevout]);
                            $exist_input = $stmt->fetch(PDO::FETCH_OBJ);

                            if (!$exist_input) {
                                $json_addr = json_decode($src_output->Addresses);
                                $address = $json_addr[0];

                                // Get the address ID
                                $addr_id = -1;
                                if (isset($addr_id_map[$address])) {
                                    $addr_id = $addr_id_map[$address];
                                } else {
                                    $src_addr = Address::query()->select(['Id'])->where('Address',$address)->first();
                                    if ($src_addr) {
                                        $addr_id = $src_addr->Id;
                                        $addr_id_map[$address] = $addr_id;
                                    }
                                }

                                $in_entity = new Input($in);
                                $in['TransactionId'] = $txid;
                                if ($addr_id > -1) {
                                    $in['AddressId'] = $addr_id;
                                }
                                $conn->statement('INSERT INTO Inputs (TransactionId, TransactionHash, AddressId, PrevoutHash, PrevoutN, Sequence, Value, ScriptSigAsm, ScriptSigHex, Created, Modified) ' .
                                    'VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, UTC_TIMESTAMP(), UTC_TIMESTAMP())',
                                    [$in['TransactionId'],
                                        $in['TransactionHash'],
                                        isset($in['AddressId']) ? $in['AddressId'] : null,
                                        $in['PrevoutHash'],
                                        $in['PrevoutN'],
                                        $in['Sequence'],
                                        isset($in['Value']) ? $in['Value'] : 0,
                                        $in['ScriptSigAsm'],
                                        $in['ScriptSigHex']
                                    ]);

                                // get last insert id
                                $stmt = $conn->getPdo()->query('SELECT LAST_INSERT_ID() AS inputId');
                                $linsert = $stmt->fetch(PDO::FETCH_OBJ);
                                $in_entity->Id = $linsert->inputId;

                                if ($in_entity->Id === 0) {
                                    $data_error = true;
                                    break;
                                }

                                if ($addr_id > -1) {
                                    $conn->statement('INSERT INTO InputsAddresses (InputId, AddressId) VALUES (?, ?) ON DUPLICATE KEY UPDATE InputId = InputId', [$in_entity->Id, $addr_id]);
                                    $conn->statement('INSERT INTO TransactionsAddresses (TransactionId, AddressId) VALUES (?, ?) ON DUPLICATE KEY UPDATE TransactionId = TransactionId', [$txid, $addr_id]);
                                }

                                if ($addr_id > -1 && isset($new_addr_map[$address])) {
                                    if (!isset($addr_id_drcr[$addr_id])) {
                                        $addr_id_drcr[$addr_id] = ['debit' => 0, 'credit' => 0];
                                    }
                                    $addr_id_drcr[$addr_id]['debit'] = bcadd($addr_id_drcr[$addr_id]['debit'], $in['Value'], 8);

                                    // Update total sent
                                    $conn->statement('UPDATE Addresses SET TotalSent = TotalSent + ? WHERE Id = ?', [$in['Value'], $addr_id]);
                                }
                            }
                        }
                    }
                }
                $diff_ms = (round(microtime(true) * 1000)) - $start_ms;
                $total_diff += $diff_ms;
                echo "$num_inputs input(s) took {$diff_ms}ms. ";

                // update tx time
                $start_ms = round(microtime(true) * 1000);
                $upd_addr_ids = [];
                //$conn->execute('UPDATE Transactions SET Value = ? WHERE Id = ?', [$total_tx_value, $txid]);
                foreach ($addr_id_drcr as $addr_id => $drcr) {
                    try {
                        $conn->statement('UPDATE TransactionsAddresses SET DebitAmount = ?, CreditAmount = ? WHERE TransactionId = ? AND AddressId = ?',
                            [$drcr['debit'], $drcr['credit'], $txid, $addr_id]);
                    } catch (Exception $e) {
                        print_r($e);
                        $data_error = true;
                        break;
                    }
                }

                //self::$redis->set('fix.txid', $txid);
                $diff_ms = (round(microtime(true) * 1000)) - $start_ms;
                $total_diff += $diff_ms;
                echo "update took {$diff_ms}ms. Total {$total_diff} ms.\n";
            }
        } catch (Exception $e) {
            print_r($e);
        }

        self::unlock('zerooutputs');
    }

    public function addrtxamounts(): void{
        set_time_limit(0);

        self::lock('addrtxamounts');

        try {
            $conn = DB::connection();
            $stmt = $conn->getPdo()->query('SELECT TransactionId, AddressId FROM TransactionsAddresses WHERE DebitAmount = 0 AND CreditAmount = 0 LIMIT 1000000');
            $txaddresses = $stmt->fetchAll(PDO::FETCH_OBJ);

            $count = count($txaddresses);
            $idx = 0;

            echo "Processing $count tx address combos...\n";
            foreach ($txaddresses as $txaddr) {
                $idx++;
                $idx_str = str_pad($idx, strlen($count), '0', STR_PAD_LEFT);

                // Check the inputs
                $stmt = $conn->getPdo()->query('SELECT SUM(I.Value) AS DebitAmount FROM Inputs I JOIN InputsAddresses IA ON IA.InputId = I.Id WHERE I.TransactionId = ? AND IA.AddressId = ?',
                    [$txaddr->TransactionId, $txaddr->AddressId]);
                $res = $stmt->fetch(PDO::FETCH_OBJ);
                $debitamount = $res->DebitAmount ? $res->DebitAmount : 0;

                $stmt = $conn->getPdo()->query('SELECT SUM(O.Value) AS CreditAmount FROM Outputs O JOIN OutputsAddresses OA ON OA.OutputId = O.Id WHERE O.TransactionId = ? AND OA.AddressId = ?',
                    [$txaddr->TransactionId, $txaddr->AddressId]);
                $res = $stmt->fetch(PDO::FETCH_OBJ);
                $creditamount = $res->CreditAmount ? $res->CreditAmount : 0;

                echo "[$idx_str/$count] Updating tx $txaddr->TransactionId, address id $txaddr->AddressId with debit amount: $debitamount, credit amount: $creditamount... ";
                $conn->statement('UPDATE TransactionsAddresses SET DebitAmount = ?, CreditAmount = ? WHERE TransactionId = ? AND AddressId = ?',
                    [$debitamount, $creditamount, $txaddr->TransactionId, $txaddr->AddressId]);
                echo "Done.\n";
            }
        } catch (Exception $e) {
            // failed
            print_r($e);
        }

        self::unlock('addrtxamounts');
    }

    /**
     * @param $tx_hash
     * @param $block_ts
     * @param $block_data
     * @param $data_error
     * @return void
     * @throws Exception
     */
    private function processtx($tx_hash, $block_ts, $block_data, &$data_error): void{
        // Get the raw transaction (Use getrawtx daemon instead (for speed!!!)
        $req = ['method' => 'getrawtransaction', 'params' => [$tx_hash],'id'=>rand()];
        $response = self::curl_json_post(self::$rpcurl, json_encode($req));
        $json = json_decode($response);
        $tx_result = $json->result;
        $raw_tx = $tx_result;
        $tx_data = self::decode_tx($raw_tx);

        $all_tx_data = $this->txdb_data_from_decoded($tx_data);
        $conn = DB::connection();

        // Create / update addresses
        $addr_id_map = [];
        foreach($all_tx_data['addresses'] as $address => $addrss) {
            $prev_addr = Address::query()->select(['Id'])->where('Address',$address)->first();
            if (!$prev_addr) {
                $new_addr = [
                    'Address' => $address,
                    'FirstSeen' => $block_ts->format('Y-m-d H:i:s'),
                ];
                $entity = new Address($new_addr);
                $res = $entity->save();
                if (!$res) {
                    $data_error = true;
                } else {
                    $addr_id_map[$address] = $entity->Id;
                }
            } else {
                $addr_id_map[$address] = $prev_addr->Id;
            }
        }

        $addr_id_drcr = []; // debits and credits grouped by address
        $numeric_tx_id = -1;
        if (!$data_error) {
            // Create transaction
            $new_tx = $all_tx_data['tx'];

            $total_tx_value = 0;
            foreach ($all_tx_data['outputs'] as $out) {
                $total_tx_value = bcadd($total_tx_value, $out['Value'], 8);
            }

            if ($block_data) {
                $new_tx['BlockHash'] = $block_data['hash'];
                $new_tx['TransactionTime'] = $block_data['time'];
            }
            $new_tx['TransactionSize'] = ((strlen($raw_tx)) / 2);
            $new_tx['InputCount'] = count($all_tx_data['inputs']);
            $new_tx['OutputCount'] = count($all_tx_data['outputs']);
            $new_tx['Hash'] = $tx_hash;
            $new_tx['Value'] = $total_tx_value;
            $new_tx['Raw'] = $raw_tx;


            $tx_entity = new Transaction($new_tx);
            $conn->statement('INSERT INTO Transactions (Version, LockTime, BlockHash, TransactionTime, InputCount, OutputCount, TransactionSize, Hash, Value, Raw, Created, Modified) VALUES ' .
                '(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, UTC_TIMESTAMP(), UTC_TIMESTAMP())',
                [
                    $new_tx['Version'],
                    $new_tx['LockTime'],
                    isset($new_tx['BlockHash']) ? $new_tx['BlockHash'] : null,
                    isset($new_tx['TransactionTime']) ? $new_tx['TransactionTime'] : null,
                    $new_tx['InputCount'],
                    $new_tx['OutputCount'],
                    $new_tx['TransactionSize'],
                    $new_tx['Hash'],
                    $new_tx['Value'],
                    $new_tx['Raw']
                ]);
            $stmt = $conn->getPdo()->query('SELECT LAST_INSERT_ID() AS txnId');
            $linsert = $stmt->fetch(PDO::FETCH_OBJ);
            $tx_entity->Id = $linsert->txnId;
            if ($tx_entity->Id === 0) {
                3;
            } else {
                $numeric_tx_id = $tx_entity->Id;
            }
        }

        if (!$data_error && $numeric_tx_id > 0) {
            // Create the inputs
            $inputs = $all_tx_data['inputs'];
            $outputs = $all_tx_data['outputs'];

            foreach ($inputs as $in) {
                $in['TransactionId'] = $numeric_tx_id;
                $in['TransactionHash'] = $tx_hash;

                if (isset($in['IsCoinbase']) && $in['IsCoinbase'] === 1) {
                    $in_entity = new Input($in);
                    $res = $in_entity->save();
                    if (!$res) {
                        $data_error = true;
                        break;
                    }
                } else {
                    $in_tx_hash = $in['PrevoutHash'];
                    $in_prevout = $in['PrevoutN'];

                    // Find the corresponding previous output
                    $in_tx = Transaction::query()->select(['Id'])->where('Hash',$in_tx_hash)->first();
                    $src_output = null;
                    if ($in_tx) {
                        $stmt = $conn->getPdo()->query('SELECT Id, Value, Addresses FROM Outputs WHERE TransactionId = ? AND Vout = ?', [$in_tx->Id, $in_prevout]);
                        $src_output = $stmt->fetch(PDO::FETCH_OBJ);
                        if ($src_output) {
                            $in['Value'] = $src_output->Value;
                            $json_addr = json_decode($src_output->Addresses);
                            $in_addr_id = 0;
                            if (isset($addr_id_map[$json_addr[0]])) {
                                $in['AddressId'] = $addr_id_map[$json_addr[0]];
                            } else {
                                $in_addr = Address::query()->select(['Id'])->where('Address',$json_addr[0])->first();
                                if ($in_addr) {
                                    $addr_id_map[$json_addr[0]] = $in_addr->Id;
                                    $in['AddressId'] = $in_addr->Id;
                                }
                            }
                        }
                    }

                    $in_entity = new Input($in);
                    $conn->statement('INSERT INTO Inputs (TransactionId, TransactionHash, AddressId, PrevoutHash, PrevoutN, Sequence, Value, ScriptSigAsm, ScriptSigHex, Created, Modified) ' .
                        'VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, UTC_TIMESTAMP(), UTC_TIMESTAMP())',
                        [$in['TransactionId'],
                            $in['TransactionHash'],
                            isset($in['AddressId']) ? $in['AddressId'] : null,
                            $in['PrevoutHash'],
                            $in['PrevoutN'],
                            $in['Sequence'],
                            isset($in['Value']) ? $in['Value'] : 0,
                            $in['ScriptSigAsm'],
                            $in['ScriptSigHex']
                        ]);

                    // get last insert id
                    $stmt = $conn->getPdo()->query('SELECT LAST_INSERT_ID() AS inputId');
                    $linsert = $stmt->fetch(PDO::FETCH_OBJ);
                    $in_entity->Id = $linsert->inputId;

                    if ($in_entity->Id === 0) {
                        $data_error = true;
                        break;
                    }

                    // Update the src_output spent if successful
                    if ($src_output) {
                        try {
                            $conn->statement('UPDATE Outputs SET IsSpent = 1, SpentByInputId = ? WHERE Id = ?', [$in_entity->Id, $src_output->Id]);
                            $conn->statement('UPDATE Inputs SET PrevoutSpendUpdated = 1 WHERE Id = ?', [$in_entity->Id]);
                        } catch (Exception $e) {
                            $data_error = true;
                            break;
                        }
                    }

                    if (isset($in['AddressId']) && $in['AddressId'] > 0) {
                        $addr_id = $in['AddressId'];
                        if (!isset($addr_id_drcr[$addr_id])) {
                            $addr_id_drcr[$addr_id] = ['debit' => 0, 'credit' => 0];
                        }
                        $addr_id_drcr[$addr_id]['debit'] = bcadd($addr_id_drcr[$addr_id]['debit'], $in['Value'], 8);

                        try {
                            $conn->statement('INSERT INTO InputsAddresses (InputId, AddressId) VALUES (?, ?) ON DUPLICATE KEY UPDATE InputId = InputId', [$in_entity->Id, $in['AddressId']]);
                            $conn->statement('UPDATE Addresses SET TotalSent = TotalSent + ? WHERE Id = ?', [$in['Value'], $in['AddressId']]);
                            $conn->statement('INSERT INTO TransactionsAddresses (TransactionId, AddressId) VALUES (?, ?) ON DUPLICATE KEY UPDATE TransactionId = TransactionId', [$numeric_tx_id, $in['AddressId']]);
                        } catch (Exception $e) {
                            $data_error = true;
                            break;
                        }
                    }
                }
            }

            foreach ($outputs as $out) {
                $out['TransactionId'] = $numeric_tx_id;
                $out_entity = new Output($out);

                //$stmt->execute('INSERT INTO Outputs')
                $conn->statement('INSERT INTO Outputs (TransactionId, Vout, Value, Type, ScriptPubKeyAsm, ScriptPubKeyHex, RequiredSignatures, Hash160, Addresses, Created, Modified) '.
                    'VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, UTC_TIMESTAMP(), UTC_TIMESTAMP())',
                    [$out['TransactionId'],
                        $out['Vout'],
                        $out['Value'],
                        $out['Type'],
                        $out['ScriptPubKeyAsm'],
                        $out['ScriptPubKeyHex'],
                        $out['RequiredSignatures'],
                        $out['Hash160'],
                        $out['Addresses']
                    ]);

                // get the last insert id
                $stmt = $conn->getPdo()->query('SELECT LAST_INSERT_ID() AS outputId');
                $linsert = $stmt->fetch(PDO::FETCH_OBJ);
                $out_entity->Id = $linsert->outputId;

                if ($out_entity->Id === 0) {
                    $data_error = true;
                    break;
                }

                $json_addr = json_decode($out['Addresses']);
                $out_addr_id = 0;
                if (isset($addr_id_map[$json_addr[0]])) {
                    $out_addr_id = $addr_id_map[$json_addr[0]];
                } else {
                    $out_addr = Address::query()->select(['Id'])->where('Address',$json_addr[0])->first();
                    if ($out_addr) {
                        $addr_id_map[$json_addr[0]] = $out_addr->Id;
                        $out_addr_id = $out_addr->Id;
                    }
                }

                if ($out_addr_id > 0) {
                    $addr_id = $out_addr_id;
                    if (!isset($addr_id_drcr[$addr_id])) {
                        $addr_id_drcr[$addr_id] = ['debit' => 0, 'credit' => 0];
                    }
                    $addr_id_drcr[$addr_id]['credit'] = bcadd($addr_id_drcr[$addr_id]['credit'], $out['Value'], 8);

                    try {
                        $conn->statement('INSERT INTO OutputsAddresses (OutputId, AddressId) VALUES (?, ?) ON DUPLICATE KEY UPDATE OutputId = OutputId', [$out_entity->Id, $out_addr_id]);
                        $conn->statement('UPDATE Addresses SET TotalReceived = TotalReceived + ? WHERE Id = ?', [$out['Value'], $out_addr_id]);
                        $conn->statement('INSERT INTO TransactionsAddresses (TransactionId, AddressId) VALUES (?, ?) ON DUPLICATE KEY UPDATE TransactionId = TransactionId', [$numeric_tx_id, $out_addr_id]);
                    } catch (Exception $e) {
                        print_r($e);
                        $data_error = true;
                        break;
                    }
                }

                // create the claim if the asm pub key starts with OP_CLAIM_NAME
                if (strpos($out['ScriptPubKeyAsm'], 'OP_CLAIM_NAME') !== false) {
                    $all_claim_data = $this->_getclaimfortxout($out['ScriptPubKeyAsm'], $tx_hash, $out['Vout'], $block_ts);
                    $claim = $all_claim_data['claim_data'];
                    $claim_stream_data = $all_claim_data['claim_stream_data'];

                    if (!$claim) {
                        continue;
                    }

                    if ($claim['ClaimType'] == 2 && !$claim_stream_data) {
                        echo "***claim stream data missing for streamType claim\n";
                        continue;
                    }

                    $claim_entity = new Claim($claim);
                    $res = $claim_entity->save();

                    if (!$res) {
                        echo "***claim could not be saved.\n";
                        continue;
                    }

                    if (!$data_error && $claim_stream_data) {
                        $claim_stream_data['Id'] = $claim_entity->Id;
                        $claim_stream_entity = new ClaimStream($claim_stream_data);
                        $res = $claim_stream_entity->save();
                        if (!$res) {
                            echo "***claim stream could not be saved.\n";
                        }
                    }
                }
            }
        }

        // update tx amounts
        if (!$data_error) {
            foreach ($addr_id_drcr as $addr_id => $drcr) {
                try {
                    $conn->statement('UPDATE TransactionsAddresses SET DebitAmount = ?, CreditAmount = ?, TransactionTime = UTC_TIMESTAMP() WHERE TransactionId = ? AND AddressId = ?',
                        [$drcr['debit'], $drcr['credit'], $numeric_tx_id, $addr_id]);
                } catch (Exception $e) {
                    print_r($e);
                    $data_error = true;
                    break;
                }
            }
        }
    }

    /**
     * @return void
     * @throws Throwable
     */
    public function parsetxs(): void{
        set_time_limit(0);

        self::lock('parsetxs');

        // Get the minimum block with no processed transactions
        echo "Parsing transactions...\n";

        $conn = DB::connection();
        //$conn->execute('SET foreign_key_checks = 0');
        //$conn->execute('SET unique_checks = 0');

        try {
            $unproc_blocks = Block::query()->select(['Id', 'Height', 'Hash', 'TransactionHashes', 'BlockTime'])->where('TransactionsProcessed',0)->orderBy('Height')->get();
            foreach ($unproc_blocks as $min_block) {
                $tx_hashes = json_decode($min_block->TransactionHashes);
                if ($tx_hashes && is_array($tx_hashes)) {
                    $block_time = $min_block->BlockTime;
                    $block_ts = DateTime::createFromFormat('U', $block_time);

                    $count = count($tx_hashes);
                    echo "Processing " . $count . " transaction(s) for block $min_block->Height ($min_block->Hash)...\n";

                    $data_error = false;
                    $conn->beginTransaction();

                    $idx = 0;
                    foreach ($tx_hashes as $tx_hash) {
                        $idx++;
                        $idx_str = str_pad($idx, strlen($count), '0', STR_PAD_LEFT);
                        echo "[$idx_str/$count] Processing tx hash: $tx_hash... ";

                        $total_diff = 0;
                        $start_ms = round(microtime(true) * 1000);
                        $exist_tx = Transaction::query()->select(['Id'])->where('Hash', $tx_hash)->first();
                        $end_ms = round(microtime(true) * 1000);
                        $diff_ms = $end_ms - $start_ms;
                        $total_diff += $diff_ms;
                        echo "findtx took {$diff_ms}ms. ";

                        if ($exist_tx) {
                            echo "Exists. Skipping.\n";
                            continue;
                        }

                        $start_ms = round(microtime(true) * 1000);
                        $this->processtx($tx_hash, $block_ts, ['hash' => $min_block->Hash, 'time' => $min_block->BlockTime], $data_error);
                        $diff_ms = round(microtime(true) * 1000) - $start_ms;
                        $total_diff += $diff_ms;
                        echo "tx took {$diff_ms}ms. Total {$total_diff}ms. ";

                        if (!$data_error && self::$redis && self::$redis->sismember(self::mempooltxkey, $tx_hash)) {
                            self::$redis->srem(self::mempooltxkey, $tx_hash);
                            echo "Removed $tx_hash from redis mempooltx.\n";
                        }

                        echo "Done.\n";
                    }

                    if (!$data_error) {
                        $conn->statement('UPDATE Blocks SET TransactionsProcessed = 1 WHERE Id = ?', [$min_block->Id]);
                    }

                    if ($data_error) {
                        echo "Rolling back!\n";
                        $conn->rollback();
                        throw new Exception('Data save failed!');
                    } else {
                        echo "Data committed.\n";
                        $conn->commit();
                    }
                }
            }

            // Try to update txs with null BlockHash
            $mempooltx = Transaction::query()->select(['Id', 'Hash'])->where('BlockHash','IS','NULL')->orderBy('Created')->get();
            $idx = 0;
            $count = count($mempooltx);
            foreach ($mempooltx as $tx) {
                $idx++;
                $tx_hash = $tx->Hash;
                $idx_str = ($count > 10 && $idx < 10) ? '0' . $idx : $idx;
                echo "[$idx_str/$count] Processing tx hash: $tx_hash... ";

                $stmt = $conn->getPdo()->query("SELECT Hash, BlockTime FROM Blocks WHERE TransactionHashes LIKE CONCAT('%', ?, '%') AND Height > ((SELECT MAX(Height) FROM Blocks) - 10000) ORDER BY Height ASC LIMIT 1", [$tx_hash]);
                $block = $stmt->fetch(PDO::FETCH_OBJ);
                if ($block) {
                    $upd_tx = ['Id' => $tx->Id, 'BlockHash' => $block->Hash, 'TransactionTime' => $block->BlockTime];
                    $upd_entity = new Transaction($upd_tx);
                    $upd_entity->save();
                    echo "Done.\n";

                    if (self::$redis && self::$redis->sismember(self::mempooltxkey, $tx_hash)) {
                        self::$redis->srem(self::mempooltxkey, $tx_hash);
                        echo "Removed $tx_hash from redis mempooltx.\n";
                    }
                } else {
                    echo "Block not found.\n";
                }
            }
        } catch (Exception $e) {
            print_r($e);
        }

        //$conn->execute('SET foreign_key_checks = 1');
        //$conn->execute('SET unique_checks = 1');

        self::unlock('parsetxs');
    }

    /**
     * @throws Throwable
     */
    public function parsenewblocks(): void{

        set_time_limit(0);
        self::lock('parsenewblocks');

        echo "Parsing new blocks...\n";
        self::$redis = Redis::connection()->client();
        try {
            // Get the best block hash
            $req = ['method' => 'getbestblockhash', 'params' => [],'id'=>rand()];
            $response = self::curl_json_post(self::$rpcurl, json_encode($req));
            $json = json_decode($response);
            print_r($response); print_r($json);
            $best_hash = $json->result;

            $req = ['method' => 'getblock', 'params' => [$best_hash],'id'=>rand()];
            $response = self::curl_json_post(self::$rpcurl, json_encode($req));
            $json = json_decode($response);
            $best_block = $json->result;

            $max_block = Block::query()->select(['Hash', 'Height'])->orderByDesc('Height')->first();
            if (!$max_block) {
                self::unlock('parsenewblocks');
                return;
            }

            $min_height = min($max_block->Height, $best_block->height);
            $max_height = max($max_block->Height, $best_block->height);
            $height_diff = $best_block->height - $max_block->Height;

            if ($height_diff <= 0) {
                self::unlock('parsenewblocks');
                return;
            }

            $conn = DB::connection();
            for ($curr_height = $min_height; $curr_height <= $max_height; $curr_height++) {
                // get the block hash
                $req = ['method' => 'getblockhash', 'params' => [$curr_height],'id'=>rand()];
                $response = self::curl_json_post(self::$rpcurl, json_encode($req));
                $json = json_decode($response);
                $curr_block_hash = $json->result;

                $next_block_hash = null;
                if ($curr_height < $max_height) {
                    $req = ['method' => 'getblockhash', 'params' => [$curr_height + 1],'id'=>rand()];
                    $response = self::curl_json_post(self::$rpcurl, json_encode($req));
                    $json = json_decode($response);
                    $next_block_hash = $json->result;
                }

                $req = ['method' => 'getblock', 'params' => [$curr_block_hash],'id'=>rand()];
                $response = self::curl_json_post(self::$rpcurl, json_encode($req));
                $json = json_decode($response);
                $curr_block = $json->result;

                if ($curr_block->confirmations < 0) {
                    continue;
                }

                $next_block = null;
                if ($next_block_hash != null) {
                    $req = ['method' => 'getblock', 'params' => [$next_block_hash],'id'=>rand()];
                    $response = self::curl_json_post(self::$rpcurl, json_encode($req));
                    $json = json_decode($response);
                    $next_block = $json->result;
                }

                if ($curr_block != null) {
                    $curr_block_ins = $this->blockdb_data_from_json($curr_block);
                    if ($next_block != null && $curr_block_ins['NextBlockHash'] == null) {
                        $curr_block_ins['NextBlockHash'] = $next_block->hash;
                    }

                    $block_data = $curr_block;
                    $block_id = -1;
                    // Make sure the block does not exist before inserting
                    $old_block = Block::query()->select(['Id'])->where('Hash',$block_data->hash)->first();
                    if (!$old_block) {
                        echo "Inserting block $block_data->height ($block_data->hash)... ";
                        $curr_block_entity = new Block($curr_block_ins);

                        $conn->statement('INSERT INTO Blocks (Bits, Chainwork, Confirmations, Difficulty, Hash, Height, MedianTime, MerkleRoot, NameClaimRoot, Nonce, PreviousBlockHash, NextBlockHash, BlockSize, Target, BlockTime, TransactionHashes, Version, VersionHex, Created, Modified) ' .
                            'VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, UTC_TIMESTAMP(), UTC_TIMESTAMP())',
                            [
                                $curr_block_entity->Bits,
                                $curr_block_entity->Chainwork,
                                $curr_block_entity->Confirmations,
                                $curr_block_ins['Difficulty'], // cakephp 3 why?
                                $curr_block_entity->Hash,
                                $curr_block_entity->Height,
                                $curr_block_entity->MedianTime,
                                $curr_block_entity->MerkleRoot,
                                $curr_block_entity->NameClaimRoot,
                                $curr_block_entity->Nonce,
                                $curr_block_entity->PreviousBlockHash,
                                $curr_block_entity->NextBlockHash,
                                $curr_block_entity->BlockSize,
                                $curr_block_entity->Target,
                                $curr_block_entity->BlockTime,
                                $curr_block_entity->TransactionHashes,
                                $curr_block_entity->Version,
                                $curr_block_entity->VersionHex,
                            ]);

                        $stmt = $conn->getPdo()->query('SELECT LAST_INSERT_ID() AS lBlockId');
                        $linsert = $stmt->fetch(PDO::FETCH_OBJ);
                        $curr_block_entity->Id = $linsert->lBlockId;
                        $block_id = $curr_block_entity->Id;

                        echo "Done.\n";
                    } else {
                        echo "Updating block $block_data->height ($block_data->hash) with next block hash: " . $curr_block_ins['NextBlockHash'] . " and confirmations: " . $curr_block_ins['Confirmations'] . "... ";
                        $upd_block = ['Id' => $old_block->Id, 'NextBlockHash' => $curr_block_ins['NextBlockHash'], 'Confirmations' => $curr_block_ins['Confirmations']];
                        $upd_entity = new Block($upd_block);
                        $block_id = $old_block->Id;
                        echo "Done.\n";
                    }

                    $txs = $block_data->tx;
                    $data_error = false;
                    foreach ($txs as $tx_hash) {
                        // Check if the transactions exist and then update the BlockHash and TxTime
                        $tx = Transaction::query()->select(['Id'])->where('Hash',$tx_hash)->first();
                        if ($tx) {
                            $upd_tx_data = [
                                'Id' => $tx->Id,
                                'BlockHash' => $block_data->hash,
                                'TransactionTime' => $block_data->time
                            ];
                            $upd_tx_entity = new Transaction($upd_tx_data);
                            $upd_tx_entity->save();
                            echo "Updated tx $tx_hash with block hash and time $block_data->time.\n";
                        } else {
                            // Doesn't exist, create a new transaction
                            echo "Inserting tx $tx_hash for block height $block_data->height... ";

                            $conn->beginTransaction();
                            $block_ts = \DateTime::createFromFormat('U', $block_data->time);
                            $this->processtx($tx_hash, $block_ts, ['hash' => $block_data->hash, 'time' => $block_data->time], $data_error);

                            if ($data_error) {
                                $conn->rollback();
                                echo "Insert failed.\n";
                            } else {
                                $conn->commit();
                                echo "Done.\n";
                            }
                        }

                        // Remove from redis if present
                        if (!$data_error && self::$redis && self::$redis->sismember(self::mempooltxkey, $tx_hash)) {
                            self::$redis->srem(self::mempooltxkey, $tx_hash);
                            echo "Removed $tx_hash from redis mempooltx.\n";
                        }
                    }

                    if (!$data_error && $block_id > -1) {
                        // set TransactionsProcessed to true
                        $conn->statement('UPDATE Blocks SET TransactionsProcessed = 1 WHERE Id = ?', [$block_id]);
                    }
                }
            }
        } catch (Exception $e) {
            print_r($e);
        }

        self::unlock('parsenewblocks');
    }

    /**
     * @throws Throwable
     */
    public function forevermempool(): void{
        self::lock('forevermempool');

        $conn = DB::connection();

        while (true) {
            try {
                $data = ['method' => 'getrawmempool', 'params' => [],'id'=>rand()];
                $res = self::curl_json_post(self::$rpcurl, json_encode($data));
                $json = json_decode($res);
                $txs = $json->result;
                $now = new DateTime('now', new DateTimeZone('UTC'));
                $data_error = false;

                if (count($txs) === 0) {
                    // If no transactions found, that means there's nothing in the mempool. Clear redis
                    if (self::$redis) {
                        self::$redis->del(self::mempooltxkey);
                        echo "Empty rawmempool. Cleared mempool txs from redis.\n";
                    }
                }

                foreach ($txs as $tx_hash) {
                    // Check redis mempool txs
                    if (self::$redis && self::$redis->exists(self::mempooltxkey)) {
                        if (self::$redis->sismember(self::mempooltxkey, $tx_hash)) {
                            echo "Found processed tx hash: $tx_hash. Skipping.\n";
                            continue;
                        }
                    }

                    echo "Processing tx hash: $tx_hash... ";
                    $exist_tx = Transaction::query()->select(['Id'])->where('Hash',$tx_hash)->first();
                    if ($exist_tx) {
                        echo "Exists. Skipping.\n";
                        continue;
                    }

                    // Process the tx
                    $conn->beginTransaction();
                    $block_ts = new DateTime('now', new DateTimeZone('UTC'));
                    $this->processtx($tx_hash, $block_ts, null, $data_error);

                    if ($data_error) {
                        echo "Rolling back!\n";
                        $conn->rollback();
                        throw new Exception('Data save failed!');
                    } else {
                        echo "Data committed.\n";
                        $conn->commit();

                        // Save to redis to prevent the DB from behing hit again
                        if (self::$redis) {
                            self::$redis->sadd(self::mempooltxkey, $tx_hash);
                        }
                    }
                }
            } catch (Exception $e) {
                echo "Mempool database error. Attempting to reconnect.\n";

                // Final fix for MySQL server has gone away (hopefully)
                try {
                    $conn->disconnect();
                } catch (\Exception $e) {
                    // ignore possible disconnect errors
                }

                $conn->reconnect();
            }

            echo "*******************\n";
            sleep(1);
        }

        self::unlock('forevermempool');
    }

    private function txdb_data_from_decoded($decoded_tx): array{
        $tx = [
            'Version' => $decoded_tx['version'],
            'LockTime' => $decoded_tx['locktime']
        ];

        $addresses = [];
        $inputs = [];
        $outputs = [];

        $vin = $decoded_tx['vin'];
        $vout = $decoded_tx['vout'];
        if (is_array($vin)) {
            foreach ($vin as $in) {
                if (isset($in['coinbase'])) {
                    $inputs[] = [
                        'IsCoinbase' => 1,
                        'Coinbase' => $in['coinbase']
                    ];
                } else {
                    $inputs[] = [
                        'PrevoutHash' => $in['txid'],
                        'PrevoutN' => $in['vout'],
                        'ScriptSigAsm' => $in['scriptSig']['asm'],
                        'ScriptSigHex' => $in['scriptSig']['hex'],
                        'Sequence' => $in['sequence']
                    ];
                }
            }

            foreach ($vout as $out) {
                $outputs[] = [
                    'Vout' => $out['vout'],
                    'Value' => bcdiv($out['value'], 100000000, 8),
                    'Type' => isset($out['scriptPubKey']['type']) ? $out['scriptPubKey']['type'] : '',
                    'ScriptPubKeyAsm' => isset($out['scriptPubKey']['asm']) ? $out['scriptPubKey']['asm'] : '',
                    'ScriptPubKeyHex' => isset($out['scriptPubKey']['hex']) ? $out['scriptPubKey']['hex'] : '',
                    'RequiredSignatures' => isset($out['scriptPubKey']['reqSigs']) ? $out['scriptPubKey']['reqSigs'] : '',
                    'Hash160' => isset($out['scriptPubKey']['hash160']) ? $out['scriptPubKey']['hash160'] : '',
                    'Addresses' => isset($out['scriptPubKey']['addresses']) ? json_encode($out['scriptPubKey']['addresses']) : null
                ];

                if (isset($out['scriptPubKey']['addresses'])) {
                    foreach ($out['scriptPubKey']['addresses'] as $address) {
                        $addresses[$address] = $address;
                    }
                }
            }
        }

        return ['tx' => $tx, 'addresses' => $addresses, 'inputs' => $inputs, 'outputs' => $outputs];
    }

    private function blockdb_data_from_json($json_block): array{
        return [
            'Bits' => $json_block->bits,
            'Chainwork' => $json_block->chainwork,
            'Confirmations' => $json_block->confirmations,
            'Difficulty' => $json_block->difficulty,
            'Hash' => $json_block->hash,
            'Height' => $json_block->height,
            'MedianTime' => $json_block->mediantime,
            'MerkleRoot' => $json_block->merkleroot,
            'NameClaimRoot' => $json_block->nameclaimroot,
            'Nonce' => $json_block->nonce,
            'PreviousBlockHash' => isset($json_block->previousblockhash) ? $json_block->previousblockhash : null,
            'NextBlockHash' => isset($json_block->nextblockhash) ? $json_block->nextblockhash : null,
            'BlockSize' => $json_block->size,
            'Target' => $json_block->target ?? null,//TODO: just $json_block->target
            'BlockTime' => $json_block->time,
            'TransactionHashes' => json_encode($json_block->tx),
            'Version' => $json_block->version,
            'VersionHex' => $json_block->versionHex
        ];
    }

    /**
     * @param $url
     * @param $data
     * @param $headers
     * @return bool|string
     * @throws Exception
     */
    private static function curl_json_post($url, $data, $headers = []): string{
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        //Log::debug('Request execution completed.');
        if ($response === false) {
            $error = curl_error($ch);
            $errno = curl_errno($ch);
            curl_close($ch);

            throw new Exception(sprintf('The request failed: %s', $error), $errno);
        } else {
            curl_close($ch);
        }

        // Close any open file handle
        return $response;
    }

    private static function curl_json_get($url, $headers = []): string{
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        //Log::debug('Request execution completed.');
        if ($response === false) {
            $error = curl_error($ch);
            $errno = curl_errno($ch);
            curl_close($ch);

            throw new \Exception(sprintf('The request failed: %s', $error), $errno);
        } else {
            curl_close($ch);
        }

        // Close any open file handle
        return $response;
    }

    private static $base58chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

    public static $op_codes = [
        ['OP_0', 0],
        ['OP_PUSHDATA', 76],
        'OP_PUSHDATA2',
        'OP_PUSHDATA4',
        'OP_1NEGATE',
        'OP_RESERVED',
        'OP_1',
        'OP_2',
        'OP_3',
        'OP_4',
        'OP_5',
        'OP_6',
        'OP_7',
        'OP_8', 'OP_9', 'OP_10', 'OP_11', 'OP_12', 'OP_13', 'OP_14', 'OP_15', 'OP_16',
        'OP_NOP', 'OP_VER', 'OP_IF', 'OP_NOTIF', 'OP_VERIF', 'OP_VERNOTIF', 'OP_ELSE', 'OP_ENDIF', 'OP_VERIFY',
        'OP_RETURN', 'OP_TOALTSTACK', 'OP_FROMALTSTACK', 'OP_2DROP', 'OP_2DUP', 'OP_3DUP', 'OP_2OVER', 'OP_2ROT', 'OP_2SWAP',
        'OP_IFDUP', 'OP_DEPTH', 'OP_DROP', 'OP_DUP', 'OP_NIP', 'OP_OVER', 'OP_PICK', 'OP_ROLL', 'OP_ROT',
        'OP_SWAP', 'OP_TUCK', 'OP_CAT', 'OP_SUBSTR', 'OP_LEFT', 'OP_RIGHT', 'OP_SIZE', 'OP_INVERT', 'OP_AND',
        'OP_OR', 'OP_XOR', 'OP_EQUAL', 'OP_EQUALVERIFY', 'OP_RESERVED1', 'OP_RESERVED2', 'OP_1ADD', 'OP_1SUB', 'OP_2MUL',
        'OP_2DIV', 'OP_NEGATE', 'OP_ABS', 'OP_NOT', 'OP_0NOTEQUAL', 'OP_ADD', 'OP_SUB', 'OP_MUL', 'OP_DIV',
        'OP_MOD', 'OP_LSHIFT', 'OP_RSHIFT', 'OP_BOOLAND', 'OP_BOOLOR',
        'OP_NUMEQUAL', 'OP_NUMEQUALVERIFY', 'OP_NUMNOTEQUAL', 'OP_LESSTHAN',
        'OP_GREATERTHAN', 'OP_LESSTHANOREQUAL', 'OP_GREATERTHANOREQUAL', 'OP_MIN', 'OP_MAX',
        'OP_WITHIN', 'OP_RIPEMD160', 'OP_SHA1', 'OP_SHA256', 'OP_HASH160',
        'OP_HASH256', 'OP_CODESEPARATOR', 'OP_CHECKSIG', 'OP_CHECKSIGVERIFY', 'OP_CHECKMULTISIG',
        'OP_CHECKMULTISIGVERIFY', 'OP_NOP1', 'OP_NOP2', 'OP_NOP3', 'OP_NOP4', 'OP_NOP5', 'OP_CLAIM_NAME',
        'OP_SUPPORT_CLAIM', 'OP_UPDATE_CLAIM',
        ['OP_SINGLEBYTE_END', 0xF0],
        ['OP_DOUBLEBYTE_BEGIN', 0xF000],
        'OP_PUBKEY', 'OP_PUBKEYHASH',
        ['OP_INVALIDOPCODE', 0xFFFF]
    ];

    public static $op_code = [
        '00' => 'OP_0', // or OP_FALSE
        '51' => 'OP_1', // or OP_TRUE
        '61' => 'OP_NOP',
        '6a' => 'OP_RETURN',
        '6d' => 'OP_2DROP',
        '75' => 'OP_DROP',
        '76' => 'OP_DUP',
        '87' => 'OP_EQUAL',
        '88' => 'OP_EQUALVERIFY',
        'a6' => 'OP_RIPEMD160',
        'a7' => 'OP_SHA1',
        'a8' => 'OP_SHA256',
        'a9' => 'OP_HASH160',
        'aa' => 'OP_HASH256',
        'ac' => 'OP_CHECKSIG',
        'ae' => 'OP_CHECKMULTISIG',
        'b5' => 'OP_CLAIM_NAME',
        'b6' => 'OP_SUPPORT_CLAIM',
        'b7' => 'OP_UPDATE_CLAIM'
    ];

    /*protected static function hash160_to_bc_address($h160, $addrType = 0) {
        $vh160 = $c . $h160;
        $h = self::_dhash($vh160);

        $addr = $vh160 . substr($h, 0, 4);
        return $addr;
        //return self::base58_encode($addr);
    }*/

    protected static function _dhash($str, $raw = false): string{
        return hash('sha256', hash('sha256', $str, true), $raw);
    }

    public static function _get_vint(&$string): int{
        // Load the next byte, convert to decimal.
        $decimal = hexdec(self::_return_bytes($string, 1));
        // Less than 253: Not encoding extra bytes.
        // More than 253, work out the $number of bytes using the 2^(offset)
        $num_bytes = ($decimal < 253) ? 0 : 2 ^ ($decimal - 253);
        // Num_bytes is 0: Just return the decimal
        // Otherwise, return $num_bytes bytes (order flipped) and converted to decimal
        return ($num_bytes == 0) ? $decimal : hexdec(self::_return_bytes($string, $num_bytes, true));
    }

    public static function hash160($string): string{
        $bs = @pack("H*", $string);
        return hash("ripemd160", hash("sha256", $bs, true));
    }

    public static function hash256($string): string{
        $bs = @pack("H*", $string);
        return hash("sha256", hash("sha256", $bs, true));
    }

    public static function hash160_to_address($hash160, $address_version = null): string{
        $c = '';
        if ($address_version == self::pubKeyAddress[0]) {
            $c = dechex(self::pubKeyAddress[1]);
        } else if ($address_version == self::scriptAddress[0]) {
            $c = dechex(self::scriptAddress[1]);
        }

        $hash160 = $c . $hash160;
        $addr = $hash160;
        return self::base58_encode_checksum($addr);
    }

    public static function base58_encode_checksum($hex): string{
        $checksum = self::hash256($hex);
        $checksum = substr($checksum, 0, 8);
        $hash = $hex . $checksum;
        return self::base58_encode($hash);
    }

    public static function _decode_script($script): string{
        $pos = 0;
        $data = array();
        while ($pos < strlen($script)) {
            $code = hexdec(substr($script, $pos, 2)); // hex opcode.
            $pos += 2;
            if ($code < 1) {
                // OP_FALSE
                $push = '0';
            } elseif ($code <= 75) {
                // $code bytes will be pushed to the stack.
                $push = substr($script, $pos, ($code * 2));
                $pos += $code * 2;
            } elseif ($code <= 78) {
                // In this range, 2^($code-76) is the number of bytes to take for the *next* number onto the stack.
                $szsz = pow(2, $code - 75); // decimal number of bytes.
                $sz = hexdec(substr($script, $pos, ($szsz * 2))); // decimal number of bytes to load and push.
                $pos += $szsz;
                $push = substr($script, $pos, ($pos + $sz * 2)); // Load the data starting from the new position.
                $pos += $sz * 2;
            } elseif ($code <= 108/*96*/) {
                // OP_x, where x = $code-80
                $push = ($code - 80);
            } else {
                $push = $code;
            }
            $data[] = $push;
        }

        return implode(" ", $data);
    }

    /*public static function script_getopname($bytes_hex) {
        $index = hexdec($bytes_hex) - 75;
        $op = self::$op_codes[$index];
        if (is_array($op)) {
            if ($bytes_hex == dechex($op[1])) {
                return $op[0];
            }
        }
        if ()

        return str_replace('OP_', '', $op);
    }*/

    public static function get_opcode($opname): ?int{
        $len = count(self::$op_codes);
        for ($i = 0; $i < $len; $i++) {
            $op = self::$op_codes[$i];
            $op = is_array($op) ? $op[0] : $op;
            if ($op === $opname) {
                return $i;
            }
        }

        return null;
    }

    public static function match_decoded($decoded, $to_match): bool{
        if (strlen($decoded) != strlen($to_match)) {
            return false;
        }

        for ($i = 0; $i < count($decoded); $i++) {
            $pushdata4 = self::get_opcode('OP_PUSHDATA4');
            if ($to_match[$i] == $pushdata4 && ($pushdata4 >= $decoded[$i][0]) > 0) {
                continue;
            }
            if ($to_match[$i] != $decoded[$i][0]) {
                return false;
            }
        }

        return true;
    }

    public static function base58_encode($hex): string{
        if (strlen($hex) == 0) {
            return '';
        }
        // Convert the hex string to a base10 integer
        $num = gmp_strval(gmp_init($hex, 16), 58);
        // Check that number isn't just 0 - which would be all padding.
        if ($num != '0') {
            $num = strtr($num, '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv', self::$base58chars);
        } else {
            $num = '';
        }
        // Pad the leading 1's
        $pad = '';
        $n = 0;
        while (substr($hex, $n, 2) == '00') {
            $pad .= '1';
            $n += 2;
        }
        return $pad . $num;
    }

    public static function decode_tx($raw_transaction): array{
        $math = EccFactory::getAdapter();
        /*$magic_byte = BitcoinLib::magicByte($magic_byte);
        $magic_p2sh_byte = BitcoinLib::magicP2SHByte($magic_p2sh_byte);*/
        $raw_transaction = trim($raw_transaction);
        if (((bool)preg_match('/^[0-9a-fA-F]{2,}$/i', $raw_transaction) !== true)
            || (strlen($raw_transaction)) % 2 !== 0
        ) {
            throw new \InvalidArgumentException("Raw transaction is invalid hex");
        }
        $txHash = hash('sha256', hash('sha256', pack("H*", trim($raw_transaction)), true));
        $txid = self::_flip_byte_order($txHash);
        $info = array();
        $info['txid'] = $txid;
        $info['version'] = $math->hexDec(self::_return_bytes($raw_transaction, 4, true));
        /*if (!in_array($info['version'], array('0', '1'))) {
            throw new \InvalidArgumentException("Invalid transaction version");
        }*/
        $input_count = self::_get_vint($raw_transaction);
        if (!($input_count >= 0 && $input_count <= 4294967296)) {
            throw new \InvalidArgumentException("Invalid input count");
        }
        $info['vin'] = self::_decode_inputs($raw_transaction, $input_count);
        if ($info['vin'] == false) {
            throw new \InvalidArgumentException("No inputs in transaction");
        }
        $output_count = self::_get_vint($raw_transaction);
        if (!($output_count >= 0 && $output_count <= 4294967296)) {
            throw new \InvalidArgumentException("Invalid output count");
        }
        $info['vout'] = self::_decode_outputs($raw_transaction, $output_count);
        $info['locktime'] = $math->hexDec(self::_return_bytes($raw_transaction, 4));
        return $info;
    }

    public static function _decode_inputs(&$raw_transaction, $input_count): array{
        $inputs = array();
        // Loop until $input count is reached, sequentially removing the
        // leading data from $raw_transaction reference.
        for ($i = 0; $i < $input_count; $i++) {
            // Load the TxID (32bytes) and vout (4bytes)
            $txid = self::_return_bytes($raw_transaction, 32, true);
            $vout = self::_return_bytes($raw_transaction, 4, true);
            // Script is prefixed with a varint that must be decoded.
            $script_length = self::_get_vint($raw_transaction); // decimal number of bytes.
            $script = self::_return_bytes($raw_transaction, $script_length);

            // Build input body depending on whether the TxIn is coinbase.
            if ($txid == '0000000000000000000000000000000000000000000000000000000000000000') {
                $input_body = array('coinbase' => $script);
            } else {
                $input_body = array('txid' => $txid,
                    'vout' => hexdec($vout),
                    'scriptSig' => array('asm' => self::_decode_script($script), 'hex' => $script));
            }
            // Append a sequence number, and finally add the input to the array.
            $input_body['sequence'] = hexdec(self::_return_bytes($raw_transaction, 4));
            $inputs[$i] = $input_body;
        }
        return $inputs;
    }

    public static function _decode_outputs(&$tx, $output_count): array{
        $math = EccFactory::getAdapter();
        /*$magic_byte = BitcoinLib::magicByte($magic_byte);
        $magic_p2sh_byte = BitcoinLib::magicP2SHByte($magic_p2sh_byte);*/
        $outputs = array();
        for ($i = 0; $i < $output_count; $i++) {
            // Pop 8 bytes (flipped) from the $tx string, convert to decimal,
            // and then convert to Satoshis.
            $satoshis = $math->hexDec(self::_return_bytes($tx, 8, true));
            // Decode the varint for the length of the scriptPubKey
            $script_length = self::_get_vint($tx); // decimal number of bytes
            $script = self::_return_bytes($tx, $script_length);


            try {
                $asm = self::_decode_scriptPubKey($script);
            } catch (\Exception $e) {
                $asm = null;
            }
            // Begin building scriptPubKey
            $scriptPubKey = array(
                'asm' => $asm,
                'hex' => $script
            );

            // Try to decode the scriptPubKey['asm'] to learn the transaction type.
            $txn_info = self::_get_transaction_type($scriptPubKey['asm']);
            if ($txn_info !== false) {
                $scriptPubKey = array_merge($scriptPubKey, $txn_info);
            }
            $outputs[$i] = array(
                'value' => $satoshis,
                'vout' => $i,
                'scriptPubKey' => $scriptPubKey);
        }
        return $outputs;
    }

    /**
     * @throws Exception
     */
    public function fixoutputs(): void{
        $sql = 'SELECT * FROM Outputs WHERE Id NOT IN (SELECT OutputId FROM OutputsAddresses)';

        $conn = DB::connection();
        $stmt = $conn->getPdo()->query($sql);
        $outs = $stmt->fetchAll(PDO::FETCH_OBJ);

        foreach ($outs as $out) {
            $txn_info = self::_get_transaction_type($out->ScriptPubKeyAsm);

            $out_data = [
                'Id' => $out->Id,
                'Type' => $txn_info['type'],
                'RequiredSignatures' => $txn_info['reqSigs'],
                'Hash160' => $txn_info['hash160'],
                'Addresses' => json_encode($txn_info['addresses'])
            ];
            $out_entity = new Output($out_data);
            $out_entity->save();

            // Fix the addresses
            foreach ($txn_info['addresses'] as $address) {
                $prev_addr = Address::query()->where('Address',$address)->first();
                $addr_id = -1;
                if ($prev_addr) {
                    $addr_id = $prev_addr->Id;
                } else {
                    $dt = new DateTime($out->Created, new DateTimeZone('UTC'));
                    $new_addr = [
                        'Address' => $address,
                        'FirstSeen' => $dt->format('Y-m-d H:i:s')
                    ];
                    $new_addr_entity = new Address($new_addr);
                    if ($new_addr_entity->save()) {
                        $addr_id = $new_addr_entity->Id;
                    }
                }

                if ($addr_id > -1) {
                    $conn->statement('INSERT INTO OutputsAddresses (OutputId, AddressId) VALUES (?, ?) ON DUPLICATE KEY UPDATE OutputId = OutputId', [$out->Id, $addr_id]);
                }
            }

            echo "Fixed output $out->Id with new data: " . print_r($out_data, true);
        }
    }

    public function fixinputs(): void{
        $sql = 'SELECT * FROM Inputs WHERE IsCoinbase <> 1 AND Id NOT IN (SELECT InputId FROM InputsAddresses)';

        $conn = DB::connection();
        $stmt = $conn->getPdo()->query($sql);
        $ins = $stmt->fetchAll(PDO::FETCH_OBJ);

        foreach ($ins as $in) {
            $prev_tx_hash = $in->PrevoutHash;
            $prev_n = $in->PrevoutN;

            // Get the previous transaction
            $prev_tx = Transaction::query()->select(['Id'])->where('Hash',$prev_tx_hash)->first();
            if (!$prev_tx) {
                echo "Previous tx for hash $prev_tx_hash not found.\n";
                continue;
            }

            $prev_tx_id = $prev_tx->Id;
            $src_output = Output::query()->where('TransactionId',$prev_tx_id)->where('Vout',$prev_n)->first(); //TODO: ->contain(['OutputAddresses'])
            $in_data = ['Id' => $in->Id];
            if ($src_output) {
                $in_data['Value'] = $src_output->Value;
                $in_data['AddressId'] = $src_output->OutputAddresses[0]->Id;

                $in_entity = new Input($in_data);
                if ($in_entity->save()) {
                    $conn->statement('INSERT INTO InputsAddresses (InputId, AddressId) VALUES (?, ?) ON DUPLICATE KEY UPDATE InputId = InputId', [$in->Id, $in_data['AddressId']]);
                }
            }

            echo "Fixed input $in->Id with new data: " . print_r($in_data, true);
        }
    }

    public static function _get_transaction_type($data): mixed{
        //$magic_byte = BitcoinLib::magicByte($magic_byte);
        //$magic_p2sh_byte = BitcoinLib::magicP2SHByte($magic_p2sh_byte);
        $has_claim = (strpos($data, 'CLAIM') !== false);
        $has_update_claim = (strpos($data, 'UPDATE_CLAIM') !== false);
        $has_op_0 = (strpos($data, 'OP_0') !== false);
        $data = explode(" ", trim($data));
        // Define information about eventual transactions cases, and
        // the position of the hash160 address in the stack.
        $define = array();
        $rule = array();

        // Other standard: pay to pubkey hash
        $define['p2pk'] = array('type' => 'pubkeyhash',
            'reqSigs' => 1,
            'data_index_for_hash' => 0);
        $rule['p2pk'] = [
            '0' => '/^[0-9a-f]+$/i',
            '1' => '/^OP_CHECKSIG/'
        ];

        // Pay to script hash
        $define['p2sh'] = array('type' => 'scripthash',
            'reqSigs' => 1,
            'data_index_for_hash' => 1);
        $rule['p2sh'] = array(
            '0' => '/^OP_HASH160/',
            '1' => '/^[0-9a-f]{40}$/i', // pos 1
            '2' => '/^OP_EQUAL/');

        // Non-standard (claim_name and support_claim)
        $define['p2c'] = array('type' => 'nonstandard',
            'reqSigs' => 1,
            'data_index_for_hash' => 7);
        $rule['p2c'] = [
            '0' => '/^OP_CLAIM_NAME|OP_SUPPORT_CLAIM/',
            '1' => '/^[0-9a-f]+$/i',
            '2' => '/^[0-9a-f]+$/i',
            '3' => '/^OP_2DROP/',
            '4' => '/^OP_DROP/',
            '5' => '/^OP_DUP/',
            '6' => '/^OP_HASH160/',
            '7' => '/^[0-9a-f]{40}$/i', // pos 7
            '8' => '/^OP_EQUALVERIFY/',
            '9' => '/^OP_CHECKSIG/',
        ];

        // Non-standard (claim_name and support_claim)
        $define['p2c2'] = array('type' => 'nonstandard',
            'reqSigs' => 1,
            'data_index_for_hash' => 7);
        $rule['p2c2'] = [
            '0' => '/^OP_CLAIM_NAME|OP_SUPPORT_CLAIM/',
            '1' => '/^OP_0/',
            '2' => '/^[0-9a-f]+$/i',
            '3' => '/^OP_2DROP/',
            '4' => '/^OP_DROP/',
            '5' => '/^OP_DUP/',
            '6' => '/^OP_HASH160/',
            '7' => '/^[0-9a-f]{40}$/i', // pos 8
            '8' => '/^OP_EQUALVERIFY/',
            '9' => '/^OP_CHECKSIG/'
        ];

        // update_claim
        $define['p2uc'] = array('type' => 'nonstandard',
            'reqSigs' => 1,
            'data_index_for_hash' => 8);
        $rule['p2uc'] = [
            '0' => '/^OP_UPDATE_CLAIM/',
            '1' => '/^[0-9a-f]+$/i',
            '2' => '/^[0-9a-f]+$/i',
            '3' => '/^[0-9a-f]+$/i',
            '4' => '/^OP_2DROP/',
            '5' => '/^OP_2DROP/',
            '6' => '/^OP_DUP/',
            '7' => '/^OP_HASH160/',
            '8' => '/^[0-9a-f]{40}$/i', // pos 8
            '9' => '/^OP_EQUALVERIFY/',
            '10' => '/^OP_CHECKSIG/'
        ];

        // Standard: pay to pubkey hash
        $define['p2ph'] = array('type' => 'pubkeyhash',
            'reqSigs' => 1,
            'data_index_for_hash' => 2);
        $rule['p2ph'] = array(
            '0' => '/^OP_DUP/',
            '1' => '/^OP_HASH160/',
            '2' => '/^[0-9a-f]{40}$/i', // 2
            '3' => '/^OP_EQUALVERIFY/',
            '4' => '/^OP_CHECKSIG/');

        if ($has_claim) {
            unset($rule['p2ph']);
            unset($rule['p2sh']);

            if ($has_op_0) {
                unset($rule['p2c']);
            } else {
                unset($rule['p2c2']);
            }

            if ($has_update_claim) {
                unset($rule['p2c']);
            } else {
                unset($rule['p2uc']);
            }
        } else {
            unset($rule['p2c']);
            unset($rule['p2c2']);
            unset($rule['p2uc']);
        }

        // Work out how many rules are applied in each case
        $valid = array();
        foreach ($rule as $tx_type => $def) {
            $valid[$tx_type] = count($def);
        }

        // Attempt to validate against each of these rules.
        $matches = [];
        for ($index = 0; $index < count($data); $index++) {
            $test = $data[$index];
            foreach ($rule as $tx_type => $def) {
                if (isset($def[$index])) {
                    preg_match($def[$index], $test, $matches[$tx_type]);
                    if (count($matches[$tx_type]) == 1) {
                        $valid[$tx_type]--;
                        break;
                    }
                }
            }
        }

        // Loop through rules, check if any transaction is a match.
        foreach ($rule as $tx_type => $def) {
            if ($valid[$tx_type] == 0) {
                // Load predefined info for this transaction type if detected.
                $return = $define[$tx_type];
                if ($tx_type === 'p2pk') {
                    $return['hash160'] = self::hash160($data[$define[$tx_type]['data_index_for_hash']]);
                    $return['addresses'][0] = self::hash160_to_address($return['hash160'], self::pubKeyAddress[0]);
                } else {
                    $return['hash160'] = $data[$define[$tx_type]['data_index_for_hash']];
                    $return['addresses'][0] = self::hash160_to_address($return['hash160'], ($tx_type === 'p2sh') ? self::scriptAddress[0] : self::pubKeyAddress[0]); // TODO: Pay to claim transaction?
                }
                unset($return['data_index_for_hash']);
            }
        }
        return (!isset($return)) ? false : $return;
    }

    public static function _decode_scriptPubKey($script, $matchBitcoinCore = false): string{
        $data = array();
        while (strlen($script) !== 0) {
            $byteHex = self::_return_bytes($script, 1);
            $byteInt = hexdec($byteHex);

            if (isset(self::$op_code[$byteHex])) {
                // This checks if the OPCODE is defined from the list of constants.
                if ($matchBitcoinCore && self::$op_code[$byteHex] == "OP_0") {
                    $data[] = '0';
                } else if ($matchBitcoinCore && self::$op_code[$byteHex] == "OP_1") {
                    $data[] = '1';
                } else {
                    $data[] = self::$op_code[$byteHex];
                }
            } elseif ($byteInt >= 0x01 && $byteInt <= 0x4e) {
                // This checks if the OPCODE falls in the PUSHDATA range
                if ($byteInt == 0x4d) {
                    // OP_PUSHDATA2
                    $byteInt = hexdec(self::_return_bytes($script, 2, true));
                    $data[] = self::_return_bytes($script, $byteInt);
                } else if ($byteInt == 0x4e) {
                    // OP_PUSHDATA4
                    $byteInt = hexdec(self::_return_bytes($script, 4, true));
                    $data[] = self::_return_bytes($script, $byteInt);
                } else if ($byteInt == 0x4c) {
                    $num_bytes = hexdec(self::_return_bytes($script, 1, true));
                    $data[] = self::_return_bytes($script, $num_bytes);
                } else {
                    $data[] = self::_return_bytes($script, $byteInt);
                }
            } elseif ($byteInt >= 0x51 && $byteInt <= 0x60) {
                // This checks if the CODE falls in the OP_X range
                $data[] = $matchBitcoinCore ? ($byteInt - 0x50) : 'OP_' . ($byteInt - 0x50);
            } else {
                throw new \RuntimeException("Failed to decode scriptPubKey");
            }
        }

        return implode(" ", $data);
    }

    /**
     * Lock
     * @param $process_name
     * @return void
     */
    public static function lock($process_name): void{
        $lock = Cache::lock($process_name);
        if(!$lock->get()){
            echo $process_name." is already running.\n";
            exit(0);
        }
    }

    /**
     * Unlock
     * @param $process_name
     * @return bool
     */
    public static function unlock($process_name): bool{
        Cache::lock($process_name)->forceRelease();
        return true;
    }

    public static function _return_bytes(&$string, $byte_count, $reverse = false): string{
        if (strlen($string) < $byte_count * 2) {
            throw new InvalidArgumentException("Could not read enough bytes");
        }
        $requested_bytes = substr($string, 0, $byte_count * 2);
        // Overwrite $string, starting $byte_count bytes from the start.
        $string = substr($string, $byte_count * 2);
        // Flip byte order if requested.
        return ($reverse == false) ? $requested_bytes : self::_flip_byte_order($requested_bytes);
    }

    public static function _flip_byte_order($bytes): string{
        return implode('', array_reverse(str_split($bytes, 2)));
    }

    /*public function parsehistoryblocks() {
        set_time_limit(0);
        header('Content-type: text/plain');

        $block_hash = null;
        // Get the minimum block hash first
        $minBlock = $this->Blocks->find()->select(['Hash'])->order(['Height' => 'asc'])->first();
        if (!$minBlock) {
            // get the best block
            $req = ['method' => 'status','id'=>rand()];
            $response = self::curl_json_post(self::lbryurl, json_encode($req));
            $json = json_decode($response);
            $block_hash = $json->result->blockchain_status->best_blockhash;
        } else {
            $block_hash = $minBlock->Hash;
        }

        echo "Processing block: $block_hash... ";
        $req = ['method' => 'block_show', 'params' => ['blockhash' => $block_hash],'id'=>rand()];
        $response = self::curl_json_post(self::lbryurl, json_encode($req));
        $json = json_decode($response);
        $block_data = $json->result;

        // Check if the block exists
        $oldBlock = $this->Blocks->find()->select(['Id'])->where(['Hash' => $block_hash])->first();
        if (!$oldBlock) {
            // Block does not exist, create the block
            $newBlock = $this->blockdb_data_from_json($block_data);
            $entity = $this->Blocks->newEntity($newBlock);
            $this->Blocks->save($entity);
        }
        echo "Done.\n";

        $prevBlockHash = isset($block_data->previousblockhash) ? $block_data->previousblockhash : null;
        do {
            $oldBlock = $this->Blocks->find()->select(['Id'])->where(['Hash' => $prevBlockHash])->first();
            $req = ['method' => 'block_show', 'params' => ['blockhash' => $prevBlockHash],'id'=>rand()];
            $response = self::curl_json_post(self::lbryurl, json_encode($req));
            $json = json_decode($response);
            $block_data = $json->result;
            $prevBlockHash = isset($block_data->previousblockhash) ? $block_data->previousblockhash : null;

            if (!$oldBlock) {
                echo "Inserting block: $block_data->hash... ";
                $newBlock = $this->blockdb_data_from_json($block_data);
                $entity = $this->Blocks->newEntity($newBlock);
                $this->Blocks->save($entity);
            } else {
                echo "Updating block: $block_data->hash with confirmations: $block_data->confirmations... ";
                $updData = ['Id' => $oldBlock->Id, 'Confirmations' => $block_data->confirmations];
                $entity = $this->Blocks->newEntity($newBlock);
                $this->Blocks->save($entity);
            }
            echo "Done.\n";
        } while($prevBlockHash != null && strlen(trim($prevBlockHash)) > 0);

        exit(0);
    }

    public function updatespends() {
        set_time_limit(0);

        self::lock('updatespends');

        try {
            $conn = ConnectionManager::get('default');
            $inputs = $this->Inputs->find()->select(['Id', 'PrevoutHash', 'PrevoutN'])->where(['PrevoutSpendUpdated' => 0, 'IsCoinbase <>' => 1])->limit(500000)->toArray();

            $count = count($inputs);
            $idx = 0;
            echo sprintf("Processing %d inputs.\n", $count);
            foreach ($inputs as $in) {
                $idx++;
                $idx_str = str_pad($idx, strlen($count), '0', STR_PAD_LEFT);

                $tx = $this->Transactions->find()->select(['Id'])->where(['Hash' => $in->PrevoutHash])->first();
                if ($tx) {
                    $data_error = false;

                    $conn->begin();

                    try {
                        // update the corresponding output and set it as spent
                        $conn->execute('UPDATE Outputs SET IsSpent = 1, SpentByInputId = ?, Modified = UTC_TIMESTAMP() WHERE TransactionId = ? AND Vout = ?', [$in->Id, $tx->Id, $in->PrevoutN]);
                    } catch (\Exception $e) {
                        $data_error = true;
                    }

                    if (!$data_error) {
                        // update the input
                        $in_data = ['Id' => $in->Id, 'PrevoutSpendUpdated' => 1];
                        $in_entity = $this->Inputs->newEntity($in_data);
                        $result = $this->Inputs->save($in_entity);

                        if (!$result) {
                            $data_error = true;
                        }
                    }

                    if ($data_error) {
                        echo sprintf("[$idx_str/$count] Could NOT update vout %s for transaction hash %s.\n", $in->PrevoutN, $in->PrevoutHash);
                        $conn->rollback();
                    } else {
                        echo sprintf("[$idx_str/$count] Updated vout %s for transaction hash %s.\n", $in->PrevoutN, $in->PrevoutHash);
                        $conn->commit();
                    }
                } else {
                    echo sprintf("[$idx_str/$count] Transaction NOT found for tx hash %s.\n", $in->PrevoutHash);
                }
            }
        } catch (\Exception $e) {
            print_r($e);
        }

        self::unlock('updatespends');
    }
    */

}