<?php

namespace Money;

class Bitcoin {
    #const BITCOIN_NODE = '173.224.125.222'; // w001.mo.us temporary
    const BITCOIN_NODE = '50.97.137.37';
    static private $pending = array();

    public static function update() {
        // update all nodes
        $list = \DB::DAO('Money_Bitcoin_Host')->search(null);
        foreach($list as $bean) {
            $bean->Last_Update = \DB::i()->now();
            $client = \Controller::Driver('Bitcoin', $bean->Money_Bitcoin_Host__);
            if (!$client->isValid()) continue;
            $info = $client->getInfo();
            if (!$info) {
                $bean->Status = 'down';
                $bean->commit();
                continue;
            }

            if (($info['generate']) && ($bean->Generate == 'N')) {
                $client->setGenerate(false);
            } elseif ((!$info['generate']) && ($bean->Generate != 'N')) {
                $client->setGenerate(true);
            }

            $bean->Version = $info['version'];
            $bean->Coins = (int)round($info['balance'] * 100000000);
            $bean->Connections = $info['connections'];
            $bean->Blocks = $info['blocks'];
            $bean->Hashes_Per_Sec = $info['hashespersec'];
            $bean->Status = 'up';
            $bean->commit();

            if (is_null($bean->Address)) { // get in addr (generate if needed)
                $list = $client->getAddressesByLabel('_DEFAULT');
                if ($list) {
                    $bean->Address = $list[0];
                } else {
                    $bean->Address = $client->getNewAddress('_DEFAULT');
                }
                $bean->commit();
            }

            if (($bean->Keep_Empty == 'Y') && ($bean->Coins > 100000000)) {
                // empty it!
                $addr = self::getNullAddr();
                try {
                    $client->sendToAddress($addr, $bean->Coins / 100000000);
                } catch(\Exception $e) {
                    // try smaller amount (maybe failed because of fee)
                    try {
                        $c = $bean->Coins / 100000000;
                        $c = round($c/4, 2);
                        if ($c > 0)
                            $client->sendToAddress($addr, $c);
                    } catch(\Exception $e) {
                        // give up
                    }
                }
            }

            if ($bean->Coins > (500*100000000)) {
                // more than 500 coins on this host, shuffle some~
                $client->sendToAddress($client->getNewAddress(), (mt_rand(18,20000)/100));
            }
        }
    }

    public static function getRate() {
        $ticker = \Money\Trade::ticker('BTC','EUR');
        $btc = \DB::DAO('Currency')->searchOne(array('Currency__' => 'BTC'));

        $btc->Ex_Bid = 1/$ticker['vwap']['value'];
        $btc->Ex_Ask = 1/$ticker['vwap']['value'];
        $btc->commit();

        \DB::DAO('Currency_History')->insert(array('Currency__' => $btc->Currency__, 'Date' => gmdate('Y-m-d'), 'Ex_Bid' => $btc->Ex_Bid, 'Ex_Ask' => $btc->Ex_Ask));
    }

    public static function mergeSmallOutputs() {
        $transaction = \DB::i()->transaction();
        $lock = \DB::i()->lock('Money_Bitcoin_Available_Output');

        $list = \DB::DAO('Money_Bitcoin_Available_Output')->search(array('Available' => 'Y', new \DB\Expr('`Value` < 100000000')), null, array(5));
        if (count($list) < 3) return false;

        $list[] = \DB::DAO('Money_Bitcoin_Available_Output')->searchOne(['Available' => 'Y', new \DB\Expr('`Value` > 100000000')]);

        $input = array();
        $amount = 0;
        foreach($list as $bean) {
            $key = \DB::DAO('Money_Bitcoin_Permanent_Address')->searchOne(array('Money_Bitcoin_Permanent_Address__' => $bean->Money_Bitcoin_Permanent_Address__));
            if (!$key) throw new \Exception('Unusable output');
            $tmp = array(
                'privkey' => \Internal\Crypt::decrypt($key->Private_Key),
                'tx' => $bean->Hash,
                'N' => $bean->N,
                'hash' => $bean->Money_Bitcoin_Permanent_Address__,
                'amount' => $bean->Value,
                'input_source' => $bean->Money_Bitcoin_Available_Output__,
            );
            $input[] = $tmp;
            $amount += $bean->Value;
            $bean->Available = 'N';
            $bean->commit();
        }
        $output = \Money\Bitcoin::getNullAddr();
        $output = \Util\Bitcoin::decode($output);
        if (!$output) return false;

        $tx = \Util\Bitcoin::makeNormalTx($input, $amount, $output, $output);
        self::publishTransaction($tx);
        return $transaction->commit();
    }

    public static function splitBigOutputs() {
        $transaction = \DB::i()->transaction();
        $lock = \DB::i()->lock('Money_Bitcoin_Available_Output');

        $bean = \DB::DAO('Money_Bitcoin_Available_Output')->searchOne(array('Available' => 'Y', new \DB\Expr('`Value` > 1000000000')));
        if (!$bean) return;

        $input = array();
        $amount = 0;

        $key = \DB::DAO('Money_Bitcoin_Permanent_Address')->searchOne(array('Money_Bitcoin_Permanent_Address__' => $bean->Money_Bitcoin_Permanent_Address__));
        if (!$key) throw new \Exception('Unusable output');
        $tmp = array(
            'privkey' => \Internal\Crypt::decrypt($key->Private_Key),
            'tx' => $bean->Hash,
            'N' => $bean->N,
            'hash' => $bean->Money_Bitcoin_Permanent_Address__,
            'amount' => $bean->Value,
            'input_source' => $bean->Money_Bitcoin_Available_Output__,
        );
        $input[] = $tmp;
        $amount += $bean->Value;
        $bean->Available = 'N';
        $bean->commit();

        $output1 = \Util\Bitcoin::decode(\Money\Bitcoin::getNullAddr());
        $output2 = \Util\Bitcoin::decode(\Money\Bitcoin::getNullAddr());

        $tx = \Util\Bitcoin::makeNormalTx($input, round(mt_rand($amount*0.4, $amount*0.6)), $output1, $output2);
        self::publishTransaction($tx);
        return $transaction->commit();
    }

    public static function getTxInput($amount, $inputs = array()) {
        // get input that covers at least $amount
        $tx_list = array();
        $total = 0;
        if ($amount <= 0) throw new \Exception('Invalid TX amount');

        // check for forced inputs
        foreach($inputs as $input) {
            $bean = \DB::DAO('Money_Bitcoin_Available_Output')->searchOne(array('Hash' => $input['hash'], 'N' => $input['n']));
            if (!$bean) continue; // not a valid input
            $total += $bean->Value;
            $tx_list[$bean->Money_Bitcoin_Available_Output__] = $bean;
            $bean->Available = 'N';
            $bean->commit();
            if (count($tx_list) > 5) break; // even only one input is enough to invalidate the old tx, let's grab 5
        }

        while(true) {
            if ($total == $amount) break;
            if (($total > $amount) && ($total - $amount > 1000000)) break;
            // need more inputs
            $skip_ok = false;
            if (count($tx_list) >= 3) {
                // need more inputs, and need those *fast*, take the largest that would fit our remaining balance
                $bean = \DB::DAO('Money_Bitcoin_Available_Output')->searchOne(array('Available' => 'Y', new \DB\Expr('`Money_Bitcoin_Available_Output__` NOT IN ('.\DB::i()->quote(array_keys($tx_list), \DB::QUOTE_LIST).')'), new \DB\Expr('`Value` > '.($amount - $total))), array(new \DB\Expr('RAND()')));
                if (!$bean) {
                    // take largest one
                    $bean = \DB::DAO('Money_Bitcoin_Available_Output')->searchOne(array('Available' => 'Y', new \DB\Expr('`Money_Bitcoin_Available_Output__` NOT IN ('.\DB::i()->quote(array_keys($tx_list), \DB::QUOTE_LIST).')')), array('Value' => 'DESC'));
                }
                if (!$bean)
                    $bean = \DB::DAO('Money_Bitcoin_Available_Output')->searchOne(array(new \DB\Expr('`Money_Bitcoin_Available_Output__` NOT IN ('.\DB::i()->quote(array_keys($tx_list), \DB::QUOTE_LIST).')')), array(new \DB\Expr('RAND()')));
            } elseif ($tx_list) {
                $bean = \DB::DAO('Money_Bitcoin_Available_Output')->searchOne(array('Available' => 'Y', new \DB\Expr('`Money_Bitcoin_Available_Output__` NOT IN ('.\DB::i()->quote(array_keys($tx_list), \DB::QUOTE_LIST).')')), array(new \DB\Expr('RAND()')));
            } else {
                $bean = \DB::DAO('Money_Bitcoin_Available_Output')->searchOne(array('Available' => 'Y'), array(new \DB\Expr('RAND()')));
            }

            if (!$bean) {
                $skip_ok = true;
                if ($tx_list) {
                    $bean = \DB::DAO('Money_Bitcoin_Available_Output')->searchOne(array(new \DB\Expr('`Money_Bitcoin_Available_Output__` NOT IN ('.\DB::i()->quote(array_keys($tx_list), \DB::QUOTE_LIST).')')), array(new \DB\Expr('RAND()')));
                } else {
                    $bean = \DB::DAO('Money_Bitcoin_Available_Output')->searchOne(null, array(new \DB\Expr('RAND()')));
                }
            }

            if (!$bean) throw new \Exception('No available output for this TX');
            // check if really available
            if (!$skip_ok) {
                $out = \DB::DAO('Money_Bitcoin_Block_Tx_Out')->searchOne(array('Hash' => $bean->Hash, 'N' => $bean->N));
                if ($out) {
                    if ($out->Claimed == 'Y') {
                        $bean->Available = 'N';
                        $bean->commit();
                        continue;
                    }
                }
            }
            $total += $bean->Value;
            $tx_list[$bean->Money_Bitcoin_Available_Output__] = $bean;
        }

        $input = array();
        foreach($tx_list as $bean) {
            $key = \DB::DAO('Money_Bitcoin_Permanent_Address')->searchOne(array('Money_Bitcoin_Permanent_Address__' => $bean->Money_Bitcoin_Permanent_Address__));
            if (!$key) throw new \Exception('Unusable output');
            $tmp = array(
                'privkey' => \Internal\Crypt::decrypt($key->Private_Key),
                'tx' => $bean->Hash,
                'N' => $bean->N,
                'hash' => $bean->Money_Bitcoin_Permanent_Address__,
                'amount' => $bean->Value,
            );
            $input[] = $tmp;
            $bean->Available = 'N';
            $bean->commit();
        }
        shuffle($input); // randomize inputs order
        return $input;
    }

