Initial commit

Author: Jong-Shian Wu

LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2018, chelpis
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README

@@ -0,0 +1 @@
+Pure Python implementation of RLP encoding utilities for CPython 3.6+

rlp.py

@@ -0,0 +1,55 @@
+def RLP(x):
+    assert _is_RLP_serializable(x)
+    if type(x) is int and x >= 0:
+        return RLP(BE(x))
+    elif type(x) is bytes:
+        return RLP_B(x)
+    else:
+        return RLP_L(x)
+
+
+def _is_RLP_serializable(value):
+    return (
+        (type(value) is int and value >= 0)
+        or type(value) is bytes
+        or (
+            type(value) is tuple
+            and all(_is_RLP_serializable(v) for v in value)
+        )
+    )
+
+
+def BE(n):
+    assert type(n) is int and n >= 0
+    byte_length = (n.bit_length() - 1) // 8 + 1
+    return n.to_bytes(byte_length, "big")
+
+
+def RLP_B(x):
+    assert type(x) is bytes
+    if len(x) == 1 and x[0] < 128:
+        return x
+        # 0 <= head <= 127
+    elif len(x) < 56:
+        return bytes([128 + len(x)]) + x
+        # 0 <= len(x) <= 55
+        # 128 <= head <= 183
+    else:
+        # 56 <= len(x) <= ...
+        # 1 <= len(BE(len(x))) <= 8
+        # 184 <= head <= 191
+        return bytes([183 + len(BE(len(x)))]) + BE(len(x)) + x
+
+
+def RLP_L(l):
+    assert type(l) is tuple
+    s = b"".join(RLP(e) for e in l)
+    if len(s) < 56:
+        # 0 <= len(s) <= 55
+        # 192 <= head <= 247
+        return bytes([192 + len(s)]) + s
+    else:
+        # 56 <= len(s) <= ...
+        # 1 <= len(BE(len(s))) <= 9
+        # 248 <= head <= 255
+        return bytes([247 + len(BE(len(s)))]) + BE(len(s)) + s