def main(): # rpc_user and rpc_password are set in the bitcoin.conf file rpc_connection = AuthServiceProxy("http://%s:%[email protected]:8332" % (rpc_user, rpc_password)) best_block_hash = rpc_connection.getbestblockhash() print(rpc_connection.getblock(best_block_hash)) # batch support : print timestamps of blocks 0 to 99 in 2 RPC round-trips: commands = [["getblockhash", height] for height in range(100)] block_hashes = rpc_connection.batch_(commands) blocks = rpc_connection.batch_([["getblock", h] for h in block_hashes]) block_times = [block["time"] for block in blocks] print(block_times)
def get_json_trans_from_rpc(block_number): # rpc_user and rpc_password are set in the bitcoin.conf file rpc_connection = AuthServiceProxy("http://%s:%[email protected]:8332" % ('yuval', 'yuval1')) print('block ', block_number) block_hash = rpc_connection.batch_([["getblockhash", block_number]]) print('block hash ', block_hash) block = rpc_connection.batch_([["getblock",i] for i in block_hash]) print('reading raw transactions') trans_hex = rpc_connection.batch_([["getrawtransaction", tx] for tx in block[0]['tx']]) #list print('decoding raw transactions') json_trans = rpc_connection.batch_([["decoderawtransaction", tx_hex] for tx_hex in trans_hex]) return [block[0]['height'],json_trans]
def update_bitcoin_other_info(): global bitcoin_blockchain_info global bitcoin_recent_blocks global bitcoin_peers global bitcoin_network_info global bitcoin_mempool global bitcoin_wallet_info if bitcoin_blockchain_info == None: # We still havent gotten the important info... wait 1 minute and return time.sleep(60) return True try: rpc_user = get_bitcoin_rpc_username() rpc_pass = get_bitcoin_rpc_password() rpc_connection = AuthServiceProxy("http://%s:%[email protected]:8332" % (rpc_user, rpc_pass), timeout=60) # Get other less important info try: # Recent blocks commands = [["getblockhash", height] for height in range(mynode_block_height - 9, mynode_block_height + 1)] block_hashes = rpc_connection.batch_(commands) bitcoin_recent_blocks = rpc_connection.batch_( [["getblock", h] for h in block_hashes]) # Get peers bitcoin_peers = rpc_connection.getpeerinfo() # Get network info bitcoin_network_info = rpc_connection.getnetworkinfo() # Get mempool bitcoin_mempool = rpc_connection.getmempoolinfo() # Get wallet info bitcoin_wallet_info = rpc_connection.getwalletinfo() except: pass except Exception as e: print "ERROR: In update_bitcoin_info - {}".format(str(e)) return False return True
def run(self, command, *args): try: rpc_connection = AuthServiceProxy( "http://%s:%s@%s:%s" % (self.rpc_user, self.rpc_password, self.rpc_host, self.rpc_port)) try: cmd_args = self._build_args(command, *args) response = rpc_connection.batch_(cmd_args) except JSONRPCException as e: return RPCAdapterResponse(None, e.message, e.code) return RPCAdapterResponse(response[0]) except Exception as e: message = 'Failed to run {} command'.format(command) self.log.error(message, e) raise RPCAdapterException(message)
def CallRPC(commands): global rpc_port global rrpc_user global rpc_password try: rpc_connection = AuthServiceProxy("http://%s:%[email protected]:%s" % (rpc_user, rpc_password, rpc_port)) print(f"connection: {rpc_connection}") result = rpc_connection.batch_(commands) print(f"Result type: {type(result)}") except JSONRPCException as json_exception: return "A JSON RPC Exception occured: " + str(json_exception) except Exception as general_exception: return "An Exception occured: " + str(general_exception) return result
def handle(self, *args, **options): rpc_user = '******' rpc_password = '******' rpc_connection = AuthServiceProxy("http://%s:%[email protected]:18443" % (rpc_user, rpc_password)) results = rpc_connection.batch_([['listunspent']]) unspents = results[0] for unspent in unspents: address = unspent["address"] amount = unspent["amount"] print('{}, {}'.format(unspent["address"], unspent["amount"])) try: order = Order.objects.get(address=address) except Order.DoesNotExist: continue if amount > order.amount or (order.amount - amount) / order.amount < 0.1: order.user.expire_date = add_months(order.user.expire_date, order.month) order.user.save(update_fields=["expire_date"]) order.delete()
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException import logging RPC_USER = '******' RPC_PASSWORD = '******' BITCOIN_SERVER = '127.0.0.1:8332' AUTHSERV = 'http://' + RPC_USER + ':' + RPC_PASSWORD + '@' + BITCOIN_SERVER print "AUTHSERV: %s" % (AUTHSERV) # set logging to debug logging.basicConfig() logging.getLogger("BitcoinRPC").setLevel(logging.DEBUG) # rpc_user and rpc_password are set in the bitcoin.conf file rpc_connection = AuthServiceProxy(AUTHSERV) best_block_hash = rpc_connection.getbestblockhash() print(rpc_connection.getblock(best_block_hash)) # batch support : print timestamps of blocks 0 to 99 in 2 RPC round-trips: commands = [["getblockhash", height] for height in range(100)] block_hashes = rpc_connection.batch_(commands) blocks = rpc_connection.batch_([["getblock", h] for h in block_hashes]) block_times = [block["time"] for block in blocks] print(block_times)
def update_bitcoin_other_info(): global mynode_block_height global bitcoin_blockchain_info global bitcoin_recent_blocks global bitcoin_recent_blocks_last_cache_height global bitcoin_peers global bitcoin_network_info global bitcoin_mempool global bitcoin_wallets while bitcoin_blockchain_info == None: # Wait until we have gotten the important info... # Checking quickly helps the API get started faster time.sleep(1) try: rpc_user = get_bitcoin_rpc_username() rpc_pass = get_bitcoin_rpc_password() rpc_connection = AuthServiceProxy("http://%s:%[email protected]:8332" % (rpc_user, rpc_pass), timeout=60) # Get other less important info try: # Recent blocks if mynode_block_height != bitcoin_recent_blocks_last_cache_height: commands = [["getblockhash", height] for height in range(mynode_block_height - 9, mynode_block_height + 1)] block_hashes = rpc_connection.batch_(commands) bitcoin_recent_blocks = rpc_connection.batch_( [["getblock", h] for h in block_hashes]) bitcoin_recent_blocks_last_cache_height = mynode_block_height # Get peers bitcoin_peers = rpc_connection.getpeerinfo() # Get network info bitcoin_network_info = rpc_connection.getnetworkinfo() # Get mempool bitcoin_mempool = rpc_connection.getmempoolinfo() # Get wallet info wallets = rpc_connection.listwallets() wallet_data = [] for w in wallets: wallet_name = urllib.pathname2url(w) wallet_rpc_connection = AuthServiceProxy( "http://%s:%[email protected]:8332/wallet/%s" % (rpc_user, rpc_pass, wallet_name), timeout=60) wallet_info = wallet_rpc_connection.getwalletinfo() wallet_data.append(wallet_info) bitcoin_wallets = wallet_data except: pass except Exception as e: print "ERROR: In update_bitcoin_info - {}".format(str(e)) return False return True
def generate_valid_source_tx( s: protocol.State, con: AuthServiceProxy, max_tx: int ) -> None: # Transmit enough funds to addresses so that we won't need # to use coinbase transactions. # There are at most MAX many transactions in one step. Hence, # we need at most that many different addresses. (We can always # use the change addresses because our transactions have nearly # no costs) num_addr = max_tx // 10 # We want at most 50 advertisements to use the # same address s.source_tx = [] start = con.getblockcount() + 1 con.generate(num_addr + 101) top = con.getblockcount() interval = range(start, top - 100) block_hashes = con.batch_([["getblockhash", h] for h in interval]) blocks = con.batch_([["getblock", ha, 2] for ha in block_hashes]) del block_hashes txs = [block['tx'][0] for block in blocks] del blocks sent_txs = [] i = 0 value = -1 txid = -1 n = -1 for tx in txs: for out in tx['vout']: if out['scriptPubKey']['type'] == 'pubkey': # The pubkey transactions are coinbase transactions because value = out['value'] txid = tx['txid'] n = out['n'] if value == -1 or txid == -1 or n == -1: raise RuntimeError("No coinbase transaction found.") addr = con.getnewaddress() sent_value = float(value) / 2 # create two addresses per transaction raw_tx = con.createrawtransaction([{'txid': txid, 'vout': n}], { addr: sent_value}) # The - is for the fees funded_tx = con.fundrawtransaction(raw_tx) signed_tx = con.signrawtransactionwithwallet(funded_tx["hex"]) if signed_tx["complete"] is False: raise RuntimeError( "bitcoind could not sign the transaction. (During " "Initialization)") txid = con.sendrawtransaction(signed_tx["hex"]) sent_txs.append(txid) i += 1 # Create a block each 100 transactions if i == 100: con.generate(1) i = 0 con.generate(1) txs = con.batch_([['getrawtransaction', txid, 1] for txid in sent_txs]) for tx in txs: for out in tx['vout']: vout = out['n'] s.source_tx.append(opreturn.Transaction(tx['txid'], vout)) c = 0 for utxo in s.source_tx: if not protocol.is_valid_utxo(utxo): c += 1 print("Found %d invalid utxos." % c)
conn = sqlite3.connect('txns.db') # Database c = conn.cursor() c.execute ("DROP TABLE IF EXISTS TXNS;") c.execute ("CREATE TABLE TXNS(ID INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, HASH TEXT NOT NULL, SIZE INTEGER NOT NULL, OUTPUTS INTEGER NOT NULL, INPUTS INTEGER NOT NULL);") best_block_hash = rpc_connection.getbestblockhash() info = rpc_connection.getinfo() chainheight= int(info["blocks"]) counter=chainheight-blockcount print "Chain Height:",chainheight print "Start Height:",counter while (counter < chainheight): blockrange = range(counter,counter+1000) commands = [ [ "getblockhash", int(height)] for height in blockrange ] block_hashes = rpc_connection.batch_(commands) blocks = rpc_connection.batch_([ [ "getblock", h ] for h in block_hashes ]) for block in blocks: txns = rpc_connection.batch_([ [ "getrawtransaction", tx, 1 ] for tx in block["tx"] ]) for rawtx in txns: c.execute("INSERT INTO TXNS (HASH, SIZE, OUTPUTS, INPUTS) VALUES (\"" +str(rawtx["txid"]) + "\", " + str(rawtx["size"]) + "," + str(len(rawtx["vout"]))+ ","+ str(len(rawtx["vin"]))+");") print "Txn inserted",str(rawtx["txid"]) if ((counter + 1000) > chainheight): counter = counter + (chainheight - counter) else: counter=counter+1000 conn.commit() conn.close()
import time import threading import sys from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException # RAW DATA CONFIGURATION rawdatafile="./rawdata.txt" # Read the file with open(rawdatafile) as f: txns = f.readlines() # Strip the lines txns = [x.strip() for x in txns] rpc_user="******" rpc_password="******" rpc_connection = AuthServiceProxy("http://%s:%[email protected]:28332"%(rpc_user, rpc_password)) # foreach tx in txns sendrawtransaction commands = [ [ "sendrawtransaction", tx] for tx in txns ] time0 = time.time() result = rpc_connection.batch_(commands) time1 = time.time() - time0 for res in result: print (str(res)) print (time1)
def pay(request, user_id, month): user = get_object_or_404(User, uuid=user_id) if month == 1: rmb = 15 price = '1个月/15元' elif month == 3: rmb = 45 price = '3个月/45元' elif month == 6: rmb = 90 price = '半年/90元' elif month == 12: rmb = 180 price = '一年/180元' else: raise Http404("Question does not exist") label = '小报童' message = '您的邮箱{},续订{}个月'.format(user.email, month) try: order = Order.objects.get(user=user, month=month) return render( request, 'pay.html', { 'user': user, 'btc_address': order.address, 'qr_message': "bitcoin:{}?amount={}&label={}&message={}".format( order.address, order.amount, label, message), 'new_expire_date': add_months(user.expire_date, month), 'price': price }) except Order.DoesNotExist: # create new order (user, month) -> (amount, address) contents = urllib.request.urlopen( "https://blockchain.info/tobtc?currency=CNY&value={}".format( rmb)).read() contents.decode("utf-8") amount = float(contents) rpc_user = '******' rpc_password = '******' rpc_connection = AuthServiceProxy("http://%s:%[email protected]:18443" % (rpc_user, rpc_password)) addresses = rpc_connection.batch_([['getnewaddress']]) address = addresses[0] order = Order(user=user, month=month, address=address, amount=amount) order.save() factory = qrcode.image.svg.SvgFillImage qr_message = "bitcoin:{}?amount={}&label={}&message={}".format( order.address, order.amount, label, message) img = qrcode.make(qr_message, image_factory=factory) path = STATIC_ROOT + 'payments/{}.svg'.format(order.address) if os.path.isfile(path): os.remove(path) for i in range(0, 10): time.sleep(.1) if not os.path.isfile(path): break if os.path.isfile(path): raise Http404("Question does not exist") img.save(path) for i in range(0, 10): time.sleep(.1) if os.path.isfile(path): new_expire_date = add_months(user.expire_date, month) return render( request, 'pay.html', { 'user': user, 'btc_address': order.address, 'qr_message': qr_message, 'new_expire_date': new_expire_date, 'price': price }) except: raise Http404('支付系统维护中,请耐心等待') raise Http404('支付系统维护中,请耐心等待')
class Process(): BCH_TO_SAT_MULTIPLIER = 100000000 def __init__(self, url='http://*****:*****@' #url += '{}:{}'.format(host, port) self.out = out self.api = API() if self.api.version.major != 0: raise ValueError('this version of the ORBIT API is not supported: {}'.format(self.orbit.version)) self.rpc = AuthServiceProxy(url, timeout=480) self.tokens = TokenDB(auto_commit=False) self.info = None def close(self): self.tokens.close() #self.rpc.close() def refresh(self): prev = None if self.info is not None: prev = self.info['blocks'] self.info = self.rpc.getblockchaininfo() if self.out: print('last BCH block sync: {}'.format(self.info['blocks']), file=self.out) self.last = self.tokens.get_last_block() if self.out: print('last ORBIT block sync: {}'.format(self.last), file=self.out) last = self.last if self.last else self.api.launched - 1 if self.out: print('blocks to sync: {}'.format(self.info['blocks'] - last), file=self.out) if self.info['blocks'] == prev: return False else: return True def get_info(self): if self.out: print("Collecting node information...", file=self.out) if self.out: print(file=self.out) if self.out: print(" ORBIT launch block: {}".format(self.api.launched), file=self.out) if self.out: print(file=self.out) if self.out: print('BCH node', file=self.out) info = self.rpc.getblockchaininfo() known = info['headers'] if self.out: print(" Last known block: {}".format(known), file=self.out) completed = info['blocks'] if self.out: print(" Last completed block: {}".format(completed), file=self.out) diff = known - completed if self.out: print(" Blocks to complete: {}".format(diff), file=self.out) pruned = info['pruned'] if self.out: print(" Pruned? {}".format(pruned), file=self.out) if pruned: prune = info['pruneheight'] if self.out: print(" Pruned at block: {}".format(prune), file=self.out) if self.out: print(file=self.out) if self.out: print('ORBIT node database', file=self.out) last = self.tokens.get_last_block() if self.out: print(' Last block sync: {}'.format(last), file=self.out) if not last: last = self.api.launched - 1 diff = completed - last if self.out: print(' Blocks to sync: {}'.format(diff), file=self.out) def _chunks(self, data, size): for i in range(0, len(data), size): yield data[i:i+size] def next(self): if not self.info: self.refresh() if self.last is None: cur = self.api.launched else: cur = self.last + 1 if cur > self.info['blocks']: if self.out: print('No more blocks', file=self.out) return None if self.out: print('processing block number {}'.format(cur), file=self.out) # FIXME check confirmations? blockhash = self.rpc.getblockhash(cur) block = self.rpc.getblock(blockhash) txcount = len(block['tx']) if self.out: print(' {} transaction{}...'.format(txcount, '' if txcount == 1 else 's'), end='', flush=True, file=self.out) # break into batches of 1,000 txs = [] txcount = 0 txhashes = self._chunks(block['tx'], 1000) for txbatch in txhashes: if self.info['pruned']: # requires a recent Bitcoin-ABC node that includes the patch for lookups by txhash and blockhash txs.extend(self.rpc.batch_([ [ "getrawtransaction", txhash, True, block['hash'] ] for txhash in txbatch ])) else: txs.extend(self.rpc.batch_([ [ "getrawtransaction", txhash, True ] for txhash in txbatch ])) txcount += len(txbatch) if self.out: print('{}...'.format(txcount), end='', flush=True, file=self.out) if self.out: print('validating...', file=self.out) blockrow = self.tokens.save_block(blockhash, cur) registrations = self.tokens.get_active_registrations_map(blockrow) for tx in txs: #if i % 5000 == 0: # if self.out: print('{}...'.format(i), end='', flush=True, file=self.out) txrow = None payments = [] for vout in tx['vout']: value = vout['value'] asmhex = vout['scriptPubKey']['hex'] if asmhex.startswith('6a'): # OP_RETURN try: # FIXME: proper pushdata op and length check orbit = self.api.parse(bytearray.fromhex(asmhex[4:])) # we skip the next byte too (pushdata) except ValueError as e: if self.out: print(" VOID {}: {}".format(tx['txid'], e), file=self.out) if orbit is not None: if self.out: print(" ORBIT @ {}".format(tx['txid']), file=self.out) if self.out: print(" Token Address: {}".format(orbit[0]), file=self.out) if self.out: print(" {}".format(orbit[1]), file=self.out) if txrow is None: txrow = self.save_tx_row(tx, blockrow) try: self.op(orbit[0], orbit[1], txrow, blockrow, registrations) except TokenError as e: # note that we don't rollback the sql transaction; we might want to re-evaluate the data later if self.out: print(" !--VOIDED: {}".format(e), file=self.out) elif value: addresses = vout['scriptPubKey']['addresses'] # because payments occur before OP_RETURN, we hold them to process after the vout loop payments.append([addresses, value]) for payment in payments: addresses = payment[0] value = payment[1] for address in addresses: if address in registrations: if len(addresses) > 1: raise ValueError('Not expecting multiple addresses for a transaction with value') if txrow is None: txrow = self.save_tx_row(tx, blockrow) regs_for_token = registrations[address] from_address = self.tokens.get_signer_address(txrow) reg_rowid = regs_for_token[from_address] self.tokens.registration_payment(txrow, blockrow, reg_rowid, value) self.tokens.process_advertisements(blockrow) orbit = self.tokens.hash(blockrow) if self.out: print(' -> {}'.format(orbit), file=self.out) self.tokens.set_last_block(cur) self.tokens.commit() self.last = cur return cur def save_tx_row(self, tx, blockrow): txrow = self.tokens.save_tx(tx['txid'], blockrow, tx['confirmations']) for txin in tx['vin']: self.tokens.save_txin(txin['txid'], txrow, txin['scriptSig']['hex']) for txout in tx['vout']: script = txout['scriptPubKey'] try: addresses = ','.join(script['addresses']) except KeyError: addresses = None self.tokens.save_txout(txrow, int(txout['value'] * self.BCH_TO_SAT_MULTIPLIER), script['type'], addresses, script['hex']) return txrow def op(self, address, op, txrow, blockrow, registrations): signer_address = self.tokens.get_signer_address(txrow) if not signer_address: raise ValueError("Unable to determine signer's address from transaction inputs") if op.admin() == True: if signer_address != address: raise TokenError("Operation requires admin but no proof of ownership for token address in transaction") elif op.admin() == False: if signer_address == address: raise TokenError("Operation may not be used by admin but transaction indicates proof of ownership for token address") if isinstance(op, allocation.Create): self.tokens.token_create(address, txrow, blockrow, op.supply, op.decimals, op.symbol, op.name, op.main_uri, op.image_uri) elif isinstance(op, allocation.Transfer): self.tokens.token_transfer(address, txrow, blockrow, signer_address, op.to, op.units) elif isinstance(op, advertisement.Advertise): self.tokens.token_advertise(address, txrow, blockrow, op.exchange_rate, op.units_avail, op.units_min, op.units_max, op.block_begin, op.block_end, op.block_deliver, op.preregister) elif isinstance(op, advertisement.Cancel): raise NotImplementedError() elif isinstance(op, advertisement.Register): rowid = self.tokens.token_register(address, txrow, blockrow, signer_address, op.units_max) if address in registrations: token_regs = registrations[address] else: token_regs = {} registrations[address] = token_regs if signer_address in token_regs: raise ValueError("Already have an active registration for this user and token") token_regs[signer_address] = rowid elif isinstance(op, advertisement.Unregister): rowid = self.tokens.token_unregister(address, txrow, blockrow, signer_address) else: raise ValueError("API version mismatch? Unsupported token operation: {}".format(type(op)))
script_dir = os.path.dirname(__file__) blocks = [] start_height = int(raw_input("Enter start height: ")) end_height = int(raw_input("Enter end height: ")) step = 10 #int(raw_input("Enter step size: ")) #integer division is being performed #start_height = ((start_height / step) * step) if ((end_height % step) != 0): end_height = (((end_height / step) + 1) * step) init = start_height for i in range(start_height + step, (end_height + 1), step): commands = [["getblockhash", height] for height in range(init, i)] block_hashes = rpc_connection.batch_(commands) #see for http rest batch processing support for hsh in block_hashes: #print hsh block = get_block_with_hash(hsh) blocks.append(block) f = open('JSONFiles/data%i.json' % i, 'w') json.dump(blocks, f, indent=4) f.close() blocks = [] print i init = i #assert isinstance(block, Block) '''block_list = BlockList(blocks)
def getBlockHeadersInRange(ctx, i, j): rpc_connection = AuthServiceProxy(getBitcoinClientURL(ctx)) commands = [["getblockhash", height] for height in range(i, j)] block_hashes = rpc_connection.batch_(commands) return block_hashes
def get_data_from_block_range(rpc_connection: authproxy.AuthServiceProxy, block_min: int, block_max: int, modulo: int, fuzzyness: int) -> list: """ Returns all data found in OP_RETURN transactions in the block range [block_min, block_max] as list of hex strings. Parameters ---------- rpc_connection : bitcoinrpc.authproxy.AuthServiceProxy The RPC connection to the bitcoind client block_min : int Lower block range bound (included) block_max : int Upper block range bound (included) modulo : int Consider only blocks that have b mod modulo = 0 fuzzyness : int Also consider a small intervall around above condition Returns ------- list A list of OpData tuples containing a hex string representing the data found and the block height it was found as well as the potential catena-like input and output """ interval = [ i for i in range(block_min, block_max + 1) if (i % modulo) <= fuzzyness ] block_hashes = rpc_connection.batch_([["getblockhash", h] for h in interval]) blocks = rpc_connection.batch_([["getblock", ha] for ha in block_hashes]) del block_hashes res = [] for b in blocks: merkle = b['merkleroot'] raw_txs = rpc_connection.batch_([["getrawtransaction", t] for t in b["tx"]]) txs = rpc_connection.batch_([["decoderawtransaction", r] for r in raw_txs]) for t in txs: for out in t["vout"]: if out["scriptPubKey"]["type"] == "nulldata": m_data = get_data_from_script_hex( out["scriptPubKey"]["hex"]) m_height = b["height"] # Catena continuation transaction is always FIRST input first_tx = t['vin'][0] m_input = _transaction_from_inputtx(first_tx) # This is the OP_RETURN output, but we want the # continuation output. Our transactions should always # have exactly two outputs, so we can simply "switch" vout = 1 if out["n"] == 0 else 0 m_output = Transaction(t['txid'], vout) op_data = OpData(m_data, m_height, m_input, m_output, merkle) res.append(op_data) return res
import binascii, leveldb from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException rpc_user = '******' rpc_password = '******' rpc = AuthServiceProxy("http://%s:%[email protected]:8332" % (rpc_user, rpc_password)) height = 0 block_hashes = [] block_count = rpc.getblockcount() while height < block_count: block_hashes.extend( rpc.batch_( [["getblockhash", height] for height in range(height, min([height + 10000, block_count]))])) height += 10000 print(len(block_hashes)) block_hashes = block_hashes[::-1] f = open("bloomfilters.bin", "wb") db = leveldb.LevelDB('./db') block_counter = 0 while len(block_hashes) > 0: print(block_counter) batch_hashes = [ block_hashes.pop() for x in range(min([100, len(block_hashes)])) ]
rpc_port = '8334' if len(sys.argv) > 1: rpc_port = sys.argv[1] if len(sys.argv) > 2: rpc_user = sys.argv[2] if len(sys.argv) > 3: rpc_password = sys.argv[3] print("Connected to port %s" % (rpc_port)) while True: rpc_connection = AuthServiceProxy("http://%s:%[email protected]:%s" % (rpc_user, rpc_password, rpc_port)) print("Getting Lotto") try: command = [["getluckyaddress"]] response = rpc_connection.batch_(command)[0] lucky_address = response['lucky_address'] owned_address = response['owned_address'] up_for_grabs = response['up_for_grabs'] print(response) if (owned_address == 'true' and up_for_grabs == 'true') or len(lucky_address) == 0: print("Sending generate command") command = [['generatetoaddress', 1, lucky_address]] response = rpc_connection.batch_(command)[0] print(response) except (KeyboardInterrupt): break except: time.sleep(1)
def setting(): p = 0 print "我们将会收取收益的5%作为费用,同意请按P,不同意请按下其他任意键:" info = raw_input() if info == "p" or info == "P": print "正在设置中………" if sett == 0: if os.makedirs("C:/WWS/date/COINNODE") : print "文件夹创建失败!请联系制作者2637037990 " print "程序异常 EXIT001" print "程序已关闭" os._exit(0) else: while p == 0 : print "请输入您的币种" coinname = raw_input() print "请确认您的币种叫做",coinname,"正确请输入Y" info = raw_input() print info if info == "Y"or info == "y" : f = open("C:/WWS/date/COINNODE/set.inf","w") f.write("#THIS IS WWS PROGRAM SET TXT DO NOT BREAK IT!") f.write("\n") f.write("[coinname] = '") f.write(coinname) f.write("'\n") p = 1 else: p = 0 while p == 1 : print "请输入钱包JSON-RPC IP地址(不包括端口)例:127.0.0.1" info = raw_input() ip = info print "请输入钱包JSON-RPC 端口 例:5201” info = raw_input() port = info print "请输入钱包JSON-RPC 用户名 : WWS" info = raw_input() username = info print "请输入钱包JSON-RPC 密码 : WWS@#$J!@TY#!Y@Ghgew" info = raw_input() password = info f.write("[ip] = '") f.write(ip) f.write("'\n") f.write("[port] = '") f.write(port) f.write("'\n") f.write("[username] = '") f.write(username) f.write("'\n") f.write("[password] = '") f.write(password) f.write("'\n") print "正在测试连接" rpc_connection = AuthServiceProxy("http://"+username+password+"@"+ip+":"+port) commands = [ [ "getblockhash", height] for height in range(100) ] block_hashes = rpc_connection.batch_(commands) blocks = rpc_connection.batch_([ [ "getblock", h ] for h in block_hashes ]) block_times = [ block["time"] for block in blocks ] if block_times > -1 : print"测试成功!!!!!!!!" f.write("[ip] = '") f.write(ip) f.write("'\n") f.write("[port] = '") f.write(port) f.write("'\n") f.write("[username] = '") f.write(username) f.write("'\n") f.write("[password] = '") f.write(password) f.write("'\n") p = 2 else: p = 1 print "对不起!测试失败,请重试!" else: print "正在读取配置文件中" f = open("C:/WWS/date/COINNODE/set.inf") z = 0 k = 0 read = "" while k == 0 : z = z + 1 line = f.readline() if z == 1 : if line != "#THIS IS WWS PROGRAM SET TXT DO NOT BREAK IT!\n": k = 1 print "数据遭到破坏!!!" read = read + line print read else: print "正在关闭程序………" print "进程关闭" os._exit(0)
def getBlocksInRange(ctx, i, j): block_hashes = getBlockHeadersInRange(ctx, i, j) rpc_connection = AuthServiceProxy(getBitcoinClientURL(ctx)) blocks = rpc_connection.batch_([["getblock", h] for h in block_hashes]) return blocks
class DaemonBTC: def __init__(self, url, timeout=90): self.rpc = AuthServiceProxy(url, timeout=timeout) def get_block(self, i): block = self.rpc.getblockhash(i) block_data = self.rpc.getblock(block) block_data['transactions'] = len(block_data['tx']) # Elasticsearch struggles with these as integers #block_data['chainwork_int'] = int(block_data['chainwork'], 16) block_data['difficulty'] = int(block_data['difficulty']) del (block_data['tx']) # Figure out how many coins moved value = 0 txs = self.get_block_transactions(i) # This is the data we need for value # txs[0]['vout'][0]['value'] for tx in txs: for vout in tx['vout']: if vout['scriptPubKey']['type'] == 'nonstandard': pass else: value = value + vout['value'] block_data['value'] = value return block_data def get_transaction(self, tx): rtx = self.rpc.getrawtransaction(tx) dtx = self.rpc.decoderawtransaction(rtx) return dtx def get_transactions(self, txs): rtx = self.rpc.batch_([["getrawtransaction", t] for t in txs]) dtx = self.rpc.batch_([["decoderawtransaction", t] for t in rtx]) return dtx def get_block_transactions(self, block): # The genesis block is special if block == 0: return [] blockhash = self.rpc.getblockhash(block) block_data = self.rpc.getblock(blockhash) transactions = [] rtx = self.rpc.batch_([["getrawtransaction", t] for t in block_data['tx']]) dtx = self.rpc.batch_([["decoderawtransaction", t] for t in rtx]) for tx in dtx: tx['height'] = block_data['height'] tx['block'] = block_data['hash'] tx['time'] = block_data['time'] # We can't use this data, let's get rid of it for i in tx['vin']: if 'scriptSig' in i: del (i['scriptSig']) for i in tx['vout']: if 'hex' in i['scriptPubKey']: del (i['scriptPubKey']['hex']) if 'asm' in i['scriptPubKey']: del (i['scriptPubKey']['asm']) transactions.append(tx) return transactions def get_block_transactions_bulk(self, block): "Return an iterable object for bulk transactions" transactions = self.get_block_transactions(block) tx = Transactions() for i in transactions: tx.add_transaction(i) return tx def get_blocks_bulk(self, blocks): rbh = self.rpc.batch_([["getblockhash", t] for t in blocks]) dbh = self.rpc.batch_([["get_block", t] for t in rbh]) output = [] for block_data in dbh: block_data['transactions'] = len(block_data['tx']) block_data['chainwork_int'] = int(block_data['chainwork'], 16) del (block_data['tx']) output.append(block_data) return output def get_max_block(self): return self.rpc.getblockcount()