def serialize(self, payload_version):
_count = len(self.signs)
return b''.join(
(self.illegalType, pack_le_uint32(self.height),
pack_varbytes(self.illegalSigner), self.evidence.serialize(),
self.compareEvidence.serialize(),
pack_varbytes(self.genesisBlockAddress), pack_varint(_count),
b''.join((pack_varbytes(self.signs[i] for i in range(_count))))))
def _serialize_extra_payload(self):
extra = self.extra_payload
spec_tx_class = DeserializerDash.SPEC_TX_HANDLERS.get(self.tx_type)
if not spec_tx_class:
assert isinstance(extra, (bytes, bytearray))
return pack_varbytes(extra)
if not isinstance(extra, spec_tx_class):
raise ValueError('Dash tx_type does not conform with extra'
' payload class: %s, %s' % (self.tx_type, extra))
return pack_varbytes(extra.serialize())
def serialize(self):
return b''.join((
pack_le_int64(self.value),
pack_varbytes(self.pk_script),
pack_varbytes(self.ek),
pack_varbytes(self.ok),
pack_varbytes(self.sk),
self.tokenid,
pack_le_int64(self.tokennftid),
pack_varbytes(self.vdata),
))
def serialize(self):
assert (len(self.proTxHash) == 32 and len(self.PubKeyOperator) == 48
and len(self.KeyIdVoting) == 20 and len(self.inputsHash) == 32)
return (pack_le_uint16(self.version) + # version
self.proTxHash + # proTxHash
pack_le_uint16(self.mode) + # mode
self.PubKeyOperator + # PubKeyOperator
self.KeyIdVoting + # KeyIdVoting
pack_varbytes(self.scriptPayout) + # scriptPayout
self.inputsHash + # inputsHash
pack_varbytes(self.payloadSig) # payloadSig
)
def serialize(self):
assert (len(self.pubKey) == 48 and len(self.payloadSig) == 96)
return (pack_le_uint16(self.version) + # version
pack_varbytes(self.userName) + # userName
self.pubKey + # pubKey
self.payloadSig # payloadSig
)
def test_pack_varbytes():
tests = [b'', b'1', b'2' * 253, b'3' * 254, b'4' * 256, b'5' * 65536]
for test in tests:
data = util.pack_varbytes(test)
deser = tx.Deserializer(data)
assert deser._read_varbytes() == test
def serialize(self):
return b''.join((
self.keyimage,
self.ringsize,
pack_varbytes(self.script),
pack_le_uint32(self.sequence),
))
def test_pack_varbytes():
tests = [b'', b'1', b'2' * 253, b'3' * 254, b'4' * 256, b'5' * 65536]
for test in tests:
data = util.pack_varbytes(test)
value, size = tx.read_varbytes(data, 0)
assert value == test and size == len(data)
def serialize(self):
return b''.join((
self.prev_hash,
pack_le_uint32(self.prev_idx),
pack_varbytes(self.script),
pack_le_uint32(self.sequence),
))
def serialize(self, payload_version):
_count = len(self.addresses)
assert _count == len(self.indexes) == len(self.amounts)
return b''.join((pack_varint(_count), b''.join((b''.join(
(pack_varbytes(self.addresses[i]), pack_varint(self.indexes[i]),
pack_le_int64(self.amounts[i]))) for i in range(_count)))))
def serialize(self):
assert (len(self.ipAddress) == 16 and len(self.KeyIdOwner) == 20
and len(self.PubKeyOperator) == 48
and len(self.KeyIdVoting) == 20 and len(self.inputsHash) == 32)
return (pack_le_uint16(self.version) + # version
pack_le_uint16(self.type) + # type
pack_le_uint16(self.mode) + # mode
self.collateralOutpoint.serialize() + # collateralOutpoint
self.ipAddress + # ipAddress
pack_be_uint16(self.port) + # port
self.KeyIdOwner + # KeyIdOwner
self.PubKeyOperator + # PubKeyOperator
self.KeyIdVoting + # KeyIdVoting
pack_le_uint16(self.operatorReward) + # operatorReward
pack_varbytes(self.scriptPayout) + # scriptPayout
self.inputsHash + # inputsHash
pack_varbytes(self.payloadSig) # payloadSig
)
def serialize(self):
assert (len(self.proTxHash) == 32 and len(self.ipAddress) == 16
and len(self.inputsHash) == 32 and len(self.payloadSig) == 96)
return (
pack_le_uint16(self.version) + # version
self.proTxHash + # proTxHash
self.ipAddress + # ipAddress
pack_be_uint16(self.port) + # port
pack_varbytes(self.scriptOperatorPayout) + # scriptOperatorPayout
self.inputsHash + # inputsHash
self.payloadSig # payloadSig
)
def serialize(self):
nLocktime = pack_le_uint32(self.locktime)
txins = (pack_varint(len(self.inputs)) +
b''.join(tx_in.serialize() for tx_in in self.inputs))
txouts = (pack_varint(len(self.outputs)) +
b''.join(tx_out.serialize() for tx_out in self.outputs))
nWitness = pack_varbytes(witness)
if self.tx_type:
uVersion = pack_le_uint16(self.version)
uTxType = pack_le_uint16(self.tx_type)
vExtra = self._serialize_extra_payload()
return uVersion + uTxType + txins + txouts + nWitness + nLocktime + vExtra
else:
nVersion = pack_le_int32(self.version)
return nVersion + txins + txouts + nWitness + nLocktime
def serialize(self):
return b''.join(
(pack_varbytes(self.name), pack_varbytes(self.description),
int_to_byte(self.precision), int_to_byte(self.assettype),
int_to_byte(self.recordtype)))
def serialize(self):
return b''.join((pack_varbytes(bytes.fromhex(self.parameter)),
pack_varbytes(bytes.fromhex(self.code))))
def serialize(self, version):
_temp = pack_varbytes(self.candidate)
if version >= VoteProducerAndCR:
return b''.join((_temp, pack_le_int64(self.votes)))
else:
return _temp
def serialize(self):
return b''.join((
int_to_byte(self.usage),
pack_varbytes(self.data),
))
def serialize_unsigned(self, payload_version):
return b''.join((self.hash, self.messageHash, int_to_byte(self.stage),
pack_varbytes(self.ownerPublicKey),
pack_varbytes(self.newOwnerPublicKey)))
def serialize(self):
return b''.join(
(pack_varbytes(self.type), pack_varbytes(self.verification_method),
pack_varbytes(self.signature)))
def serialize_unsigned(self, payload_version):
return b''.join((self.type, pack_varbytes(self.data),
pack_varbytes(self.ownerPublicKey), self.draftHash,
pack_varint(len(self.budgets)),
b''.join(budget.serialize()
for budget in self.budgets), self.recipient))
def serialize_others(self):
_count = len(self.signers)
return b''.join(
(pack_varbytes(self.blockconfirm), pack_varint(_count), b''.join(
(pack_varbytes(self.signers[i] for i in range(_count))))))
def serialize_unsigned(self):
return pack_varbytes(self.header)
def serialize_unsigned(self):
return b''.join((self.proposalhash, pack_varbytes(self.signer),
int_to_byte(1) if self.accept else int_to_byte(0)))
def serialize(self, payload_version):
if len(self.content) == 0:
return pack_varbytes(self.content)
else:
return pack_varbytes(self.content)
def serialize(self):
return b''.join(
(pack_varbytes(self.specification), pack_varbytes(self.operation),
b'' if self.operation != b'update' else pack_varbytes(
self.previoustxid)))
def serialize(self, payload_version):
return b''.join((self.serialize_unsigned(payload_version),
pack_varbytes(self.signature)))
def serialize(self, payload_version):
_count = len(self.arbitrators)
return b''.join(
(pack_varbytes(self.sponsor), pack_le_uint32(self.blockHeight),
pack_varint(_count), b''.join(
(pack_varbytes(self.arbitrators[i]) for i in range(_count)))))
def serialize(self, payload_version):
return b''.join((self.serialize_unsigned(payload_version),
pack_varbytes(self.ownerSignature),
pack_varbytes(self.newOwnerSignature),
int_to_byte(self.trackingType), self.opinionHash,
pack_varbytes(self.generalSignature)))
def serialize(self):
return b''.join((
pack_le_int64(self.value),
pack_varbytes(self.pk_script),
))
def serialize_unsigned(self, payload_version):
return b''.join((pack_varbytes(self.code), self.cid,
self.did if payload_version > 0 else b'',
pack_varbytes(self.nickname), pack_varbytes(self.url),
pack_le_uint64(self.location)))