    public static function getPaymentAddr($payment_id) {
        $private = \Util\Bitcoin::genPrivKey();
        $info = \Util\Bitcoin::decodePrivkey($private);

        $insert = array(
            'Money_Bitcoin_Permanent_Address__' => $info['hash'],
            'Money_Bitcoin_Host__' => null,
            'Money_Merchant_Transaction_Payment__' => $payment_id,
            'Private_Key' => \Internal\Crypt::encrypt($private),
            'Created' => \DB::i()->now(),
            'Used' => 'Y',
            'Callback' => 'Money/Merchant/Transaction::bitcoinEvent'
        );

        if (!\DB::DAO('Money_Bitcoin_Permanent_Address')->insert($insert)) return false;

        return \Money\Bitcoin\Address::byHash($info['hash']);
    }

    public static function getNullAddr($priv = false) {
        $private = \Util\Bitcoin::genPrivKey();
        $info = \Util\Bitcoin::decodePrivkey($private);
        $address = \Util\Bitcoin::encode($info);

        $insert = array(
            'Money_Bitcoin_Permanent_Address__' => $info['hash'],
            'Money_Bitcoin_Host__' => null,
            'User_Wallet__' => null,
            'Private_Key' => \Internal\Crypt::encrypt($private),
            'Created' => \DB::i()->now(),
            'Used' => 'Y',
        );

        if (!\DB::DAO('Money_Bitcoin_Permanent_Address')->insert($insert)) return false;

        if ($priv) return array('priv' => $private, 'info' => $info, 'address' => $address);

        return $address;
    }

    public static function getVerboseAddr($wallet, $description, $ipn = null, $user = null, $callback = null) {
        if ($wallet && $wallet['Currency__'] != 'BTC') return false;

        $private = \Util\Bitcoin::genPrivKey();
        $info = \Util\Bitcoin::decodePrivkey($private);
        $address = \Util\Bitcoin::encode($info);

        $insert = array(
            'Money_Bitcoin_Permanent_Address__' => $info['hash'],
            'Money_Bitcoin_Host__' => null,
            'User_Wallet__' => $wallet ? $wallet->getId() : null,
            'Private_Key' => \Internal\Crypt::encrypt($private),
            'Created' => \DB::i()->now(),
            'Description' => $description,
            'Ipn' => $ipn,
            'Used' => 'Y', // do not use it for normal purposes
            'Callback' => $callback
        );
        if (!is_null($user)) $insert['User_Rest__'] = $user->getRestId();

        if (!\DB::DAO('Money_Bitcoin_Permanent_Address')->insert($insert)) return false;

        return $address;
    }

    public static function getPermanentAddr($wallet, $user = null) {
        if ($wallet['Currency__'] != 'BTC') return false;

        $unused = \DB::DAO('Money_Bitcoin_Permanent_Address')->searchOne(array('User_Wallet__' => $wallet->getId(), 'Used' => 'N'));
        if ($unused) {
            if (strlen($unused->Money_Bitcoin_Permanent_Address__) != 40) return $unused->Money_Bitcoin_Permanent_Address__;
            return \Util\Bitcoin::encode(array('version' => 0, 'hash' => $unused->Money_Bitcoin_Permanent_Address__));
        }

        $private = \Util\Bitcoin::genPrivKey();
        $info = \Util\Bitcoin::decodePrivkey($private);
        $address = \Util\Bitcoin::encode($info);

        $insert = array(
            'Money_Bitcoin_Permanent_Address__' => $info['hash'],
            'Money_Bitcoin_Host__' => null,
            'User_Wallet__' => $wallet->getId(),
            'Private_Key' => \Internal\Crypt::encrypt($private),
            'Created' => \DB::i()->now(),
        );
        if (!is_null($user)) $insert['User_Rest__'] = $user->getRestId();

        if (!\DB::DAO('Money_Bitcoin_Permanent_Address')->insert($insert)) return false;

        return $address;
    }

    /**
     * Create a bitcoin address with some dynamic configuration, like autoselling, mails, etc...
     * @param \User\Wallet $wallet
     * @param array        $options
     * @param \User        $user
     * @return bool|string
     * @throws \TokenException
     */
    public static function getAddrWithOptions(\User\Wallet $wallet, array $options = [], \User $user = null) {
        if ($wallet['Currency__'] != 'BTC') throw new \TokenException('Invalid currency provided', 'invalid_source_currency');

        // filter fields in options
        // autosell: bool Sell bitcoins when received
        // email: bool Send email either when receiving bitcoins (no autosell) or once sold
        // data: string custom data returned in the mail
        // currency: string The currency used for autosell, default to default wallet
        $filtered_options = [];
        $fields = ['autosell' => 'bool', 'email' => 'bool', 'data' => 'string', 'currency' => 'string'];
        foreach ($fields as $field => $type) {
            if (isset($options[$field])) {
                $value = $options[$field];
                switch ($type) {
                    case 'bool':
                        $value = (bool)$value;
                        break;
                    default:
                    case 'string':
                        // truncate strings to 128 chars
                        $value = substr((string)$value, 0, 128);
                        break;
                }
                $filtered_options[$field] = $value;
            }
        }

        if (isset($filtered_options['autosell']) && $filtered_options['autosell']) {
            if (!isset($filtered_options['currency'])) {
                throw new \TokenException('Missing currency for autosell', 'autosell_missing_currency');
            }
        }

        // check currency if set
        if (isset($filtered_options['currency'])) {
            // check if that currency exists
            $cur = \Currency::get($filtered_options['currency']);
            if (!$cur || $cur->isVirtual()) {
                throw new \TokenException('Invalid currency or virtual currency', 'invalid_target_currency');
            }
        }

        // generate a new bitcoin address
        $private = \Util\Bitcoin::genPrivKey();
        $info = \Util\Bitcoin::decodePrivkey($private);
        $address = \Util\Bitcoin::encode($info);

        $insert = array(
            'Money_Bitcoin_Permanent_Address__' => $info['hash'],
            'Money_Bitcoin_Host__' => null,
            'User_Wallet__' => $wallet->getId(),
            'Private_Key' => \Internal\Crypt::encrypt($private),
            'Created' => \DB::i()->now(),
            'Description' => json_encode($filtered_options),
            'Used' => 'Y', // do not use it for normal purposes
            'Callback' => 'Money/Bitcoin::optionAddrEvent'
        );
        // if the call was done through the API
        if (!is_null($user)) $insert['User_Rest__'] = $user->getRestId();

        if (!\DB::DAO('Money_Bitcoin_Permanent_Address')->insert($insert)) {
            throw new \TokenException('Couldn\'t create bitcoin address, please contact mtgox', 'unknown_error');
        };

        return $address;
    }

    public static function optionAddrEvent($addr, $hash_n, $block, $amount) {
        // ignore until we have enough confirmations
        if (!$block) return;

        $options = json_decode($addr->Description, true);
        /** @var $source_wallet \User\Wallet */
        $source_wallet = \User\Wallet::byId($addr->User_Wallet__);

        // manage autosell
        if (isset($options['autosell']) && $options['autosell']) {
            $callback = null;
            if (isset($options['email']) && $options['email']) {
                $callback = 'Money/Bitcoin::optionAddrSellEmail';
                if ($options['data']) {
                    $callback .= '|' . $options['data'];
                }
            }
            \Money\Trade::addOrder($source_wallet->getUser(), 'ask', $amount, $options['currency'], [], null, $callback);
        } else {
            // send email with details about the transaction
            if (isset($options['email']) && $options['email']) {
                $mail_page = \Registry::getInstance()->OptionAddrBlockEmail ?: 'mail/option_addr_bitcoin_rcvd.mail';
                $mail_data = [
                    '_HASH'   => $hash_n,
                    '_BLOCK'  => $block,
                    '_AMOUNT' => $amount
                ];
                if (isset($options['data'])) $mail_data['_DATA'] = $options['data'];
                \Tpl::userMail($mail_page, $source_wallet->getUser(), $mail_data);
            }
        }
    }

    public static function optionAddrSellEmail($user, $oid, $type, $data = null) {
        $user = \User::byId($user, false, true);
        $trade_info = \Money\Trade::getOrderExecutionResult($user, $oid, $type == 'bid');
        $mail_page = \Registry::getInstance()->OptionAddrOrderEmail ?: 'mail/option_addr_bitcoin_sold.mail';
        $mail_data = [
            '_TRADE_INFO' => $trade_info,
        ];
        if ($data) $mail_data['_DATA'] = $data;
        return \Tpl::userMail($mail_page, $user, $mail_data);
    }

    public static function checkOrders() {
        // check data in Money_Bitcoin_Order to see if any order is completed
        $db = \DB::i();
        $list = $db['Money_Bitcoin_Order']->search(array('Status' => 'pending'));
        $clients = array();

        foreach($list as $bean) {
            if (!isset($clients[$bean->Money_Bitcoin_Host__])) $clients[$bean->Money_Bitcoin_Host__] = \Controller::Driver('Bitcoin', $bean->Money_Bitcoin_Host__);
            $client = $clients[$bean->Money_Bitcoin_Host__];
            $total = (int)round($client->getReceivedByAddress($bean->Address, 3) * 100000000); // 3 confirmations

            if ($bean->Coins == $total) { // nothing moved
                if ($db->dateRead($bean->Expires) < time()) {
                    $bean->Status = 'expired';
                    $bean->commit();
                    continue;
                }
            }
            $bean->Coins = $total;
            $total += $bean->Coins_Extra;
            if ($bean->Total <= $total) {
                // payment complete!
                $bean->Status = 'ok';
                $bean->commit();

                // mark order paid
                $order = \Order::byId($bean->Order__);
                if ($order->isPaid()) continue; // ?!
                $info = array(
                    'method' => 'BITCOIN',
                    'class' => 'Bitcoin',
                    'stamp' => time(),
                );
                $order->paid($info);
                continue;
            }

            $total_nc = (int)round($client->getReceivedByAddress($bean->Address, 0) * 100000000);
            $bean->Coins_NC = $total_nc;
            $bean->commit();
        }
    }

