def getAddressesBalance(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_ADDRESSES_BALANCE)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
response = []
for address in params[ADDRESSES]:
addrBalance = getAddressBalance(
id,
{
ADDRESS: address
}
)
response.append(
{
ADDRESS: address,
BALANCE: addrBalance
}
)
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def getBlockByNumber(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_BLOCK_BY_NUMBER)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
if not params[BLOCK_NUMBER].startswith('0x'):
blockNumber = hex(int(params[BLOCK_NUMBER]))
else:
blockNumber = params[BLOCK_NUMBER]
block = RPCConnector.request(RPC_ENDPOINT, id, GET_BLOCK_BY_NUMBER_METHOD, [blockNumber, True])
response = {
TRANSACTIONS: block[TRANSACTIONS]
}
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def getAddressUnspent(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_ADDRESS_UNSPENT)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
connResponse = RPCConnector.request(RPC_ELECTRUM_ENDPOINT, id, GET_ADDRESS_UNSPENT_METHOD, [params[ADDRESS]])
response = []
for tx in connResponse:
response.append(
{
TX_HASH: tx[TX_HASH_SNAKE_CASE],
VOUT: str(tx[TX_POS_SNAKE_CASE]),
STATUS:
{
CONFIRMED: tx[HEIGHT] != 0,
BLOCK_HEIGHT: str(tx[HEIGHT])
},
VALUE: str(tx[VALUE])
}
)
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def getTransactionReceipt(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_TRANSACTION_RECEIPT)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
response = RPCConnector.request(RPC_ENDPOINT, id, GET_TRANSACTION_RECEIPT_METHOD, [params[TX_HASH]])
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def getBlockByHash(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_BLOCK_BY_HASH)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
block = RPCConnector.request(RPC_CORE_ENDPOINT, id, GET_BLOCK_METHOD, [params[BLOCK_HASH], VERBOSITY_MORE_MODE])
err = rpcutils.validateJSONRPCSchema(block, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return block
def searchAddressesIntoBlock(data):
if not SubcriptionsHandler.coinInAddressSubscription():
#raise rpcErrorHandler.InternalServerError("No coin " + os.environ["COIN"] + " founded in ADDRESSES_SUBSCRIBED")
return
if not SubcriptionsHandler.getSubscriptionsAvailable():
#raise rpcErrorHandler.InternalServerError("No addresses subscribed for" + os.environ["COIN"])
return
reqParsed = None
try:
reqParsed = json.loads(data)
except Exception as e:
raise rpcErrorHandler.BadRequestError("Payload is not JSON message: " +
str(e))
params = reqParsed[rpcConstants.PARAMS]
blockNumber = params[rpcConstants.RESULT][NUMBER]
block = apirpc.getBlockByNumber(random.randint(1, sys.maxsize),
{BLOCK_NUMBER: blockNumber})
for address in SubcriptionsHandler.getSubscriptionsAvailable():
for transaction in block[TRANSACTIONS]:
if address == transaction[FROM] or address == transaction[TO]:
notifyThread = threading.Thread(target=notifyHandler,
args=(address, ),
daemon=True)
notifyThread.start()
def getTransaction(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_TRANSACTION)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
transactionRaw = RPCConnector.request(RPC_ELECTRUM_ENDPOINT, id, GET_TRANSACTION_METHOD, [params[TX_HASH]])
transaction = RPCConnector.request(RPC_CORE_ENDPOINT, id, DECODE_RAW_TRANSACTION_METHOD, [transactionRaw])
err = rpcutils.validateJSONRPCSchema(transaction, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return transaction
def subscribeAddressBalance(ws, id, params):
requestSchema = utils.getWSRequestMethodSchema(SUBSCRIBE_ADDRESS_BALANCE)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return SubcriptionsHandler.subscribe(utils.ensureHash(params[ADDRESS]), ws)
def broadcastTransaction(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(BROADCAST_TRANSACTION)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
transactionHash = RPCConnector.request(RPC_ENDPOINT, id, SEND_RAW_TRANSACTION_METHOD, [params[RAW_TRANSACTION]])
response = {
BROADCASTED: transactionHash
}
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def getTransactionCount(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_TRANSACTION_COUNT)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
count = RPCConnector.request(RPC_ENDPOINT, id, GET_TRANSACTION_COUNT_METHOD, [utils.ensureHash(params[ADDRESS]), PENDING if params[PENDING] else LATEST])
response = {
TRANSACTION_COUNT: count
}
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def getGasPrice(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_GAS_PRICE)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
gas = RPCConnector.request(RPC_ENDPOINT, id, GET_GAS_PRICE_METHOD, None)
response = {
GAS_PRICE: gas
}
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def notify(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(NOTIFY)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
payload = RPCConnector.request(RPC_ELECTRUM_ENDPOINT, id, NOTIFY_METHOD, [params[ADDRESS], params[CALLBACK_ENDPOINT]])
response = {
SUCCESS: payload
}
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def estimateGas(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(ESTIMATE_GAS)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
gas = RPCConnector.request(RPC_ENDPOINT, id, ESTIMATE_GAS_METHOD, [params[TX]])
response = {
ESTIMATED_GAS: gas
}
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def getBlockByHash(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_BLOCK_BY_HASH)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
block = RPCConnector.request(RPC_ENDPOINT, id, GET_BLOCK_BY_HASH_METHOD, [params[BLOCK_HASH], True])
response = {
TRANSACTIONS: block[TRANSACTIONS]
}
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def getTransactionHex(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_TRANSACTION_HEX)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
rawTransaction = RPCConnector.request(RPC_ELECTRUM_ENDPOINT, id, GET_TRANSACTION_METHOD, [params[TX_HASH]])
response = {
RAW_TRANSACTION: rawTransaction
}
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def subscribeAddressBalance(ws, id, params):
requestSchema = utils.getWSRequestMethodSchema(SUBSCRIBE_ADDRESS_BALANCE)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
if not SubcriptionsHandler.addressHasClients(params[ADDRESS]):
response = apirpc.notify(id, {
ADDRESS: params[ADDRESS],
CALLBACK_ENDPOINT: BITCOIN_CALLBACK_ENDPOINT
})
if not response[SUCCESS]:
raise rpcerrorhandler.BadRequestError("Can not subscribe " +
params[ADDRESS] + " to node")
return SubcriptionsHandler.subscribe(params[ADDRESS], ws)
def getHeight(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_HEIGHT)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
latestHash = RPCConnector.request(RPC_ENDPOINT, id, GET_BLOCK_BY_NUMBER_METHOD, [LATEST, True])
response = {
LATEST_BLOCK_INDEX: latestHash[NUMBER],
LATEST_BLOCK_HASH: latestHash[HASH]
}
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def broadcastTransaction(id, params):
requestSchema = utils.getRequestMethodSchema(BROADCAST_TRANSACTION)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
RPCConnector.request(RPC_CORE_ENDPOINT, id, SEND_RAW_TRANSACTION_METHOD, [params[RAW_TRANSACTION]])
return {}
def getAddressBalance(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_ADDRESS_BALANCE)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
connResponse = RPCConnector.request(RPC_ELECTRUM_ENDPOINT, id, GET_ADDRESS_BALANCE_METHOD, [params[ADDRESS]])
response = {
CONFIRMED: utils.convertToSatoshi(connResponse[CONFIRMED]),
UNCONFIRMED: utils.convertToSatoshi(connResponse[UNCONFIRMED])
}
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def getHeight(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_HEIGHT)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
latestBlockHeight = int(RPCConnector.request(RPC_CORE_ENDPOINT, id, GET_BLOCK_COUNT_METHOD, []))
latestBlockHash = RPCConnector.request(RPC_CORE_ENDPOINT, id, GET_BLOCK_HASH_METHOD, [latestBlockHeight])
response = {
LATEST_BLOCK_INDEX: latestBlockHeight,
LATEST_BLOCK_HASH: latestBlockHash
}
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def getBlockByNumber(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_BLOCK_BY_NUMBER)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
try:
blockNumber = int(params[BLOCK_NUMBER], base=10)
except Exception as err:
raise rpcerrorhandler.BadRequestError(str(err))
blockHash = RPCConnector.request(RPC_CORE_ENDPOINT, id, GET_BLOCK_HASH_METHOD,[blockNumber])
return getBlockByHash(
id,
{
BLOCK_HASH: blockHash
}
)
def getAddressBalance(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_ADDRESS_BALANCE)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
connLatest = RPCConnector.request(RPC_ENDPOINT, id, GET_BALANCE_METHOD, [utils.ensureHash(params[ADDRESS]), LATEST])
connPending = RPCConnector.request(RPC_ENDPOINT, id, GET_BALANCE_METHOD, [utils.ensureHash(params[ADDRESS]), PENDING])
response = {
CONFIRMED: connPending,
UNCONFIRMED: hex(int(connPending, 16) - int(connLatest, 16))
}
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def getTransaction(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_TRANSACTION)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
transaction = RPCConnector.request(RPC_ENDPOINT, id, GET_TRANSACTION_BY_HASH_METHOD, [params[TX_HASH]])
if transaction is None:
raise rpcerrorhandler.BadRequestError("Could not get transaction from node")
inputs = []
outputs = []
inputs.append(
{
ADDRESS: transaction[FROM],
AMOUNT: transaction[VALUE]
}
)
outputs.append(
{
ADDRESS: transaction[TO],
AMOUNT: transaction[VALUE]
}
)
response = {
TRANSACTION: transaction,
INPUTS: inputs,
OUTPUTS: outputs
}
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def getAddressHistory(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_ADDRESS_HISTORY)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
addrHistory = RPCConnector.request(RPC_ELECTRUM_ENDPOINT, id, GET_ADDRESS_HISTORY_METHOD, [params[ADDRESS]])
response = {
TX_HASHES: []
}
for item in addrHistory:
response[TX_HASHES].append(item[TX_HASH_SNAKE_CASE])
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def getTransactionCount(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_TRANSACTION_COUNT)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
txs = RPCConnector.request(RPC_ELECTRUM_ENDPOINT, id, GET_ADDRESS_HISTORY_METHOD, [params[ADDRESS]])
pending = 0
for tx in txs:
if tx[HEIGHT] == 0:
pending += 1
response = {
TRANSACTION_COUNT: str(pending) if params[PENDING] else str(len(txs) - pending)
}
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
def getFeePerByte(id, params):
requestSchema, responseSchema = utils.getMethodSchemas(GET_FEE_PER_BYTE)
err = rpcutils.validateJSONRPCSchema(params, requestSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
try:
confirmations = int(params[CONFIRMATIONS], base=10)
except ValueError as err:
raise rpcerrorhandler.BadRequestError(str(err))
feePerByte = RPCConnector.request(RPC_CORE_ENDPOINT, id, ESTIMATE_SMART_FEE_METHOD, [confirmations])
response = {
FEE_PER_BYTE: utils.convertToSatoshi(feePerByte[FEE_RATE])
}
err = rpcutils.validateJSONRPCSchema(response, responseSchema)
if err is not None:
raise rpcerrorhandler.BadRequestError(err.message)
return response
async def websocketServerHandler(request):
ws = ServerWebSocket()
await ws.websocket.prepare(request)
reqParsed = None
try:
async for msg in ws.websocket:
if msg.type == aiohttp.WSMsgType.TEXT:
reqParsed = rpcutils.parseRpcRequest(msg.data)
if reqParsed[rpcutils.METHOD] == "close":
await ws.websocket.close()
elif reqParsed[
rpcutils.METHOD] not in wsutils.webSocketMethods:
raise rpcErrorHandler.BadRequestError(
"WS Method not supported for " + os.environ['COIN'])
else:
payload = wsutils.webSocketMethods[reqParsed[
rpcutils.METHOD]](ws, reqParsed[rpcutils.ID],
reqParsed[rpcutils.PARAMS])
await ws.websocket.send_str(
json.dumps(
rpcutils.generateRPCResultResponse(
reqParsed[rpcutils.ID], payload)))
elif msg.type == aiohttp.WSMsgType.ERROR:
raise rpcErrorHandler.InternalServerError(
'ws connection closed with exception %s' %
ws.websocket.exception())
except rpcErrorHandler.Error as e:
await ws.websocket.send_str(
json.dumps(
rpcutils.generateRPCResultResponse(
reqParsed[rpcutils.ID] if reqParsed is not None else
rpcutils.UNKNOWN_RPC_REQUEST_ID, e.jsonEncode())))
SubcriptionsHandler.removeClient(ws)
return ws
