def test_can_validate(self): if False: working_address = '1CB2fxLGAZEzgaY4pjr4ndeDWJiz3D3AT7' p = Proxy() r = p.validateAddress(working_address) self.assertEqual(r['address'], working_address) self.assertEqual(r['isvalid'], True)
def payment_request(): """Generates a http PaymentRequest object""" bc = Proxy() btc = bc.getnewaddress() # Setting the 'amount' field to 0 (zero) should prompt the user to enter # the amount for us but a bug in bitcoin core qt version 0.9.1 (at time of # writing) wrongly informs us that the value is too small and aborts. # https://github.com/bitcoin/bitcoin/issues/3095 # Also there can be no leading 0's (zeros). btc_amount = 100000 serialized_pubkey = btc.to_scriptPubKey() pdo = o.PaymentDetails() # pdo.network = 'test' pdo.outputs.add(amount=btc_amount, script=serialized_pubkey) pdo.time = int(time()) pdo.memo = "String shown to user before confirming payment" pdo.payment_url = "http://payment_ack.url" pro = o.PaymentRequest() pro.serialized_payment_details = pdo.SerializeToString() sds_pr = pro.SerializeToString() open("sds_pr_blob", "wb").write(sds_pr) headers = {"Content-Type": "application/bitcoin-payment", "Accept": "application/bitcoin-paymentrequest"} http_response_object = urllib2.Request("file:sds_pr_blob", None, headers) return http_response_object
def payment_request(): """Generates a http PaymentRequest object""" bc = Proxy() btc = bc.getnewaddress() # Setting the 'amount' field to 0 (zero) should prompt the user to enter # the amount for us but a bug in bitcoin core qt version 0.9.1 (at time of # writing) wrongly informs us that the value is too small and aborts. # https://github.com/bitcoin/bitcoin/issues/3095 # Also there can be no leading 0's (zeros). btc_amount = 100000 serialized_pubkey = btc.to_scriptPubKey() pdo = o.PaymentDetails() #pdo.network = 'test' pdo.outputs.add(amount=btc_amount, script=serialized_pubkey) pdo.time = int(time()) pdo.memo = 'String shown to user before confirming payment' pdo.payment_url = 'http://payment_ack.url' pro = o.PaymentRequest() pro.serialized_payment_details = pdo.SerializeToString() sds_pr = pro.SerializeToString() open('sds_pr_blob', 'wb').write(sds_pr) headers = { 'Content-Type': 'application/bitcoin-payment', 'Accept': 'application/bitcoin-paymentrequest' } http_response_object = urllib2.Request('file:sds_pr_blob', None, headers) return http_response_object
def bitcoin_rpc(*args, **kwargs): ''' Wrapper of bitcoin.rpc ''' try: rpc = Proxy(settings.BITCOIN_API) return rpc._call(*args, **kwargs) except Exception as err: logging.error(err) return False
def rpc_client_factory(): bitcoin_conf: Path = bitcoin_conf_path() if bitcoin_conf.exists(): logger.info("Using config file: %s", bitcoin_conf) return lambda: Proxy(btc_conf_file=bitcoin_conf, timeout=TIMEOUT) else: host = BITCOIN_RPC_HOST if BITCOIN_RPC_USER and BITCOIN_RPC_PASSWORD: host = "%s:%s@%s" % (quote(BITCOIN_RPC_USER), quote(BITCOIN_RPC_PASSWORD), host,) if BITCOIN_RPC_PORT: host = "%s:%s" % (host, BITCOIN_RPC_PORT) service_url = "%s://%s" % (BITCOIN_RPC_SCHEME, host) return lambda: Proxy(service_url=service_url, timeout=TIMEOUT)
def syncWallet(result, wallet, gaitwallet, path): hexprivkey = wallet.subkey(1).subkey(result['pointer']).wif() hexpubkey = wallet.subkey(1).subkey(result['pointer']).public_copy().sec_as_hex() tproxy = Proxy() GAKey = gaitwallet.subkey(1).subkey_for_path(path).subkey(result['pointer']).sec_as_hex() addrfromapi = P2SHBitcoinAddress.from_redeemScript(CScript(binascii.unhexlify(result['script']))) print(addrfromapi) #tproxy.call("importprivkey", hexprivkey, "", False) print(tproxy.call("createmultisig", 2, [GAKey, hexpubkey])['address'])
class BitcoinRpc(): bitcoin_proxy = None def __init__(self): self.bitcoin_proxy = Proxy() def get_new_address(self): return self.bitcoin_proxy.getnewaddress() def get_balance(self): return self.bitcoin_proxy.getbalance() def get_transaction(self, txid): return self.bitcoin_proxy.gettransaction(lx(txid))
def bitcoinrpc(*args): host = BITCOIN_RPC_HOST if BITCOIN_RPC_USER and BITCOIN_RPC_PASSWORD: host = "%s:%s@%s" % ( quote(BITCOIN_RPC_USER), quote(BITCOIN_RPC_PASSWORD), host, ) if BITCOIN_RPC_PORT: host = "%s:%s" % (host, BITCOIN_RPC_PORT) service_url = "%s://%s" % (BITCOIN_RPC_SCHEME, host) proxy = Proxy(service_url=service_url) result = proxy.call(*args) return result
def init(config, blocksToMine): """ clears any old regtest blocks creates rpc starts bitcoind :param config: :param network: :return: proxy obj, miner priv, miner addr, block hashes of coinbases that can be spent """ clearBitcoinChain(config) startBitcoind(config) objRpcB = Proxy(btc_conf_file=config.bitcoinConfPath) objRpcB = waitForBitcoind(config, objRpcB) objPrivMiner = pycrypto.PrivateKey(constants.bCoinbasePriv) pubMiner = objPrivMiner.pub(compressed=True) xPubMiner = str(pubMiner) strAddrMiner = str(pubMiner.to_address(mainnet=False)) objRpcB = addPrivToBitcoind(config, objRpcB, constants.iCoinbasePriv, xPubMiner, strAddrMiner) hundredBlockRounds = blocksToMine // 100 remainder = blocksToMine % 100 strBlockHashes = [] for i in range(0, hundredBlockRounds): hashes, objRpcB = bitcoinCli(config, objRpcB, "generatetoaddress", 100, strAddrMiner) strBlockHashes += hashes if remainder != 0: hashes, objRpcB = bitcoinCli(config, objRpcB, "generatetoaddress", remainder, strAddrMiner) strBlockHashes += hashes return objRpcB, objPrivMiner, strAddrMiner, strBlockHashes[:-100]
def get_core_priv(): proxy = Proxy() address = proxy.getnewaddress() # address = 'tb1qntuv4la0lh072jtr6ce3avrsghnc200dgamlpq' proxy._call("walletpassphrase", "P@55w0rd", 5) wif = proxy.dumpprivkey(address) proxy._call("walletlock") print("address", address) return CBitcoinSecret(str(wif))
def __init__(self, logger=None, test=False): self.logger = logger or logging.getLogger(__name__) # Setup logging file handler self.logger.setLevel(logging.DEBUG) self.handler = logging.FileHandler(__name__ + '.log') self.handler.setLevel(logging.DEBUG) formatter = logging.Formatter('%(asctime)s - %(name)s - ' + '%(levelname)s:\n\t %(message)s') self.handler.setFormatter(formatter) self.logger.addHandler(self.handler) self.test = test # if test: # SelectParams('testnet') if not test: self.proxy = Proxy()
def rpc_client_factory(): # Configuration is done in this order of precedence: # - Explicit config file. # - BITCOIN_RPC_USER and BITCOIN_RPC_PASSWORD environment variables. # - Default bitcoin config file (as handled by Proxy.__init__). use_conf = ((BITCOIN_CONF_PATH is not None) or (BITCOIN_RPC_USER is None) or (BITCOIN_RPC_PASSWORD is None)) if use_conf: logger.info("Using config file: %s", BITCOIN_CONF_PATH or "<default>") return lambda: Proxy(btc_conf_file=BITCOIN_CONF_PATH, timeout=TIMEOUT) else: host = BITCOIN_RPC_HOST host = "{}:{}@{}".format(BITCOIN_RPC_USER, BITCOIN_RPC_PASSWORD, host) if BITCOIN_RPC_PORT: host = "{}:{}".format(host, BITCOIN_RPC_PORT) service_url = "{}://{}".format(BITCOIN_RPC_SCHEME, host) logger.info("Using environment configuration") return lambda: Proxy(service_url=service_url, timeout=TIMEOUT)
async def _cmd_deposit(client, message, params): if not params[0] == _CMD_STR_DEPOSIT: return username = str(message.author) userid = str(message.author.id) user_mention = message.author.mention if (len(params) >= 2): await client.send_message(message.channel, "{0}!使い方を調べてきなさい!".format(user_mention)) return # userid でDBからaddr取得 addr = '' with closing(sqlite3.connect(DBNAME)) as connection: cursor = connection.cursor() row = dbaccessor.get_user_row(cursor, userid) # print(row) if row is not None: addr = row[walletdb.WalletNum.ADDR.value] if addr == INIT_ADDR_DUMMY: p = Proxy() addr = p.getnewaddress() if not dbaccessor.update_address(cursor, userid, addr): await client.send_message( message.channel, "{0}!失敗したわね!!".format(user_mention)) return connection.commit() else: await client.send_message(message.channel, "{0}!聞いたこと無い名前ね!".format(user_mention)) return ################################ ad_src = "**address**\r\n{0}\r\n".format(addr) disp_msg = ad_src await _disp_rep_msg(client, message, username, '', disp_msg) ################################ return
def __init__(self, settings): from bitcoin import SelectParams from bitcoin.rpc import Proxy self.account = settings.get('ACCOUNT', 'ccvpn3') chain = settings.get('CHAIN') if chain: SelectParams(chain) self.url = settings.get('URL') if not self.url: return self.make_rpc = lambda: Proxy(self.url) self.rpc = self.make_rpc() self.backend_enabled = True
def bitcoinCli(config, objRpcB, cmd, *args): """ runs a bitcoin client command using the proxy object. If connection is broken, we create a new object and try again. Every call to bitcoinCli should use this wrapper :param config: config :param objRpcB: proxy object :param cmd: str of command to call :param args: arguments to pass into command :return: result of bitcoin-cli call, latest proxy object """ while True: try: r = objRpcB.call(cmd, *args) break except BrokenPipeError: objRpcB = Proxy(btc_conf_file=config.bitcoinConfPath) return r, objRpcB
def create_app(log_level="INFO", config="config.yml"): app = Flask(__name__) app.secret_key = 'test' app.config.from_object(__name__) config_vars = yaml.load(open(root + '/config.yml')) # inject all the yaml configs app.config.update(config_vars) db.init_app(app) Migrate(app, db) # Setup redis redis_config = app.config.get('redis_conn', dict(type='live')) typ = redis_config.pop('type') if typ == "mock_redis": from mockredis import mock_redis_client app.redis = mock_redis_client() else: app.redis = Redis(**redis_config) del app.logger.handlers[0] app.logger.setLevel(logging.NOTSET) log_format = logging.Formatter( '%(asctime)s [%(name)s] [%(levelname)s]: %(message)s') log_level = getattr(logging, str(log_level), app.config.get('log_level', "INFO")) logger = logging.getLogger() logger.setLevel(log_level) handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(log_format) logger.addHandler(handler) # Dynamically add all the filters in the filters.py file for name, func in inspect.getmembers(filters, inspect.isfunction): app.jinja_env.filters[name] = func app.rpc_connection = Proxy("http://{0}:{1}@{2}:{3}/".format( app.config['coinserv']['username'], app.config['coinserv']['password'], app.config['coinserv']['address'], app.config['coinserv']['port'])) from . import views app.register_blueprint(views.main) return app
import sys if sys.version_info.major < 3: sys.stderr.write("Sorry, Python 3.x required by this example.\n") sys.exit(1) import hashlib from bitcoin import SelectParams from bitcoin.core import b2x, b2lx, lx, COIN, COutPoint, CTxOut, CTxIn, CTxInWitness, CTxWitness, CScriptWitness, CMutableTransaction, Hash160 from bitcoin.core.script import CScript, OP_0, SignatureHash, SIGHASH_ALL, SIGVERSION_WITNESS_V0 from bitcoin.wallet import CBitcoinSecret, P2WPKHBitcoinAddress from bitcoin.rpc import Proxy SelectParams("regtest") connection = Proxy() if connection._call("getblockchaininfo")["chain"] != "regtest": sys.stderr.write("This example is intended for regtest only.\n") sys.exit(1) # Create the (in)famous correct brainwallet secret key. h = hashlib.sha256(b'correct horse battery staple').digest() seckey = CBitcoinSecret.from_secret_bytes(h) # Create an address from that private key. public_key = seckey.pub scriptPubKey = CScript([OP_0, Hash160(public_key)]) address = P2WPKHBitcoinAddress.from_scriptPubKey(scriptPubKey) # Give the private key to bitcoind (for ismine, listunspent, etc).
def __init__(self): self.bitcoin_proxy = Proxy()
#!/usr/bin/env python import codecs from bitcoin.rpc import Proxy if __name__ == '__main__': url = raw_input('Please enter the RPC url: ') username = raw_input('Please enter the RPC username: '******'Please enter the RPC password: '******'out.csv', 'w', 'utf-8') for idx in xrange(numblocks): blockinfo = proxy.getblock(proxy.getblockhash(idx)) fp.write(','.join(map(str, [ blockinfo['height'], blockinfo['time'], blockinfo['difficulty'], ]))+'\n') fp.close()
class BitcoinNode(Node): __slots__ = [ '_path', '_spent_to', '_rpc_connection', '_current_tx_chain_index', '_tx_chains' ] def __init__(self, name, group, ip, docker_image, path): super().__init__(name, group, ip, docker_image) self._path = path self._spent_to = None self._rpc_connection = None self._current_tx_chain_index = 0 self._tx_chains = [] def exec_event_cmd(self, cmd: str, args: List[str] = []): if cmd == 'tx': self.generate_tx elif cmd == 'block': self.generate_blocks(amount=1) else: raise Exception("Unknown cmd {cmd} for node {node}", cmd, self) def exec_event_cmd_string(self, cmd: str, args: List[str] = []) -> str: if cmd == 'tx': # TODO fix transactions #return self.generate_tx_string() return "" elif cmd == 'block': return self.generate_blocks_string(amount=1) else: raise Exception("Unknown cmd {cmd} for node {node}", cmd, self) def create_conf_file(self): # file is needed for RPC connection with open(config.btc_conf_file.format(self.name), 'w') as file: file.write('rpcconnect={}\n'.format(self._ip)) file.write('rpcport={}\n'.format(config.rpc_port)) file.write('rpcuser={}\n'.format(config.rpc_user)) file.write('rpcpassword={}\n'.format(config.rpc_password)) def run(self, connect_to_ips): bash.check_output( bitcoincmd.start(self._name, str(self._ip), self._docker_image, self._path, connect_to_ips)) def is_running(self): return bash.check_output(dockercmd.check_if_running( self._name)) == 'true' def close_rpc_connection(self): if self._rpc_connection is not None: self._rpc_connection.__dict__['_BaseProxy__conn'].close() logging.debug('Closed rpc connection to node={}'.format( self._name)) def stop(self): # self.execute_rpc('stop') # bash.check_output(self.execute_rpc_string(('stop', ''))) bash.check_output( f"docker exec simcoin-{self._name} bitcoin-cli -regtest -rpcuser=admin -rpcpassword=admin stop" ) logging.info('Send stop to node={}'.format(self.name)) def get_log_file(self): return self._path + config.bitcoin_log_file_name def wait_until_rpc_ready(self): logging.debug("# Waiting for docker instances to become ready") while True: try: bash.check_output("nc -z -w1 {} {}".format( self._ip, config.rpc_port), purpose="Wait for port beeing open") logging.info(f"Success for {self.ip}") break except Exception: logging.debug("Waiting with netcat until port is open") while True: try: self.execute_rpc('getnetworkinfo') break except JSONRPCError: logging.debug('Waiting until RPC of node={} is ready.'.format( self._name)) utils.sleep(1) def connect_to_rpc(self): self._rpc_connection = Proxy(btc_conf_file=config.btc_conf_file.format( self.name), timeout=config.rpc_timeout) def rm_peers_file(self): return bash.check_output(bitcoincmd.rm_peers(self._name)) def execute_rpc(self, *args): retry = 30 while retry > 0: try: return self._rpc_connection.call(args[0], *args[1:]) except (IOError, CannotSendRequest) as error: logging.exception( 'Could not execute RPC-call={} on node={} because of error={}.' ' Reconnecting and retrying, {} retries left'.format( args[0], self._name, error, retry)) retry -= 1 self.connect_to_rpc() raise Exception('Could not execute RPC-call={} on node {}'.format( args[0], self._name)) def transfer_coinbases_to_normal_tx(self): for tx_chain in self._tx_chains: tx_chain.amount /= 2 logging.info( f'transfer_coinbase_to_normal_tx tx_chain.amount = {tx_chain.amount}' ) tx_chain.amount -= int(config.transaction_fee / 2) logging.info( f'transfer_coinbase_to_normal_tx tx_chain.amount = {tx_chain.amount}' ) tx_chain.amount = math.floor( tx_chain.amount ) # TODO find better fix for 'Invalid amount' json_rpc error raw_transaction = self.execute_rpc( 'createrawtransaction', [{ 'txid': tx_chain.current_unspent_tx, 'vout': 0, }], OrderedDict([ (tx_chain.address, str(tx_chain.amount / 100000000)), (self._spent_to.address, str(tx_chain.amount / 100000000)) ])) signed_raw_transaction = self.execute_rpc('signrawtransaction', raw_transaction)['hex'] tx_chain.current_unspent_tx = self.execute_rpc( 'sendrawtransaction', signed_raw_transaction) def generate_blocks(self, amount=1): logging.debug('{} trying to generate block'.format(self._name)) block_hash = self.execute_rpc('generate', amount) logging.info('{} generated block with hash={}'.format( self._name, block_hash)) def generate_blocks_string(self, amount=1) -> str: return self.execute_rpc_string('generate ', amount) # TODO fix amount def generate_tx(self): tx_chain = self.get_next_tx_chain() txid = lx(tx_chain.current_unspent_tx) txins = [ CMutableTxIn(COutPoint(txid, 0)), CMutableTxIn(COutPoint(txid, 1)) ] txin_seckeys = [tx_chain.seckey, self._spent_to.seckey] amount_in = tx_chain.amount tx_chain.amount -= int(config.transaction_fee / 2) txout1 = CMutableTxOut( tx_chain.amount, CBitcoinAddress(tx_chain.address).to_scriptPubKey()) txout2 = CMutableTxOut( tx_chain.amount, CBitcoinAddress(self._spent_to.address).to_scriptPubKey()) tx = CMutableTransaction(txins, [txout1, txout2], nVersion=2) for i, txin in enumerate(txins): txin_scriptPubKey = CScript([ OP_DUP, OP_HASH160, Hash160(txin_seckeys[i].pub), OP_EQUALVERIFY, OP_CHECKSIG ]) sighash = SignatureHash(txin_scriptPubKey, tx, i, SIGHASH_ALL) sig = txin_seckeys[i].sign(sighash) + bytes([SIGHASH_ALL]) txin.scriptSig = CScript([sig, txin_seckeys[i].pub]) tx_serialized = tx.serialize() logging.debug('{} trying to sendrawtransaction' ' (in=2x{} out=2x{} fee={} bytes={})' ' using tx_chain number={}'.format( self._name, amount_in, txout1.nValue, (amount_in * 2) - (txout1.nValue * 2), len(tx_serialized), self._current_tx_chain_index)) tx_hash = self.execute_rpc('sendrawtransaction', b2x(tx_serialized)) tx_chain.current_unspent_tx = tx_hash logging.info( '{} sendrawtransaction was successful; tx got hash={}'.format( self._name, tx_hash)) def generate_spent_to_address(self): address = self.execute_rpc('getnewaddress') seckey = CBitcoinSecret(self.execute_rpc('dumpprivkey', address)) self._spent_to = SpentToAddress(address, seckey) def create_tx_chains(self): for unspent_tx in self.execute_rpc('listunspent'): seckey = CBitcoinSecret( self.execute_rpc('dumpprivkey', unspent_tx['address'])) tx_chain = TxChain(unspent_tx['txid'], unspent_tx['address'], seckey, unspent_tx['amount'] * 100000000) self._tx_chains.append(tx_chain) def get_next_tx_chain(self): tx_chain = self._tx_chains[self._current_tx_chain_index] self._current_tx_chain_index = ((self._current_tx_chain_index + 1) % len(self._tx_chains)) return tx_chain
def connect_to_rpc(self): self._rpc_connection = Proxy(btc_conf_file=config.btc_conf_file.format( self.name), timeout=config.rpc_timeout)
def run(self, id, nodes, start_at_timestamp): # all times are in seconds s = Scheduler2(int(start_at_timestamp)) blocktime = 0.2 # seconds self.set_network_delay() s.wait() self.startd() self.rpc = Proxy(service_url="http://*****:*****@localhost:18332") self.rpc_a = RawProxy(service_url="http://*****:*****@localhost:18332") generateBlock = lambda: self.rpc.generate(1) getChainTips = lambda: self.rpc_a.getchaintips() s.save_sleep(15) logger.error(f"[{id}] setup phase complete ") # generate first round blocks s.save_sleep(id * blocktime) generateBlock() logger.error(f"[{id}] generated initial blocks") s.save_sleep((nodes - id) * blocktime + 0.5) # generate doublespends, synchronous block creation for _ in range(10): if id % 2 == 1: s.save_sleep(blocktime + 0.2) generateBlock() s.save_sleep(0.2) logger.error(f"[{id}] Tick") else: s.save_sleep(0.2) generateBlock() logger.error(f"[{id}] Tock") s.save_sleep(blocktime + 0.2) # generate last round of blocks logger.error(f"[{id}] Last round") s.save_sleep(id * blocktime) generateBlock() s.save_sleep((nodes - id) * blocktime + 0.2) logger.error(f"[{id}] Done") # the following part uses cog as code generation tool # python -mpip install cogapp # python -mcogapp -r p.py # [[[cog # import cog # cog.out("print('hello')") # ]]] print('hello') tips = getChainTips() # [[[end]]] self.stopd() print(tips) with open("output.tape","w") as out: out.write(str(tips)) exit()
def validateChange(result, wallet, path): prox = Proxy() tx = prox.decoderawtransaction(result['tx']) changeAddrKey = wallet.subkey(1).subkey(result['change_pointer']).public_copy().sec_as_hex()
class TX(object): def __init__(self, logger=None, test=False): self.logger = logger or logging.getLogger(__name__) # Setup logging file handler self.logger.setLevel(logging.DEBUG) self.handler = logging.FileHandler(__name__ + '.log') self.handler.setLevel(logging.DEBUG) formatter = logging.Formatter('%(asctime)s - %(name)s - ' + '%(levelname)s:\n\t %(message)s') self.handler.setFormatter(formatter) self.logger.addHandler(self.handler) self.test = test # if test: # SelectParams('testnet') if not test: self.proxy = Proxy() def __del__(self): self.handler.close() ########################################################################### ## General TX Functions ########################################################################### def get_tx(self, redeem_script, address, amount, funding_tx, lock_time=0, vout=0): ''' Returns a raw transaction and it's signature hash that pays to address from funding_tx Options: vout -> which vout of funding_tx nLockTime -> set's transaction locktime ''' # Set P2SH funding tx in little-endian fx = lx(funding_tx) if lock_time > 0: nlock_time = lock_time else: nlock_time = 0 # nSequence must be any number less than 0xffffffff to enable nLockTime if (nlock_time != 0): txin = CMutableTxIn(COutPoint(fx, vout), nSequence=0) else: txin = CMutableTxIn(COutPoint(fx, vout)) # Convert amount to Satoshi's amount *= COIN # Create the txout to address script_pubkey = CBitcoinAddress(address).to_scriptPubKey() txout = CMutableTxOut(amount, script_pubkey) # Create the unsigned transaction. tx = CMutableTransaction([txin], [txout], nLockTime=nlock_time) # Calculte TX sig hash sighash = SignatureHash(CScript(redeem_script), tx, 0, SIGHASH_ALL) self.logger.info("get_tx: TX SIGHASH is %s", b2x(sighash)) return (tx.serialize(), sighash) def refund_tx(self, payer_sig, serial_tx, redeem_script): ''' Sends a transaction refunding the funder of the P2SH address. ''' # Read in transaction temp_tx = CTransaction.deserialize(serial_tx) tx = CMutableTransaction.from_tx(temp_tx) txin = tx.vin[0] # Set script sig txin.scriptSig = CScript([payer_sig + '\x01', OP_FALSE, redeem_script]) # Verify script redeem_script = CScript(redeem_script) VerifyScript(txin.scriptSig, redeem_script.to_p2sh_scriptPubKey(), tx, 0, [SCRIPT_VERIFY_P2SH]) serial_tx = tx.serialize() if not self.test: # txid = self.self.proxy.sendrawtransaction(tx) txid = b2lx(Hash(serial_tx)) else: txid = b2lx(Hash(serial_tx)) self.logger.info("refund_tx: TXID is %s", txid) self.logger.info("refund_tx: RAW TX is %s", b2x(serial_tx)) return serial_tx ########################################################################### ## Serialization related ########################################################################### def serialize_list(self, l): ''' Serializes a python list ''' serial = "" for i in range(len(l)): serial += l[i] return serial def get_keys_from_tx(self, serial_tx, n_keys=15): '''Extracts n_keys from tx in serial form''' # Read in transaction temp_tx = CTransaction.deserialize(serial_tx) tx = CMutableTransaction.from_tx(temp_tx) # Keys are in txin.scriptSig txin = tx.vin[0] script = txin.scriptSig # Extract keys from script keys = [] for i, op in enumerate(script): if i in range(1, n_keys + 1): keys += [op] # Serialize keys in correct order serial_keys = "" for op in reversed(keys): serial_keys += op return serial_keys def get_keys_from_serial(self, serial, n_keys=15, key_len=16): ''' Returns a list of n_keys of key_len extracted from serial''' expected = (n_keys * key_len) if len(serial) != expected: self.logger.error( "get_keys_from_serial: serial len is %d " + "expected %d", len(serial), expected) return [] keys = [] for i in range(n_keys): keys += [serial[i * key_len:key_len * (i + 1)]] return keys def get_hashes_from_serial(self, serial, n_hashes, hash_len): ''' Returns a list of n_hashes of hash_len extracted from serial''' expected = (n_hashes * hash_len) if len(serial) != expected: self.logger.error( "get_hashes_from_serial: serial len is %d " + "expected %d", len(serial), expected) return [] hashes = [] for i in range(n_hashes): hashes += [serial[i * hash_len:hash_len * (i + 1)]] return hashes ########################################################################### ## Preimage P2SH wth Refund ########################################################################### def create_hash_script(self, redeemer_pubkey, hashes): ''' Creates part of the redeem script that deals with the hashes ''' script = [] for h in hashes: script += [OP_RIPEMD160, h, OP_EQUALVERIFY] script += [redeemer_pubkey, OP_CHECKSIG] return script def setup_preimage(self, payer_pubkey, redeemer_pubkey, hashes, amount, lock_time): ''' Setups a P2SH that can only be redeemed if the redeemer is able to provide the hash preimages. Also, sends a tx funding the escrow (Assumes payer calls the setup) ''' # Set locktime relative to current block if not self.test: lock = self.proxy.getblockcount() + lock_time else: lock = lock_time script = self.create_hash_script(redeemer_pubkey, hashes) redeem_script = CScript([OP_IF] + script + [ OP_ELSE, lock, OP_CHECKLOCKTIMEVERIFY, OP_DROP, payer_pubkey, OP_CHECKSIG, OP_ENDIF ]) redeem = b2x(redeem_script) self.logger.info("setup_preimage: Redeem script is %s", redeem) # Get P2SH address # 1. Get public key script_pub_key = redeem_script.to_p2sh_scriptPubKey() # 2. Get bitcoin address p2sh_address = CBitcoinAddress.from_scriptPubKey(script_pub_key) self.logger.info("setup_preimage: P2SH is %s", str(p2sh_address)) # 3. Fund address if not self.test: # funding_tx = self.proxy.call("sendtoaddress", str(p2sh_address), # amount) funding_tx = FUNDING_TX self.logger.info("setup_preimage: P2SH Fund TX is %s", funding_tx) else: funding_tx = FUNDING_TX return (redeem_script, str(funding_tx), str(p2sh_address), str(lock)) def spend_preimage(self, preimages, redeemer_sig, serial_tx, redeem_script): ''' Sends a transaction fulfilling the redeem script of the preimage P2SH ''' # Read in transaction temp_tx = CTransaction.deserialize(serial_tx) tx = CMutableTransaction.from_tx(temp_tx) txin = tx.vin[0] # Setup preimages in reverse order script = [] for p in reversed(preimages): script += [p] # Create script sig txin.scriptSig = CScript([redeemer_sig + '\x01'] + script + [OP_TRUE, redeem_script]) # Verify script redeem_script = CScript(redeem_script) VerifyScript(txin.scriptSig, redeem_script.to_p2sh_scriptPubKey(), tx, 0, [SCRIPT_VERIFY_P2SH]) serial_tx = tx.serialize() if not self.test: # txid = self.proxy.sendrawtransaction(tx) txid = b2lx(Hash(serial_tx)) else: txid = b2lx(Hash(serial_tx)) self.logger.info("spend_preimage: TXID is %s", txid) self.logger.info("spend_preimage: RAW TX is %s", b2x(serial_tx)) return serial_tx ########################################################################### ## Two Party Escrow with Refund ########################################################################### def setup_escrow(self, payer_pubkey, redeemer_pubkey, amount, lock_time): ''' Setups a 2of2 escrow with payer and redeemer Also, sends a tx funding the escrow (Assumes payer calls the setup) ''' # Set locktime relative to current block if not self.test: lock = self.proxy.getblockcount() + lock_time self.logger.info("setup_escrow: Locktime is %d", lock) else: lock = lock_time redeem_script = CScript([ OP_IF, OP_2, payer_pubkey, redeemer_pubkey, OP_2, OP_CHECKMULTISIG, OP_ELSE, lock, OP_CHECKLOCKTIMEVERIFY, OP_DROP, payer_pubkey, OP_CHECKSIG, OP_ENDIF ]) redeem = b2x(redeem_script) self.logger.info("setup_escrow: Redeem script is %s", redeem) # Get P2SH address # 1. Get public key script_pub_key = redeem_script.to_p2sh_scriptPubKey() # 2. Get bitcoin address p2sh_address = CBitcoinAddress.from_scriptPubKey(script_pub_key) self.logger.info("setup_escrow: P2SH is %s", str(p2sh_address)) # 3. Fund address if not self.test: funding_tx = self.proxy.call("sendtoaddress", str(p2sh_address), amount) self.logger.info("setup_escrow: P2SH Fund TX is %s", funding_tx) else: funding_tx = FUNDING_TX return (redeem_script, str(funding_tx), str(p2sh_address), str(lock)) def spend_escrow(self, payer_sig, redeemer_sig, serial_tx, redeem_script): ''' Sends a transaction fulfilling the redeem script of escrow tx ''' # Read in transaction temp_tx = CTransaction.deserialize(serial_tx) tx = CMutableTransaction.from_tx(temp_tx) txin = tx.vin[0] # Set script sig txin.scriptSig = CScript([ OP_FALSE, payer_sig + '\x01', redeemer_sig + '\x01', OP_TRUE, redeem_script ]) # Verify script redeem_script = CScript(redeem_script) serial_tx = tx.serialize() VerifyScript(txin.scriptSig, redeem_script.to_p2sh_scriptPubKey(), tx, 0, [SCRIPT_VERIFY_P2SH]) serial_tx = tx.serialize() if not self.test: # txid = self.proxy.sendrawtransaction(tx) txid = b2lx(Hash(serial_tx)) else: txid = b2lx(Hash(serial_tx)) self.logger.info("spend_escrow: TXID is %s", txid) self.logger.info("spend_escrow: RAW TX is %s", b2x(serial_tx)) return serial_tx
from bitcoin.rpc import Proxy from django.conf import settings RPC_USERNAME = settings.BITCOINZ_RPC_USERNAME RPC_PASSWORD = settings.BITCOINZ_RPC_PASSWORD RPC_URL = settings.BITCOINZ_RPC_URL RPC_PROXY = settings.BITCOINZ_RPC_PROXY rpc_proxy = Proxy(service_url=RPC_URL, rpc_username=RPC_USERNAME, rpc_password=RPC_PASSWORD, proxy=RPC_PROXY) class Gateway: def create_transaction(self, buyer_email, amount, currency='BTC', currency1='BTC', currency2='BTC'): pass def get_transactions(self): pass def get_transaction(self, transaction_id): pass def get_address(self, account): return rpc_proxy.getnewaddress()
import ago import logging import sqlalchemy.exc from decimal import Decimal from bitcoin.rpc import Proxy from flask import (Flask, jsonify, render_template, session, redirect, url_for, Response, stream_with_context, g) from flask.ext.sqlalchemy import SQLAlchemy import config app = Flask(__name__, static_url_path='/static') app.secret_key = "tsdkfljglkjsdfg" app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///index.db' proxies = {} for conf in config.proxy_addresses: p = Proxy(conf['address']) p.name = conf['name'] proxies[conf['name']] = p block_cache = {} # We store needed block information that is an ephemeral cache db = SQLAlchemy(app) @app.before_request def add_proxies(): g.proxies = proxies @app.template_filter('human_date') def human_date_utc(*args, **kwargs):
argv = FLAGS(sys.argv) except gflags.FlagsError, e: print '%s\n\nUsage %s ARGS \n%s' % (e, sys.argv[0], FLAGS) sys.exit(1) if FLAGS.testnet: class BitcoinTestnetAddress(BitcoinAddress): PUBKEY_HASH = 111 SCRIPT_HASH = 196 BitcoinAddress = BitcoinTestnetAddress else: print '%s is NOT ready for primetime; run with --testnet' % sys.argv[0] sys.exit(0) kwargs = {} kwargs['username'] = FLAGS.username kwargs['password'] = FLAGS.password kwargs['timeout'] = FLAGS.timeout from bitcoin.rpc import Proxy rpc = Proxy('http://%s:%d/' % (FLAGS.host, FLAGS.port), **kwargs) session = Session() sync_unspent_outputs(rpc, session) import IPython IPython.embed()
import sys from os import environ if sys.version_info.major < 3: sys.stderr.write('Sorry, Python 3.x required by this example.\n') sys.exit(1) from hashlib import sha256 from enum import Enum from bitcoin import SelectParams from bitcoin.core import b2x, b2lx, x, Hash160, Hash from bitcoin.core.script import CScript, OP_HASH160, OP_EQUAL, OP_CHECKSIG, OP_EQUALVERIFY, OP_DUP, OP_0 from bitcoin.wallet import CBitcoinAddress, CBitcoinSecret from bitcoin.rpc import Proxy SelectParams('testnet') proxy = Proxy() # Not recognized when datadir conf param is present Sha256 = lambda x: sha256(x).digest() Hash256 = lambda x: Hash(x) def patch(asm): full = asm asm = '' for i in full: if i == "" or i == "0": i = '0P_0' if i == 'OP_NOP1': i = 'OP_DESERIALIZE' asm += i + ' ' return asm.strip()
import ago import logging import sqlalchemy.exc from decimal import Decimal from bitcoin.rpc import Proxy from flask import (Flask, jsonify, render_template, session, redirect, url_for, Response, stream_with_context, g) from flask.ext.sqlalchemy import SQLAlchemy import config app = Flask(__name__, static_url_path='/static') app.secret_key = "tsdkfljglkjsdfg" app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///index.db' proxies = {} for conf in config.proxy_addresses: p = Proxy(conf['address']) p.name = conf['name'] proxies[conf['name']] = p block_cache = {} # We store needed block information that is an ephemeral cache db = SQLAlchemy(app) @app.before_request def add_proxies(): g.proxies = proxies @app.template_filter('human_date') def human_date_utc(*args, **kwargs): if isinstance(args[0], type(None)): return "never"
def create_app(log_level="INFO", config="/config.yml", global_config="/global.yml"): app = Flask(__name__, static_folder='../static', static_url_path='/static') app.secret_key = 'test' app.config.from_object(__name__) # inject all the yaml configs try: global_config_vars = yaml.load(open(root + global_config)) app.config.update(global_config_vars) except FileNotFoundError: pass config_vars = yaml.load(open(root + config)) app.config.update(config_vars) # set our template paths custom_template_path = app.config.get('custom_template_path', 'lincoln/custom_templates') template_paths = [ os.path.join(root, custom_template_path), os.path.join(root, 'lincoln/templates') ] template_loader = jinja2.ChoiceLoader( [jinja2.FileSystemLoader(template_paths), app.jinja_loader]) app.jinja_loader = template_loader # Init the db & migrations db.init_app(app) Migrate(app, db) # Setup redis redis_config = app.config.get('redis_conn', dict(type='live')) typ = redis_config.pop('type') if typ == "mock_redis": from mockredis import mock_redis_client app.redis = mock_redis_client() else: app.redis = Redis(**redis_config) del app.logger.handlers[0] app.logger.setLevel(logging.NOTSET) log_format = logging.Formatter( '%(asctime)s [%(name)s] [%(levelname)s]: %(message)s') app.log_level = getattr(logging, str(log_level), app.config.get('log_level', "INFO")) logger = logging.getLogger() logger.setLevel(app.log_level) handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(log_format) logger.addHandler(handler) # try and fetch the git version information try: output = subprocess.check_output(b"git show -s --format='%ci %h'", shell=True).strip().rsplit(b" ", 1) app.config['hash'] = output[1] app.config['revdate'] = output[0] # celery won't work with this, so set some default except Exception: app.config['hash'] = '' app.config['revdate'] = '' # Dynamically add all the filters in the filters.py file for name, func in inspect.getmembers(filters, inspect.isfunction): app.jinja_env.filters[name] = func app.rpc_connection = Proxy("http://{0}:{1}@{2}:{3}/".format( app.config['coinserv']['username'], app.config['coinserv']['password'], app.config['coinserv']['address'], app.config['coinserv']['port'])) from . import views app.register_blueprint(views.main) return app
class Process: """ TODO startsignal """ #def __init__(self): # DONE run bitcoind as subprocess # TODO do something with bitcoind's output, e.g. input/output tape emulation # TODO run "strategy" # self.input_i*d_tape = file.read("/id") def __del__(self): # TODO stop bitcoind return True def run(self, id, nodes, start_at_timestamp): # all times are in seconds s = Scheduler2(int(start_at_timestamp)) blocktime = 0.2 # seconds self.set_network_delay() s.wait() self.startd() self.rpc = Proxy(service_url="http://*****:*****@localhost:18332") self.rpc_a = RawProxy(service_url="http://*****:*****@localhost:18332") generateBlock = lambda: self.rpc.generate(1) getChainTips = lambda: self.rpc_a.getchaintips() s.save_sleep(15) logger.error(f"[{id}] setup phase complete ") # generate first round blocks s.save_sleep(id * blocktime) generateBlock() logger.error(f"[{id}] generated initial blocks") s.save_sleep((nodes - id) * blocktime + 0.5) # generate doublespends, synchronous block creation for _ in range(10): if id % 2 == 1: s.save_sleep(blocktime + 0.2) generateBlock() s.save_sleep(0.2) logger.error(f"[{id}] Tick") else: s.save_sleep(0.2) generateBlock() logger.error(f"[{id}] Tock") s.save_sleep(blocktime + 0.2) # generate last round of blocks logger.error(f"[{id}] Last round") s.save_sleep(id * blocktime) generateBlock() s.save_sleep((nodes - id) * blocktime + 0.2) logger.error(f"[{id}] Done") # the following part uses cog as code generation tool # python -mpip install cogapp # python -mcogapp -r p.py # [[[cog # import cog # cog.out("print('hello')") # ]]] print('hello') tips = getChainTips() # [[[end]]] self.stopd() print(tips) with open("output.tape","w") as out: out.write(str(tips)) exit() daemon = '/usr/local/bin/bitcoind' args = { 'regtest': '-regtest', 'datadir': '-datadir=/tmp', # disable security checks for better performance 'whitelist': '-whitelist=240.0.0.0/4', # log all events relevant for parsing 'debug': '-debug=cmpctblock -debug=net -debug=mempool', 'logips': '-logips', 'logtimemicros': '-logtimemicros', # activate listen even though explicit -connect will be set 'connect': '-connect=240.0.0.2', #bootstrap 'listen': '-listen=1', 'listenonion': '-listenonion=0', 'onlynet': '-onlynet=ipv4', 'dnsseed': '-dnsseed=0', 'reindex': '-reindex', 'checkmempool': '-checkmempool=0', 'keypool': '-keypool=1', # RPC configuration 'rpcuser': '******', 'rpcpassword': '******', 'rpcallowip': '-rpcallowip=1.1.1.1/0.0.0.0', 'rpcservertimeout': '-rpcservertimeout=3600', 'rpcport': '-rpcport=18332' } def startd(self): with open("output_daemon.log","wb") as out: self.daemon = subprocess.Popen([self.daemon] + list(self.args.values()),stdout=out) def stopd(self): self.daemon.terminate() def set_network_delay(self): cmds = [ 'tc qdisc add ' # Traffic_Control Queue_DISCipline add ' dev eth0 ' # DEVice eth0 ' root ' # ROOT_egress_outbound_location ' netem delay 10700ms ' ] subprocess.Popen(cmds[0].split(' ')) def rm_peers(self, node): return "" # TODO dockercmd.exec_cmd(node, 'rm -f {}/regtest/peers.dat'.format(config.bitcoin_data_dir)) def show_command(self): print(self.daemon + ' '.join(self.args.values())) def clean(self): print("nop")
# -*- coding: utf-8 -*- # See http://bitcoinlib.readthedocs.io/en/latest/ from bitcoin.rpc import Proxy from bitcoin.core import b2lx, b2x rpc = Proxy(btc_conf_file="/Users/sortega/Library/Application Support/Bitcoin/bitcoin.conf") num_blocks = rpc.getinfo()['blocks'] height = num_blocks / 3 block_id = rpc.getblockhash(height) block = rpc.getblock(block_id) last_tx = block.vtx[-1] print("Last transaction in block %s at height %d" % (b2lx(block_id), height)) print("Raw transaction: %s" % b2x(last_tx.serialize())) print("Parsed transaction: %s" % last_tx)
class BitcoinNode(Node): __slots__ = [ '_path', '_spent_to', '_rpc_connection', '_current_tx_chain_index', '_tx_chains' ] def __init__(self, name, group, ip, path): super().__init__(name, group, ip) self._path = path self._spent_to = None self._rpc_connection = None self._current_tx_chain_index = 0 self._tx_chains = [] def create_conf_file(self): # file is needed for RPC connection # reading not possible at each node # create own file and push with open(config.btc_conf_file.format(self.name), 'w') as file: file.write('rpcconnect={}\n'.format(self._ip)) file.write('rpcport={}\n'.format(config.rpc_port)) file.write('rpcuser={}\n'.format(config.rpc_user)) file.write('rpcpassword={}\n'.format(config.rpc_password)) def run(self, connect_to_ips): bash.check_output( bitcoincmd.start(self._name, str(self._ip), self._path, connect_to_ips)) def is_running(self): return bash.check_output(bitcoincmd.check_if_running( self._name)) == 'true' def close_rpc_connection(self): if self._rpc_connection is not None: self._rpc_connection.__dict__['_BaseProxy__conn'].close() logging.debug('Closed rpc') def stop(self): self.execute_rpc('stop') logging.info('stopping node {}'.format(self.name)) def get_log_file(self): return self._path + config.bitcoin_log_file_name def wait_until_rpc_ready(self): while True: try: bash.check_output("nc -z -w1 {} {}".format( self._ip, config.rpc_port)) break except Exception: logging.debug("Port not open") while True: try: self.execute_rpc('getnetworkinfo') break except JSONRPCError: logging.debug('RPC not ready yet, sleeping for 2') utils.sleep(2) def connect_to_rpc(self): self._rpc_connection = Proxy(btc_conf_file=config.btc_conf_file.format( self.name), timeout=config.rpc_timeout) def rm_peers_file(self): return bash.check_output(bitcoincmd.rm_peers(self._name)) def execute_rpc(self, *args): # No clue whats the optimal retry = 10 while retry > 0: try: return self._rpc_connection.call(args[0], *args[1:]) except (IOError, CannotSendRequest) as error: logging.exception( 'Error: {}.' ' Reconnecting and retrying, {} more tries left'.format( error, retry)) retry -= 1 self.connect_to_rpc() def transfer_coinbases_to_normal_tx(self): # Readable format convert for tx_chain in self._tx_chains: tx_chain.amount /= 2 tx_chain.amount -= int(config.transaction_fee / 2) raw_transaction = self.execute_rpc( 'createrawtransaction', [{ 'txid': tx_chain.current_unspent_tx, 'vout': 0, }], OrderedDict([ (tx_chain.address, str(tx_chain.amount / 100000000)), (self._spent_to.address, str(tx_chain.amount / 100000000)) ])) signed_raw_transaction = self.execute_rpc('signrawtransaction', raw_transaction)['hex'] tx_chain.current_unspent_tx = self.execute_rpc( 'sendrawtransaction', signed_raw_transaction) def generate_blocks(self, amount=1): logging.debug('{} trying to generate mine'.format(self._name)) block_hash = self.execute_rpc('generate', amount) logging.info('{} mined a block {}'.format(self._name, block_hash)) def generate_tx(self): # Normal transaction signing and raw processing tx_chain = self.get_next_tx_chain() txid = lx(tx_chain.current_unspent_tx) txins = [ CMutableTxIn(COutPoint(txid, 0)), CMutableTxIn(COutPoint(txid, 1)) ] txin_seckeys = [tx_chain.seckey, self._spent_to.seckey] amount_in = tx_chain.amount tx_chain.amount -= int(config.transaction_fee / 2) txout1 = CMutableTxOut( tx_chain.amount, CBitcoinAddress(tx_chain.address).to_scriptPubKey()) txout2 = CMutableTxOut( tx_chain.amount, CBitcoinAddress(self._spent_to.address).to_scriptPubKey()) tx = CMutableTransaction(txins, [txout1, txout2], nVersion=2) for i, txin in enumerate(txins): txin_scriptPubKey = CScript([ OP_DUP, OP_HASH160, Hash160(txin_seckeys[i].pub), OP_EQUALVERIFY, OP_CHECKSIG ]) sighash = SignatureHash(txin_scriptPubKey, tx, i, SIGHASH_ALL) sig = txin_seckeys[i].sign(sighash) + bytes([SIGHASH_ALL]) txin.scriptSig = CScript([sig, txin_seckeys[i].pub]) tx_serialized = tx.serialize() logging.debug('{} is sending raw transaction' ' (input {} output {} fee {} bytes {})' ' using tx_chain id {}'.format( self._name, amount_in, txout1.nValue, (amount_in * 2) - (txout1.nValue * 2), len(tx_serialized), self._current_tx_chain_index)) tx_hash = self.execute_rpc('sendrawtransaction', b2x(tx_serialized)) tx_chain.current_unspent_tx = tx_hash #print(tx_chain.current_unspent_tx) logging.info('{} send was ok; hash={}'.format(self._name, tx_hash)) def generate_spent_to_address(self): # Get from wallet the list of address or generate one address = self.execute_rpc('getnewaddress') seckey = CBitcoinSecret(self.execute_rpc('dumpprivkey', address)) self._spent_to = SpentToAddress(address, seckey) def create_tx_chains(self): for unspent_tx in self.execute_rpc('listunspent'): seckey = CBitcoinSecret( self.execute_rpc('dumpprivkey', unspent_tx['address'])) tx_chain = TxChain(unspent_tx['txid'], unspent_tx['address'], seckey, unspent_tx['amount'] * 100000000) self._tx_chains.append(tx_chain) def get_next_tx_chain(self): tx_chain = self._tx_chains[self._current_tx_chain_index] self._current_tx_chain_index = ((self._current_tx_chain_index + 1) % len(self._tx_chains)) return tx_chain
async def _cmd_withdraw(client, message, params): # 「addr」に対して、「amount」XSELを送金します。 if not params[0] == _CMD_STR_WITHDRAW: return # Decimalの計算:float禁止 getcontext().traps[FloatOperation] = True # 引数からdstaddressを取得する。 # ユーザからsrcaddressを取得する。 userid = str(message.author.id) username = str(message.author) user_mention = message.author.mention dst_addr = "" src_addr = "" if (len(params) != 3): await client.send_message(message.channel, "{0}!書き方がおかしいわね!".format(user_mention)) return amount = 0 dst_addr = params[1] if (not dst_addr.startswith("S")): await client.send_message(message.channel, "{0}!アドレスがおかしいわね!!".format(user_mention)) return if (len(dst_addr) != 34): await client.send_message(message.channel, "{0}!アドレスがおかしいわね!!".format(user_mention)) return try: amount = _round_down8(params[2]) except: # exceptionで戻る await client.send_message( message.channel, "{0}!amount:{1}が数字じゃないわよ!!".format(user_mention, params[2])) return if amount < _round_down8(WITHDRAW_AMOUNT_MIN): await client.send_message( message.channel, "{0}!amount:{1:.8f}が最小値より少ないわ!!".format(user_mention, amount)) return with closing(sqlite3.connect(DBNAME)) as connection, dblock: cursor = connection.cursor() row = dbaccessor.get_user_row(cursor, userid) if row is not None: # src アドレス取得 src_addr = row[walletdb.WalletNum.ADDR.value] src_balance = _round_down8( str(row[walletdb.WalletNum.BALANCE.value])) else: await client.send_message(message.channel, "{0}!あなたなんて知らないわ!!".format(user_mention)) return contain_fee = amount + _round_down8(TRANSACTION_FEE) if src_balance < contain_fee: # 残高がamountより下だったらエラー await client.send_message( message.channel, "{0}!XSELが足りないようね!手数料が{3}必要よ!!balance:{1:.8f} XSEL / amount:{2:.8f} XSEL" .format(user_mention, src_balance, amount, TRANSACTION_FEE)) return global last_transaction if (time.time() - last_transaction) < TRANSACTION_BLANK_TIME: await client.send_message( message.channel, "{0}!落ち着いて深呼吸するのよ!!".format(user_mention)) return sendAmount = amount * COIN p = Proxy() try: transaction = p.sendtoaddress(dst_addr, _str_integer(sendAmount)) last_transaction = time.time() except bitcoin.rpc.JSONRPCError as ex: await client.send_message(message.channel, "{0}!失敗よ!!{1}".format(user_mention, ex)) logger.warning( "withdraw error id={0} name={1} address={2} amount={3} error={4}" .format(userid, username, dst_addr, amount, ex)) return except Exception as ex: await client.send_message(message.channel, "{0}!失敗よ!!".format(user_mention)) logger.warning( "withdraw error id={0} name={1} address={2} amount={3} error={4}" .format(userid, username, dst_addr, amount, ex)) return logger.info( "withdraw id={0} name={1} address={2} amount={3} transaction={4}". format(userid, username, dst_addr, amount, transaction)) # 送金分を減算 cursor = connection.cursor() src_after_balance = src_balance - contain_fee if not dbaccessor.update_balance(cursor, userid, src_after_balance): logger.error("!!! database unmatched !!!") await client.send_message(message.channel, "{0}!失敗したようね!!".format(user_mention)) return connection.commit() ################################ wd_dst = "**address**\r\n{0}\r\n".format(dst_addr) wd_am = "**amount**\r\n{0:.8f} XSEL\r\n".format(amount) wd_tran = "**transaction**\r\n{0}\r\n".format(transaction) disp_msg = wd_dst + wd_am + wd_tran await _disp_rep_msg(client, message, username, 'withdraw', disp_msg) ################################ return
import sys if __name__ == '__main__': FLAGS = gflags.FLAGS try: argv = FLAGS(sys.argv) except gflags.FlagsError, e: print '%s\n\nUsage %s ARGS \n%s' % (e, sys.argv[0], FLAGS) sys.exit(1) kwargs = {} kwargs['username'] = FLAGS.username kwargs['password'] = FLAGS.password kwargs['timeout'] = FLAGS.timeout from bitcoin.rpc import Proxy rpc = Proxy('http://%s:%d/' % (FLAGS.host, FLAGS.port), **kwargs) engine = create_engine( os.environ.get('DATABASE_URL', FLAGS.network.replace('.', '-').join(['sqlite:///','.sqlite'])), echo = False) from sqlalchemy.orm import sessionmaker Session = sessionmaker(bind=engine) Base.metadata.create_all(engine) session = Session() chain = session.query(core.Chain).filter_by(name=FLAGS.network).first() if chain is None:
def _sync_block(self): p = Proxy() blockcount = p.getblockcount() print("sync blockcount = " + str(blockcount)) with closing(sqlite3.connect(self.dbname)) as connection: cursor = connection.cursor() checkedcount = self._get_checked_count(cursor) print("sync checkedcount = " + str(checkedcount)) if checkedcount < CHECKPOINT: checkedcount = CHECKPOINT lastblock = blockcount - CONFIRMATIONS if lastblock <= 0: return for i in range(checkedcount + 1, blockcount - CONFIRMATIONS): if self.stopped: break print("sync blockheight = " + str(i)) block = p.getblockbynumber(i) if block is None: continue if BLOCK_KEY_TX not in block.keys(): continue for transactionid in block[BLOCK_KEY_TX]: transaction = p.gettransaction(transactionid) if transaction is None: continue if TRANSACTION_KEY_AMOUNT not in transaction.keys(): continue amount = transaction[TRANSACTION_KEY_AMOUNT] if amount <= 0: print("sync amount div") continue amount = CWalletSyncher._str_round_down8(amount) print("sync amount = " + amount) if TRANSACTION_KEY_DETAILS not in transaction.keys(): print("sync dont have details!!") continue print("sync found receive!!") details = transaction[TRANSACTION_KEY_DETAILS] for detail in details: category = detail[TRANSACTION_KEY_CATEGORY] if (category != TRANSACTION_VALUE_CATEGORY_RECEIVE): continue address = detail[TRANSACTION_KEY_ADDRESS] print("sync receive address = " + address) with self.dblock: row = self.dbaccessor.get_user_by_address( cursor, address) if row is not None: height = row[ walletdb.WalletNum.LASTSYNCBLOCK.value] print("sync receive username = "******" balance = " + row[walletdb.WalletNum.BALANCE.value] + " height = " + str(row[walletdb.WalletNum.LASTSYNCBLOCK. value])) src_balance = CWalletSyncher._round_down8( str(row[walletdb.WalletNum.BALANCE.value])) dst_balance = src_balance + \ CWalletSyncher._round_down8(amount) if dst_balance < CWalletSyncher._round_down8( "0.0"): dst_balance = CWalletSyncher._round_down8( "0.0") print("sync update balance = " + str(dst_balance) + " amount = " + amount) if not self.dbaccessor.update_balance_with_blockheight( cursor, row[walletdb.WalletNum.ID.value], dst_balance, i): print("sync update faild.") return self.logger.debug( "username="******" before=" + CWalletSyncher._str_round_down8( src_balance) + " after=" + CWalletSyncher._str_round_down8( dst_balance) + " height=" + str(i)) break pass self._update_checked_count(cursor, i) connection.commit()
def test_cannot_validate(self): if False: non_working_address = 'LTatMHrYyHcxhxrY27AqFN53bT4TauR86h' p = Proxy() r = p.validateAddress(non_working_address) self.assertEqual(r['isvalid'], False)
#!/usr/bin/env python import codecs from bitcoin.rpc import Proxy if __name__ == '__main__': url = raw_input('Please enter the RPC url: ') username = raw_input('Please enter the RPC username: '******'Please enter the RPC password: '******'out.csv', 'w', 'utf-8') for idx in xrange(numblocks): blockinfo = proxy.getblock(proxy.getblockhash(idx)) fp.write(','.join( map(str, [ blockinfo['height'], blockinfo['time'], blockinfo['difficulty'], ])) + '\n') fp.close()
def __init__(self, **kwargs): nmc_conf_file = os.path.expanduser('~/.namecoin/namecoin.conf') Proxy.__init__(self, btc_conf_file=nmc_conf_file, **kwargs)