    public static function getAddressForOrder($order) {
        $total = $order->getTotal();
        if ($total->getCurrency()->Currency__ != 'BTC') return false;
        $btc = $total['value'];

        $bean = \DB::DAO('Money_Bitcoin_Order')->searchOne(array('Order__' => $order->getId()));
        if ($bean) {
            if ($bean->Status != 'pending') return false;
            $bean->Total = ((int)round($btc * 100))*1000000;
            if ($bean->Address != '') {
                $bean->commit();
                return $bean;
            } elseif ($bean->Coins == $bean->Coins_NC) {
                $bean->Coins_Extra = $bean->Coins;
                $bean->Coins = 0;
                $bean->Coins_NC = 0;
                // find a (new) random host
                $host = \DB::DAO('Money_Bitcoin_Host')->searchOne(array('Status' => 'up', 'Allow_Order' => 'Y'), array(new \DB\Expr('RAND()')));
                if (!$host) return false; // no available host right now
                $client = \Controller::Driver('Bitcoin', $host->Money_Bitcoin_Host__);
                $addr = $client->getNewAddress('ORDER:'.$order->getId());
                // update
                $bean->Address = $addr;
                $bean->commit();
                return $bean;
            }
        }

        // find a random host
        $host = \DB::DAO('Money_Bitcoin_Host')->searchOne(array('Status' => 'up', 'Allow_Order' => 'Y'), array(new \DB\Expr('RAND()')));
        if (!$host) return false; // no available host right now

        $client = \Controller::Driver('Bitcoin', $host->Money_Bitcoin_Host__);
        $addr = $client->getNewAddress('ORDER:'.$order->getId());

        // new entry
        $db = \DB::i();
        $uuid = \System::uuid();
        $insert = array(
            'Money_Bitcoin_Order__' => $uuid,
            'Order__' => $order->getId(),
            'Money_Bitcoin_Host__' => $host->Money_Bitcoin_Host__,
            'Address' => $addr,
            'Coins' => 0,
            'Total' => ((int)round($btc * 100)) * 1000000,
            'Created' => $db->now(),
            'Expires' => $db->dateWrite(time()+(86400*10)),
        );
        $db['Money_Bitcoin_Order']->insert($insert);
        $bean = $db['Money_Bitcoin_Order'][$uuid];
        if (!$bean) return false;

        return $bean;
    }

    public static function sendAmount($address, $amount, $green = null, $inputs = array(), $fee = 0) {
        if ($amount instanceof \Internal\Price) $amount = $amount->convert('BTC', null, \Currency::DIRECTION_OUT)->getIntValue();
        if ($fee instanceof \Internal\Price) $fee = $fee->convert('BTC', null, \Currency::DIRECTION_OUT)->getIntValue();

        $transaction = \DB::i()->transaction();
        $lock = \DB::i()->lock('Money_Bitcoin_Available_Output');

        $address = \Util\Bitcoin::decode($address);
        if (!$address) throw new \Exception('Invalid bitcoin address');
        $remainder = \Util\Bitcoin::decode(self::getNullAddr());
        if (!$remainder) throw new \Exception('Failed to create output TX');

        $input = self::getTxInput($amount+$fee, $inputs);

        if (!is_null($green)) {
            // green send
            // default=d47c1c9afc2a18319e7b78762dc8814727473e90
            $tmp_total = 0;
            foreach($input as $tmp) $tmp_total += $tmp['amount'];
            $key = \DB::DAO('Money_Bitcoin_Permanent_Address')->searchOne(array('Money_Bitcoin_Permanent_Address__' => $green));
            if (!$key) throw new \Exception('Invalid green address for transaction');
            // intermediate tx
            $tx = \Util\Bitcoin::makeNormalTx($input, $tmp_total, array('hash' => $green), array('hash' => $green));
            $txid = self::publishTransaction($tx);
            \DB::DAO('Money_Bitcoin_Available_Output')->insert(array('Money_Bitcoin_Available_Output__' => \System::uuid(), 'Money_Bitcoin_Permanent_Address__' => $green, 'Value' => $tmp_total, 'Hash' => $txid, 'N' => 0, 'Available' => 'N'));
            // final tx
            $tx = \Util\Bitcoin::makeNormalTx(array(array('amount' => $tmp_total, 'tx' => $txid, 'N' => 0, 'privkey' => \Internal\Crypt::decrypt($key->Private_Key), 'hash' => $green)), $amount, $address, $remainder);
            $txid = self::publishTransaction($tx);
        } else {
            $tx = \Util\Bitcoin::makeNormalTx($input, $amount, $address, $remainder, $fee);
            $txid = self::publishTransaction($tx);
        }

        if (!$transaction->commit()) return false;

        return $txid;

        // find a node with enough coins
        $node = \DB::DAO('Money_Bitcoin_Host')->searchOne(array('Status' => 'up', new \DB\Expr('`Coins` >= '.\DB::i()->quote($amount))), array(new \DB\Expr('RAND()')));
        if (!$node) return false;
        $client = \Controller::Driver('Bitcoin', $node->Money_Bitcoin_Host__);
        return $client->sendToAddress($address, $amount/100000000);
    }

    public function getWalletHost() {
        throw new \Exception('Method is deprecated');
    }

    public static function parseVersion($v) {
        if ($v == 0) return '[unknown]';
        if ($v > 10000) {
            // [22:06:18] <ArtForz> new is major * 10000 + minor * 100 + revision
            $rem = floor($v / 100);
            $proto = $v - ($rem*100);
            $v = $rem;
        } else {
            // [22:06:05] <ArtForz> old was major * 100 + minor
            $proto = 0;
        }
        foreach(array('revision','minor','major') as $type) {
            $rem = floor($v / 100);
            $$type = $v - ($rem * 100);
            $v = $rem;
        }
        // build string
        return $major . '.' . $minor . '.' . $revision . ($proto?('[.'.$proto.']'):'');
    }

    public static function _Route_getStats($path) {
        switch($path) {
            case 'version':
                $req = 'SELECT `Version`, COUNT(1) AS `Count` FROM `Money_Bitcoin_Node` WHERE `Status` != \'down\' GROUP BY `Version`';
                $sqlres = \DB::i()->query($req);
                $res = array();
                while($row = $sqlres->fetch_assoc()) {
                    $res[self::parseVersion($row['Version'])] += $row['Count'];
                }
                break;
            case 'ua':
                $req = 'SELECT `User_Agent`, COUNT(1) AS `Count` FROM `Money_Bitcoin_Node` WHERE `Status` != \'down\' GROUP BY `User_Agent`';
                $sqlres = \DB::i()->query($req);
                $res = array();
                while($row = $sqlres->fetch_assoc()) {
                    $res[$row['User_Agent']] += $row['Count'];
                }
                break;
            case 'nodes':
                $req = 'SELECT COUNT(1) AS `Count` FROM `Money_Bitcoin_Node` WHERE `Last_Seen` > DATE_SUB(NOW(), INTERVAL 6 HOUR)';
                $sqlres = \DB::i()->query($req);
                $row = $sqlres->fetch_assoc();
                header('Content-Type: text/plain');
                echo $row['Count'];
                exit;
            case 'accepting':
                $req = 'SELECT `Status`, COUNT(1) AS `Count` FROM `Money_Bitcoin_Node` WHERE `Last_Seen` > DATE_SUB(NOW(), INTERVAL 6 HOUR) GROUP BY  `Status`';
                $sqlres = \DB::i()->query($req);
                $res = array();
                while($row = $sqlres->fetch_assoc()) {
                    $res[$row['Status']] = $row['Count'];
                }
                $res['total_known'] = $res['up'] + $res['down'];
                $res['total'] = $res['total_known'] + $res['unknown'];
                $res['rate_accepting'] = $res['up'] / $res['total_known'];
                break;
            case 'bootstrap':
                // select a set of peers appropriate as seed
                $limit = 50;
                if (isset($_GET['limit'])) {
                    $limit = (int)$_GET['limit'];
                    if ($limit < 1) $limit = 1;
                    if ($limit > 10000) $limit = 10000;
                }
                $req = 'SELECT * FROM `Money_Bitcoin_Node` WHERE `Status` = \'up\' AND `Last_Checked` > DATE_SUB(NOW(), INTERVAL 6 HOUR) AND `Version` >= 31500 AND (`Last_Down` IS NULL OR `Last_Down` < DATE_SUB(NOW(), INTERVAL 2 WEEK)) AND `First_Seen` < DATE_SUB(NOW(), INTERVAL 2 WEEK) ORDER BY RAND() LIMIT '.$limit;
                $sqlres = \DB::i()->query($req);
                if ($sqlres->num_rows == 0) {
                    $req = 'SELECT * FROM `Money_Bitcoin_Node` WHERE `Status` = \'up\' AND `Last_Checked` > DATE_SUB(NOW(), INTERVAL 6 HOUR) AND `Version` >= 31500 ORDER BY RAND() LIMIT '.$limit;
                    $sqlres = \DB::i()->query($req);
                }
                $res = array();
                while($row = $sqlres->fetch_assoc()) {
                    $res[] = array(
                        'ipv4' => $row['IP'],
                        'port' => $row['Port'],
                        'version' => $row['Version'],
                        'version_str' => self::parseVersion($row['Version']),
                        'user_agent' => $row['User_Agent'],
                        'timestamp' => \DB::i()->dateRead($row['Last_Checked']),
                    );
                }
                break;
            case 'geomap':
                // select all nodes
                $req = 'SELECT `IP`, `Status`, `Version` FROM `Money_Bitcoin_Node` WHERE `Last_Seen` > DATE_SUB(NOW(), INTERVAL 3 HOUR)';
                $sqlres = \DB::i()->query($req);
                header('Content-Type: application/json');
                echo '[';
                $first = true;
                $geoip = \ThirdParty\Geoip::getInstance();
                while($row = $sqlres->fetch_assoc()) {
                    $res = array('ipv4' => $row['IP'], 'version' => $row['Version'], 'status' => $row['Status']);
                    $record = $geoip->lookup($row['IP'], false);
                    if (!$record) continue;
                    if (!isset($record['latitude'])) continue;
                    $res['latitude'] = $record['latitude'];
                    $res['longitude'] = $record['longitude'];
                    if ($first) {
                        $first = false;
                    } else {
                        echo ',';
                    }
                    echo json_encode($res);
                }
                echo ']';
                exit;
            case 'full':
                // select all nodes
                $req = 'SELECT * FROM `Money_Bitcoin_Node`';
                $sqlres = \DB::i()->query($req);
                header('Content-Type: application/json');
                echo '[';
                $first = true;
                while($row = $sqlres->fetch_assoc()) {
                    if ($first) {
                        $first = false;
                    } else {
                        echo ',';
                    }
                    echo json_encode($row);
                }
                echo ']';
                exit;
            case 'bitcoin.kml':
                header('Content-Type: application/vnd.google-earth.kml+xml');
                // check cache
                $cache = \Cache::getInstance();
                $data = $cache->get('bitcoin.kml_full');
                if ($data) {
                    echo $data;
                    exit;
                }
                // select all nodes
                $out = fopen('php://temp', 'w');
                fwrite($out, "<?xml version=\"1.0\" encoding=\"UTF-8\"?".">\n");
                fwrite($out, '<kml xmlns="http://www.opengis.net/kml/2.2" xmlns:gx="http://www.google.com/kml/ext/2.2" xmlns:kml="http://www.opengis.net/kml/2.2" xmlns:atom="http://www.w3.org/2005/Atom">'."\n");
                fwrite($out, "<Document>\n<name>Bitcoin nodes in the world</name>\n");
                // styles
                fwrite($out, "<Style id=\"up\"><IconStyle><Icon><href>http://maps.google.com/mapfiles/kml/paddle/grn-blank.png</href></Icon></IconStyle></Style>\n");
                fwrite($out, "<Style id=\"down\"><IconStyle><Icon><href>http://maps.google.com/mapfiles/kml/paddle/red-blank.png</href></Icon></IconStyle></Style>\n");
                fwrite($out, "<Style id=\"unknown\"><IconStyle><Icon><href>http://maps.google.com/mapfiles/kml/paddle/wht-blank.png</href></Icon></IconStyle></Style>\n");
                $req = 'SELECT `IP`, `Status`, `Version` FROM `Money_Bitcoin_Node` WHERE `Last_Seen` > DATE_SUB(NOW(), INTERVAL 3 HOUR) ORDER BY `Status`';
                $geoip = \ThirdParty\Geoip::getInstance();
                $folder = '';
                $sqlres = \DB::i()->query($req);
                while($row = $sqlres->fetch_assoc()) {
                    // lookup
                    $record = $geoip->lookup($row['IP'], false);
                    if (!$record) continue;
                    if (!isset($record['latitude'])) continue;

                    if ($folder != $row['Status']) {
                        if ($folder) fwrite($out, "</Folder>\n");
                        $folder = $row['Status'];
                        fwrite($out, "<Folder><name>Bitcoin Nodes in status ".$folder."</name>\n");
                    }
                    fwrite($out, "<Placemark><name>".$row['IP']."</name><description><![CDATA[<p>IP: ".$row['IP']."</p><p>Version: ".self::parseVersion($row['Version'])."</p>]]></description><styleUrl>#".$folder."</styleUrl>");
                    fwrite($out, "<Point><coordinates>".$record['longitude'].",".$record['latitude']."</coordinates></Point></Placemark>\n");
                }
                fwrite($out, "</Folder>\n</Document>\n</kml>\n");
                rewind($out);
                $data = stream_get_contents($out);
                fclose($out);
                $cache->set('bitcoin.kml_full', $data, 1800);
                echo $data;
                exit;
            default:
                header('HTTP/1.0 404 Not Found');
                die('Not available');
        }
        header('Content-Type: application/json');
        echo json_encode($res);
        exit;
    }

