from struct import unpack
import json
from .tools import *
from .address import PrivateKey, Address, PublicKey, ScriptAddress
from binascii import hexlify, unhexlify
[docs]class Transaction(dict):
def __init__(self, raw_tx=None, tx_format="decoded", version=1, lockTime=0, testnet=False):
assert tx_format in ("decoded", "raw")
self["format"] = tx_format
self["testnet"] = testnet
self["segwit"] = False
self["txId"] = None
self["hash"] = None
self["version"] = version
self["size"] = 0
self["vSize"] = 0
self["bSize"] = 0
self["lockTime"] = lockTime
self["vIn"] = dict()
self["vOut"] = dict()
self["rawTx"] = None
self["blockHash"] = None
self["confirmations"] = None
self["time"] = None
self["blockTime"] = None
self["blockIndex"] = None
self["coinbase"] = False
self["fee"] = None
self["data"] = None
self["amount"] = None
if raw_tx is None:
return
self["amount"] = 0
stream = self.get_stream(raw_tx)
start = stream.tell()
(self["version"],) = unpack('<L', stream.read(4))
n = read_var_int(stream)
sw = 0
sw_len = 0
if n == b'\x00':
sw = 1
self["flag"] = stream.read(1)
n = read_var_int(stream)
ic = var_int_to_int(n)
for k in range(ic):
self["vIn"][k] = dict()
self["vIn"][k]["txId"] = stream.read(32)
self["vIn"][k]["vOut"] = unpack('<L', stream.read(4))[0]
n = var_int_to_int(read_var_int(stream))
self["vIn"][k]["scriptSig"] = stream.read(n)
(self["vIn"][k]["sequence"],) = unpack('<L', stream.read(4))
for k in range(var_int_to_int(read_var_int(stream))):
self["vOut"][k] = dict()
self["vOut"][k]["value"] = unpack('<Q', stream.read(8))[0]
self["amount"] += self["vOut"][k]["value"]
self["vOut"][k]["scriptPubKey"] = stream.read(var_int_to_int(read_var_int(stream)))
s = parse_script(self["vOut"][k]["scriptPubKey"], sw)
self["vOut"][k]["nType"] = s["nType"]
self["vOut"][k]["type"] = s["type"]
if self["data"] is None:
if s["nType"] == 3:
self["data"] = s["data"]
if s["nType"] not in (3, 4, 7):
self["vOut"][k]["addressHash"] = s["addressHash"]
self["vOut"][k]["reqSigs"] = s["reqSigs"]
if sw:
sw = stream.tell() - start
for k in range(ic):
self["vIn"][k]["txInWitness"] = [stream.read(var_int_to_int(read_var_int(stream))) \
for c in range(var_int_to_int(read_var_int(stream)))]
sw_len = stream.tell() - sw + 2
self["lockTime"] = unpack('<L', stream.read(4))[0]
end = stream.tell()
stream.seek(start)
b = stream.read(end - start)
self["rawTx"] = b
self["size"] = end - start
self["bSize"] = end - start - sw_len
self["weight"] = self["bSize"] * 3 + self["size"]
self["vSize"] = math.ceil(self["weight"] / 4)
if ic == 1 and \
self["vIn"][0]["txId"] == b'\x00' * 32 and \
self["vIn"][0]["vOut"] == 0xffffffff:
self["coinbase"] = True
else:
self["coinbase"] = False
if sw:
self["segwit"] = True
self["hash"] = double_sha256(b)
self["txId"] = double_sha256(b[:4] + b[6:sw] + b[-4:])
else:
self["segwit"] = False
self["txId"] = double_sha256(b)
self["hash"] = self["txId"]
def decode(self, testnet=None):
if self["format"] == "decoded":
self.encode()
self["format"] = "decoded"
if testnet is not None:
self["testnet"] = testnet
if type(self["txId"]) == bytes:
self["txId"] = rh2s(self["txId"])
if "flag" in self:
if type(self["flag"]) == bytes:
self["flag"] = rh2s(self["flag"])
if type(self["hash"]) == bytes:
self["hash"] = rh2s(self["hash"])
if type(self["rawTx"]) == bytes:
self["rawTx"] = hexlify(self["rawTx"]).decode()
for i in self["vIn"]:
if type(self["vIn"][i]["txId"]) == bytes:
self["vIn"][i]["txId"] = rh2s(self["vIn"][i]["txId"])
if type(self["vIn"][i]["scriptSig"]) == bytes:
self["vIn"][i]["scriptSig"] = hexlify(self["vIn"][i]["scriptSig"]).decode()
try:
t = list()
for w in self["vIn"][i]["txInWitness"]:
if type(w) == bytes:
w = hexlify(w).decode()
t.append(w)
self["vIn"][i]["txInWitness"] = t
self["vIn"][i]["txInWitnessAsm"] = [decode_script(ws, 1) for ws in
self["vIn"][i]["txInWitness"]]
self["vIn"][i]["txInWitnessOpcodes"] = [decode_script(ws) for ws in
self["vIn"][i]["txInWitness"]]
except:
pass
try:
if type(self["vIn"][i]["addressHash"]) == bytes:
self["vIn"][i]["addressHash"] = hexlify(self["vIn"][i]["addressHash"]).decode()
sh = True if self["vIn"][i]["nType"] in (1, 5) else False
witness_version = None if self["vIn"][i]["nType"] < 5 else 0
self["vIn"][i]["address"] = hash_to_address(self["vIn"][i]["addressHash"],
self["testnet"],
sh,
witness_version)
except:
pass
if "scriptPubKey" in self["vIn"][i]:
if type(self["vIn"][i]["scriptPubKey"]) == bytes:
self["vIn"][i]["scriptPubKey"] = hexlify(self["vIn"][i]["scriptPubKey"]).decode()
self["vIn"][i]["scriptPubKeyOpcodes"] = decode_script(self["vIn"][i]["scriptPubKey"])
self["vIn"][i]["scriptPubKeyAsm"] = decode_script(self["vIn"][i]["scriptPubKey"], 1)
if "redeemScript" in self["vIn"][i]:
if type(self["vIn"][i]["redeemScript"]) == bytes:
self["vIn"][i]["redeemScript"] = hexlify(self["vIn"][i]["redeemScript"]).decode()
self["vIn"][i]["redeemScriptOpcodes"] = decode_script(self["vIn"][i]["redeemScript"])
self["vIn"][i]["redeemScriptAsm"] = decode_script(self["vIn"][i]["redeemScript"], 1)
if not self["coinbase"]:
if type(self["vIn"][i]["scriptSig"]) == bytes:
self["vIn"][i]["scriptSig"] = hexlify(self["vIn"][i]["scriptSig"]).decode()
self["vIn"][i]["scriptSigOpcodes"] = decode_script(self["vIn"][i]["scriptSig"])
self["vIn"][i]["scriptSigAsm"] = decode_script(self["vIn"][i]["scriptSig"], 1)
for i in self["vOut"]:
if type(self["vOut"][i]["scriptPubKey"]) == bytes:
self["vOut"][i]["scriptPubKey"] = hexlify(self["vOut"][i]["scriptPubKey"]).decode()
try:
if type(self["vOut"][i]["addressHash"]) == bytes:
self["vOut"][i]["addressHash"] = hexlify(self["vOut"][i]["addressHash"]).decode()
sh = True if self["vOut"][i]["nType"] in (1, 5) else False
witness_version = None if self["vOut"][i]["nType"] < 5 else 0
self["vOut"][i]["address"] = hash_to_address(self["vOut"][i]["addressHash"],
self["testnet"],
sh,
witness_version)
except:
pass
self["vOut"][i]["scriptPubKeyOpcodes"] = decode_script(self["vOut"][i]["scriptPubKey"])
self["vOut"][i]["scriptPubKeyAsm"] = decode_script(self["vOut"][i]["scriptPubKey"], 1)
if "data" in self:
if type(self["data"]) == bytes:
self["data"] = hexlify(self["data"]).decode()
return self
def encode(self):
if type(self["txId"]) == str:
self["txId"] = s2rh(self["txId"])
if "flag" in self:
if type(self["flag"]) == str:
self["flag"] = s2rh(self["flag"])
if type(self["hash"]) == str:
self["hash"] = s2rh(self["hash"])
if type(self["rawTx"]) == str:
self["rawTx"] = unhexlify(self["rawTx"])
for i in self["vIn"]:
if type(self["vIn"][i]["txId"]) == str:
self["vIn"][i]["txId"] = s2rh(self["vIn"][i]["txId"])
if type(self["vIn"][i]["scriptSig"]) == str:
self["vIn"][i]["scriptSig"] = unhexlify(self["vIn"][i]["scriptSig"])
try:
t = list()
for w in self["vIn"][i]["txInWitness"]:
if type(w) == str:
w = unhexlify(w)
t.append(w)
self["vIn"][i]["txInWitness"] = t
if "txInWitnessAsm" in self["vIn"][i]:
del self["vIn"][i]["txInWitnessAsm"]
if "txInWitnessOpcodes" in self["vIn"][i]:
del self["vIn"][i]["txInWitnessOpcodes"]
except:
pass
try:
if type(self["vIn"][i]["addressHash"]) == str:
self["vIn"][i]["addressHash"] = unhexlify(self["vIn"][i]["addressHash"])
if "address" in self["vIn"][i]:
del self["vIn"][i]["address"]
except:
pass
if "scriptSigAsm" in self["vIn"][i]:
del self["vIn"][i]["scriptSigAsm"]
if "scriptSigOpcodes" in self["vIn"][i]:
del self["vIn"][i]["scriptSigOpcodes"]
for i in self["vOut"]:
if type(self["vOut"][i]["scriptPubKey"]) == str:
self["vOut"][i]["scriptPubKey"] = unhexlify(self["vOut"][i]["scriptPubKey"])
try:
if type(self["vOut"][i]["addressHash"]) == str:
self["vOut"][i]["addressHash"] = unhexlify(self["vOut"][i]["addressHash"])
if "address" in self["vOut"][i]:
del self["vOut"][i]["address"]
except:
pass
if "scriptPubKeyOpcodes" in self["vOut"][i]:
del self["vOut"][i]["scriptPubKeyOpcodes"]
if "scriptPubKeyAsm" in self["vOut"][i]:
del self["vOut"][i]["scriptPubKeyAsm"]
if "data" in self:
if type(self["data"]) == str:
self["data"] = unhexlify(self["data"])
self["format"] = "raw"
return self
def get_stream(self, stream):
if type(stream) != io.BytesIO:
if type(stream) == str:
stream = unhexlify(stream)
if type(stream) == bytes:
stream = io.BytesIO(stream)
else:
raise TypeError
return stream
def serialize(self, segwit=True, hex=True):
chunks = []
chunks.append(struct.pack('<L', self["version"]))
if segwit and self["segwit"]:
chunks.append(b"\x00\x01")
chunks.append(int_to_var_int(len(self["vIn"])))
for i in self["vIn"]:
if type(self["vIn"][i]['txId']) == bytes:
chunks.append(self["vIn"][i]['txId'])
else:
chunks.append(s2rh(self["vIn"][i]['txId']))
chunks.append(struct.pack('<L', self["vIn"][i]['vOut']))
if type(self["vIn"][i]['scriptSig']) == bytes:
chunks.append(int_to_var_int(len(self["vIn"][i]['scriptSig'])))
chunks.append(self["vIn"][i]['scriptSig'])
else:
chunks.append(int_to_var_int(int(len(self["vIn"][i]['scriptSig']) / 2)))
chunks.append(unhexlify(self["vIn"][i]['scriptSig']))
chunks.append(struct.pack('<L', self["vIn"][i]['sequence']))
chunks.append(int_to_var_int(len(self["vOut"])))
for i in self["vOut"]:
chunks.append(struct.pack('<Q', self["vOut"][i]['value']))
if type(self["vOut"][i]['scriptPubKey']) == bytes:
chunks.append(int_to_var_int(len(self["vOut"][i]['scriptPubKey'])))
chunks.append(self["vOut"][i]['scriptPubKey'])
else:
chunks.append(int_to_var_int(int(len(self["vOut"][i]['scriptPubKey']) / 2)))
chunks.append(unhexlify(self["vOut"][i]['scriptPubKey']))
if segwit and self["segwit"]:
for i in self["vIn"]:
chunks.append(int_to_var_int(len(self["vIn"][i]['txInWitness'])))
for w in self["vIn"][i]['txInWitness']:
if type(w) == bytes:
chunks.append(int_to_var_int(len(w)))
chunks.append(w)
else:
chunks.append(int_to_var_int(int(len(w) / 2)))
chunks.append(unhexlify(w))
chunks.append(struct.pack('<L', self['lockTime']))
tx = b''.join(chunks)
return tx if not hex else hexlify(tx).decode()
def json(self):
try:
return json.dumps(self)
except:
pass
return json.dumps(self.decode())
def add_input(self, tx_id=None, v_out=0, sequence=0xffffffff,
script_sig=b"", tx_in_witness=None, amount=None,
script_pub_key=None, address=None, private_key=None):
if tx_id is None:
tx_id = b"\x00" * 32
v_out = 0xffffffff
assert v_out == 0xffffffff and sequence == 0xffffffff
assert not self["vIn"]
if type(tx_id) == str:
tx_id = s2rh(tx_id)
if type(script_sig) == str:
script_sig = unhexlify(script_sig)
assert type(tx_id) == bytes
assert len(tx_id) == 32
assert type(v_out) == int
assert v_out <= 0xffffffff and v_out >= 0
assert type(sequence) == int
assert sequence <= 0xffffffff and sequence >= 0
assert type(script_sig) == bytes
assert len(script_sig) <= 520
if private_key:
if type(private_key) != PrivateKey:
private_key = PrivateKey(private_key)
if amount:
assert type(amount) == int
assert amount >= 0 and amount <= MAX_AMOUNT
if tx_in_witness:
assert type(tx_in_witness) == list
l = 0
witness = []
for w in tx_in_witness:
if type(w) == str:
witness.append(unhexlify(w) if self["format"] == "raw" else w)
else:
witness.append(w if self["format"] == "raw" else unhexlify(w))
l += 1 + len(w)
if len(w) >= 0x4c:
l += 1
if len(w) > 0xff:
l += 1
# witness script limit
assert l <= 10000
if tx_id == b"\x00" * 32:
assert v_out == 0xffffffff and sequence == 0xffffffff and len(script_sig) <= 100
self["coinbase"] = True
# script_pub_key
if script_pub_key:
if type(script_pub_key) == str:
script_pub_key = unhexlify(script_pub_key)
type(script_pub_key) == bytes
if address is not None:
if type(address) == str:
net = True if address_net_type(address) == 'mainnet' else False
assert not net == self["testnet"]
script = address_to_script(address)
elif type(address) in (Address, ScriptAddress):
assert type(address) == Address
script = address_to_script(address.address)
if script_pub_key:
assert script_pub_key == script
else:
script_pub_key = script
k = len(self["vIn"])
self["vIn"][k] = dict()
self["vIn"][k]["vOut"] = v_out
self["vIn"][k]["sequence"] = sequence
if self["format"] == "raw":
self["vIn"][k]["txId"] = tx_id
self["vIn"][k]["scriptSig"] = script_sig
if script_pub_key:
self["vIn"][k]["scriptPubKey"] = script_pub_key
else:
self["vIn"][k]["txId"] = rh2s(tx_id)
self["vIn"][k]["scriptSig"] = hexlify(script_sig).decode()
self["vIn"][k]["scriptSigOpcodes"] = decode_script(script_sig)
self["vIn"][k]["scriptSigAsm"] = decode_script(script_sig, 1)
if script_pub_key:
self["vIn"][k]["scriptPubKey"] = hexlify(script_pub_key).decode()
if tx_in_witness:
self["segwit"] = True
self["vIn"][k]["txInWitness"] = witness
if amount:
self["vIn"][k]["value"] = amount
if private_key:
self["vIn"][k].private_key = private_key
self.__refresh__()
return self
def add_output(self, amount, address=None, script_pub_key=None):
assert address is not None or script_pub_key is not None
assert not (address is None and script_pub_key is None)
assert type(amount) == int
assert amount >= 0 and amount <= MAX_AMOUNT
if script_pub_key:
if type(script_pub_key) == str:
script_pub_key = unhexlify(script_pub_key)
assert type(script_pub_key) == bytes
else:
if type(address) == Address:
address = address.address
script_pub_key = address_to_script(address)
k = len(self["vOut"])
self["vOut"][k] = dict()
self["vOut"][k]["value"] = amount
segwit = True if "segwit" in self else False
s = parse_script(script_pub_key, segwit)
self["vOut"][k]["nType"] = s["nType"]
self["vOut"][k]["type"] = s["type"]
if self["format"] == "raw":
self["vOut"][k]["scriptPubKey"] = script_pub_key
if self["data"] is None:
if s["nType"] == 3:
self["data"] = s["data"]
if s["nType"] not in (3, 4, 7):
self["vOut"][k]["addressHash"] = s["addressHash"]
self["vOut"][k]["reqSigs"] = s["reqSigs"]
else:
self["vOut"][k]["scriptPubKey"] = hexlify(script_pub_key).decode()
if self["data"] is None:
if s["nType"] == 3:
self["data"] = hexlify(s["data"]).decode()
if s["nType"] not in (3, 4, 7):
self["vOut"][k]["addressHash"] = hexlify(s["addressHash"]).decode()
self["vOut"][k]["reqSigs"] = s["reqSigs"]
self["vOut"][k]["scriptPubKeyOpcodes"] = decode_script(script_pub_key)
self["vOut"][k]["scriptPubKeyAsm"] = decode_script(script_pub_key, 1)
sh = True if self["vOut"][k]["nType"] in (1, 5) else False
witness_version = None if self["vOut"][k]["nType"] < 5 else 0
if "addressHash" in self["vOut"][k]:
self["vOut"][k]["address"] = hash_to_address(self["vOut"][k]["addressHash"],
self["testnet"],
sh,
witness_version)
self.__refresh__()
return self
def del_output(self, n=None):
if not self["vOut"]:
return self
if n is None:
n = len(self["vOut"]) - 1
new_out = dict()
c = 0
for i in range(len(self["vOut"])):
if i != n:
new_out[c] = self["vOut"][i]
c += 1
self["vOut"] = new_out
self.__refresh__()
return self
def del_input(self, n):
if not self["vIn"]:
return self
if n is None:
n = len(self["vIn"]) - 1
new_in = dict()
c = 0
for i in range(len(self["vIn"])):
if i != n:
new_in[c] = self["vIn"][i]
c += 1
self["vIn"] = new_in
self.__refresh__()
return self
def sign_input(self, n, private_key=None, script_pub_key=None, redeem_script=None, sighash_type=SIGHASH_ALL):
if private_key is not None:
if private_key:
if type(private_key) != PrivateKey:
private_key_obj = PrivateKey(private_key)
public_key = PublicKey(private_key_obj).key
private_key = private_key_obj.key
else:
if "privateKey" not in self["vIn"][n]:
return self
private_key = self["vIn"][n].private_key.key
public_key = PublicKey(self["vIn"][n].private_key).key
if redeem_script:
if type(redeem_script) == str:
redeem_script = unhexlify(redeem_script).decode()
assert type(redeem_script) == bytes
script = redeem_script
else:
script = script_pub_key
sighash = self.sig_hash_input(n, script_pub_key=script, sighash_type=sighash_type)
if type(sighash) == str:
sighash = s2rh(sighash)
signature = sign_message(sighash, private_key, 0) + bytes([sighash_type])
if redeem_script:
if self["vIn"][n]["scriptSig"]:
sig_script = self["vIn"][n]["scriptSig"]
if type(sig_script) == str:
sig_script = unhexlify(sig_script).decode()
sig_script = bytes([len(public_key)]) + public_key + sig_script
sig_script = bytes([len(signature)]) + signature + sig_script
else:
sig_script = bytes([len(signature)]) + signature
sig_script += bytes([len(public_key)]) + public_key
if len(redeem_script) <= 0x4b:
sig_script += bytes([len(redeem_script)]) + redeem_script
elif len(redeem_script) <= 0xff:
sig_script = BYTE_OPCODE["OP_PUSHDATA1"] + bytes([len(redeem_script)]) + redeem_script
elif len(redeem_script) <= 0xffff:
sig_script = BYTE_OPCODE["OP_PUSHDATA2"] + bytes([len(redeem_script)]) + redeem_script
else:
sig_script = BYTE_OPCODE["OP_PUSHDATA4"] + bytes([len(redeem_script)]) + redeem_script
else:
sig_script = bytes([len(signature)]) + signature
sig_script += bytes([len(public_key)]) + public_key
if self["format"] == "raw":
self["vIn"][n]["scriptSig"] = sig_script
else:
self["vIn"][n]["scriptSig"] = hexlify(sig_script).decode()
self["vIn"][n]["scriptSigOpcodes"] = decode_script(sig_script)
self["vIn"][n]["scriptSigAsm"] = decode_script(sig_script, 1)
self.__refresh__()
return self
def sig_hash_input(self, n, script_pub_key=None, sighash_type=SIGHASH_ALL):
# check n
assert n >= 0
tx_in_count = len(self["vIn"])
if n >= tx_in_count:
if self["format"] == "raw":
return b'\x01' + b'\x00' * 31
else:
return rh2s(b'\x01' + b'\x00' * 31)
# check script_pub_key for input
if script_pub_key is not None:
script_code = script_pub_key
else:
assert "scriptPubKey" in self["vIn"][n]
script_code = self["vIn"][n]["scriptPubKey"]
if type(script_code) == str:
script_code = unhexlify(script_code)
assert type(script_code) == bytes
# remove opcode separators
script_code = delete_from_script(script_code, BYTE_OPCODE["OP_CODESEPARATOR"])
preimage = bytearray()
if ((sighash_type & 31) == SIGHASH_SINGLE) and (n >= (len(self["vOut"]))):
if self["format"] == "raw":
return b'\x01' + b'\x00' * 31
else:
return rh2s(b'\x01' + b'\x00' * 31)
preimage += struct.pack('<L', self["version"])
preimage += b'\x01' if sighash_type & SIGHASH_ANYONECANPAY else int_to_var_int(tx_in_count)
for i in self["vIn"]:
# skip all other inputs for SIGHASH_ANYONECANPAY case
if (sighash_type & SIGHASH_ANYONECANPAY) and (n != i):
continue
sequence = self["vIn"][i]["sequence"]
if (sighash_type & 31) == SIGHASH_SINGLE and (n != i):
sequence = 0
if (sighash_type & 31) == SIGHASH_NONE and (n != i):
sequence = 0
tx_id = self["vIn"][i]["txId"]
if type(tx_id) == str:
tx_id = s2rh(tx_id)
input = tx_id + struct.pack('<L', self["vIn"][i]["vOut"])
if n == i:
input += int_to_var_int(len(script_code)) + script_code
input += struct.pack('<L', sequence)
else:
input += b'\x00' + struct.pack('<L', sequence)
preimage += input
if (sighash_type & 31) == SIGHASH_NONE:
preimage += b'\x00'
else:
if (sighash_type & 31) == SIGHASH_SINGLE:
preimage += int_to_var_int(n + 1)
else:
preimage += int_to_var_int(len(self["vOut"]))
if (sighash_type & 31) != SIGHASH_NONE:
for i in self["vOut"]:
script_pub_key = self["vOut"][i]["scriptPubKey"]
if type(self["vOut"][i]["scriptPubKey"]) == str:
script_pub_key = unhexlify(script_pub_key)
if i > n and (sighash_type & 31) == SIGHASH_SINGLE:
continue
if (sighash_type & 31) == SIGHASH_SINGLE and (n != i):
preimage += b'\xff' * 8 + b'\x00'
else:
preimage += self["vOut"][i]["value"].to_bytes(8, 'little')
preimage += int_to_var_int(len(script_pub_key)) + script_pub_key
preimage += self["lockTime"].to_bytes(4, 'little')
preimage += struct.pack(b"<i", sighash_type)
return double_sha256(preimage) if self["format"] == "raw" else rh2s(double_sha256(preimage))
def __refresh__(self):
if not self["vOut"] or not self["vIn"]:
return
no_segwit_view = self.serialize(segwit=False, hex=False)
self["txId"] = double_sha256(no_segwit_view)
self["rawTx"] = self.serialize(segwit=True, hex=False)
self["hash"] = double_sha256(self["rawTx"])
self["size"] = len(self["rawTx"])
self["bSize"] = len(no_segwit_view)
self["weight"] = self["bSize"] * 3 + self["size"]
self["vSize"] = math.ceil(self["weight"] / 4)
if self["format"] != "raw":
self["txId"] = rh2s(self["txId"])
self["hash"] = rh2s(self["hash"])
self["rawTx"] = hexlify(self["rawTx"]).decode()
input_sum = 0
for i in self["vIn"]:
if "value" in self["vIn"][i]:
input_sum += self["vIn"][i]["value"]
else:
input_sum = None
break
output_sum = 0
for i in self["vOut"]:
if "value" in self["vOut"][i]:
output_sum += self["vOut"][i]["value"]
else:
output_sum = None
break
self["amount"] = output_sum
if output_sum and input_sum:
self["fee"] = input_sum - output_sum
else:
self["fee"] = None
