def Mokestis():
p = RawProxy()
#txidd = input("Iveskite transakcija")
#txid = str(txidd)
txid = '0627052b6f28912f2703066a912ea577f2ce4da4caa5a5fbd8a57286c345c2f2'
raw_tx = p.getrawtransaction(txid)
decoded_tx = p.decoderawtransaction(raw_tx)
sumIn = 0
sumOut = 0
for output in decoded_tx['vin']:
vinTxId = output['txid']
raw_vintx = p.getrawtransaction(vinTxId)
decoded_vintx = p.decoderawtransaction(raw_vintx)
vin_vout = output['vout']
for out in decoded_vintx['vout']:
if (out['n'] == vin_vout):
sumIn += out['value']
for output in decoded_tx['vout']:
sumOut += output['value']
tx_fee = sumIn - sumOut
print("Transakcijos: ", txid)
print("mokestis: ", tx_fee, "BTC")
def get_utxo(index, txid):
p = RawProxy()
raw_tx = p.getrawtransaction(txid)
decoded_tx = p.decoderawtransaction(raw_tx)
outputs = decoded_tx['vout']
utxo = outputs[index]
return utxo['value']
def Brangiausia():
p = RawProxy()
txid = "4410c8d14ff9f87ceeed1d65cb58e7c7b2422b2d7529afc675208ce2ce09ed7d"
raw_tx = p.getrawtransaction(txid)
decoded_tx = p.decoderawtransaction(raw_tx)
sumIn = 0
sumOut = 0
for output in decoded_tx['vin']:
vinTxId = output['txid']
raw_vintx = p.getrawtransaction(vinTxId)
decoded_vintx = p.decoderawtransaction(raw_vintx)
vin_vout = output['vout']
for out in decoded_vintx['vout']:
if (out['n'] == vin_vout):
sumIn += out['value']
for output in decoded_tx['vout']:
sumOut += output['value']
tx_fee = sumIn - sumOut
print("Transakcijos: ", txid)
print("mokestis: ", tx_fee, "BTC")
def checkTrans():
transValue = 0
transId = raw_input("Enter transaction Id: ")
p = RawProxy()
trans = p.decoderawtransaction(p.getrawtransaction(transId))
for outputTrans in trans['vin']:
transIdLocal = outputTrans['txid']
vout = outputTrans['vout']
transLocal = p.decoderawtransaction(p.getrawtransaction(transIdLocal))
for outputTransLocal in transLocal['vout']:
if outputTransLocal['n'] == vout:
transValue = transValue + outputTransLocal['value']
for output in trans['vout']:
transValue = transValue - output['value']
print(transValue)
def find_transaction_fee():
p = RawProxy()
print('Iveskite pasirinktos transakcijos id')
txid = input_txid()
txinval = 0
txoutval = 0
try:
raw_tx = p.getrawtransaction(txid)
except Exception as e:
logging.error(traceback.format_exc())
globals.control = 0
return
decoded_tx = p.decoderawtransaction(raw_tx)
vins = decoded_tx['vin']
vouts = decoded_tx['vout']
for input in vins:
txinval = txinval + get_utxo(input['vout'], input['txid'])
for output in vouts:
txoutval = txoutval + output['value']
globals.control = 0
print('Transakcijos kaina:')
print(f'{txinval - txoutval} BTC')
return
class BlockThread(threading.Thread):
"""
A block, a thread.
"""
p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
mod_sqrt_power = (p + 1) // 4
def __init__(self, args=()):
super(BlockThread, self).__init__()
self.queue = args[0]
self.rpc_addr = args[1]
self.rpc_port = args[2]
self.proxy = None
self.nblock = 0
self._stop_event = threading.Event()
def init_rpc_co(self):
try:
if (self.rpc_addr):
self.proxy = RawProxy(service_url=self.rpc_addr, service_port=self.rpc_port)
else:
self.proxy = RawProxy(service_port=self.rpc_port)
except Exception as e:
perror("Unable to connect: " + str(e))
def modular_sqrt(self, a):
"""
Return n where n * n == a (mod p).
If no such n exists, an arbitrary value will be returned. From pycoin.
"""
return pow(a, self.mod_sqrt_power, self.p)
def get_y(self, x, sign):
"""
Get the Y coordinate from a compressed key.
-x: x coordinate
-sign: sign of Y
"""
y_squared = (x**3 + 7) % self.p
y = self.modular_sqrt(y_squared)
if (sign == "02" and y & 1) or (sign == "03" and not y & 1) :
return -y % self.p
else:
return y
def run(self):
while(1):
if self.stopped() and self.nblock == 0:
logging.info('%s Stopped', self.name)
break
if self.nblock:
self.init_rpc_co()
#logging.info('%s running with %s', self.name, self.nblock)
keys = []
bhash = self.proxy.getblockhash(self.nblock)
block = self.proxy.getblock(bhash)
for txid in block['tx']:
data = self._get_keys(txid, self.nblock)
if data == None or len(data) == 0:
continue
keys += data
keys = dict((x[2], x) for x in keys).values() # delete duplicates in list
for elt in keys:
if self.queue.full():
self.queue.join()
self.queue.put(elt)
self.nblock = 0
self.proxy.close()
self.proxy = None
return
def _get_keys(self, txid, block):
"""
Retrieve all keys from a transaction and construct a list according
to the db schema.
-txid: transaction id
-block: block number
"""
tx = self.proxy.getrawtransaction(txid)
tx_d = self.proxy.decoderawtransaction(tx)
keys = []
return_keys = []
for elt in tx_d['vin']:
if 'coinbase' in elt.keys():
continue
if 'txinwitness' in elt.keys():
tab = elt['txinwitness']
elif 'scriptSig' in elt.keys():
sc = elt['scriptSig']
tab = [x for x in sc['asm'].split(' ')]
#If there is a redeem script
rds = [x for x in tab if x[0] == '5']
if (len(rds) > 0):
for x in rds:
keys += [p for p in self.proxy.decodescript(x)['asm'].split(' ') if
p[0:2] in ['02', '03', '04']]
else:
keys += [p for p in tab if p[0:2] in ['02', '03', '04']]
for key in keys:
sign = key[:2]
if sign != "04":
#Because sometimes very strange keys, and also because
#there are "0"
if (len(key) < 60 or len(key) > 70): continue
sx = '0x' + key[2:].upper()
x = int(sx, 16)
y = self.get_y(x, sign)
sy = "%X" % y
#keys.append([tx, nblock, hash, ])
else:
if (len(key) < 120 or len(key) > 136): continue
sx = key[2:66].upper()
x = int(sx, 16)
sy = key[66:].upper()
y = int(sy, 16)
hash = P2PKHBitcoinAddress.from_pubkey(bytes.fromhex(key), 0)
return_keys.append([block, txid, str(hash), sx, sy])
return return_keys
def is_working(self):
"""
Return True if working.
"""
if self.nblock:
return True
else:
return False
def set_block(self, nblock):
"""
Set self.nblock.
-nblock: block number
"""
self.nblock = nblock
def stop(self):
self._stop_event.set()
def stopped(self):
return self._stop_event.is_set()
from bitcoin.rpc import RawProxy
p = RawProxy()
txid = str(raw_input("Enter transaction ID: "))
# decoding transaction by getting raw transaction
decoded_tx = p.decoderawtransaction(p.getrawtransaction(txid))
# counting total output value
total_out = 0
for output in decoded_tx['vout']:
total_out += output['value']
# counting total input value
total_in = 0
for input in decoded_tx['vin']:
x = p.decoderawtransaction(p.getrawtransaction(input['txid']))
for output in x['vout']:
total_in += output['value']
print("Total input: %f" % total_in)
print("Total output: %f" % total_out)
fee = total_in - total_out
print("Fee: %f" % fee)
from bitcoin.rpc import RawProxy
p = RawProxy()
trx = raw_input("Enter the ID of transaction: ")
# Uncomment the following line if need to check the special transaction.
# trx = "4410c8d14ff9f87ceeed1d65cb58e7c7b2422b2d7529afc675208ce2ce09ed7d"
# Gets raw trx in hex
rawTrx = p.getrawtransaction(trx)
# Decodes trx into a JSON object
decodedTrx = p.decoderawtransaction(rawTrx)
sumIn = 0
sumOut = 0
for input in decodedTrx['vin']:
vinTrxId = input['txid']
rawVinTrx = p.getrawtransaction(vinTrxId)
decodedVinTrx = p.decoderawtransaction(rawVinTrx)
vinOut = input['vout']
for output in decodedVinTrx['vout']:
if (vinOut == output['n']):
sumIn = sumIn + output['value']
for output in decodedTrx['vout']:
sumOut = sumOut + output['value']
print(sumIn - sumOut)
from bitcoin.rpc import RawProxy
p = RawProxy()
txid = str(raw_input("Enter transaction ID: "))
decoded_tx = p.decoderawtransaction(p.getrawtransaction(txid))
total_out = 0
for output in decoded_tx['vout']:
total_out += output['value']
total_in = 0
for input in decoded_tx['vin']:
out_index = input['vout']
input_tx = p.getrawtransaction(input['txid'])
decoded_input_tx = p.decoderawtransaction(input_tx)
total_in += decoded_input_tx['vout'][out_index]['value']
print("Total input: %f" % total_in)
print("Total output: %f" % total_out)
fee = total_in - total_out
print("Fee: %f" % fee)
from bitcoin.rpc import RawProxy
p = RawProxy()
txid = "0627052b6f28912f2703066a912ea577f2ce4da4caa5a5fbd8a57286c345c2f2"
raw_tx_in_hex = p.getrawtransaction(txid)
decoded_tx = p.decoderawtransaction(raw_tx_in_hex)
# print out
for data in decoded_tx['vout']:
print(data['scriptPubKey']['addresses'], data['value'])
from bitcoin.rpc import RawProxy
import sys
p = RawProxy()
# Alice's transaction ID
txid = sys.argv[1]
# First, retrieve the raw transaction in hex
raw_tx = p.getrawtransaction(txid)
# Decode the transaction hex into a JSON object
decoded_tx = p.decoderawtransaction(raw_tx)
outputValue=0
# Retrieve each of the outputs from the transaction
for output in decoded_tx['vout']:
outputValue+=output['value']
inputValue=0
for input in decoded_tx['vin']:
r_tx=p.getrawtransaction(input['txid'])
readable_tx=p.decoderawtransaction(r_tx)
voutas=input['vout']
for transakcija in readable_tx['vout']:
print(label0)
while index <= totalBlocks:
blockValue = 0
heightOfBlock = startBlock + index
blockHash = p.getblockhash(heightOfBlock)
block = p.getblock(blockHash)
transactions = block['tx']
for txid in transactions:
transactionValue = 0
rawTransactions = p.getrawtransaction(txid)
decoded_tx = p.decoderawtransaction(rawTransactions)
for output in decoded_tx['vout']:
transactionValue = transactionValue + output['value']
blockValue = blockValue + transactionValue
totalValue = totalValue + blockValue
if index == 0:
minimum = blockValue
if blockValue < minimum:
minimum = blockValue
if blockValue > maximum:
maximum = blockValue
import pprint
pp = pprint.PrettyPrinter(indent=1)
# Bitcoin Core에 접속한다.
p = RawProxy()
# MemPool에 있는 Tx 개수를 확인한다
mem = p.getmempoolinfo()
print("\n\nNumber of Tx :", mem['size'])
# MemPool에 있는Txid를 조회한다.
memTxid = p.getrawmempool()
# MemPool에 있는 Tx 데이터 10개 만 상세 데이터를 조회한다.
i = 0
for tx in memTxid:
# MemPool에 있는 Txid의 상세 데이터를 읽어온다.
memTx = p.getmempoolentry(tx)
rawTx = p.getrawtransaction(tx)
print("\nTXID :", tx)
pp.pprint(memTx)
print("\nRaw TX :")
print(rawTx)
i += 1
if i > 10:
break
# rawTx 데이터를 decode 한다
dTx = p.decoderawtransaction(rawTx)
print("\n\n")
pp.pprint(dTx)
from bitcoin.rpc import RawProxy
import sys
p = RawProxy()
txid = sys.argv[1]
raw_tx = p.getrawtransaction(txid)
decoded_tx = p.decoderawtransaction(raw_tx)
output_total = 0
for out in decoded_tx['vout']:
output_total += out['value']
input_value = 0
for input in decoded_tx['vin']:
input_txid = input['txid']
input_vout = input['vout']
raw_input_tx = p.getrawtransaction(input_txid)
decoded_input_tx = p.decoderawtransaction(raw_input_tx)
input_value += decoded_input_tx['vout'][input_vout]['value']
fee = input_value - output_total
print "Transaction's ", txid, " fee was ", fee, " BTC"
from bitcoin.rpc import RawProxy
p = RawProxy()
# Alice's transaction ID
txid = "0627052b6f28912f2703066a912ea577f2ce4da4caa5a5fbd8a57286c345c2f2"
# First, retrieve the raw transaction in hex
raw_tx = p.getrawtransaction(txid)
# Decode the transaction hex into a JSON object
decoded_tx = p.decoderawtransaction(raw_tx)
# Retrieve each of the outputs from the transaction
for output in decoded_tx['vout']:
print(output['scriptPubKey']['addresses'], output['value'])
# `pc_transaction.py` example
from bitcoin.rpc import RawProxy
p = RawProxy() #sujungimas
# Pavyzdinis ID: "4410c8d14ff9f87ceeed1d65cb58e7c7b2422b2d7529afc675208ce2ce09ed7d"
txid = input("Iveskite transakcijos ID\n")
# First, retrieve the raw transaction in hex - is pavyzdzio visa tranzakcijos info
raw_tx = p.getrawtransaction(txid)
# Decode the transaction hex into a JSON object - is pavyzdzio
decoded_tx = p.decoderawtransaction(raw_tx)
i_sum = [] #saugojimo kintamasis
what_got = 0
# Retrieve each of the outputs from the transaction
for output in decoded_tx['vout']:
i_sum.append(output['value']) #issaugo verte
print("Ka tranzakcijos gavejas gavo: ")
for ou in i_sum:
print(ou)
what_got += ou #ka gavo issaugo
whole_sum = 0 #bendra suma
# Calculating whole sum
for input in decoded_tx['vin']: #susumuojami visi pervedimai kuriuos atliko
out_index = input['vout']
from bitcoin.rpc import RawProxy
p = RawProxy()
txid = input("Iveskite tranaskcijos hash: ")
raw_tx = p.getrawtransaction(txid)
decoded_tx = p.decoderawtransaction(raw_tx)
tx_value = 0
for output in decoded_tx['vout']:
tx_value = tx_value + output['value']
print("Outputs: ", tx_value)
input_tx_value = 0
for input in decoded_tx['vin']:
if input.has_key('txid'):
index_of_tx = input['vout']
input_raw_tx = p.getrawtransaction(input['txid'])
input_decoded_tx = p.decoderawtransaction(input_raw_tx)
output_vout = input_decoded_tx['vout'][index_of_tx]
input_tx_value = input_tx_value + output_vout['value']
fee = input_tx_value - tx_value
else:
fee = 0
print("Inputs: ", input_tx_value)
print ("Transaction fee: ", fee)
from bitcoin.rpc import RawProxy
import pprint
p = RawProxy()
rawT = p.getrawtransaction(
"1c03c65d2a9f744c8b3ca5fe93096924b880c8ac10dbebf59531f5497bcb6eaa")
decoded_rawT = p.decoderawtransaction(rawT)
#goes through transactions and creates a list of dictionaries where each
#dictionary has the txid and vout# of each input
inputDict = {}
for x in decoded_rawT['vin']:
inputDict[x['txid']] = x['vout']
ADDLIST = []
#goes through inputDict, and adds the addresses to ADDLIST
for key in inputDict:
newAdd = findAddress(inputDict[key], key)
if newAdd not in ADDLIST:
ADDLIST.append(newAdd)
pprint.pprint(ADDLIST)
from bitcoin.rpc import RawProxy
p = RawProxy()
txid = raw_input("Write transaction id:")
raw_tx = p.getrawtransaction(txid)
decoded_tx = p.decoderawtransaction(raw_tx)
output = 0
for i in decoded_tx['vout']:
output += i['value']
print(txid)
value_first = 0
for value in decoded_tx['vin']:
value_txid = value['txid']
value_result = value['vout']
value_tx = p.getrawtransaction(value_txid)
decoded_value_tx = p.decoderawtransaction(value_tx)
value_first += decoded_value_tx['vout'][value_result]['value']
txfee = value_first - output
print(txfee)
from bitcoin.rpc import RawProxy
# Create a connection to local Bitcoin Core node
p = RawProxy()
TX_ID = input("Iveskite transakcijos ID:")
# TX_ID = 'd0bd3560694a1c2db52b8411b7a6d6557fde298528b97b30c27271f32c8abd5b'
try:
raw_tx = p.getrawtransaction(TX_ID)
decoded_tx = p.decoderawtransaction(raw_tx)
output_value = sum([i['value'] for i in decoded_tx['vout']])
# raw_tx_input = p.getrawtransaction(decoded_tx['vin'])
input_value = 0
for vin in decoded_tx['vin']:
vin_TX_ID = vin['txid']
vin_vout = vin['vout']
vin_tx = p.getrawtransaction(vin_TX_ID)
decoded_vin_tx = p.decoderawtransaction(vin_tx)
input_value += decoded_vin_tx['vout'][vin_vout]['value']
# raw_tx_input_id = decoded_tx['vin'][0]['vout']
# decoded_tx_input = p.decoderawtransaction(raw_tx_input)
# input_value = decoded_tx_input['vout'][raw_tx_input_id]['value']
# print(decoded_tx['vin'])
print(output_value, input_value)
from bitcoin.rpc import RawProxy
import sys, getopt
# Create a connection to local Bitcoin Core node
p = RawProxy()
# Retrieve the raw transaction by ID
txid = sys.argv[1]
raw_tx = p.getrawtransaction(txid)
# Decode the transaction
decoded_tx = p.decoderawtransaction(raw_tx)
# suranda output'o value
outputSum = 0
for output in decoded_tx['vout']:
# Add up the value of each output
outputSum += output['value']
# suranda input'u value
inputSum = 0
for input in decoded_tx['vin']:
rawInputTransaction = p.getrawtransaction(input['txid'])
InputTransaction = p.decoderawtransaction(rawInputTransaction)
index = input['vout'] # rodo kelintas vout'as praeitam output'e
tempVout = InputTransaction['vout']
specificVout = tempVout[index]
inputSum += specificVout['value']
print("Transakcijos mokestis: {} BTC".format(inputSum - outputSum))
from bitcoin.rpc import RawProxy
p = RawProxy()
txid = raw_input(
"Input your transactionID (just type \'no\' if you dont want to) -> ")
if txid == "no":
txid = "4410c8d14ff9f87ceeed1d65cb58e7c7b2422b2d7529afc675208ce2ce09ed7d"
tx_fee = 0
tx_input = 0
tx_output = 0
#decoce the transaction
raw_tx = p.getrawtransaction(txid)
decoded_tx = p.decoderawtransaction(raw_tx)
# calculate in value
for input in decoded_tx['vin']:
tx_prev = input['txid']
tx_prev_index = input['vout']
# get into prev transaction
tx_prev_decoded = p.decoderawtransaction(p.getrawtransaction(tx_prev))
tx_input = tx_input + tx_prev_decoded['vout'][tx_prev_index]['value']
print("Transaction input", tx_input)
# calculate out value
for output in decoded_tx['vout']:
tx_output = tx_output + output['value']
import sys
p = RawProxy()
if len(sys.argv) != 2:
print("Too many arguments or no transaction ID passed! ")
sys.exit()
# Alice's transaction ID
txid = str(sys.argv[1])
# First, retrieve the raw transaction in hex
raw_tx = p.getrawtransaction(txid)
# Decode the transaction hex into a JSON object
decoded_tx = p.decoderawtransaction(raw_tx)
s = 0
for output in decoded_tx['vin']:
vindex = output['vout']
raw_New = p.getrawtransaction(output['txid'])
decode_New = p.decoderawtransaction(raw_New)
for index, outp in enumerate(decode_New['vout']):
if index == vindex:
s=outp['value'] + s
s2 = 0
for output in decoded_tx['vout']:
s2+= output['value']