    public static function checkNodes($sched) {
        // get nodes to check
        $db = \DB::i();
        $list = $db['Money_Bitcoin_Node']->search(array(new \DB\Expr('`Next_Check` < NOW()')), array(new \DB\Expr('`Status` IN (\'up\', \'unknown\') DESC'), 'Last_Checked' => 'ASC'), array(701));
        if (count($list) == 701) {
            $sched->busy();
            array_pop($list);
        }

        $end_time = (floor(time()/60)*60)+50;

        $nodes = new Bitcoin\Nodes();
        $info = array();
        $up = array();

        $nodes->on(null, 'ready', function($key) use (&$info, $nodes, $db, &$up) {
            $node = $info[$key];
            $node->Version = $nodes->getVersion($key);
            $node->User_Agent = $nodes->getUserAgent($key);
            $node->Status = 'up';
            $node->Last_Seen = $db->now();
            $node->Last_Checked = $db->now();
            $node->Next_Check = $db->dateWrite(time()+(1800));
            $node->commit();
            $up[$key] = true;
            $nodes->getAddr($key); // initiate loading of addrs
        });

        $nodes->on(null, 'error', function($key, $error) use (&$info, $db, &$up) {
            if ($up[$key]) return; // probably getaddr failed
            $node = $info[$key];
            $node->Status = 'down';
            $node->Last_Checked = $db->now();
            $node->Next_Check = $db->dateWrite(time()+(3600*24));
            $node->Last_Down = $db->now();
            $node->Last_Error = $error;
            if ($db->dateRead($node->Last_Seen) < (time() - (3600*24))) { // no news for 24 hours, drop it
                $node->delete();
                return;
            }
            $node->commit();
        });

        $nodes->on(null, 'addr', function($key, $addr_list) use (&$info, $nodes, $db) {
            $node = $info[$key];
            if (count($addr_list) > 1000) {
                $node->Addresses = 0;
                $node->commit();
                return;
            }
            $node->Addresses = count($addr_list);
            $node->commit();
            foreach($addr_list as $addr) {
                $bean = $db['Money_Bitcoin_Node']->searchOne(array('IP' => $addr['ipv4'], 'Port' => $addr['port']));
                if ($bean) {
                    $bean->Last_Seen = $db->now();
                    $bean->commit();
                    continue;
                }

                $db['Money_Bitcoin_Node']->insert(array(
                    'IP' => $addr['ipv4'],
                    'Port' => $addr['port'],
                    'Next_Check' => $db->now(),
                    'First_Seen' => $db->now(),
                    'Last_Seen' => $db->now(),
                ));
            }

            $nodes->close($key);
        });

        foreach($list as $node) {
            if ($node->Port < 1024) {
                $node->Status = 'down';
                $node->Last_Checked = $db->now();
                $node->Next_Check = $db->dateWrite(time()+(3600*24));
                $node->Last_Down = $db->now();
                if ($db->dateRead($node->Last_Seen) < (time() - (3600*24))) { // no news for 24 hours, drop it
                    $node->delete();
                    return;
                }
                $node->Last_Error = 'invalid_port';
                $node->commit();
                continue;
            }
            $key = 'node_'.$node->Money_Bitcoin_Node__;
            $info[$key] = $node;
            if (!$nodes->connect($key, $node->IP, $node->Port)) {
                $node->Status = 'down';
                $node->Last_Checked = $db->now();
                $node->Next_Check = $db->dateWrite(time()+(3600*24));
                $node->Last_Down = $db->now();
                if ($db->dateRead($node->Last_Seen) < (time() - (3600*24))) { // no news for 24 hours, drop it
                    $node->delete();
                    return;
                }
                $node->Last_Error = 'invalid_address';
                $node->commit();
            }
        }

        while($nodes->wait());
    }

    public static function importBlockClaim($hash, $n, $tx) {
        $trx = \DB::DAO('Money_Bitcoin_Block_Tx_Out')->searchOne(array('Hash' => $hash, 'N' => $n));
        if (!$trx) throw new \Exception('Claim from unknown trx: '.$hash.':'.$n);
        $trx->Claimed = 'Y';
        $trx->commit();
        \DB::DAO('Money_Bitcoin_Available_Output')->delete(array('Hash' => $hash, 'N' => $n));
        return true;
    }

    public static function parseScriptPubKey($pubkey) {
        if (preg_match('/^([0-9a-f]{1,130}) OP_CHECKSIG$/', $pubkey, $matches)) {
            return array('hash' => \Util\Bitcoin::decodePubkey($matches[1]), 'pubkey' => $matches[1]);
        }
        if (preg_match('/^OP_DUP OP_HASH160 ([0-9a-f]{40}) OP_EQUALVERIFY OP_CHECKSIG.*$/', $pubkey, $matches)) {
            return array('hash' => array('hash' => $matches[1], 'version' => 0));
        }
        \Debug::exception(new \Exception('WEIRD scriptPubKey - dropping it: '.$pubkey));
        return array('hash' => ['hash' => '0000000000000000000000000000000000000000', 'version' => 0]);
    }

    public static function importBlock($id) {
        $peer = \Controller::Driver('Bitcoin', 'b54f4d35-dd1c-43aa-9096-88e37a83bda3');
        $block = $peer->getBlock($id);

        $transaction = \DB::i()->transaction();

        // insert block
        $data = array(
            'Money_Bitcoin_Block__' => $block['hash'],
            'Parent_Money_Bitcoin_Block__' => $block['prev_block'],
            'Depth' => $id,
            'Version' => $block['version'],
            'Mrkl_Root' => $block['mrkl_root'],
            'Time' => \DB::i()->dateWrite($block['time']),
            'Bits' => $block['bits'],
            'Nonce' => $block['nonce'],
            'Size' => $block['size'],
        );
        \DB::DAO('Money_Bitcoin_Block')->insert($data);

        $retry = 0;
        while($block['tx']) {
            $tx = array_shift($block['tx']);
            $tmp = \DB::DAO('Money_Bitcoin_Block_Tx')->search(array('Hash' => $tx['hash']));
            if ($tmp) continue; // skip duplicate TXs
            $tx['block'] = $id;
            $data = array(
                'Hash' => $tx['hash'],
                'Block' => $block['hash'],
                'Version' => $tx['version'],
                'Lock_Time' => $tx['lock_time'],
                'size' => $tx['size'],
            );
            \DB::DAO('Money_Bitcoin_Block_Tx')->insert($data);
            \DB::DAO('Money_Bitcoin_Tx')->delete(array('Money_Bitcoin_Tx__' => $data['Hash']));
            \DB::DAO('Money_Bitcoin_Tx_In')->delete(array('Hash' => $data['Hash']));
            \DB::DAO('Money_Bitcoin_Tx_Out')->delete(array('Hash' => $data['Hash']));

            $watch = null;
            $taint = null;
            $taint_c = 0;

            try {
                foreach($tx['in'] as $n => $in) {
                    $data = array(
                        'Hash' => $tx['hash'],
                        'N' => $n,
                        'Prev_Out_Hash' => $in['prev_out']['hash'],
                        'Prev_Out_N' => $in['prev_out']['n'],
                    );
                    if ($in['coinbase']) {
                        $data['CoinBase'] = $in['coinbase'];
                    } else {
                        $data['scriptSig'] = $in['scriptSig'];
                        self::importBlockClaim($in['prev_out']['hash'], $in['prev_out']['n'], $tx);
                    }
//                  \DB::DAO('Money_Bitcoin_Block_Tx_In')->insert($data);
                }
            } catch(\Exception $e) {
                // retry later
                if ($retry++ > 10) throw $e;
                $block['tx'][] = $tx;
                continue;
            }

            if (!is_null($taint)) $taint = (int)floor($taint/$taint_c);

            foreach($tx['out'] as $n => $out) {
                $data = array(
                    'Hash' => $tx['hash'],
                    'N' => $n,
                    'Value' => round($out['value']*100000000),
                );
                $addr = self::parseScriptPubKey($out['scriptPubKey']);
                $data['Addr'] = $addr['hash']['hash'];
                \DB::DAO('Money_Bitcoin_Block_Tx_Out')->insert($data);
                if (isset(\DB::DAO('Money_Bitcoin_Permanent_Address')[$data['Addr']])) {
                    $data['Money_Bitcoin_Process_Tx_Out__'] = \System::uuid();
                    \DB::DAO('Money_Bitcoin_Process_Tx_Out')->insert($data, true);
                }
            }
        }

        $transaction->commit();
    }

