def stream_deserialize(cls, f): self = super(CSqueak, cls).stream_deserialize(f) encContent = ser_read(f, ENC_CONTENT_LENGTH) object.__setattr__(self, 'encContent', encContent) sig = ser_read(f, SIGNATURE_LENGTH) object.__setattr__(self, 'sig', sig) return self
def stream_deserialize(cls, f, protover=PROTO_VERSION): recvbuf = ser_read(f, 4 + 12 + 4 + 4) # check magic if recvbuf[:4] != squeak.params.params.MESSAGE_START: raise ValueError( "Invalid message start '%s', expected '%s'" % (b2x(recvbuf[:4]), b2x(squeak.params.params.MESSAGE_START))) # remaining header fields: command, msg length, checksum command = recvbuf[4:4 + 12].split(b"\x00", 1)[0] msglen = struct.unpack(b"<i", recvbuf[4 + 12:4 + 12 + 4])[0] checksum = recvbuf[4 + 12 + 4:4 + 12 + 4 + 4] # read message body recvbuf += ser_read(f, msglen) msg = recvbuf[4 + 12 + 4 + 4:4 + 12 + 4 + 4 + msglen] th = hashlib.sha256(msg).digest() h = hashlib.sha256(th).digest() if checksum != h[:4]: raise ValueError("got bad checksum %s" % repr(recvbuf)) recvbuf = recvbuf[4 + 12 + 4 + 4 + msglen:] if command in messagemap: cls = messagemap[command] return cls.msg_deser(_BytesIO(msg)) else: print("Command '%s' not in messagemap" % repr(command)) return None
def stream_deserialize(cls, f): self = cls() for attr, fmt, num_bytes, _ in self.fields: if fmt not in ['bytes']: setattr(self, attr, struct.unpack(fmt, ser_read(f, num_bytes))[0]) elif fmt == 'bytes': setattr(self, attr, ser_read(f, num_bytes)) return self
def tx_version_to_vars(version): """Converts an int32 representation into serialization type and version.""" f = BytesIO() f.write(struct.pack(b'<I', version)) f.seek(0) version_value = struct.unpack(b'<H', ser_read(f, 2))[0] serialization_type = struct.unpack(b'<H', ser_read(f, 2))[0] return (version_value, serialization_type)
def stream_deserialize(cls, f, without_time=False): c = cls() if c.protover >= CADDR_TIME_VERSION and not without_time: c.nTime = struct.unpack(b"<I", ser_read(f, 4))[0] c.nServices = struct.unpack(b"<Q", ser_read(f, 8))[0] c.pchReserved = ser_read(f, 12) c.ip = socket.inet_ntoa(ser_read(f, 4)) c.port = struct.unpack(b">H", ser_read(f, 2))[0] return c
def stream_deserialize(cls, f): n = VarIntSerializer.stream_deserialize(f) pubkeys = tuple( SqueakPublicKey.from_bytes(ser_read(f, PUB_KEY_LENGTH)) for i in range(n)) nMinBlockHeight = struct.unpack(b"<i", ser_read(f, 4))[0] nMaxBlockHeight = struct.unpack(b"<i", ser_read(f, 4))[0] hashReplySqk = ser_read(f, HASH_LENGTH) return cls(pubkeys, nMinBlockHeight, nMaxBlockHeight, hashReplySqk)
def stream_deserialize(cls, f): prev_out = OutPoint.stream_deserialize(f) sequence = struct.unpack(b'<I', ser_read(f, 4))[0] value = struct.unpack(b'<q', ser_read(f, 8))[0] block_height = struct.unpack(b'<I', ser_read(f, 4))[0] block_index = struct.unpack(b'<I', ser_read(f, 4))[0] sig_script = BytesSerializer.stream_deserialize(f) return cls(prev_out, sequence, value, block_height, block_index, sig_script)
def stream_deserialize(cls, f): self = cls() if not hasattr(self, 'fields'): setattr(self, 'fields', list(block_header_fields)) for attr, fmt, num_bytes, _ in self.fields: if fmt not in ['bytes']: setattr(self, attr, struct.unpack(fmt, ser_read(f, num_bytes))[0]) elif fmt == 'bytes': setattr(self, attr, ser_read(f, num_bytes)) return self
def msg_deser(cls, f, protover=PROTO_VERSION): hashSqk = ser_read(f, HASH_LENGTH) secretKey = ser_read(f, SECRET_KEY_LENGTH) markerbyte = struct.unpack(b'B', ser_read(f, 1))[0] flagbyte = struct.unpack(b'B', ser_read(f, 1))[0] if markerbyte == 0 and flagbyte == 1: offer = COffer.stream_deserialize(f) else: offer = None return cls(hashSqk, secretKey, offer)
def deserialize_witness(self, f): value = struct.unpack(b'<q', ser_read(f, 8))[0] block_height = struct.unpack(b'<I', ser_read(f, 4))[0] block_index = struct.unpack(b'<I', ser_read(f, 4))[0] sig_script = BytesSerializer.stream_deserialize(f) self.value = value self.block_height = block_height self.block_index = block_index self.sig_script = sig_script
def stream_deserialize_value(self, f): if self.bounds is TypeRef.Usage.single: value = self.type.stream_deserialize_value(f) elif self.bounds.is_fixed(): value = [self.type.stream_deserialize_value(f) for n in range(0, self.bounds.min())] elif self.bounds is TypeRef.Usage.optional: if self.type.type is FieldType.Type.pubkey: key = ser_read(f, 1) if key[0] is 0: return None data = key + ser_read(f, 32) return PubKey.deserialize(data) elif self.type.type is FieldType.Type.ecdsa: key = ser_read(f, 1) if key[0] is 0: return None raise NotImplementedError('ECDSA deserealization is not implemented') try: value = self.type.stream_deserialize_value(f) except BaseException as ex: # due to some strange bug, python 3 is unable to capture SeparatorByteSignal exception by its type, # and `isinstance(ex, SeparatorByteSignal)` returns False as well :( # so we have to capture generic exception and re-raise if it is not SeparatorByteSignal, which # can be determined only by the presence of its method if not callable(getattr(ex, "is_eof", None)): raise if ex.is_eof(): # -- met 0xFF separator byte, indicating absent value value = None else: raise if self.type.type is FieldType.Type.fvi: pass elif self.type.type is FieldType.Type.str: value = None if value is b'\x00' or len(value) is 0 else value elif self.type.type is FieldType.Type.bytes: value = None if len(value) is 0 else value elif self.type.type in [FieldType.Type.sha256, FieldType.Type.sha256d]: value = None if value is bytes([0] * 32) else value elif self.type.type in [FieldType.Type.ripmd160, FieldType.Type.hash160]: value = None if value is bytes([0] * 20) else value else: raise SchemaError(f'optional fields can be only of `str`, `fvi`, `bytes` and complex types') else: no = VarIntSerializer.stream_deserialize(f) value = [self.type.stream_deserialize_value(f) for n in range(0, no)] return value
def stream_deserialize_value(self, f): lut = { FieldType.Type.u8: lambda: ser_read(f, 1), FieldType.Type.u16: lambda: struct.unpack(b'<H', ser_read(f, 2))[0], FieldType.Type.u32: lambda: struct.unpack(b'<I', ser_read(f, 4))[0], FieldType.Type.u64: lambda: struct.unpack(b'<Q', ser_read(f, 8))[0], FieldType.Type.i8: lambda: ser_read(f, 1), FieldType.Type.i16: lambda: struct.unpack(b'<h', ser_read(f, 2))[0], FieldType.Type.i32: lambda: struct.unpack(b'<i', ser_read(f, 4))[0], FieldType.Type.i64: lambda: struct.unpack(b'<q', ser_read(f, 8))[0], FieldType.Type.vi: lambda: VarIntSerializer.stream_deserialize(f), FieldType.Type.fvi: lambda: FlagVarIntSerializer.stream_deserialize(f), FieldType.Type.str: lambda: VarStringSerializer.stream_deserialize(f).decode('utf-8'), FieldType.Type.bytes: lambda: BytesSerializer.stream_deserialize(f), FieldType.Type.sha256: lambda: Hash256Id.stream_deserialize(f), FieldType.Type.sha256d: lambda: Hash256Id.stream_deserialize(f), FieldType.Type.ripmd160: lambda: Hash160Id.stream_deserialize(f), FieldType.Type.hash160: lambda: Hash160Id.stream_deserialize(f), FieldType.Type.pubkey: lambda: PubKey.stream_deserialize(f), FieldType.Type.ecdsa: lambda: None, } if self.type in lut.keys(): return lut[self.type]() else: raise NotImplementedError()
def stream_deserialize(cls, f, without_time=False): c = cls() if c.protover >= CADDR_TIME_VERSION and not without_time: c.nTime = struct.unpack(b"<I", ser_read(f, 4))[0] c.nServices = struct.unpack(b"<Q", ser_read(f, 8))[0] packedIP = ser_read(f, 16) if bytes(packedIP[0:12]) == IPV4_COMPAT: # IPv4 c.ip = socket.inet_ntop(socket.AF_INET, packedIP[12:16]) else: #IPv6 c.ip = socket.inet_ntop(socket.AF_INET6, packedIP) c.port = struct.unpack(b">H", ser_read(f, 2))[0] return c
def deserialize_prefix(self, f): """Deserialize the transaction prefix.""" txin_count = VarIntSerializer.stream_deserialize(f) txins = [] for i in range(txin_count): txin = TxIn() txin.deserialize_prefix(f) txins.append(txin) txouts = VectorSerializer.stream_deserialize(TxOut, f) locktime = struct.unpack(b'<I', ser_read(f, 4))[0] expiry = struct.unpack(b'<I', ser_read(f, 4))[0] self.txins = list(txins) self.txouts = list(txouts) self.locktime = locktime self.expiry = expiry
def vars_to_tx_version(version_value, serialization_type): """Converts serialization type and tx version into a 32 bit int.""" f = BytesIO() f.write(struct.pack(b'<H', version_value)) f.write(struct.pack(b'<H', serialization_type)) f.seek(0) version = struct.unpack(b'<i', ser_read(f, 4))[0] return version
def stream_deserialize(cls, f): val = ser_read(f, 1)[0] mask = 0x80 & val flag = True if mask is 0x80 else False r = val & 0x7f if r < 0x7c: val = r elif r == 0x7c: val = ser_read(f, 1)[0] elif r == 0x7d: val = struct.unpack(b'<H', ser_read(f, 2))[0] elif r == 0x7e: val = struct.unpack(b'<I', ser_read(f, 4))[0] elif val == 0x7f: raise SeparatorByteSignal(FlagVarIntSerializer.Separator.EOL) elif val == 0xff: raise SeparatorByteSignal(FlagVarIntSerializer.Separator.EOF) return val, flag
def stream_deserialize(cls, f): self = super(CAuxPow, cls).stream_deserialize(f) hashBlock = ser_read(f, 32) vMerkleBranch = uint256VectorSerializer.stream_deserialize(f) nIndex = struct.unpack(b"<I", ser_read(f, 4))[0] vChainMerkleBranch = uint256VectorSerializer.stream_deserialize(f) nChainIndex = struct.unpack(b"<I", ser_read(f, 4))[0] parentBlockHeader = CAltcoinBlockHeader.stream_deserialize(f) object.__setattr__(self, 'hashBlock', hashBlock) object.__setattr__(self, 'vMerkleBranch', vMerkleBranch) object.__setattr__(self, 'nIndex', nIndex) object.__setattr__(self, 'vChainMerkleBranch', vChainMerkleBranch) object.__setattr__(self, 'nChainIndex', nChainIndex) object.__setattr__(self, 'parentBlockHeader', parentBlockHeader) return self
def deserialize_field(self, tx, kwargs, attr, fmt, num_bytes, f): if fmt not in ['inputs', 'outputs', 'bytes']: kwargs[attr] = struct.unpack(fmt, ser_read(f, num_bytes))[0] elif fmt == 'inputs': kwargs[attr] = VectorSerializer.stream_deserialize(CMutableTxIn, f) elif fmt == 'outputs': kwargs[attr] = VectorSerializer.stream_deserialize(CMutableTxOut, f) elif fmt == 'bytes': kwargs[attr] = BytesSerializer.stream_deserialize(f)
def stream_deserialize(cls, f): self = super(Block, cls).stream_deserialize(f) for attr, fmt, num_bytes, _ in self.block_fields: if fmt not in ['bytes', 'vectortx']: setattr(self, attr, struct.unpack(fmt, ser_read(f, num_bytes))[0]) elif fmt == 'bytes': setattr(self, attr, BytesSerializer.stream_deserialize(f)) elif fmt == 'vectortx': setattr(self, attr, VectorSerializer.stream_deserialize(Transaction, f)) setattr(self, 'vMerkleTree', tuple(Block.build_merkle_tree_from_txs(getattr(self, 'vtx')))) return self
def stream_deserialize(cls, f): self = cls() for attr, fmt, num_bytes, _ in self.fields: if fmt not in ['inputs', 'outputs', 'bytes']: setattr(self, attr, struct.unpack(fmt, ser_read(f, num_bytes))[0]) elif fmt == 'inputs': setattr(self, attr, VectorSerializer.stream_deserialize(CTxIn, f)) elif fmt == 'outputs': setattr(self, attr, VectorSerializer.stream_deserialize(CTxOut, f)) elif fmt == 'bytes': setattr(self, attr, BytesSerializer.stream_deserialize(f)) return self
def stream_deserialize(cls, f, protover=PROTO_VERSION): recvbuf = ser_read(f, 4 + 12 + 4 + 4) # check magic if recvbuf[:4] != bitcoin.params.MESSAGE_START: raise ValueError("Invalid message start '%s', expected '%s'" % (b2x(recvbuf[:4]), b2x(bitcoin.params.MESSAGE_START))) # remaining header fields: command, msg length, checksum command = recvbuf[4:4+12].split(b"\x00", 1)[0] msglen = struct.unpack(b"<i", recvbuf[4+12:4+12+4])[0] checksum = recvbuf[4+12+4:4+12+4+4] return MsgHeader(command, msglen, checksum)
def stream_deserialize(cls, f): c = cls() c.nVersion = struct.unpack(b"<i", ser_read(f,4))[0] c.nRelayUntil = struct.unpack(b"<q", ser_read(f,8))[0] c.nExpiration = struct.unpack(b"<q", ser_read(f,8))[0] c.nID = struct.unpack(b"<i", ser_read(f,4))[0] c.nCancel = struct.unpack(b"<i", ser_read(f,4))[0] c.setCancel = intVectorSerializer.deserialize(f) c.nMinVer = struct.unpack(b"<i", ser_read(f,4))[0] c.nMaxVer = struct.unpack(b"<i", ser_read(f,4))[0] c.setSubVer = intVectorSerializer.deserialize(f) c.nPriority = struct.unpack(b"<i", ser_read(f,4))[0] c.strComment = VarStringSerializer.deserialize(f) c.strStatusBar = VarStringSerializer.deserialize(f) c.strReserved = VarStringSerializer.deserialize(f) return c
def stream_deserialize(cls, f, protover=PROTO_VERSION): recvbuf = ser_read(f, 4 + 12 + 4 + 4) # check magic if recvbuf[:4] != bitcoin.params.MESSAGE_START: raise ValueError( "Invalid message start '%s', expected '%s'" % (b2x(recvbuf[:4]), b2x(bitcoin.params.MESSAGE_START))) # remaining header fields: command, msg length, checksum command = recvbuf[4:4 + 12].split(b"\x00", 1)[0] msglen = struct.unpack(b"<i", recvbuf[4 + 12:4 + 12 + 4])[0] checksum = recvbuf[4 + 12 + 4:4 + 12 + 4 + 4] return MsgHeader(command, msglen, checksum)
def stream_deserialize(cls, f): def bits(f, n): ret = [] bytes = (ord(b) for b in f.read(n)) for b in bytes: for i in xrange(8): ret.append((b >> i) & 1) return ret self = super(CMerkleBlock, cls).stream_deserialize(f) nTX = struct.unpack('<L', ser_read(f, 4))[0] nHashes = VarIntSerializer.stream_deserialize(f) vHashes = [] for i in range(nHashes): vHashes.append(ser_read(f, 32)) nFlags = VarIntSerializer.stream_deserialize(f) vFlags = bits(f, nFlags) object.__setattr__(self, 'nTX', nTX) object.__setattr__(self, 'vHashes', vHashes) object.__setattr__(self, 'vFlags', vFlags) return self
def stream_deserialize(cls, f): c = cls() c.nVersion = struct.unpack(b"<i", ser_read(f, 4))[0] c.nRelayUntil = struct.unpack(b"<q", ser_read(f, 8))[0] c.nExpiration = struct.unpack(b"<q", ser_read(f, 8))[0] c.nID = struct.unpack(b"<i", ser_read(f, 4))[0] c.nCancel = struct.unpack(b"<i", ser_read(f, 4))[0] c.setCancel = intVectorSerialzer.deserialize(f) c.nMinVer = struct.unpack(b"<i", ser_read(f, 4))[0] c.nMaxVer = struct.unpack(b"<i", ser_read(f, 4))[0] c.setSubVer = VarStringSerializer.deserialize(f) c.nPriority = struct.unpack(b"<i", ser_read(f, 4))[0] c.strComment = VarStringSerializer.deserialize(f) c.strStatusBar = VarStringSerializer.deserialize(f) c.strReserved = VarStringSerializer.deserialize(f) return c
def stream_deserialize(cls, f): self = cls() self.version = struct.unpack(b'<i', ser_read(f, 4))[0] _, ser_type = tx_version_to_vars(self.version) if ser_type == TX_SERIALIZE_NO_WITNESS: self.deserialize_prefix(f) elif ser_type == TX_SERIALIZE_ONLY_WITNESS: self.deserialize_witness(f, False) elif ser_type == TX_SERIALIZE_WITNESS_SIGNING: self.deserialize_witness_signing(f) elif ser_type == TX_SERIALIZE_WITNESS_VALUE_SIGNING: self.deserialize_witness_value_signing(f) elif ser_type == TX_SERIALIZE_FULL: self.deserialize_prefix(f) self.deserialize_witness(f, True) else: raise Exception('Unsupported transaction type.') return self
def deserialize_prefix(self, f): prev_out = OutPoint.stream_deserialize(f) sequence = struct.unpack(b'<I', ser_read(f, 4))[0] self.prev_out = prev_out self.sequence = sequence
def stream_deserialize(cls, f): hash = ser_read(f, 32) vin = CTxIn.stream_deserialize(f) sig = BytesSerializer.stream_deserialize(f) height = struct.unpack(b"<I", ser_read(f, 4))[0] return cls(hash, vin, sig, height)
def stream_deserialize(cls, f): hash = ser_read(f, 32) index = struct.unpack(b'<I', ser_read(f, 4))[0] tree = struct.unpack(b'<b', ser_read(f, 1))[0] return cls(hash, index, tree)
def stream_deserialize(cls, f): merkleHash = ser_read(f, 32) return cls(merkleHash)
def stream_deserialize(cls, f): version = struct.unpack(b'<i', ser_read(f, 4))[0] prev_block = ser_read(f, 32) merkle_root = ser_read(f, 32) stake_root = ser_read(f, 32) vote_bits = struct.unpack(b'<H', ser_read(f, 2))[0] final_state = ser_read(f, 6) voters = struct.unpack(b'<H', ser_read(f, 2))[0] fresh_stake = struct.unpack(b'<B', ser_read(f, 1))[0] revocations = struct.unpack(b'<B', ser_read(f, 1))[0] pool_size = struct.unpack(b'<I', ser_read(f, 4))[0] bits = struct.unpack(b'<I', ser_read(f, 4))[0] sbits = struct.unpack(b'<q', ser_read(f, 8))[0] height = struct.unpack(b'<I', ser_read(f, 4))[0] size = struct.unpack(b'<I', ser_read(f, 4))[0] timestamp = struct.unpack(b'<I', ser_read(f, 4))[0] nonce = struct.unpack(b'<I', ser_read(f, 4))[0] extra_data = ser_read(f, 36) return cls(version, prev_block, merkle_root, stake_root, vote_bits, final_state, voters, fresh_stake, revocations, pool_size, bits, sbits, height, size, timestamp, nonce, extra_data)
def stream_deserialize(cls, f): value = struct.unpack(b'<q', ser_read(f, 8))[0] version = struct.unpack(b'<H', ser_read(f, 2))[0] pk_script = BytesSerializer.stream_deserialize(f) return cls(value, version, pk_script)
def stream_deserialize(cls, f): c = cls() c.nVersion = struct.unpack(b"<i", ser_read(f, 4))[0] c.vHave = uint256VectorSerializer.stream_deserialize(f) return c
def deserialize_witness_value_signing(self, f): value = struct.unpack(b'<q', ser_read(f, 8))[0] sig_script = BytesSerializer.stream_deserialize(f) self.value = value self.sig_script = sig_script
def stream_deserialize(cls, f): c = cls() c.type = struct.unpack(b"<i", ser_read(f, 4))[0] c.hash = ser_read(f, 32) return c
def stream_deserialize(cls, f): nonce = ser_read(f, HASH_LENGTH) strPaymentInfo = VarStringSerializer.stream_deserialize(f) host = VarStringSerializer.stream_deserialize(f) port = struct.unpack(b">H", ser_read(f, 2))[0] return cls(nonce, strPaymentInfo, host, port)
def stream_deserialize(cls, f): nVersion = struct.unpack(b"<i", ser_read(f, 4))[0] vInterested = VectorSerializer.stream_deserialize(CInterested, f) return cls(vInterested=vInterested, protover=nVersion)