mirror of
https://github.com/aljazceru/python-teos.git
synced 2025-12-17 22:24:23 +01:00
95759793ba
bitcoin_cli as a global variable in the main __init__.py was creating issues related to http.client.CannotSendRequest: Request-sent and connection re-usage. Define a new connection per request.
262 lines
9.0 KiB
Python
262 lines
9.0 KiB
Python
import re
|
|
import os
|
|
import time
|
|
import json
|
|
import logging
|
|
import binascii
|
|
from threading import Thread
|
|
from flask import Flask, request, Response, abort
|
|
|
|
from pisa.rpc_errors import *
|
|
from test2.simulator.utils import sha256d
|
|
from pisa.tools import check_txid_format
|
|
from test2.simulator.transaction import TX
|
|
from test2.simulator.zmq_publisher import ZMQPublisher
|
|
from pisa.conf import FEED_PROTOCOL, FEED_ADDR, FEED_PORT
|
|
|
|
app = Flask(__name__)
|
|
HOST = 'localhost'
|
|
PORT = '18443'
|
|
|
|
TIME_BETWEEN_BLOCKS = 5
|
|
|
|
mempool = []
|
|
mined_transactions = {}
|
|
blocks = {}
|
|
blockchain = []
|
|
|
|
|
|
@app.route('/', methods=['POST'])
|
|
def process_request():
|
|
"""
|
|
process_requests simulates the bitcoin-rpc server run by bitcoind. The available commands are limited to the ones
|
|
we'll need to use in pisa. The model we will be using is pretty simplified to reduce the complexity of simulating
|
|
bitcoind:
|
|
|
|
Raw transactions: raw transactions will actually be transaction ids (txids). Pisa will, therefore, receive
|
|
encrypted blobs that encrypt ids instead of real transactions.
|
|
|
|
decoderawtransaction: querying for the decoding of a raw transaction will return a dictionary with a single
|
|
field: "txid", which will match with the txid provided in the request
|
|
|
|
sendrawtransaction: sending a rawtransaction will notify our mining simulator to include such transaction in a
|
|
subsequent block.
|
|
|
|
getrawtransaction: requesting a rawtransaction from a txid will return a dictionary containing a single field:
|
|
"confirmations", since rawtransactions are only queried to check whether a transaction has
|
|
made it to a block or not.
|
|
|
|
getblockcount: the block count will be get from the mining simulator by querying how many blocks have been
|
|
emited so far.
|
|
|
|
getblock: querying for a block will return a dictionary with a three fields: "tx" representing a list
|
|
of transactions, "height" representing the block height and "hash" representing the block
|
|
hash. Both will be got from the mining simulator.
|
|
|
|
getblockhash: a block hash is only queried by pisad on bootstrapping to check the network bitcoind is
|
|
running on.
|
|
|
|
getbestblockhash: returns the hash of the block in the tip of the chain
|
|
|
|
help: help is only used as a sample command to test if bitcoind is running when bootstrapping
|
|
pisad. It will return a 200/OK with no data.
|
|
"""
|
|
|
|
global mempool
|
|
request_data = request.get_json()
|
|
method = request_data.get('method')
|
|
|
|
response = {"id": 0, "result": 0, "error": None}
|
|
no_param_err = {"code": RPC_MISC_ERROR, "message": "JSON value is not a {} as expected"}
|
|
|
|
if method == "decoderawtransaction":
|
|
rawtx = get_param(request_data)
|
|
|
|
if isinstance(rawtx, str):
|
|
if TX.deserialize(rawtx) is not None:
|
|
response["result"] = {"txid": rawtx}
|
|
|
|
else:
|
|
response["error"] = {"code": RPC_DESERIALIZATION_ERROR, "message": "TX decode failed"}
|
|
|
|
else:
|
|
response["error"] = no_param_err
|
|
response["error"]["message"] = response["error"]["message"].format("string")
|
|
|
|
elif method == "sendrawtransaction":
|
|
# TODO: A way of rejecting transactions should be added to test edge cases.
|
|
rawtx = get_param(request_data)
|
|
|
|
if isinstance(rawtx, str):
|
|
if TX.deserialize(rawtx) is not None:
|
|
if rawtx not in list(mined_transactions.keys()):
|
|
mempool.append(rawtx)
|
|
|
|
else:
|
|
response["error"] = {"code": RPC_VERIFY_ALREADY_IN_CHAIN,
|
|
"message": "Transaction already in block chain"}
|
|
|
|
else:
|
|
response["error"] = {"code": RPC_DESERIALIZATION_ERROR, "message": "TX decode failed"}
|
|
|
|
else:
|
|
response["error"] = no_param_err
|
|
response["error"]["message"] = response["error"]["message"].format("string")
|
|
|
|
elif method == "getrawtransaction":
|
|
txid = get_param(request_data)
|
|
|
|
if isinstance(txid, str):
|
|
block = blocks.get(mined_transactions.get(txid))
|
|
|
|
if block:
|
|
response["result"] = {"confirmations": len(blockchain) - block.get('height')}
|
|
|
|
elif txid in mempool:
|
|
response["result"] = {"confirmations": 0}
|
|
|
|
else:
|
|
response["error"] = {'code': RPC_INVALID_ADDRESS_OR_KEY,
|
|
'message': 'No such mempool or blockchain transaction. Use gettransaction for '
|
|
'wallet transactions.'}
|
|
else:
|
|
response["error"] = no_param_err
|
|
response["error"]["message"] = response["error"]["message"].format("string")
|
|
|
|
print(response)
|
|
|
|
elif method == "getblockcount":
|
|
response["result"] = len(blockchain)
|
|
|
|
elif method == "getblock":
|
|
blockid = get_param(request_data)
|
|
|
|
if isinstance(blockid, str):
|
|
block = blocks.get(blockid)
|
|
|
|
if block:
|
|
block["hash"] = blockid
|
|
response["result"] = block
|
|
|
|
else:
|
|
response["error"] = {"code": RPC_INVALID_ADDRESS_OR_KEY, "message": "Block not found"}
|
|
|
|
else:
|
|
response["error"] = no_param_err
|
|
response["error"]["message"] = response["error"]["message"].format("string")
|
|
|
|
elif method == "getblockhash":
|
|
height = get_param(request_data)
|
|
|
|
if isinstance(height, int):
|
|
if 0 <= height <= len(blockchain):
|
|
response["result"] = blockchain[height]
|
|
|
|
else:
|
|
response["error"] = {"code": RPC_INVALID_PARAMETER, "message": "Block height out of range"}
|
|
else:
|
|
response["error"] = no_param_err
|
|
response["error"]["message"] = response["error"]["message"].format("integer")
|
|
|
|
elif method == "getbestblockhash":
|
|
response["result"] = blockchain[-1]
|
|
|
|
elif method == "help":
|
|
pass
|
|
|
|
else:
|
|
return abort(404, "Method not found")
|
|
|
|
return Response(json.dumps(response), status=200, mimetype='application/json')
|
|
|
|
|
|
def get_param(request_data):
|
|
param = None
|
|
|
|
params = request_data.get("params")
|
|
|
|
if isinstance(params, list) and len(params) > 0:
|
|
param = params[0]
|
|
|
|
return param
|
|
|
|
|
|
def load_data():
|
|
pass
|
|
|
|
|
|
def create_dummy_transaction(prev_tx_id=None, prev_out_index=None):
|
|
tx = TX()
|
|
|
|
if prev_tx_id is None:
|
|
prev_tx_id = os.urandom(32).hex()
|
|
|
|
if prev_out_index is None:
|
|
prev_out_index = 0
|
|
|
|
tx.version = 1
|
|
tx.inputs = 1
|
|
tx.outputs = 1
|
|
tx.prev_tx_id = [prev_tx_id]
|
|
tx.prev_out_index = [prev_out_index]
|
|
tx.nLockTime = 0
|
|
tx.scriptSig = ['47304402204e45e16932b8af514961a1d3a1a25fdf3f4f7732e9d624c6c61548ab5fb8cd410220181522ec8eca07de4860'
|
|
'a4acdd12909d831cc56cbbac4622082221a8768d1d0901']
|
|
tx.scriptSig_len = [77]
|
|
tx.nSequence = [4294967295]
|
|
tx.value = [5000000000]
|
|
tx.scriptPubKey = ['4104ae1a62fe09c5f51b13905f07f06b99a2f7159b2225f374cd378d71302fa28414e7aab37397f554a7df5f142c21c'
|
|
'1b7303b8a0626f1baded5c72a704f7e6cd84cac']
|
|
tx.scriptPubKey_len = [67]
|
|
|
|
return tx.serialize()
|
|
|
|
|
|
def simulate_mining():
|
|
global mempool, mined_transactions, blocks, blockchain
|
|
prev_block_hash = None
|
|
|
|
mining_simulator = ZMQPublisher(topic=b'hashblock', feed_protocol=FEED_PROTOCOL, feed_addr=FEED_ADDR,
|
|
feed_port=FEED_PORT)
|
|
|
|
while True:
|
|
block_hash = os.urandom(32).hex()
|
|
coinbase_tx = create_dummy_transaction()
|
|
coinbase_tx_hash = sha256d(coinbase_tx)
|
|
|
|
txs_to_mine = dict({coinbase_tx_hash: coinbase_tx})
|
|
|
|
if len(mempool) != 0:
|
|
# We'll mine up to 100 txs per block
|
|
for rawtx in mempool[:99]:
|
|
txid = sha256d(rawtx)
|
|
txs_to_mine[txid] = rawtx
|
|
|
|
mempool = mempool[99:]
|
|
|
|
# Keep track of the mined transaction (to respond to getrawtransaction)
|
|
for txid, tx in txs_to_mine.items():
|
|
mined_transactions[txid] = {"tx": tx, "block": block_hash}
|
|
|
|
blocks[block_hash] = {"tx": list(txs_to_mine.keys()), "height": len(blockchain),
|
|
"previousblockhash": prev_block_hash}
|
|
|
|
mining_simulator.publish_data(binascii.unhexlify(block_hash))
|
|
blockchain.append(block_hash)
|
|
prev_block_hash = block_hash
|
|
|
|
print("New block mined: {}".format(block_hash))
|
|
print("\tTransactions: {}".format(list(txs_to_mine.keys())))
|
|
|
|
time.sleep(TIME_BETWEEN_BLOCKS)
|
|
|
|
|
|
def run_simulator():
|
|
mining_thread = Thread(target=simulate_mining)
|
|
mining_thread.start()
|
|
|
|
# Setting Flask log to ERROR only so it does not mess with out logging
|
|
logging.getLogger('werkzeug').setLevel(logging.ERROR)
|
|
|
|
app.run(host=HOST, port=PORT)
|