You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
128 lines
4.3 KiB
128 lines
4.3 KiB
# Serializes into the Ripple Format
|
|
#
|
|
# Inspired by https://github.com/miracle2k/ripple-python and https://github.com/ripple/ripple-lib
|
|
# Docs at https://wiki.ripple.com/Binary_Format and https://developers.ripple.com/transaction-common-fields.html
|
|
#
|
|
# The first four bits specify the field type (int16, int32, account..)
|
|
# the other four the record type (amount, fee, destination..) and then
|
|
# the actual data follow. This currently only supports the Payment
|
|
# transaction type and the fields that are required for it.
|
|
|
|
from trezor.messages.RippleSignTx import RippleSignTx
|
|
|
|
from . import helpers
|
|
|
|
FIELD_TYPE_INT16 = 1
|
|
FIELD_TYPE_INT32 = 2
|
|
FIELD_TYPE_AMOUNT = 6
|
|
FIELD_TYPE_VL = 7
|
|
FIELD_TYPE_ACCOUNT = 8
|
|
|
|
FIELDS_MAP = {
|
|
"account": {"type": FIELD_TYPE_ACCOUNT, "key": 1},
|
|
"amount": {"type": FIELD_TYPE_AMOUNT, "key": 1},
|
|
"destination": {"type": FIELD_TYPE_ACCOUNT, "key": 3},
|
|
"fee": {"type": FIELD_TYPE_AMOUNT, "key": 8},
|
|
"sequence": {"type": FIELD_TYPE_INT32, "key": 4},
|
|
"type": {"type": FIELD_TYPE_INT16, "key": 2},
|
|
"signingPubKey": {"type": FIELD_TYPE_VL, "key": 3},
|
|
"flags": {"type": FIELD_TYPE_INT32, "key": 2},
|
|
"txnSignature": {"type": FIELD_TYPE_VL, "key": 4},
|
|
"lastLedgerSequence": {"type": FIELD_TYPE_INT32, "key": 27},
|
|
"destinationTag": {"type": FIELD_TYPE_INT32, "key": 14},
|
|
}
|
|
|
|
TRANSACTION_TYPES = {"Payment": 0}
|
|
|
|
|
|
def serialize(msg: RippleSignTx, source_address: str, pubkey=None, signature=None):
|
|
w = bytearray()
|
|
# must be sorted numerically first by type and then by name
|
|
write(w, FIELDS_MAP["type"], TRANSACTION_TYPES["Payment"])
|
|
write(w, FIELDS_MAP["flags"], msg.flags)
|
|
write(w, FIELDS_MAP["sequence"], msg.sequence)
|
|
write(w, FIELDS_MAP["destinationTag"], msg.payment.destination_tag)
|
|
write(w, FIELDS_MAP["lastLedgerSequence"], msg.last_ledger_sequence)
|
|
write(w, FIELDS_MAP["amount"], msg.payment.amount)
|
|
write(w, FIELDS_MAP["fee"], msg.fee)
|
|
write(w, FIELDS_MAP["signingPubKey"], pubkey)
|
|
write(w, FIELDS_MAP["txnSignature"], signature)
|
|
write(w, FIELDS_MAP["account"], source_address)
|
|
write(w, FIELDS_MAP["destination"], msg.payment.destination)
|
|
return w
|
|
|
|
|
|
def write(w: bytearray, field: dict, value):
|
|
if value is None:
|
|
return
|
|
write_type(w, field)
|
|
if field["type"] == FIELD_TYPE_INT16:
|
|
w.extend(value.to_bytes(2, "big"))
|
|
elif field["type"] == FIELD_TYPE_INT32:
|
|
w.extend(value.to_bytes(4, "big"))
|
|
elif field["type"] == FIELD_TYPE_AMOUNT:
|
|
w.extend(serialize_amount(value))
|
|
elif field["type"] == FIELD_TYPE_ACCOUNT:
|
|
write_bytes_varint(w, helpers.decode_address(value))
|
|
elif field["type"] == FIELD_TYPE_VL:
|
|
write_bytes_varint(w, value)
|
|
else:
|
|
raise ValueError("Unknown field type")
|
|
|
|
|
|
def write_type(w: bytearray, field: dict):
|
|
if field["key"] <= 0xF:
|
|
w.append((field["type"] << 4) | field["key"])
|
|
else:
|
|
# this concerns two-bytes fields such as lastLedgerSequence
|
|
w.append(field["type"] << 4)
|
|
w.append(field["key"])
|
|
|
|
|
|
def serialize_amount(value: int) -> bytearray:
|
|
if value < 0:
|
|
raise ValueError("Only non-negative integers are supported")
|
|
if value > helpers.MAX_ALLOWED_AMOUNT:
|
|
raise ValueError("Value is too large")
|
|
|
|
b = bytearray(value.to_bytes(8, "big"))
|
|
b[0] &= 0x7F # clear first bit to indicate XRP
|
|
b[0] |= 0x40 # set second bit to indicate positive number
|
|
return b
|
|
|
|
|
|
def write_bytes_varint(w: bytearray, value: bytes):
|
|
"""Serialize a variable length bytes."""
|
|
write_varint(w, len(value))
|
|
w.extend(value)
|
|
|
|
|
|
def write_varint(w: bytearray, val: int):
|
|
"""
|
|
Implements variable-length int encoding from Ripple.
|
|
See: https://ripple.com/wiki/Binary_Format#Variable_Length_Data_Encoding
|
|
"""
|
|
if val < 0:
|
|
raise ValueError("Only non-negative integers are supported")
|
|
elif val < 192:
|
|
w.append(val)
|
|
elif val <= 12480:
|
|
val -= 193
|
|
w.append(193 + rshift(val, 8))
|
|
w.append(val & 0xFF)
|
|
elif val <= 918744:
|
|
val -= 12481
|
|
w.append(241 + rshift(val, 16))
|
|
w.append(rshift(val, 8) & 0xFF)
|
|
w.append(val & 0xFF)
|
|
else:
|
|
raise ValueError("Value is too large")
|
|
|
|
|
|
def rshift(val, n):
|
|
"""
|
|
Implements signed right-shift.
|
|
See: http://stackoverflow.com/a/5833119/15677
|
|
"""
|
|
return (val % 0x100000000) >> n
|