def serializar(self):
'''Serializa este mensaje para enviarlo a la red'''
# versión es 4 bytes little endian
res = int_a_little_endian(self.versión, 4)
# servicios tiene 8 bytes little endian
res += int_a_little_endian(self.servicios, 8)
# timestamp es 8 bytes little endian
res += int_a_little_endian(self.timestamp, 8)
# servicios receptor son 8 bytes little endian
res += int_a_little_endian(self.servicios_receptor, 8)
# IPV4 es 10 00 bytes y 2 ff bytes después ip receptor
res += b'\x00' * 10 + b'\xff\xff' + self.ip_receptor
# puerto receptor son 2 bytes, little endian debería ser 0
res += int_a_little_endian(self.puerto_receptor, 2)
# servicios emisor son 8 bytes little endian
res += int_a_little_endian(self.servicios_emisor, 8)
# IPV4 son los bytes 10 00 y 2 ff bytes luego ip emisor
res += b'\x00' * 10 + b'\xff\xff' + self.ip_emisor
# puerto emisor son 2 bytes, little endian debería ser 0
res += int_a_little_endian(self.puerto_emisor, 2)
# nonce deberían ser 8 bytes
res += self.nonce
# agente usuario es una cadena variable, así que varint primero
res += codificar_varint(len(self.agente_usuario))
res += self.agente_usuario
# el último bloque son 4 bytes little endian
res += int_a_little_endian(self.último_bloque, 4)
# retransmisión es 00 si es falso, 01 si es verdadero
if self.retransmisión:
res += b'\x01'
else:
res += b'\x00'
return res
def serializar(self):
# comienza con el número de cosas como un varint
res = codificar_varint(len(self.data))
for tipo_datos, identificador in self.data:
# tipo de datos es 4 bytes little endian
res += int_a_little_endian(tipo_datos, 4)
# identificador necesita estar en little endian
res += identificador[::-1]
return res
def serializar(self):
'''Devuelve la serialización en bytes de la transacción'''
# serializa versión (4 bytes, little endian)
res = int_a_little_endian(self.versión, 4)
# codificar_varint en el número de inputs
res += codificar_varint(len(self.tx_ins))
# itera los inputs
for tx_in in self.tx_ins:
# serializa cada input
res += tx_in.serializar()
# codificar_varint sobre el número de outputs
res += codificar_varint(len(self.tx_outs))
# itera outputs
for tx_out in self.tx_outs:
# serializa cada output
res += tx_out.serializar()
# serializa locktime (4 bytes, little endian)
res += int_a_little_endian(self.locktime, 4)
return res
def serializar(self):
'''Serializa este mensaje para enviarlo a la red'''
# la versión del protocolo es 4 bytes little-endian
res = int_a_little_endian(self.versión, 4)
# el número de hashes es un varint
res += codificar_varint(self.num_hashes)
# el bloque inicial es en little-endian
res += self.bloque_inicial[::-1]
# el bloque final es también en little-endian
res += self.bloque_final[::-1]
return res
def filtrocarga(self, flag=1):
'''Devuelve la carga que va en un mensaje filtrocarga'''
# comienza con el tamaño del filtro en bytes
carga = codificar_varint(self.tamaño)
# luego súmale el filtro a bytes
carga += self.filtro_bytes()
# la función contador es 4 bytes little endian
carga += int_a_little_endian(self.función_contador, 4)
# ajuste is 4 bytes little endian
carga += int_a_little_endian(self.ajuste, 4)
# flag es 1 byte little endian
carga += int_a_little_endian(flag, 1)
return carga
def serializar(self):
# inicializa lo que enviaremos de vuelta
res = b''
# ve a través de cada cosa
for cosa in self.cosas:
# si la cosa es un entero, es un op code
if type(cosa) == int:
# convierte la cosa en un único byte entero usando int_a_little_endian
res += int_a_little_endian(cosa, 1)
else:
# en otro caso, esto es un elemento
# obtén la longitud en bytes
longitud = len(cosa)
# convierte la longitud en un único byte entero usando int_a_little_endian
prefijo = int_a_little_endian(longitud, 1)
# añade al resultado tanto la longitud como la cosa
res += prefijo + cosa
# obtén la longitud de todo
total = len(res)
# codificar_varint la longitud total de res y anteponlo
return codificar_varint(total) + res
