def peek(byte_string):
t, remainder, err = BigSize.pop(byte_string)
if err:
return None, "could not get type: %s" % err
l, remainder, err = BigSize.pop(remainder)
if err:
return None, "could not get length: %s" % err
if len(remainder) < l:
return None, "value truncated"
return Tlv(t, remainder[:l]), None
def pop(byte_string):
t, byte_string, err = BigSize.pop(byte_string)
if err:
return None, None, "could not get type: %s" % err
l, byte_string, err = BigSize.pop(byte_string)
if err:
return None, None, "could not get length: %s" % err
if len(byte_string) < l:
return None, None, "value truncated"
return Tlv(t, byte_string[:l]), byte_string[l:], None
def encode_non_final(amt_to_forward, outgoing_cltv_value, short_channel_id,
art_no, pixels):
unextended = TlvHopPayload.encode_non_final(amt_to_forward,
outgoing_cltv_value,
short_channel_id)
old_len, content, err = BigSize.pop(unextended)
assert err is None
art_no_content = Extension._encode_art_no(art_no)
pixel_content = Extension._encode_pixels(pixels)
new_content = content + art_no_content + pixel_content
return BigSize.encode(len(new_content)) + new_content
def encode_final(amt_to_forward, outgoing_cltv_value, payment_secret,
total_msat, art_no, pixels):
unextended = TlvHopPayload.encode_final(amt_to_forward,
outgoing_cltv_value,
pament_secret=payment_secret,
totol_msat=total_msat)
old_len, content, err = BigSize.pop(unextended)
assert err is None
art_no_content = Extension._encode_art_no(art_no)
pixel_content = Extension._encode_pixels(pixels)
new_content = content + art_no_content + pixel_content
return BigSize.encode(len(new_content)) + new_content
def encode_non_final(amt_to_forward, outgoing_cltv_value,
short_channel_id):
payload = (
TlvHopPayload.encode_amt_to_forward(amt_to_forward) +
TlvHopPayload.encode_outgoing_cltv_value(outgoing_cltv_value) +
TlvHopPayload.encode_short_channel_id(short_channel_id))
return BigSize.encode(len(payload)) + payload
def parse(byte_string, extension_parsers=None):
length, remainder, err = BigSize.pop(byte_string)
if err:
return None, err
if length == 1:
return None, "unknown version"
if length == 0:
return LegacyHopPayload.parse(remainder)
if len(remainder) != length:
return None, "remainder length does not match state length"
return TlvHopPayload.parse(remainder,
extension_parsers=extension_parsers)
def encode_final(amt_to_forward,
outgoing_cltv_value,
payment_secret=None,
total_msat=None):
payload = (
TlvHopPayload.encode_amt_to_forward(amt_to_forward) +
TlvHopPayload.encode_outgoing_cltv_value(outgoing_cltv_value))
if payment_secret:
assert total_msat != None, "payment_secret without total_msat"
payload += TlvHopPayload.encode_payment_data(
payment_secret, total_msat)
return BigSize.encode(len(payload)) + payload
def encode_custom_test(amt_to_forward=None,
outgoing_cltv_value=None,
short_channel_id=None,
payment_data=None):
# prepares a payload that may violate some of the BOLT 4 tlv payload
# rules
payload = b''
if amt_to_forward:
payload += TlvHopPayload.encode_amt_to_forward(amt_to_forward)
if outgoing_cltv_value:
payload += (
TlvHopPayload.encode_outgoing_cltv_value(outgoing_cltv_value))
if short_channel_id:
payload += TlvHopPayload.encode_short_channel_id(short_channel_id)
if payment_data:
payload += (TlvHopPayload.encode_payment_data(
payment_data[0], payment_data[1]))
return BigSize.encode(len(payload)) + payload
def encode(self):
return BigSize.encode(self.t) + BigSize.encode(self.l) + self.v
"name": "four byte no read",
"value": 0,
"bytes": "fe",
"exp_error": "unexpected EOF"
}, {
"name": "eight byte no read",
"value": 0,
"bytes": "ff",
"exp_error": "unexpected EOF"
}]
if __name__ == "__main__":
print("running test cases")
for test in BIGSIZE_DECODING_TESTS:
#print("test: %s" % test)
v, remainder, err = BigSize.pop(h2b(test['bytes']))
#print("%s %s %s %s" % (test['value'], str(v), remainder, err))
if 'exp_error' in test.keys():
assert err is not None, "did not get error as expected"
else:
assert v == test['value'], "did not get value expected"
print("passed test cases")
print("running small")
TEST_ITERATIONS = 10000
for _ in range(TEST_ITERATIONS):
v = random.randint(0, 0xfc)
encoded = BigSize.encode(v)
decoded, remainder, err = BigSize.pop(encoded)
assert err is None, "unexpected error"
assert len(remainder) == 0, "unexpected remainder"