def _encode_ballot(w: bytearray, ballot): ballot_tag = 6 write_uint8(w, ballot_tag) write_bytes(w, ballot.source) write_uint32_be(w, ballot.period) write_bytes(w, ballot.proposal) write_uint8(w, ballot.ballot)
def write_string(w, s: str): buf = s.encode() write_uint32(w, len(buf)) write_bytes(w, buf) # if len isn't a multiple of 4, add padding bytes reminder = len(buf) % 4 if reminder: write_bytes(w, bytes([0] * (4 - reminder)))
def encode_cancel_lease_tx_to_bytes(tx): w = bytearray() write_uint8(w, tx.transactionType) write_uint64_be(w, tx.fee) write_uint16_be(w, tx.feeScale) write_uint64_be(w, helpers.convert_to_nano_sec(tx.timestamp)) write_bytes(w, base58.decode(tx.txId)) return w
def write_tx_input_check(w, i: TxInputType): write_bytes(w, i.prev_hash) write_uint32(w, i.prev_index) write_uint32(w, i.script_type) write_uint32(w, len(i.address_n)) for n in i.address_n: write_uint32(w, n) write_uint32(w, i.sequence) write_uint64(w, i.amount or 0)
def _encode_proposal(w: bytearray, proposal): proposal_tag = 5 write_uint8(w, proposal_tag) write_bytes(w, proposal.source) write_uint32_be(w, proposal.period) write_uint32_be(w, len(proposal.proposals) * PROPOSAL_LENGTH) for proposal_hash in proposal.proposals: write_bytes(w, proposal_hash)
def write_variant32(w: Writer, value: int) -> None: variant = bytearray() while True: b = value & 0x7F value >>= 7 b |= (value > 0) << 7 variant.append(b) if value == 0: break write_bytes(w, bytes(variant))
def write_string(w, s: AnyStr) -> None: """Write XDR string padded to a multiple of 4 bytes.""" if isinstance(s, str): buf = s.encode() else: buf = s write_uint32(w, len(buf)) write_bytes(w, buf) # if len isn't a multiple of 4, add padding bytes reminder = len(buf) % 4 if reminder: write_bytes(w, bytes([0] * (4 - reminder)))
def _encode_common(w: bytearray, operation, str_operation): operation_tags = { "reveal": 107, "transaction": 108, "origination": 109, "delegation": 110, } write_uint8(w, operation_tags[str_operation]) write_bytes(w, operation.source) _encode_zarith(w, operation.fee) _encode_zarith(w, operation.counter) _encode_zarith(w, operation.gas_limit) _encode_zarith(w, operation.storage_limit)
def encode_payment_tx_to_bytes(tx): w = bytearray() write_uint8(w, tx.transactionType) write_uint64_be(w, helpers.convert_to_nano_sec(tx.timestamp)) write_uint64_be(w, tx.amount) write_uint64_be(w, tx.fee) write_uint16_be(w, tx.feeScale) write_bytes(w, base58.decode(tx.recipient)) try: attachment_bytes = base58.decode(tx.attachment) except Exception: attachment_bytes = bytes(tx.attachment, 'utf-8') write_uint16_be(w, len(attachment_bytes)) write_bytes(w, attachment_bytes) return w
def _encode_manager_delegation(w: bytearray, delegate): MICHELSON_LENGTH = 42 # length is fixed this time(no variable length fields) _encode_manager_common(w, MICHELSON_LENGTH, "PUSH") write_bytes(w, delegate) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["SOME"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["SET_DELEGATE"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["CONS"])
def write_auth(w: bytearray, auth: EosAuthorization) -> int: write_uint32_le(w, auth.threshold) write_variant32(w, len(auth.keys)) for key in auth.keys: write_variant32(w, key.type) write_bytes(w, key.key) write_uint16_le(w, key.weight) write_variant32(w, len(auth.accounts)) for account in auth.accounts: write_uint64_le(w, account.account.actor) write_uint64_le(w, account.account.permission) write_uint16_le(w, account.weight) write_variant32(w, len(auth.waits)) for wait in auth.waits: write_uint32_le(w, wait.wait_sec) write_uint16_le(w, wait.weight)
def _get_operation_bytes(w: bytearray, msg): write_bytes(w, msg.branch) # when the account sends first operation in lifetime, # we need to reveal its publickey if msg.reveal is not None: _encode_common(w, msg.reveal, "reveal") write_bytes(w, msg.reveal.public_key) # transaction operation if msg.transaction is not None: _encode_common(w, msg.transaction, "transaction") _encode_zarith(w, msg.transaction.amount) _encode_contract_id(w, msg.transaction.destination) _encode_data_with_bool_prefix(w, msg.transaction.parameters) # origination operation elif msg.origination is not None: _encode_common(w, msg.origination, "origination") write_bytes(w, msg.origination.manager_pubkey) _encode_zarith(w, msg.origination.balance) _encode_bool(w, msg.origination.spendable) _encode_bool(w, msg.origination.delegatable) _encode_data_with_bool_prefix(w, msg.origination.delegate) _encode_data_with_bool_prefix(w, msg.origination.script) # delegation operation elif msg.delegation is not None: _encode_common(w, msg.delegation, "delegation") _encode_data_with_bool_prefix(w, msg.delegation.delegate)
def _get_operation_bytes(w: bytearray, msg): write_bytes(w, msg.branch) # when the account sends first operation in lifetime, # we need to reveal its public key if msg.reveal is not None: _encode_common(w, msg.reveal, "reveal") write_bytes(w, msg.reveal.public_key) # transaction operation if msg.transaction is not None: _encode_common(w, msg.transaction, "transaction") _encode_zarith(w, msg.transaction.amount) _encode_contract_id(w, msg.transaction.destination) # support delegation and transfer from the old scriptless contracts (now with manager.tz script) if msg.transaction.parameters_manager is not None: parameters_manager = msg.transaction.parameters_manager if parameters_manager.set_delegate is not None: _encode_manager_delegation(w, parameters_manager.set_delegate) elif parameters_manager.cancel_delegate is not None: _encode_manager_delegation_remove(w) elif parameters_manager.transfer is not None: if (parameters_manager.transfer.destination.tag == TezosContractType.Implicit): _encode_manager_to_implicit_transfer( w, parameters_manager.transfer) else: _encode_manager_to_manager_transfer( w, parameters_manager.transfer) else: _encode_data_with_bool_prefix(w, msg.transaction.parameters) # origination operation elif msg.origination is not None: _encode_common(w, msg.origination, "origination") _encode_zarith(w, msg.origination.balance) _encode_data_with_bool_prefix(w, msg.origination.delegate) write_bytes(w, msg.origination.script) # delegation operation elif msg.delegation is not None: _encode_common(w, msg.delegation, "delegation") _encode_data_with_bool_prefix(w, msg.delegation.delegate) elif msg.proposal is not None: _encode_proposal(w, msg.proposal) elif msg.ballot is not None: _encode_ballot(w, msg.ballot)
def write_tx_output(w, o: TxOutputBinType): write_uint64(w, o.amount) if o.decred_script_version is not None: write_uint16(w, o.decred_script_version) write_varint(w, len(o.script_pubkey)) write_bytes(w, o.script_pubkey)
def write_tx_input_decred_witness(w, i: TxInputType): write_uint64(w, i.amount or 0) write_uint32(w, 0) # block height fraud proof write_uint32(w, 0xFFFFFFFF) # block index fraud proof write_varint(w, len(i.script_sig)) write_bytes(w, i.script_sig)
def write_pubkey(w, address: str): # first 4 bytes of an address are the type, there's only one type (0) write_uint32(w, 0) write_bytes(w, public_key_from_address(address))
def write_tx_input(w, i: TxInputType): write_bytes_reversed(w, i.prev_hash) write_uint32(w, i.prev_index) write_varint(w, len(i.script_sig)) write_bytes(w, i.script_sig) write_uint32(w, i.sequence)
def _encode_manager_to_manager_transfer(w: bytearray, manager_transfer): MICHELSON_LENGTH = 77 value_natural = bytearray() _encode_natural(value_natural, manager_transfer.amount) sequence_length = MICHELSON_LENGTH + len(value_natural) _encode_manager_common(w, sequence_length, "PUSH", to_contract=True) _encode_contract_id(w, manager_transfer.destination) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["CONTRACT"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["unit"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["ASSERT_SOME"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["PUSH"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["mutez"]) _encode_natural(w, manager_transfer.amount) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["UNIT"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["TRANSFER_TOKENS"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["CONS"])
def _encode_manager_delegation_remove(w: bytearray): MICHELSON_LENGTH = 14 # length is fixed this time(no variable length fields) _encode_manager_common(w, MICHELSON_LENGTH, "NONE") write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["SET_DELEGATE"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["CONS"])
def _encode_manager_to_implicit_transfer(w: bytearray, manager_transfer): MICHELSON_LENGTH = 48 value_natural = bytearray() _encode_natural(value_natural, manager_transfer.amount) sequence_length = MICHELSON_LENGTH + len(value_natural) _encode_manager_common(w, sequence_length, "PUSH") write_bytes(w, manager_transfer.destination.hash) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["IMPLICIT_ACCOUNT"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["PUSH"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["mutez"]) _encode_natural(w, manager_transfer.amount) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["UNIT"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["TRANSFER_TOKENS"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["CONS"])
def _encode_contract_id(w: bytearray, contract_id): write_uint8(w, contract_id.tag) write_bytes(w, contract_id.hash)
def write_action_transfer(w: bytearray, msg: EosActionTransfer): write_uint64_le(w, msg.sender) write_uint64_le(w, msg.receiver) write_asset(w, msg.quantity) write_variant32(w, len(msg.memo)) write_bytes(w, msg.memo)
def write_bytes_with_len(w, buf: bytes): write_uint32_le(w, len(buf)) write_bytes(w, buf)
def _encode_data_with_bool_prefix(w: bytearray, data): if data: _encode_bool(w, True) write_bytes(w, data) else: _encode_bool(w, False)
def _encode_manager_common(w: bytearray, sequence_length, operation, to_contract=False): IMPLICIT_ADDRESS_LENGTH = 21 SMART_CONTRACT_ADDRESS_LENGTH = 22 # 5 = tag and sequence_length (1 byte + 4 bytes) argument_length = sequence_length + 5 helpers.write_bool(w, True) write_uint8(w, helpers.DO_ENTRYPOINT_TAG) write_uint32_be(w, argument_length) write_uint8(w, helpers.MICHELSON_SEQUENCE_TAG) write_uint32_be(w, sequence_length) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["DROP"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["NIL"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["operation"]) write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES[operation]) if to_contract is True: write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["address"]) else: write_bytes(w, helpers.MICHELSON_INSTRUCTION_BYTES["key_hash"]) if operation == "PUSH": write_bytes(w, bytes([10])) # byte sequence if to_contract is True: write_uint32_be(w, SMART_CONTRACT_ADDRESS_LENGTH) else: write_uint32_be(w, IMPLICIT_ADDRESS_LENGTH)
def write_bytes_with_length(w, buf: bytearray): write_varint(w, len(buf)) write_bytes(w, buf)
def write_tx_output(w, o: TxOutputBinType): write_uint64(w, o.amount) write_varint(w, len(o.script_pubkey)) write_bytes(w, o.script_pubkey)