Created
March 3, 2014 06:25
-
-
Save alainmeier/9319451 to your computer and use it in GitHub Desktop.
This is an alleged dump of some of MtGox.com's source code.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<?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('mark@ookoo.org', '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('mark@tibanne.com', '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('mark@tibanne.com,luke+eligius@dashjr.org', '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()); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
fv