Refactor abi encoding and decoding

Author: mohanson

example/storage.py

@@ -29,7 +29,7 @@
 if args.action == 'set':
     user = pleth.wallet.Wallet(int(args.prikey, 0))
     data = pleth.abi.function_selector('set', ['uint256']) + pleth.abi.argument_encoding([
-        pleth.abi.encode_uint256(42),
+        pleth.abi.Uint256.encode(42),
     ])
     hash = user.contract_exec(bytearray.fromhex(args.addr[2:]), 0, data)
     print(f'hash = 0x{hash.hex()}')

pleth/__init__.py

@@ -3,6 +3,7 @@
 from . import core
 from . import denomination
 from . import ecdsa
+from . import io
 from . import keccak
 from . import objectdict
 from . import rate

pleth/abi.py

@@ -1,4 +1,6 @@
+import io
 import pleth.core
+import pleth.io
 
 # The Contract Application Binary Interface (ABI) is the standard way to interact with contracts in the Ethereum
 # ecosystem, both from outside the blockchain and for contract-to-contract interaction. Data is encoded according to
@@ -8,27 +10,6 @@
 # See: https://docs.soliditylang.org/en/latest/abi-spec.html
 
 
-def encode_uint256(data: int) -> bytearray:
-    assert data >= 0
-    assert data <= 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-    return bytearray(data.to_bytes(32))
-
-
-def decode_uint256(data: bytearray) -> int:
-    assert len(data) == 32
-    return int.from_bytes(data)
-
-
-def encode_address(data: bytearray) -> bytearray:
-    assert len(data) == 20
-    return bytearray(12) + data
-
-
-def decode_address(data: bytearray) -> bytearray:
-    assert len(data) == 32
-    return data[12:]
-
-
 def function_selector(name: str, args_type: list[str]) -> bytearray:
     s = name + '(' + ','.join(args_type) + ')'
     return pleth.core.hash(bytearray(s.encode()))[:4]
@@ -39,3 +20,40 @@ def argument_encoding(data: list[bytearray]) -> bytearray:
     for e in data:
         s.extend(e)
     return s
+
+
+class Address:
+    @classmethod
+    def decode(cls, reader: io.IOBase) -> bytearray:
+        return pleth.io.read_full(reader, 32)[12:]
+
+    @classmethod
+    def encode(cls, origin: bytearray) -> bytearray:
+        assert len(origin) == 20
+        return bytearray(12) + origin
+
+
+class Bytes:
+    @classmethod
+    def decode(cls, reader: io.IOBase) -> bytearray:
+        length = Uint256.decode(reader)
+        padded = (length + 31) & -32
+        return pleth.io.read_full(reader, padded)[:length]
+
+    @classmethod
+    def encode(cls, origin: bytearray) -> bytearray:
+        length = len(origin)
+        padded = (length + 31) & -32
+        return Uint256.encode(length) + origin + bytearray(padded - length)
+
+
+class Uint256:
+    @classmethod
+    def decode(cls, reader: io.IOBase) -> int:
+        return int.from_bytes(pleth.io.read_full(reader, 32), 'big')
+
+    @classmethod
+    def encode(cls, origin: int) -> bytearray:
+        assert origin >= 0
+        assert origin <= 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+        return bytearray(origin.to_bytes(32, 'big'))

pleth/io.py

@@ -0,0 +1,12 @@
+import io
+
+
+def read_full(reader: io.IOBase, n: int) -> bytearray:
+    # Read exactly n bytes from reader, or raise EOFError.
+    data = bytearray()
+    while len(data) < n:
+        once = reader.read(n - len(data))
+        if not once:
+            raise EOFError('io: EOF')
+        data.extend(once)
+    return data