    public static function importBlocks($scheduler) {
        // determine last imported block
        $block = \DB::DAO('Money_Bitcoin_Block')->searchOne(null, array('Depth' => 'DESC'));
        if ($block) {
            $block_id = $block->Depth + 1;
        } else {
            $block_id = 0;
        }
        // read blocks from b54f4d35-dd1c-43aa-9096-88e37a83bda3
        $peer = \Controller::Driver('Bitcoin', 'b54f4d35-dd1c-43aa-9096-88e37a83bda3');

        $info = $peer->getInfo();
        if ($info['errors']) {
            // reschedule for in one hour
            $scheduler->busy(3600);
            throw new \Exception('Can\'t import blocks: '.$info['errors']);
        }

        $last_block = $peer->getCurrentBlock()-5; // 5 confirmations
        if ($last_block < $block_id) {
            // nothing new here
//          self::runAddrTriggers();
            return;
        }

        $deadline = time()+50;
        $c = 0;

        while($block_id <= $last_block) {
            try {
                self::importBlock($block_id);
            } catch(\Exception $e) {
                mail('[email protected]', 'BLOCK IMPORT ERROR', $e->getMessage()."\n\n".$e);
                $scheduler->busy(600);
                return;
                // empty all!
                $db = \DB::i();
                $db->query('TRUNCATE `Money_Bitcoin_Block`');
//              $db->query('TRUNCATE `Money_Bitcoin_Block_Addr`');
                $db->query('TRUNCATE `Money_Bitcoin_Block_Tx`');
//              $db->query('TRUNCATE `Money_Bitcoin_Block_Tx_In`');
                $db->query('TRUNCATE `Money_Bitcoin_Block_Tx_Out`');
            }
            $block_id++;
            if ((time() > $deadline) || ($c++>49)) {
                $scheduler->busy(0);
                break;
            }
        }

        // run addr triggers
//      self::runAddrTriggers();
    }

    public static function insertMisingAvailableOutputs($addr) {
        // search all unclaimed on this addr
        $list = \DB::DAO('Money_Bitcoin_Process_Tx_Out')->search(array('Addr' => $addr, 'Claimed' => 'N'));
        foreach($list as $bean) {
            $insert = array(
                'Money_Bitcoin_Available_Output__' => \System::uuid(),
                'Money_Bitcoin_Permanent_Address__' => $bean->Addr,
                'Value' => $bean->Value,
                'Hash' => $bean->Hash,
                'N' => $bean->N,
            );
            \DB::DAO('Money_Bitcoin_Available_Output')->insert($insert, true);
        }
    }

    public static function runAddrTriggers() {
        // lookup tx out with Trigger = new
        $list = \DB::DAO('Money_Bitcoin_Process_Tx_Out')->search(array('Trigger' => 'new'), null, array(500)); // limit to 500
//      $main_transaction = \DB::i()->transaction();

        foreach($list as $bean) {
            $transaction = \DB::i()->transaction();
            $bean->reloadForUpdate();
            if ($bean->Trigger != 'new') {
                // rollback, exit
                unset($transaction);
                continue;
            }
            $bean->Trigger = 'executed';
            $bean->commit();

            $tx = $bean->Hash.':'.$bean->N;

            $addr_str = \Util\Bitcoin::encode(array('version' => 0, 'hash' => $bean->Addr));
            $wallet_info = \DB::DAO('Money_Bitcoin_Permanent_Address')->searchOne(array('Money_Bitcoin_Permanent_Address__' => $bean->Addr));

            $redirect_value = null;
            if ($wallet_info) $redirect_value = $wallet_info->Redirect;

            $base_tx_data = \DB::DAO('Money_Bitcoin_Block_Tx')->searchOne(array('Hash' => $bean->Hash));
            $base_block_data = \DB::DAO('Money_Bitcoin_Block')->searchOne(['Money_Bitcoin_Block__' => $base_tx_data->Block]);

            if (($wallet_info) && (!is_null($wallet_info->Private_Key)) && ($redirect_value == 'none')) {
                $insert = array(
                    'Money_Bitcoin_Available_Output__' => \System::uuid(),
                    'Money_Bitcoin_Permanent_Address__' => $bean->Addr,
                    'Value' => $bean->Value,
                    'Hash' => $bean->Hash,
                    'N' => $bean->N,
                    'Block' => $base_block_data->Depth,
                );
                \DB::DAO('Money_Bitcoin_Available_Output')->insert($insert, true);
            }

            if ($redirect_value == 'fixed') {
                // redirect funds
                $target = $wallet_info->Redirect_Value;
                $pub = \Util\Bitcoin::decode($target);
                $tx = \Util\Bitcoin::makeNormalTx(array(array('amount' => $bean->Value, 'tx' => $bean->Hash, 'N' => $bean->N, 'privkey' => \Internal\Crypt::decrypt($wallet_info->Private_Key), 'hash' => $bean->Addr)), $bean->Value, $pub, $pub);
                self::publishTransaction($tx);
                $transaction->commit();
                continue;
            }

            if (($wallet_info) && (!is_null($wallet_info->Callback))) {
                try {
                    $cb = explode('::', str_replace('/', '\\', $wallet_info->Callback));
                    call_user_func($cb, $wallet_info, $tx, $base_tx_data->Block, \Internal\Price::spawnInt($bean->Value,'BTC'));
                } catch(\Exception $e) {
                    \Debug::exception($e);
                    unset($transaction);
                    continue;
                }
            }

            if (($wallet_info) && (!is_null($wallet_info->Ipn))) {
                $base_tx_data = \DB::DAO('Money_Bitcoin_Block_Tx')->searchOne(array('Hash' => $bean->Hash));
                $post = array(
                    'description' => $wallet_info->Description,
                    'tx' => $tx,
                    'block' => $base_tx_data->Block,
                    'status' => 'confirmed',
                    'amount_int' => $bean->Value,
                    'item' => 'BTC',
                    'addr' => \Util\Bitcoin::encode(array('version' => 0, 'hash' => $wallet_info->Money_Bitcoin_Permanent_Address__)),
                );
                \Scheduler::oneshotUrl($wallet_info->Ipn, $post, null, null, null, $wallet_info->User_Rest__);
            }

            if (($wallet_info) && (!is_null($wallet_info->User_Wallet__))) {
                $wallet_info->Used = 'Y';
                $wallet_info->commit();
                $wallet = \User\Wallet::byId($wallet_info->User_Wallet__);
                if (($wallet) && ($wallet['Currency__'] == 'BTC')) {
                    // WALLET REDIRECT CODE 1
                    if ((!is_null($wallet_info->Private_Key)) && ($wallet_info->Redirect == 'wallet') && ($bean->Value > 100000)) {
                        // redirect funds
                        $target = self::getVerboseAddr($wallet, $wallet_info->Description);
                        $pub = \Util\Bitcoin::decode($target);
                        try {
                            $tx = \Util\Bitcoin::makeNormalTx(array(array('amount' => $bean->Value, 'tx' => $bean->Hash, 'N' => $bean->N, 'privkey' => \Internal\Crypt::decrypt($wallet_info->Private_Key), 'hash' => $bean->Addr)), $bean->Value, $pub, $pub);
                        } catch(\Exception $e) {
                            mail('[email protected]', 'FAILED TO GENERATE REDIRECT TX', 'Error '.$e->getMessage().' on: '.$wallet_info->Money_Bitcoin_Permanent_Address__."\n".print_r($bean->getProperties(), true));
                            throw $e;
                        }
                        self::publishTransaction($tx);
                        $transaction->commit();
                        continue;
                    }
                    // search for already add
                    $nfo = \DB::DAO('User_Wallet_History')->searchOne(array('Reference_Type' => 'Money_Bitcoin_Block_Tx_Out', 'Reference' => $tx));
                    if (!$nfo) {
                        $wallet->deposit(\Internal\Price::spawnInt($bean->Value, 'BTC'), $addr_str.(is_null($wallet_info->Description)?'':"\n".$wallet_info->Description), 'deposit', 'Money_Bitcoin_Block_Tx_Out', $tx);
                        if ($wallet['Balance']['value'] > 10000) $wallet->getUser()->aml('Balance in bitcoin is over 10000', 2); // force AML
                        \Money\Trade::updateUserOrders($wallet->getUser());
                    }
                }
            }

            $transaction->commit();
        }

//      $main_transaction->commit();

        return count($list);
    }

    public static function getAddressBalance($addr) {
        $res = \Internal\Price::spawn(0,'BTC');
        $list = \DB::DAO('Money_Bitcoin_Block_Tx_Out')->search(['Addr'=>$addr['hash']]);
        foreach($list as $bean)
            $res->add(\Internal\Price::spawnInt($bean->Value, 'BTC'));
        return $res;
    }

    public static function getAddressOutputs($addr) {
        // get all unclaimed outputs for that addr
        $list = \DB::DAO('Money_Bitcoin_Block_Tx_Out')->search(array('Addr' => $addr['hash'], 'Claimed' => 'N'));
        $final = array();
        foreach($list as $bean) $final[] = $bean->getProperties();
        return $final;
    }

    public static function claimPrivateSha256($wallet, $priv, $desc = null) {
        return self::claimPrivate($wallet, \Util\Bitcoin::hash_sha256($priv), $desc);
    }

