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'