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):
return b''.join(
(pack_le_int32(self.version), pack_varint(len(self.inputs)),
b''.join(tx_in.serialize() for tx_in in self.inputs),
pack_varint(len(self.outputs)),
b''.join(tx_out.serialize() for tx_out in self.outputs),
pack_le_uint32(self.locktime)))
def serialize_unsigned(self):
return b''.join(
(int_to_byte(self.type), int_to_byte(self.payload_version),
self.payload.serialize() if self.payload else b'',
pack_varint(len(self.attributes)),
b''.join(attr.serialize() for attr in self.attributes),
pack_varint(len(self.inputs)), b''.join(tx_in.serialize()
for tx_in in self.inputs),
pack_varint(len(self.outputs)),
b''.join(tx_out.serialize() for tx_out in self.outputs),
pack_le_uint32(self.locktime)))
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))
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 + nLocktime + vExtra
else:
nVersion = pack_le_int32(self.version)
return nVersion + txins + txouts + nLocktime
def serialize(self, version):
return b''.join((
int_to_byte(self.vote_type), # vote type
pack_varint(len(self.candidates)),
b''.join(
candidate.serialize(version)
for candidate in self.candidates)))
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 test_pack_varint():
tests = list(range(0, 258))
tests.extend([1024, 65535, 65536, 4294967295, 4294967296, 8294967296])
for n in tests:
data = util.pack_varint(n)
deser = tx.Deserializer(data)
assert deser._read_varint() == n
async def make_raw_block(self, b):
'''Construct a raw block'''
header = await self.make_raw_header(b)
transactions = []
if b.get('height') > 0:
transactions = await self.getrawtransactions(b.get('tx'), False)
raw_block = header
num_txs = len(transactions)
if num_txs > 0:
raw_block += pack_varint(num_txs)
raw_block += b''.join(transactions)
else:
raw_block += b'\x00'
return raw_block
def serialize(self):
return b''.join((
self.serialize_unsigned(),
pack_varint(len(self.scripts)),
b''.join(script.serialize() for script in self.scripts),
))
def serialize(self):
return b''.join((int_to_byte(self.version),
pack_varint(len(self.contents)), b''.join(
content.serialize(self.version)
for content in self.contents)))
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(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 create_raw_transaction(self, did, json_payload):
LOG.info("Creating raw transaction...")
spec = json_payload["header"]["specification"]
operation = json_payload["header"]["operation"]
verification = json_payload["proof"]["verificationMethod"]
signature = json_payload["proof"]["signature"]
payload = json_payload["payload"]
try:
did_sidechain_rpc = DidSidechainRpc()
addresses = [self.wallets[self.current_wallet_index]["address"]]
utxo_txid, asset_id, value, prev_idx = did_sidechain_rpc.get_utxos(
addresses)
wallet_exhausted = 0
while float(value) < 0.000001:
if wallet_exhausted == config.NUM_WALLETS:
LOG.info(
"None of the wallets have enough UTXOs to send a transaction"
)
return None
self.current_wallet_index += 1
if self.current_wallet_index > config.NUM_WALLETS - 1:
self.current_wallet_index = 0
utxo_txid, asset_id, value, prev_idx = did_sidechain_rpc.get_utxos(
addresses)
wallet_exhausted += 1
change = int((10**8) * (float(value) - self.did_sidechain_fee))
previous_txid = ""
if operation == "update":
previous_txid = json_payload["header"]["previousTxid"]
tx_header = tx_ela.DIDHeaderInfo(
specification=str.encode(spec),
operation=str.encode(operation),
previoustxid=str.encode(previous_txid))
tx_proof = tx_ela.DIDProofInfo(
type=b"ECDSAsecp256r1",
verification_method=str.encode(verification),
signature=str.encode(signature))
tx_payload = tx_ela.TxPayloadDIDOperation(
header=tx_header, payload=str.encode(payload),
proof=tx_proof).serialize()
sender_hashed_public_key = self.address_to_programhash(
self.wallets[self.current_wallet_index]["address"], False)
did_hashed = self.address_to_programhash(did, False)
# Variables needed for raw_tx
tx_type = b'\x0a' # DID transaction
payload_version = struct.pack("<B", 0) # one byte
output_count = struct.pack("<B", 2) # one byte
lock_time = struct.pack("<L", 0) # 4 bytes
program_count = struct.pack("<B", 1) # one byte
tx_attributes = tx_ela.TxAttribute(usage=129,
data=b'1234567890').serialize()
tx_input = tx_ela.TxInputELA(prev_hash=hex_str_to_hash(utxo_txid),
prev_idx=prev_idx,
sequence=0).serialize()
# DID requires 2 outputs. The first one is DID string with amount 0 and the second one is change address
# and amount. Fee is about 100 sela (.000001 ELA)
output1 = tx_ela.TxOutputELA(asset_id=hex_str_to_hash(asset_id),
value=0,
output_lock=0,
pk_script=did_hashed,
output_type=None,
output_payload=None).serialize(
tx_ela.TransferAsset)
output2 = tx_ela.TxOutputELA(asset_id=hex_str_to_hash(asset_id),
value=change,
output_lock=0,
pk_script=sender_hashed_public_key,
output_type=None,
output_payload=None).serialize(
tx_ela.TransferAsset)
raw_tx_string = (tx_type + payload_version + tx_payload +
program_count + tx_attributes + program_count +
tx_input + output_count + output1 + output2 +
lock_time)
code = self.get_code_from_pb()
signature = self.ecdsa_sign(raw_tx_string)
parameter = (struct.pack("B", len(signature)) + signature).hex()
parameter_bytes = bytes.fromhex(parameter)
code_bytes = bytes.fromhex(code)
script = (pack_varint(len(parameter_bytes)) + parameter_bytes +
pack_varint(len(code_bytes)) + code_bytes)
real_tx = (tx_type + payload_version + tx_payload + program_count +
tx_attributes + program_count + tx_input +
output_count + output1 + output2 + lock_time +
program_count + script)
return real_tx
except Exception as err:
message = "Error: " + str(err) + "\n"
exc_type, exc_obj, exc_tb = sys.exc_info()
message += "Unexpected error: " + str(exc_type) + "\n"
message += ' File "' + exc_tb.tb_frame.f_code.co_filename + '", line ' + str(
exc_tb.tb_lineno) + "\n"
LOG.info(f"Error while creating a transaction: {message}")
return None
def serialize(self, payload_version):
return b''.join(
(pack_le_uint32(self.height), pack_varbytes(self.address),
pack_varint(len(self.sidechaintxhashes)), b''.join(
(txhash for txhash in self.sidechaintxhashes))))
def test_pack_varint():
tests = list(range(0, 258))
tests.extend([1024, 65535, 65536, 4294967295, 4294967296, 8294967296])
for n in tests:
data = util.pack_varint(n)
deser = tx.Deserializer(data)
assert deser._read_varint() == n
import struct
with pytest.raises(struct.error):
util.pack_varint(-1)
assert util.pack_varint(0) == b'\0'
assert util.pack_varint(5) == b'\5'
assert util.pack_varint(252) == b'\xfc'
assert util.pack_varint(253) == b'\xfd\xfd\0'
assert util.pack_varint(65535) == b'\xfd\xff\xff'
assert util.pack_varint(65536) == b'\xfe\0\0\1\0'
assert util.pack_varint(2**32 - 1) == b'\xfe\xff\xff\xff\xff'
assert util.pack_varint(2**32) == b'\xff\0\0\0\0\1\0\0\0'
assert util.pack_varint(2**64-1) \
== b'\xff\xff\xff\xff\xff\xff\xff\xff\xff'
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 test_pack_varint():
tests = list(range(0, 258))
tests.extend([1024, 65535, 65536, 4294967295, 4294967296, 8294967296])
for n in tests:
data = util.pack_varint(n)
value, size = tx.read_varint(data, 0)
assert value == n and size == len(data)
import struct
with pytest.raises(struct.error):
util.pack_varint(-1)
assert util.pack_varint(0) == b'\0'
assert util.pack_varint(5) == b'\5'
assert util.pack_varint(252) == b'\xfc'
assert util.pack_varint(253) == b'\xfd\xfd\0'
assert util.pack_varint(65535) == b'\xfd\xff\xff'
assert util.pack_varint(65536) == b'\xfe\0\0\1\0'
assert util.pack_varint(2**32 - 1) == b'\xfe\xff\xff\xff\xff'
assert util.pack_varint(2**32) == b'\xff\0\0\0\0\1\0\0\0'
assert util.pack_varint(2**64-1) \
== b'\xff\xff\xff\xff\xff\xff\xff\xff\xff'