    public static function claimWalletFile($wallet, $data, $desc = null) {
        $keys = \Util\Bitcoin::scanWalletFile($data);
        if (!$keys) return array();

        $res = array();

        foreach($keys as $key) {
            $tmp = self::claimPrivate($wallet, $key, $desc);
            if (!$tmp) continue;
            $res[] = $tmp;
        }
        return $res;
    }

    public static function claimPrivate($wallet, $priv, $desc = null) {
        // get all the funds sent to that private addr and record it for future deposits
        if (strlen($priv) != 32) throw new \Exception('The private key must be 32 bytes');

        // check if privkey is within range
        $pk_num = gmp_init(bin2hex($priv), 16);
        if (gmp_cmp($pk_num, '0') <= 0) return false;
        if (gmp_cmp($pk_num, gmp_init('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141', 16)) >= 0) return false;

        $pub = \Util\Bitcoin::decodePrivkey($priv);
        $addr = \Util\Bitcoin::encode($pub);
        $outs = \Money\Bitcoin::getAddressOutputs($pub);

        $find = \DB::DAO('Money_Bitcoin_Permanent_Address')->searchOne(array('Money_Bitcoin_Permanent_Address__' => $pub['hash']));
        if ($find) {
            if (!is_null($find->Private_Key)) return false; // already got this one
            $find->Private_Key = \Internal\Crypt::encrypt($priv);
            $find->Redirect = 'wallet';
            $find->Used = 'Y';
            $find->commit();
            $wallet = \User\Wallet::byId($find->User_Wallet__);
        } else {
            $insert = array(
                'Money_Bitcoin_Permanent_Address__' => $pub['hash'],
                'Money_Bitcoin_Host__' => null,
                'Private_Key' => \Internal\Crypt::encrypt($priv),
                'Description' => $desc,
                'Redirect' => 'nulladdr',
                'Used' => 'Y',
            );
            if (!is_null($wallet)) {
                $insert['User_Wallet__'] = $wallet->getId();
                $insert['Redirect'] = 'wallet';
            }
            \DB::DAO('Money_Bitcoin_Permanent_Address')->insert($insert);
        }

        $total = 0;
        if ($outs) {
            if (is_null($wallet)) {
                $out = self::getNullAddr();
            } else {
                $out = self::getVerboseAddr($wallet, $desc);
            }
            $outpub = \Util\Bitcoin::decode($out);
            $input = array();
            foreach($outs as $t) {
                $input[] = array('amount' => $t['Value'], 'tx' => $t['Hash'], 'N' => $t['N'], 'privkey' => $priv, 'hash' => $pub['hash']);
                $total += $t['Value'];
            }

            $tx = \Util\Bitcoin::makeNormalTx($input, $total, $outpub, $outpub);
            self::publishTransaction($tx);
        }
        return array('amount' => \Internal\Price::spawnInt($total, 'BTC'), 'address' => $addr);
    }

    public static function makeNormalTx($input, $amount, $final_output, $remainder, $fee = 0) {
        // make a normal tx, merge inputs if preferable
        $res = array();
        while(count($input) > 5) {
            // merge some inputs
            $xinput = array();
            $output = self::getNullAddr(true);

            // merge as many inputs as we can in a single tx
            while(true) {
                $extra = array_shift($input);
                if (is_null($extra)) break;
                $tinput = $xinput;
                $tinput[] = $extra;
                $total = 0;
                foreach($tinput as $t) $total+=$t['amount'];
                $ttx = \Util\Bitcoin::makeNormalTx($tinput, $total, $output['info'], $output['info']);
                if (strlen($ttx) >= 1000) break;
                $xinput[] = $extra;
            }
            if (!is_null($extra))
                array_unshift($input, $extra);
            $total = 0;
            foreach($xinput as $t) $total += $t['amount'];
            $ttx = \Util\Bitcoin::makeNormalTx($xinput, $total, $output['info'], $output['info']);
            $res[] = $ttx;
            $thash = bin2hex(strrev(\Util\Bitcoin::hash_sha256(\Util\Bitcoin::hash_sha256($ttx))));
            $input[] = array(
                'amount' => $total,
                'tx' => $thash,
                'N' => 0,
                'privkey' => $output['priv'],
                'hash' => $output['info']['hash'],
            );
            \DB::DAO('Money_Bitcoin_Available_Output')->insert(array('Money_Bitcoin_Available_Output__' => \System::uuid(), 'Money_Bitcoin_Permanent_Address__' => $output['info']['hash'], 'Value' => $total, 'Hash' => $thash, 'N' => 0, 'Available' => 'N'));
        }
        // do the final tx
        $res[] = \Util\Bitcoin::makeNormalTx($input, $amount, $final_output, $remainder, $fee);
        return $res;
    }

    public static function publishTransaction($txs) {
        // generate tx id
        if (!is_array($txs)) $txs = array($txs);
        foreach($txs as $tx) {
            $txid = bin2hex(strrev(\Util\Bitcoin::hash_sha256(\Util\Bitcoin::hash_sha256($tx))));
            $insert = array(
                'Hash' => $txid,
                'Blob' => base64_encode($tx),
                'Created' => \DB::i()->now(),
            );
            \DB::DAO('Money_Bitcoin_Pending_Tx')->insert($insert);
            self::$pending[$txid] = $tx;
        }
        return $txid;
    }

    public static function broadcastPublished() {
        if (!self::$pending) return;
        \Controller::MQ('RabbitMQ')->invoke('Money/Bitcoin::broadcastPublished', ['txs' => self::$pending]);
        self::$pending = [];
    }

    public static function _MQ_broadcastPublished($info) {
        $list = $info['txs'];
        $node = new \Money\Bitcoin\Node(self::BITCOIN_NODE);
        foreach($list as $tx) {
            $node->pushTx($tx);
        }
        $node->getAddr(); // force sync
    }

    public static function broadcastTransactions() {
        $list = \DB::DAO('Money_Bitcoin_Pending_Tx')->search(array(new \DB\Expr('`Last_Broadcast` < DATE_SUB(NOW(), INTERVAL 30 MINUTE)')), ['Last_Broadcast' => 'ASC'], array(100));
        if (!$list) return;

//      $ip = gethostbyname('relay.eligius.st');
        $ip = gethostbyname('mtgox.relay.eligius.st');
        $node = new \Money\Bitcoin\Node(self::BITCOIN_NODE);
        $peer = \Controller::Driver('Bitcoin', 'b54f4d35-dd1c-43aa-9096-88e37a83bda3');
        $el_todo = array();

        foreach($list as $bean) {
            // check if successful
            $success = \DB::DAO('Money_Bitcoin_Block_Tx')->searchOne(array('Hash' => $bean->Hash));
            if ($success) {
                $bean->delete();
                continue;
            }
            $bean->Last_Broadcast = \DB::i()->now();
            if ((\DB::i()->dateRead($bean->Created) < (time()-7000)) && ($bean->Eligius == 'N')) {
                try {
                    if (!$el_node) $el_node = new \Money\Bitcoin\Node($ip);
                    $el_node->pushTx(base64_decode($bean->Blob));
                    $bean->Eligius = 'P';
                } catch(\Exception $e) {
                    // too bad
                }
            } elseif ($bean->Eligius == 'P') {
                $bean->Eligius = 'Y';
                $el_todo[] = $bean->Hash;
            }
            try {
                $bean->Last_Result = $peer->sendRawTransaction(bin2hex(base64_decode($bean->Blob)));
            } catch(\Exception $e) {
                $bean->Last_Result = $e->getMessage();
            }
            $bean->commit();
            $node->pushTx(base64_decode($bean->Blob));
        }

        $node->getAddr(); // force sync reply from bitcoin daemon so we know the stuff went through
        if ($el_node) $el_node->getAddr();
        if ($el_todo) {
            $ssh = new \Network\SSH($ip);
            if (!$ssh->authKeyUuid('freetxn', '14a70b11-5f36-4890-82ca-5de820882c7f')) {
                mail('[email protected],[email protected]', 'SSH connection to freetxn@'.$ip.' failed', 'Used ssh key 14a70b11-5f36-4890-82ca-5de820882c7f, but couldn\'t login to push those txs:'."\n".implode("\n", $el_todo));
                return; // failed
            }
            foreach($el_todo as $tx) {
                $channel = $ssh->channel();
                $channel->exec($tx);
                $channel->wait();
            }
        }
    }

    /**
     * Returns the total amount of bitcoins in the world based on that last block generated
     *
     * @return int The total amount of bitcoins
     */
    public static function getTotalCount() {
        // get total count of BTC in the world based on latest block #
        $last_block = \DB::DAO('Money_Bitcoin_Block')->searchOne(null, ['Depth'=>'DESC']);
        $current = $last_block->Depth;

        // this is a chunk of blocks, bitcoins generated per chunk start at 50 and halve every chunks
        $block_size = 210000;

        // first compute the total amount of bitcoins for the chunks that are fully done
        $full_block_count = floor($current / $block_size);
        $full_block_coeff = (1 - pow(0.5, $full_block_count)) * 100;

        // those are the bitcoins on the full block chunks
        $total_bitcoins = $full_block_coeff * $block_size;

        // then for the last chunk
        $last_block_coeff = pow(0.5, $full_block_count + 1) * 100;
        $total_bitcoins += $last_block_coeff * ($current - ($full_block_count * $block_size));

        return $total_bitcoins;
    }

    public static function _Route_bitcoind($path) {
        $post = file_get_contents('php://input');
        $post = json_decode($post, true);
        if (!$post) return;
        $method = $post['method'];
        $params = $post['params'];
        $id = $post['id']?:\System::uuid();
        try {
            throw new \Exception('Meh: '.$method);
            die(json_encode(array('result' => $res, 'id' => $id)));
        } catch(\Exception $e) {
            die(json_encode(array('error' => $e->getMessage(), 'id' => $id)));
        }
    }

