Inside Bitcoin

1001        for x in self.prefilled_txn:
1002            ret.prefilled_txn.append(PrefilledTransaction(x.index - last_index - 1, x.tx))
1003            last_index = x.index
1004        return ret
1005
1006    def get_siphash_keys(self):
1007        header_nonce = self.header.serialize()
1008        header_nonce += self.nonce.to_bytes(8, "little")
1009        hash_header_nonce_as_str = sha256(header_nonce)
1010        key0 = int.from_bytes(hash_header_nonce_as_str[0:8], "little")
1011        key1 = int.from_bytes(hash_header_nonce_as_str[8:16], "little")
1012        return [ key0, key1 ]
1013
1014    # Version 2 compact blocks use wtxid in shortids (rather than txid)
1015    def initialize_from_block(self, block, nonce=0, prefill_list=None, use_witness=False):
1016        if prefill_list is None:
1017            prefill_list = [0]
1018        self.header = CBlockHeader(block)
1019        self.nonce = nonce
1020        self.prefilled_txn = [ PrefilledTransaction(i, block.vtx[i]) for i in prefill_list ]
1021        self.shortids = []
1022        self.use_witness = use_witness
1023        [k0, k1] = self.get_siphash_keys()
1024        for i in range(len(block.vtx)):
1025            if i not in prefill_list:
1026                tx_hash = block.vtx[i].txid_int
1027                if use_witness:
1028                    tx_hash = block.vtx[i].wtxid_int
1029                self.shortids.append(calculate_shortid(k0, k1, tx_hash))
1030
1031    def __repr__(self):
1032        return "HeaderAndShortIDs(header=%s, nonce=%d, shortids=%s, prefilledtxn=%s" % (repr(self.header), self.nonce, repr(self.shortids), repr(self.prefilled_txn))
1033
1034
1035class BlockTransactionsRequest:
1036    __slots__ = ("blockhash", "indexes")
1037
1038    def __init__(self, blockhash=0, indexes = None):
1039        self.blockhash = blockhash
1040        self.indexes = indexes if indexes is not None else []
1041
1042    def deserialize(self, f):
1043        self.blockhash = deser_uint256(f)
1044        indexes_length = deser_compact_size(f)
1045        for _ in range(indexes_length):
1046            self.indexes.append(deser_compact_size(f))
1047
1048    def serialize(self):
1049        r = b""
1050        r += ser_uint256(self.blockhash)
1051        r += ser_compact_size(len(self.indexes))
1052        for x in self.indexes:
1053            r += ser_compact_size(x)
1054        return r
1055
1056    # helper to set the differentially encoded indexes from absolute ones
1057    def from_absolute(self, absolute_indexes):
1058        self.indexes = []
1059        last_index = -1
1060        for x in absolute_indexes:
1061            self.indexes.append(x-last_index-1)
1062            last_index = x
1063
1064    def to_absolute(self):
1065        absolute_indexes = []
1066        last_index = -1
1067        for x in self.indexes:
1068            absolute_indexes.append(x+last_index+1)
1069            last_index = absolute_indexes[-1]
1070        return absolute_indexes
1071
1072    def __repr__(self):
1073        return "BlockTransactionsRequest(hash=%064x indexes=%s)" % (self.blockhash, repr(self.indexes))
1074
1075
1076class BlockTransactions:
1077    __slots__ = ("blockhash", "transactions")
1078
1079    def __init__(self, blockhash=0, transactions = None):
1080        self.blockhash = blockhash
1081        self.transactions = transactions if transactions is not None else []
1082
1083    def deserialize(self, f):
1084        self.blockhash = deser_uint256(f)
1085        self.transactions = deser_vector(f, CTransaction)
1086
1087    def serialize(self, with_witness=True):
1088        r = b""
1089        r += ser_uint256(self.blockhash)
1090        if with_witness:
1091            r += ser_vector(self.transactions, "serialize_with_witness")
1092        else:
1093            r += ser_vector(self.transactions, "serialize_without_witness")
1094        return r
1095
1096    def __repr__(self):
1097        return "BlockTransactions(hash=%064x transactions=%s)" % (self.blockhash, repr(self.transactions))
1098
1099
1100class CPartialMerkleTree:
1101    __slots__ = ("nTransactions", "vBits", "vHash")
1102
1103    def __init__(self):
1104        self.nTransactions = 0
1105        self.vHash = []
1106        self.vBits = []
1107
1108    def deserialize(self, f):
1109        self.nTransactions = int.from_bytes(f.read(4), "little")
1110        self.vHash = deser_uint256_vector(f)
1111        vBytes = deser_string(f)
1112        self.vBits = []
1113        for i in range(len(vBytes) * 8):
1114            self.vBits.append(vBytes[i//8] & (1 << (i % 8)) != 0)
1115
1116    def serialize(self):
1117        r = b""
1118        r += self.nTransactions.to_bytes(4, "little")
1119        r += ser_uint256_vector(self.vHash)
1120        vBytesArray = bytearray([0x00] * ((len(self.vBits) + 7)//8))
1121        for i in range(len(self.vBits)):
1122            vBytesArray[i // 8] |= self.vBits[i] << (i % 8)
1123        r += ser_string(bytes(vBytesArray))
1124        return r
1125
1126    def __repr__(self):
1127        return "CPartialMerkleTree(nTransactions=%d, vHash=%s, vBits=%s)" % (self.nTransactions, repr(self.vHash), repr(self.vBits))
1128
1129
1130class CMerkleBlock:
1131    __slots__ = ("header", "txn")
1132
1133    def __init__(self):
1134        self.header = CBlockHeader()
1135        self.txn = CPartialMerkleTree()
1136
1137    def deserialize(self, f):
1138        self.header.deserialize(f)
1139        self.txn.deserialize(f)
1140
1141    def serialize(self):
1142        r = b""
1143        r += self.header.serialize()
1144        r += self.txn.serialize()
1145        return r
1146
1147    def __repr__(self):
1148        return "CMerkleBlock(header=%s, txn=%s)" % (repr(self.header), repr(self.txn))
1149
1150
1151# Objects that correspond to messages on the wire
1152class msg_version:
1153    __slots__ = ("addrFrom", "addrTo", "nNonce", "relay", "nServices",
1154                 "nStartingHeight", "nTime", "nVersion", "strSubVer")
1155    msgtype = b"version"
1156
1157    def __init__(self):
1158        self.nVersion = 0
1159        self.nServices = 0
1160        self.nTime = int(time.time())
1161        self.addrTo = CAddress()
1162        self.addrFrom = CAddress()
1163        self.nNonce = random.getrandbits(64)
1164        self.strSubVer = ''
1165        self.nStartingHeight = -1
1166        self.relay = 0
1167
1168    def deserialize(self, f):
1169        self.nVersion = int.from_bytes(f.read(4), "little", signed=True)
1170        self.nServices = int.from_bytes(f.read(8), "little")
1171        self.nTime = int.from_bytes(f.read(8), "little", signed=True)
1172        self.addrTo = CAddress()
1173        self.addrTo.deserialize(f, with_time=False)
1174
1175        self.addrFrom = CAddress()
1176        self.addrFrom.deserialize(f, with_time=False)
1177        self.nNonce = int.from_bytes(f.read(8), "little")
1178        self.strSubVer = deser_string(f).decode('utf-8')
1179
1180        self.nStartingHeight = int.from_bytes(f.read(4), "little", signed=True)
1181
1182        # Relay field is optional for version 70001 onwards
1183        # But, unconditionally check it to match behaviour in bitcoind
1184        self.relay = int.from_bytes(f.read(1), "little")  # f.read(1) may return an empty b''
1185
1186    def serialize(self):
1187        r = b""
1188        r += self.nVersion.to_bytes(4, "little", signed=True)
1189        r += self.nServices.to_bytes(8, "little")
1190        r += self.nTime.to_bytes(8, "little", signed=True)
1191        r += self.addrTo.serialize(with_time=False)
1192        r += self.addrFrom.serialize(with_time=False)
1193        r += self.nNonce.to_bytes(8, "little")
1194        r += ser_string(self.strSubVer.encode('utf-8'))
1195        r += self.nStartingHeight.to_bytes(4, "little", signed=True)
1196        r += self.relay.to_bytes(1, "little")
1197        return r
1198
1199    def __repr__(self):
1200        return 'msg_version(nVersion=%i nServices=%i nTime=%s addrTo=%s addrFrom=%s nNonce=0x%016X strSubVer=%s nStartingHeight=%i relay=%i)' \
1201            % (self.nVersion, self.nServices, time.ctime(self.nTime),
1202               repr(self.addrTo), repr(self.addrFrom), self.nNonce,
1203               self.strSubVer, self.nStartingHeight, self.relay)
1204
1205
1206class msg_verack:
1207    __slots__ = ()
1208    msgtype = b"verack"
1209
1210    def __init__(self):
1211        pass
1212
1213    def deserialize(self, f):
1214        pass
1215
1216    def serialize(self):
1217        return b""
1218
1219    def __repr__(self):
1220        return "msg_verack()"
1221
1222
1223class msg_addr:
1224    __slots__ = ("addrs",)
1225    msgtype = b"addr"
1226
1227    def __init__(self):
1228        self.addrs = []
1229
1230    def deserialize(self, f):
1231        self.addrs = deser_vector(f, CAddress)
1232
1233    def serialize(self):
1234        return ser_vector(self.addrs)
1235
1236    def __repr__(self):
1237        return "msg_addr(addrs=%s)" % (repr(self.addrs))
1238
1239
1240class msg_addrv2:
1241    __slots__ = ("addrs",)
1242    msgtype = b"addrv2"
1243
1244    def __init__(self):
1245        self.addrs = []
1246
1247    def deserialize(self, f):
1248        self.addrs = deser_vector(f, CAddress, "deserialize_v2")
1249
1250    def serialize(self):