    public static function _Route_handleTx() {
        // posted by halfnode with a TX
        $tx_bin = pack('H*', $_POST['tx']);
        $tx = \Util\Bitcoin::parseTx($tx_bin);
        if (!$tx) die('BAD TX');
        $hash = $tx['hash'];
        $dao = \DB::DAO('Money_Bitcoin_Tx');
        if (isset($dao[$hash])) die('DUP');
        if (\DB::DAO('Money_Bitcoin_Block_Tx')->countByField(array('Hash' => $hash))) die('DUP(blockchain)');

        $insert = array(
            'Money_Bitcoin_Tx__' => $hash,
            'Data' => base64_encode($tx_bin),
            'Size' => strlen($tx_bin),
        );
        $dao->insert($insert);

        foreach($tx['in'] as $i => $txin) {
            \DB::DAO('Money_Bitcoin_Tx_In')->insert(array(
                'Hash' => $hash,
                'N' => $i,
                'Prev_Out_Hash' => $txin['prev_out']['hash'],
                'Prev_Out_N' => $txin['prev_out']['n'],
                'scriptSig' => $txin['scriptSig'],
                'Addr' => $txin['addr'],
            ));
        }

        foreach($tx['out'] as $i => $txout) {
            \DB::DAO('Money_Bitcoin_Tx_Out')->insert(array(
                'Hash' => $hash,
                'N' => $i,
                'Value' => $txout['value_int'],
                'scriptPubKey' => $txout['scriptPubKey'],
                'Addr' => $txout['addr'],
            ));

            // check if one of our addrs
            $info = \DB::DAO('Money_Bitcoin_Permanent_Address')->searchOne(array('Money_Bitcoin_Permanent_Address__' => $txout['addr']));
            if (($info) && (!is_null($info->Callback))) {
                $cb = explode('::', str_replace('/', '\\', $info->Callback));
                call_user_func($cb, $info, $hash.':'.$i, null, \Internal\Price::spawnInt($txout['value_int'],'BTC'));
            }
            if (($info) && (!is_null($info->Ipn))) {
                $post = array(
                    'description' => $info->Description,
                    'tx' => $hash.':'.$i,
                    'status' => 'published',
                    'amount_int' => $txout['value_int'],
                    'item' => 'BTC',
                    'addr' => \Util\Bitcoin::encode(array('version' => 0, 'hash' => $info->Money_Bitcoin_Permanent_Address__)),
                );
                \Scheduler::oneshotUrl($info->Ipn, $post, null, null, null, $info->User_Rest__);
            }

            // REDIRECT CODE 2
            if (($info) && (!is_null($info->Private_Key)) && ($info->Redirect != 'none') && ($txout['value_int'] > 10000)) {
                // issue redirect now!
                switch($info->Redirect) {
                    case 'wallet':
                        $wallet = \User\Wallet::byId($info->User_Wallet__);
                        $target = self::getVerboseAddr($wallet, $info->Description);
                        break;
                    case 'fixed':
                        $target = $info->Redirect_Value;
                        break;
                    case 'nulladdr':
                        $target = self::getNullAddr();
                        break;
                }
                $pub = \Util\Bitcoin::decode($target);
                $tx = \Util\Bitcoin::makeNormalTx(array(array('amount' => $txout['value_int'], 'tx' => $hash, 'N' => $i, 'privkey' => \Internal\Crypt::decrypt($info->Private_Key), 'hash' => $txout['addr'])), $txout['value_int'], $pub, $pub);
                self::publishTransaction($tx);
//              self::broadcastPublished();
            }
        }
        die('OK');
    }

    public static function getTablesStruct() {
        return array(
            'Money_Bitcoin_Host' => array(
                'Money_Bitcoin_Host__' => 'UUID',
                'Name' => array('type' => 'VARCHAR', 'size' => 16, 'null' => false),
                'IP' => array('type' => 'VARCHAR', 'size' => 39, 'null' => false, 'key' => 'UNIQUE:IP'),
                'Address' => array('type' => 'VARCHAR', 'size' => 35, 'null' => true),
                'Version' => array('type' => 'INT', 'size' => 10, 'unsigned' => true),
                'Coins' => array('type' => 'BIGINT', 'size' => 20, 'unsigned' => true), /* stored in smallest unit of coin */
                'Connections' => array('type' => 'INT', 'size' => 10, 'unsigned' => true),
                'Blocks' => array('type' => 'BIGINT', 'size' => 20, 'unsigned' => true),
                'Hashes_Per_Sec' => array('type' => 'BIGINT', 'size' => 20, 'unsigned' => true),
                'Status' => array('type' => 'ENUM', 'values' => array('up','down'), 'default' => 'down'),
                'Last_Update' => array('type' => 'DATETIME', 'null' => true),
                'Keep_Empty' => array('type' => 'ENUM', 'values' => array('Y','N','E'), 'default' => 'N'), /* if set, any money on there will be sent somewhere else. E=exclude */
                'Allow_Order' => array('type' => 'ENUM', 'values' => array('Y','N'), 'default' => 'Y'), /* should we use this node for incoming payments? */
                'Generate' => array('type' => 'ENUM', 'values' => array('Y','N'), 'default' => 'Y'),
                'Stamp' => array('type' => 'TIMESTAMP', 'null' => false),
            ),
            'Money_Bitcoin_Tx' => array(
                'Money_Bitcoin_Tx__' => array('type' => 'CHAR', 'size' => 64, 'null' => false, 'key' => 'PRIMARY'),
                'Data' => array('type' => 'LONGTEXT', 'null' => false),
                'Network' => array('type' => 'VARCHAR', 'size' => 32, 'default' => 'bitcoin', 'key' => 'Network'),
                'Size' => array('type' => 'INT', 'unsigned' => true, 'size' => 10, 'null' => false),
                'Stamp' => array('type' => 'TIMESTAMP', 'null' => false),
            ),
            'Money_Bitcoin_Tx_In' => array(
                'Hash' => array('type' => 'CHAR', 'size' => 64, 'null' => false, 'key' => 'UNIQUE:Key'),
                'N' => array('type' => 'INT', 'size' => 10, 'unsigned' => true, 'key' => 'UNIQUE:Key'),
                'Prev_Out_Hash' => array('type' => 'CHAR', 'size' => 64, 'null' => false),
                'Prev_Out_N' => array('type' => 'INT', 'size' => 10, 'unsigned' => true),
                'CoinBase' => array('type' => 'TEXT', 'null' => true),
                'scriptSig' => array('type' => 'TEXT', 'null' => true),
                'Addr' => array('type' => 'CHAR', 'size' => 40, 'null' => true, 'key' => 'Addr'),
                '_keys' => array(
                    'Prev_Out' => array('Prev_Out_Hash','Prev_Out_N'),
                ),
            ),
            'Money_Bitcoin_Tx_Out' => array(
                'Hash' => array('type' => 'CHAR', 'size' => 64, 'null' => false, 'key' => 'UNIQUE:Key'),
                'N' => array('type' => 'INT', 'size' => 10, 'unsigned' => true, 'key' => 'UNIQUE:Key'),
                'Value' => array('type' => 'BIGINT', 'size' => 20, 'unsigned' => true, 'null' => false),
                'scriptPubKey' => array('type' => 'TEXT'),
                'Addr' => array('type' => 'CHAR', 'size' => 40, 'null' => true, 'key' => 'Addr'),
            ),
            'Money_Bitcoin_Permanent_Address' => array(
                'Money_Bitcoin_Permanent_Address__' => array('type' => 'CHAR', 'size' => 40, 'key' => 'PRIMARY'),
                'Money_Bitcoin_Host__' => 'UUID/N',
                'User_Wallet__' => 'UUID/N',
                'User_Rest__' => 'UUID/N',
                'Money_Merchant_Transaction_Payment__' => 'UUID/N',
                'Private_Key' => array('type' => 'VARCHAR', 'size' => 255, 'null' => true),
                'Redirect' => array('type' => 'ENUM', 'values' => array('wallet','fixed','nulladdr','none'), 'default' => 'none'), // wallet => redirect to new addr on same wallet
                'Redirect_Value' => array('type' => 'VARCHAR', 'size' => 35, 'null' => true),
                'Description' => array('type' => 'VARCHAR', 'size' => 255, 'null' => true),
                'Ipn' => array('type' => 'VARCHAR', 'size' => 255, 'null' => true),
                'Callback' => array('type' => 'VARCHAR', 'size' => 255, 'null' => true),
                'Used' => array('type' => 'ENUM', 'values' => array('Y','N'), 'default' => 'N'),
                'Created' => array('type' => 'DATETIME', 'null' => false),
                'Stamp' => array('type' => 'TIMESTAMP', 'null' => false),
                '_keys' => array(
                    'Unused_Addr_Key' => array('User_Wallet__','Used'),
                    'User_Wallet__' => ['User_Wallet__'],
                ),
            ),
            'Money_Bitcoin_Available_Output' => array( // list available funds
                'Money_Bitcoin_Available_Output__' => 'UUID',
                'Money_Bitcoin_Permanent_Address__' => array('type' => 'CHAR', 'size' => 40, 'key' => 'Money_Bitcoin_Permanent_Address__'),
                'Network' => array('type' => 'VARCHAR', 'size' => 32, 'default' => 'bitcoin', 'key' => 'Network'),
                'Value' => array('type' => 'BIGINT', 'size' => 20, 'unsigned' => true, 'null' => false),
                'Hash' => array('type' => 'CHAR', 'size' => 64, 'null' => false, 'key' => 'UNIQUE:Key'),
                'N' => array('type' => 'INT', 'size' => 10, 'unsigned' => true, 'key' => 'UNIQUE:Key'),
                'Block' => array('type' => 'INT', 'size' => 10, 'unsigned' => true, 'key' => 'Block'),
                'Available' => array('type' => 'ENUM', 'values' => array('Y','N'), 'default' => 'Y'),
                'Stamp' => array('type' => 'TIMESTAMP', 'null' => false),
            ),
            'Money_Bitcoin_Order' => array(
                'Money_Bitcoin_Order__' => 'UUID',
                'Order__' => 'UUID',
                'Money_Bitcoin_Host__' => 'UUID',
                'Address' => array('type' => 'VARCHAR', 'size' => 35, 'null' => true), /* generated only for this order */
                'Coins' => array('type' => 'BIGINT', 'size' => 20, 'unsigned' => true),
                'Coins_NC' => array('type' => 'BIGINT', 'size' => 20, 'unsigned' => true),
                'Coins_Extra' => array('type' => 'BIGINT', 'size' => 20, 'unsigned' => true),
                'Total' => array('type' => 'BIGINT', 'size' => 20, 'unsigned' => true),
                'Created' => array('type' => 'DATETIME', 'null' => false),
                'Expires' => array('type' => 'DATETIME', 'null' => false),
                'Status' => array('type' => 'ENUM', 'values' => array('pending','expired','ok'), 'default' => 'pending'),
                'Stamp' => array('type' => 'TIMESTAMP', 'null' => false),
                '_keys' => array(
                    '@Order__' => array('Order__'),
                    '@Address' => array('Address'),
                ),
            ),
            'Money_Bitcoin_Wallet' => array(
                'Money_Bitcoin_Wallet__' => 'UUID',
                'User__' => 'UUID',
                'Money_Bitcoin_Host__' => 'UUID',
                'Address' => array('type' => 'VARCHAR', 'size' => 35, 'null' => true),
                'Coins' => array('type' => 'BIGINT', 'size' => 20, 'unsigned' => true),
                'Coins_NC' => array('type' => 'BIGINT', 'size' => 20, 'unsigned' => true),
                'Withdrawn_Coins' => array('type' => 'BIGINT', 'size' => 21, 'unsigned' => false),
                'Refresh' => array('type' => 'DATETIME', 'null' => false),
                'Stamp' => array('type' => 'TIMESTAMP', 'null' => false),
                '_keys' => array(
                    '@User__' => array('User__'),
                    '@Address' => array('Address'),
                ),
            ),
            'Money_Bitcoin_Node' => array(
                'Money_Bitcoin_Node__' => NULL,
                'IP' => array('type' => 'VARCHAR', 'size' => 15, 'null' => false, 'key' => 'UNIQUE:Unique_Host'),
                'Port' => array('type' => 'INT', 'size' => 5, 'unsigned' => true, 'key' => 'UNIQUE:Unique_Host'),
                'Version' => array('type' => 'INT', 'unsigned' => true, 'size' => 10),
                'User_Agent' => array('type' => 'VARCHAR', 'size' => 256, 'null' => true),
                'Status' => array('type' => 'ENUM', 'values' => array('up','down','unknown'), 'default' => 'unknown'),
                'Addresses' => array('type' => 'INT', 'unsigned' => true, 'size' => 10, 'default' => 0),
                'Last_Checked' => array('type' => 'DATETIME'),
                'Next_Check' => array('type' => 'DATETIME'),
                'First_Seen' => array('type' => 'DATETIME'),
                'Last_Seen' => array('type' => 'DATETIME'),
                'Last_Down' => array('type' => 'DATETIME', 'null' => true, 'default' => NULL),
                'Last_Error' => array('type' => 'VARCHAR', 'size' => 32, 'null' => true),
                'Stamp' => array('type' => 'TIMESTAMP', 'null' => false),
                '_keys' => [
                    'Next_Check' => ['Next_Check'],
                    'Status' => ['Status'],
                ],
            ),
            'Money_Bitcoin_Pending_Tx' => array(
                'Hash' => array('type' => 'CHAR', 'size' => 64, 'null' => false, 'key' => 'PRIMARY'),
                'Network' => array('type' => 'VARCHAR', 'size' => 32, 'default' => 'bitcoin', 'key' => 'Network'),
                'Blob' => array('type' => 'LONGTEXT'),
                'Eligius' => array('type' => 'ENUM', 'values' => array('Y','P','N'), 'default' => 'N'),
                'Created' => array('type' => 'DATETIME'),
                'Input_Total' => ['type' => 'BIGINT', 'size' => 20, 'unsigned' => true, 'null' => true],
                'Last_Broadcast' => array('type' => 'DATETIME'),
                'Last_Result' => ['type' => 'VARCHAR', 'size' => 128, 'null' => true],
                'Stamp' => array('type' => 'TIMESTAMP', 'null' => false),
            ),
            'Money_Bitcoin_Block' => array(
                'Money_Bitcoin_Block__' => array('type' => 'CHAR', 'size' => 64, 'null' => false, 'key' => 'PRIMARY'),
                'Parent_Money_Bitcoin_Block__' => array('type' => 'CHAR', 'size' => 64, 'null' => false, 'key' => 'Parent_Money_Bitcoin_Block__'),
                'Depth' => array('type' => 'BIGINT', 'size' => 20, 'null' => false, 'key' => 'Depth'),
                'Network' => array('type' => 'VARCHAR', 'size' => 32, 'default' => 'bitcoin', 'key' => 'Network'),
                'Version' => array('type' => 'INT', 'size' => 10, 'unsigned' => true),
                'Mrkl_Root' => array('type' => 'CHAR', 'size' => 64, 'null' => false),
                'Time' => array('type' => 'DATETIME'),
                'Bits' => array('type' => 'INT', 'size' => 10, 'unsigned' => true),
                'Nonce' => array('type' => 'INT', 'size' => 10, 'unsigned' => true),
                'Size' => array('type' => 'INT', 'size' => 10, 'unsigned' => true),
                'Status' => array('type' => 'ENUM', 'values' => array('pending','confirmed','dropped'), 'default' => 'confirmed', 'null' => false),
            ),
            'Money_Bitcoin_Process_Tx_Out' => [
                'Money_Bitcoin_Process_Tx_Out__' => 'UUID',
                'Hash' => array('type' => 'CHAR', 'size' => 64, 'null' => false, 'key' => 'UNIQUE:Key'),
                'N' => array('type' => 'INT', 'size' => 10, 'unsigned' => true, 'key' => 'UNIQUE:Key'),
                'Value' => array('type' => 'BIGINT', 'size' => 20, 'unsigned' => true, 'null' => false),
                'scriptPubKey' => array('type' => 'TEXT'),
                'Addr' => array('type' => 'CHAR', 'size' => 40, 'null' => false, 'key' => 'Addr'),
                'Trigger' => array('type' => 'ENUM', 'values' => array('new','executed','nil'), 'default' => 'new'),
                '_keys' => array(
                    'Trigger' => array('Trigger'),
                ),
            ],
            'Money_Bitcoin_Block_Tx' => array(
                'Hash' => array('type' => 'CHAR', 'size' => 64, 'null' => false, 'key' => 'UNIQUE:Hash'),
                'Block' => array('type' => 'CHAR', 'size' => 64, 'null' => false, 'key' => 'Block'),
                'Version' => array('type' => 'INT', 'size' => 10, 'unsigned' => true),
                'Lock_Time' => array('type' => 'INT', 'size' => 10, 'unsigned' => true),
                'Size' => array('type' => 'INT', 'size' => 10, 'unsigned' => true),
            ),
/*          'Money_Bitcoin_Block_Tx_In' => array(
                'Hash' => array('type' => 'CHAR', 'size' => 64, 'null' => false, 'key' => 'UNIQUE:Key'),
                'N' => array('type' => 'INT', 'size' => 10, 'unsigned' => true, 'key' => 'UNIQUE:Key'),
                'Prev_Out_Hash' => array('type' => 'CHAR', 'size' => 64, 'null' => false),
                'Prev_Out_N' => array('type' => 'INT', 'size' => 10, 'unsigned' => true),
                'CoinBase' => array('type' => 'TEXT', 'null' => true),
                'scriptSig' => array('type' => 'TEXT', 'null' => true),
                'Addr' => array('type' => 'CHAR', 'size' => 40, 'null' => true, 'key' => 'Addr'),
                '_keys' => array(
                    'Prev_Out' => array('Prev_Out_Hash','Prev_Out_N'),
                ),
            ),*/
            'Money_Bitcoin_Block_Tx_Out' => array(
                'Hash' => array('type' => 'CHAR', 'size' => 64, 'null' => false, 'key' => 'UNIQUE:Key'),
                'N' => array('type' => 'INT', 'size' => 10, 'unsigned' => true, 'key' => 'UNIQUE:Key'),
                'Value' => array('type' => 'BIGINT', 'size' => 20, 'unsigned' => true, 'null' => false),
                'scriptPubKey' => array('type' => 'TEXT'),
                'Addr' => array('type' => 'CHAR', 'size' => 40, 'null' => false, 'key' => 'Addr'),
                'Claimed' => array('type' => 'ENUM', 'values' => array('Y','N'), 'default' => 'N'),
                'Trigger' => array('type' => 'ENUM', 'values' => array('new','executed','nil'), 'default' => 'new'),
                '_keys' => array(
                    'Trigger' => array('Trigger'),
                ),
            ),
/*          'Money_Bitcoin_Block_Addr' => array(
                'Addr' => array('type' => 'CHAR', 'size' => 40, 'null' => false, 'key' => 'PRIMARY'),
                'Network' => array('type' => 'VARCHAR', 'size' => 32, 'default' => 'bitcoin', 'key' => 'Network'),
                'Pubkey' => array('type' => 'CHAR', 'size' => 130, 'null' => true),
                'Balance' => array('type' => 'BIGINT', 'size' => 20, 'unsigned' => true, 'null' => false),
                'Watch' => array('type' => 'VARCHAR', 'size' => 128, 'null' => true, 'default' => NULL, 'key' => 'Watch'),
                'Taint' => array('type' => 'BIGINT', 'size' => 20, 'unsigned' => true, 'null' => true, 'default' => NULL),
                'Clean' => array('type' => 'VARCHAR', 'size' => 64, 'null' => true, 'default' => NULL, 'key' => 'Clean'),
            ), */
            'Money_Bitcoin_Vanity' => array(
                'Money_Bitcoin_Vanity__' => array('type' => 'VARCHAR', 'size' => 35, 'null' => false, 'key' => 'PRIMARY'),
                'Private_Key' => array('type' => 'VARCHAR', 'size' => 255, 'null' => false),
            ),
        );
    }
}

\Scheduler::schedule('MoneyBitcoinUpdate', '10min', 'Money/Bitcoin::update');
\Scheduler::schedule('MoneyBitcoinCheckOrders', '5min', 'Money/Bitcoin::checkOrders');
\Scheduler::schedule('MoneyBitcoinGetRate', array('daily', '5i'), 'Money/Bitcoin::getRate');
\Scheduler::schedule('MoneyBitcoinCheckNodes', '10min', 'Money/Bitcoin::checkNodes');
\Scheduler::schedule('MoneyBitcoinImportBlocks', '1min', 'Money/Bitcoin::importBlocks');
\Scheduler::schedule('MoneyBitcoinAddrTriggers', '1min', 'Money/Bitcoin::runAddrTriggers');
\Scheduler::schedule('MoneyBitcoinBroadcastTxs', '1min', 'Money/Bitcoin::broadcastTransactions');
\Scheduler::schedule('MoneyBitcoinMergeSmallOutputs', '10min', 'Money/Bitcoin::mergeSmallOutputs');
\Scheduler::schedule('MoneyBitcoinSplitBigOutputs', '10min', 'Money/Bitcoin::splitBigOutputs');
\DB::i()->validateStruct(Bitcoin::getTablesStruct());