diff --git a/tests/all_tests.nim b/tests/all_tests.nim
index b9e224c..f31c88f 100644
--- a/tests/all_tests.nim
+++ b/tests/all_tests.nim
@@ -17,4 +17,5 @@ import
   test_logs,
   test_json_marshalling,
   test_signed_tx,
-  test_execution_types
+  test_execution_types,
+  test_string_decoder
diff --git a/tests/test_contracts.nim b/tests/test_contracts.nim
index 3d594e5..2507fa8 100644
--- a/tests/test_contracts.nim
+++ b/tests/test_contracts.nim
@@ -14,25 +14,55 @@ import
   ../web3,
   ./helpers/utils
 
+type
+  Data1 = object
+    a: UInt256
+    data: seq[byte]
+
 contract(EncodingTest):
-  proc setBool(val: Bool)
-  proc getBool(): Bool {.view.}
+  proc setBool(val: bool)
+  proc getBool(): bool {.view.}
+  proc setData1(a: UInt256, d: seq[byte])
+  proc getData1(): Data1
+  proc getManyData1(): seq[Data1]
 
-const EncodingTestCode =  "608060405260008060006101000a81548160ff02191690831515021790555034801561002a57600080fd5b506101048061003a6000396000f3006080604052600436106049576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806312a7b91414604e5780631e26fd3314607a575b600080fd5b348015605957600080fd5b50606060a6565b604051808215151515815260200191505060405180910390f35b348015608557600080fd5b5060a460048036038101908080351515906020019092919050505060bc565b005b60008060009054906101000a900460ff16905090565b806000806101000a81548160ff021916908315150217905550505600a165627a7a72305820be0033d3993a43508dbcb21e47d345021ad5f89e26e035767fdae7ba9ef2ae310029"
+const EncodingTestCode =  "608060405260008060006101000a81548160ff02191690831515021790555034801561002a57600080fd5b50610b508061003a6000396000f3fe608060405234801561001057600080fd5b50600436106100575760003560e01c806312a7b9141461005c5780631cb3eebe1461007a5780631e26fd33146100965780639944cc71146100b25780639fd159e6146100d0575b600080fd5b6100646100ee565b60405161007191906103cf565b60405180910390f35b610094600480360381019061008f919061048f565b610104565b005b6100b060048036038101906100ab919061051b565b610187565b005b6100ba6101a3565b6040516100c79190610624565b60405180910390f35b6100d8610259565b6040516100e59190610745565b60405180910390f35b60008060009054906101000a900460ff16905090565b604051806040016040528084815260200183838080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f82011690508083019250505050505050815250600160008201518160000155602082015181600101908161017e91906109a2565b50905050505050565b806000806101000a81548160ff02191690831515021790555050565b6101ab61039a565b6001604051806040016040529081600082015481526020016001820180546101d2906107c5565b80601f01602080910402602001604051908101604052809291908181526020018280546101fe906107c5565b801561024b5780601f106102205761010080835404028352916020019161024b565b820191906000526020600020905b81548152906001019060200180831161022e57829003601f168201915b505050505081525050905090565b6060600367ffffffffffffffff81111561027657610275610767565b5b6040519080825280602002602001820160405280156102af57816020015b61029c61039a565b8152602001906001900390816102945790505b50905060005b8151811015610396576001604051806040016040529081600082015481526020016001820180546102e5906107c5565b80601f0160208091040260200160405190810160405280929190818152602001828054610311906107c5565b801561035e5780601f106103335761010080835404028352916020019161035e565b820191906000526020600020905b81548152906001019060200180831161034157829003601f168201915b50505050508152505082828151811061037a57610379610a74565b5b60200260200101819052508061038f90610ad2565b90506102b5565b5090565b604051806040016040528060008152602001606081525090565b60008115159050919050565b6103c9816103b4565b82525050565b60006020820190506103e460008301846103c0565b92915050565b600080fd5b600080fd5b6000819050919050565b610407816103f4565b811461041257600080fd5b50565b600081359050610424816103fe565b92915050565b600080fd5b600080fd5b600080fd5b60008083601f84011261044f5761044e61042a565b5b8235905067ffffffffffffffff81111561046c5761046b61042f565b5b60208301915083600182028301111561048857610487610434565b5b9250929050565b6000806000604084860312156104a8576104a76103ea565b5b60006104b686828701610415565b935050602084013567ffffffffffffffff8111156104d7576104d66103ef565b5b6104e386828701610439565b92509250509250925092565b6104f8816103b4565b811461050357600080fd5b50565b600081359050610515816104ef565b92915050565b600060208284031215610531576105306103ea565b5b600061053f84828501610506565b91505092915050565b610551816103f4565b82525050565b600081519050919050565b600082825260208201905092915050565b60005b83811015610591578082015181840152602081019050610576565b60008484015250505050565b6000601f19601f8301169050919050565b60006105b982610557565b6105c38185610562565b93506105d3818560208601610573565b6105dc8161059d565b840191505092915050565b60006040830160008301516105ff6000860182610548565b506020830151848203602086015261061782826105ae565b9150508091505092915050565b6000602082019050818103600083015261063e81846105e7565b905092915050565b600081519050919050565b600082825260208201905092915050565b6000819050602082019050919050565b600060408301600083015161068a6000860182610548565b50602083015184820360208601526106a282826105ae565b9150508091505092915050565b60006106bb8383610672565b905092915050565b6000602082019050919050565b60006106db82610646565b6106e58185610651565b9350836020820285016106f785610662565b8060005b85811015610733578484038952815161071485826106af565b945061071f836106c3565b925060208a019950506001810190506106fb565b50829750879550505050505092915050565b6000602082019050818103600083015261075f81846106d0565b905092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b600060028204905060018216806107dd57607f821691505b6020821081036107f0576107ef610796565b5b50919050565b60008190508160005260206000209050919050565b60006020601f8301049050919050565b600082821b905092915050565b6000600883026108587fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8261081b565b610862868361081b565b95508019841693508086168417925050509392505050565b6000819050919050565b600061089f61089a610895846103f4565b61087a565b6103f4565b9050919050565b6000819050919050565b6108b983610884565b6108cd6108c5826108a6565b848454610828565b825550505050565b600090565b6108e26108d5565b6108ed8184846108b0565b505050565b5b81811015610911576109066000826108da565b6001810190506108f3565b5050565b601f82111561095657610927816107f6565b6109308461080b565b8101602085101561093f578190505b61095361094b8561080b565b8301826108f2565b50505b505050565b600082821c905092915050565b60006109796000198460080261095b565b1980831691505092915050565b60006109928383610968565b9150826002028217905092915050565b6109ab82610557565b67ffffffffffffffff8111156109c4576109c3610767565b5b6109ce82546107c5565b6109d9828285610915565b600060209050601f831160018114610a0c57600084156109fa578287015190505b610a048582610986565b865550610a6c565b601f198416610a1a866107f6565b60005b82811015610a4257848901518255600182019150602085019450602081019050610a1d565b86831015610a5f5784890151610a5b601f891682610968565b8355505b6001600288020188555050505b505050505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b6000610add826103f4565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8203610b0f57610b0e610aa3565b5b60018201905091905056fea2646970667358221220265a3d7b004b7ea36bfc364804ed8717fcb6adf60b5edf24d773660fb7c736df64736f6c63430008130033"
 
 #[ Contract EncodingTest
-pragma solidity ^0.4.18;
+pragma solidity ^0.8.0;
 
 contract EncodingTest {
     bool boolVal = false;
 
+    struct Data1 {
+        uint a;
+        bytes data;
+    }
+
+    Data1 data1;
+
     function setBool(bool _boolVal) public {
         boolVal = _boolVal;
     }
 
-    function getBool() public constant returns (bool) {
+    function getBool() public view returns (bool) {
         return boolVal;
     }
+
+    function setData1(uint a, bytes calldata data) public {
+        data1 = Data1(a, data);
+    }
+
+    function getData1() public view returns(Data1 memory) {
+        return data1;
+    }
+
+    function getManyData1() public view returns(Data1[] memory result) {
+        result = new Data1[](3);
+        for (uint i = 0; i < result.length; ++i) {
+            result[i] = data1;
+        }
+    }
 }
 ]#
 
@@ -83,7 +113,7 @@ contract MetaCoin {
 }
 ]#
 contract(MetaCoin):
-  proc sendCoin(receiver: Address, amount: UInt256): Bool
+  proc sendCoin(receiver: Address, amount: UInt256): bool
   proc getBalance(address: Address): UInt256 {.view.}
   proc Transfer(fromAddr, toAddr: indexed[Address], value: UInt256) {.event.}
   proc BlaBla(fromAddr: indexed[Address]) {.event.}
@@ -124,12 +154,27 @@ suite "Contracts":
       let ns = web3.contractSender(EncodingTest, cc)
 
       var b = await ns.getBool().call()
-      assert(b == Bool.parse(false))
+      assert(b == false)
 
-      echo "setBool: ", await ns.setBool(Bool.parse(true)).send()
+      let r = await ns.setBool(true).send()
+      echo "setBool: ", r
 
       b = await ns.getBool().call()
-      assert(b == Bool.parse(true))
+      assert(b == true)
+
+      let data1data = @[1.byte, 2, 3, 4, 5]
+      discard await ns.setData1(123.u256, data1data).send()
+
+      let data1 = await ns.getData1().call()
+      assert(data1.a == 123.u256)
+      assert(data1.data == data1data)
+
+      let manyData1 = await ns.getManyData1().call()
+      assert(manyData1.len == 3)
+      for i in 0 .. manyData1.high:
+        assert(manyData1[i].a == 123.u256)
+        assert(manyData1[i].data == data1data)
+
     waitFor asynctest()
 
   test "number storage":
diff --git a/tests/test_string_decoder.nim b/tests/test_string_decoder.nim
new file mode 100644
index 0000000..63c7681
--- /dev/null
+++ b/tests/test_string_decoder.nim
@@ -0,0 +1,35 @@
+import pkg/unittest2
+import ../web3
+
+type
+  PubKeyBytes = DynamicBytes[48, 48]
+  WithdrawalCredentialsBytes = DynamicBytes[32, 32]
+  SignatureBytes = DynamicBytes[96, 96]
+  Int64LeBytes = DynamicBytes[8, 8]
+
+const logData = "00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000030b2f5263a3454de3a9116b0edaa3cfbb2795a99482ee268b7aed5b15b532d9b20c34b67c82877ba1326326f3ae6cc5ad3000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020010000000000000000000000a3f7076718fa4fed91b5830a45489053eb367afb0000000000000000000000000000000000000000000000000000000000000008004059730700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000608ee47adfab0819ec0d9144a3f76c0a663f8d7d66a2cfd994eb5d23d15d779430ec85ecd3c91bf7b4d229a9c4a8bee83e0096913d0b05525307114d75fa9baf79b4634ba80d3d262dd769c66fb6af25bff30a5ce04600940d2271278fad5b3096000000000000000000000000000000000000000000000000000000000000000802f3000000000000000000000000000000000000000000000000000000000000"
+
+template init[N: static int](T: type DynamicBytes[N, N]): T =
+  T newSeq[byte](N)
+
+suite "String decoders":
+  test "Log message decoding":
+    var
+      pubkey = init PubKeyBytes
+      withdrawalCredentials = init WithdrawalCredentialsBytes
+      amount = init Int64LeBytes
+      signature = init SignatureBytes
+      index = init Int64LeBytes
+
+    var offset = 0
+    offset += decode(logData, offset, pubkey)
+    offset += decode(logData, offset, withdrawalCredentials)
+    offset += decode(logData, offset, amount)
+    offset += decode(logData, offset, signature)
+    offset += decode(logData, offset, index)
+
+    assert($pubkey == "0xb2f5263a3454de3a9116b0edaa3cfbb2795a99482ee268b7aed5b15b532d9b20c34b67c82877ba1326326f3ae6cc5ad3")
+    assert($withdrawalCredentials == "0x010000000000000000000000a3f7076718fa4fed91b5830a45489053eb367afb")
+    assert($amount == "0x0040597307000000")
+    assert($signature == "0x8ee47adfab0819ec0d9144a3f76c0a663f8d7d66a2cfd994eb5d23d15d779430ec85ecd3c91bf7b4d229a9c4a8bee83e0096913d0b05525307114d75fa9baf79b4634ba80d3d262dd769c66fb6af25bff30a5ce04600940d2271278fad5b3096")
+    assert($index == "0x02f3000000000000")
diff --git a/web3.nim b/web3.nim
index 4cc4884..6ab0f75 100644
--- a/web3.nim
+++ b/web3.nim
@@ -8,7 +8,7 @@
 # those terms.
 
 import
-  std/[macros, strutils, options, json, tables, uri, strformat]
+  std/[options, math, json, tables, uri, strformat]
 
 from os import DirSep, AltSep
 
@@ -16,7 +16,7 @@ import
   stint, httputils, chronicles, chronos, nimcrypto/keccak,
   json_rpc/[rpcclient, jsonmarshal], stew/byteutils, eth/keys,
   chronos/apps/http/httpclient,
-  web3/[eth_api_types, conversions, ethhexstrings, transaction_signing, encoding]
+  web3/[eth_api_types, conversions, ethhexstrings, transaction_signing, encoding, contract_dsl]
 
 template sourceDir: string = currentSourcePath.rsplit({DirSep, AltSep}, 1)[0]
 
@@ -24,7 +24,7 @@ template sourceDir: string = currentSourcePath.rsplit({DirSep, AltSep}, 1)[0]
 createRpcSigs(RpcClient, sourceDir & "/web3/eth_api_callsigs.nim")
 
 export UInt256, Int256, Uint128, Int128
-export eth_api_types, conversions, encoding, HttpClientFlag, HttpClientFlags
+export eth_api_types, conversions, encoding, contract_dsl, HttpClientFlag, HttpClientFlags
 
 type
   Web3* = ref object
@@ -35,11 +35,11 @@ type
     lastKnownNonce*: Option[Quantity]
     onDisconnect*: proc() {.gcsafe, raises: [].}
 
-  Sender*[T] = ref object
+  Web3SenderImpl = ref object
     web3*: Web3
     contractAddress*: Address
 
-  EncodeResult* = tuple[dynamic: bool, data: string]
+  Sender*[T] = ContractInstance[T, Web3SenderImpl]
 
   SubscriptionEventHandler* = proc (j: JsonNode) {.gcsafe, raises: [].}
   SubscriptionErrorHandler* = proc (err: CatchableError) {.gcsafe, raises: [].}
@@ -55,14 +55,6 @@ type
     historicalEventsProcessed: bool
     removed: bool
 
-  ContractCallBase = ref object of RootObj
-    web3: Web3
-    data: seq[byte]
-    to: Address
-    value: UInt256
-
-  ContractCall*[T] = ref object of ContractCallBase
-
 proc handleSubscriptionNotification(w: Web3, j: JsonNode) =
   let s = w.subscriptions.getOrDefault(j{"subscription"}.getStr())
   if not s.isNil and not s.removed:
@@ -162,6 +154,24 @@ proc subscribeForLogs*(w: Web3, options: JsonNode,
   else:
     result.historicalEventsProcessed = true
 
+proc addAddressAndSignatureToOptions(options: JsonNode, address: Address, topic: seq[byte]): JsonNode =
+  result = if options.isNil: newJObject() else: options
+  if "address" notin result:
+    result["address"] = %address
+  var topics = result{"topics"}
+  if topics.isNil:
+    topics = newJArray()
+    result["topics"] = topics
+  topics.elems.insert(%to0xHex(topic), 0)
+
+proc subscribeForLogs*(s: Web3SenderImpl, options: JsonNode,
+                       topic: seq[byte],
+                       logsHandler: SubscriptionEventHandler,
+                       errorHandler: SubscriptionErrorHandler,
+                       withHistoricEvents = true): Future[Subscription] =
+  let options = addAddressAndSignatureToOptions(options, s.contractAddress, topic)
+  s.web3.subscribeForLogs(options, logsHandler, errorHandler, withHistoricEvents)
+
 proc subscribeForBlockHeaders*(w: Web3,
                                blockHeadersCallback: proc(b: BlockHeader) {.gcsafe, raises: [].},
                                errorHandler: SubscriptionErrorHandler): Future[Subscription]
@@ -184,376 +194,13 @@ proc unsubscribe*(s: Subscription): Future[void] {.async.} =
   s.removed = true
   discard await s.web3.provider.eth_unsubscribe(s.id)
 
-proc unknownType() = discard # Used for informative errors
-
-template typeSignature(T: typedesc): string =
-  when T is string:
-    "string"
-  elif T is DynamicBytes:
-    "bytes"
-  elif T is FixedBytes:
-    "bytes" & $T.N
-  elif T is StUint:
-    "uint" & $T.bits
-  elif T is Address:
-    "address"
-  elif T is Bool:
-    "bool"
-  else:
-    unknownType(T)
-
-proc initContractCall[T](web3: Web3, data: string, to: Address): ContractCall[T] {.inline.} =
-  try:
-    ContractCall[T](web3: web3, data: hexToSeqByte(data), to: to)
-  except ValueError as ex:
-    raise newException(AssertionDefect, ex.msg)
-
-type
-  InterfaceObjectKind = enum
-    function, constructor, event
-  MutabilityKind = enum
-    pure, view, nonpayable, payable
-  FunctionInputOutput = object
-    name: string
-    typ: NimNode
-  EventInput = object
-    name: string
-    typ: NimNode
-    indexed: bool
-  FunctionObject = object
-    name: string
-    stateMutability: MutabilityKind
-    inputs: seq[FunctionInputOutput]
-    outputs: seq[FunctionInputOutput]
-  ConstructorObject = object
-    stateMutability: MutabilityKind
-    inputs: seq[FunctionInputOutput]
-    outputs: seq[FunctionInputOutput]
-  EventObject = object
-    name: string
-    inputs: seq[EventInput]
-    anonymous: bool
-
-  InterfaceObject = object
-    case kind: InterfaceObjectKind
-    of function: functionObject: FunctionObject
-    of constructor: constructorObject: ConstructorObject
-    of event: eventObject: EventObject
-
-proc joinStrings(s: varargs[string]): string = join(s)
-
-proc getSignature(function: FunctionObject | EventObject): NimNode =
-  result = newCall(bindSym"joinStrings")
-  result.add(newLit(function.name & "("))
-  for i, input in function.inputs:
-    result.add(newCall(bindSym"typeSignature", input.typ))
-    if i != function.inputs.high:
-      result.add(newLit(","))
-  result.add(newLit(")"))
-  result = newCall(ident"static", result)
-
-proc addAddressAndSignatureToOptions(options: JsonNode, address: Address, signature: string): JsonNode =
-  result = options
-  if result.isNil:
-    result = newJObject()
-  if "address" notin result:
-    result["address"] = %address
-  var topics = result{"topics"}
-  if topics.isNil:
-    topics = newJArray()
-    result["topics"] = topics
-  topics.elems.insert(%signature, 0)
-
-proc parseContract(body: NimNode): seq[InterfaceObject] =
-  proc parseOutputs(outputNode: NimNode): seq[FunctionInputOutput] =
-    result.add FunctionInputOutput(typ: (if outputNode.kind == nnkEmpty: ident"void" else: outputNode))
-
-  proc parseInputs(inputNodes: NimNode): seq[FunctionInputOutput] =
-    for i in 1..<inputNodes.len:
-      let input = inputNodes[i]
-      input.expectKind(nnkIdentDefs)
-      let typ = input[^2]
-      for j in 0 .. input.len - 3:
-        let arg = input[j]
-        result.add(FunctionInputOutput(
-          name: $arg,
-          typ: typ,
-        ))
-
-  proc parseEventInputs(inputNodes: NimNode): seq[EventInput] =
-    for i in 1..<inputNodes.len:
-      let input = inputNodes[i]
-      input.expectKind(nnkIdentDefs)
-      let typ = input[^2]
-      for j in 0 .. input.len - 3:
-        let arg = input[j]
-        case typ.kind:
-        of nnkBracketExpr:
-          if $typ[0] == "indexed":
-            result.add EventInput(
-              name: $arg,
-              typ: typ[1],
-              indexed: true
-            )
-          else:
-            result.add EventInput(name: $arg, typ: typ)
-        else:
-          result.add EventInput(name: $arg, typ: typ)
-
-  var
-    constructor: Option[ConstructorObject]
-    functions: seq[FunctionObject]
-    events: seq[EventObject]
-  for procdef in body:
-    doAssert(procdef.kind == nnkProcDef,
-      "Contracts can only be built with procedures")
-    let
-      isconstructor = procdef[4].findChild(it.strVal == "constructor") != nil
-      isevent = procdef[4].findChild(it.strVal == "event") != nil
-    doAssert(not (isconstructor and constructor.isSome),
-      "Contract can only have a single constructor")
-    doAssert(not (isconstructor and isevent),
-      "Can't be both event and constructor")
-    if not isevent:
-      let
-        ispure = procdef[4].findChild(it.strVal == "pure") != nil
-        isview = procdef[4].findChild(it.strVal == "view") != nil
-        ispayable = procdef[4].findChild(it.strVal == "payable") != nil
-      doAssert(not (ispure and isview),
-        "can't be both `pure` and `view`")
-      doAssert(not ((ispure or isview) and ispayable),
-        "can't be both `pure` or `view` while being `payable`")
-      if isconstructor:
-        constructor = some(ConstructorObject(
-          stateMutability: if ispure: pure elif isview: view elif ispayable: payable else: nonpayable,
-          inputs: parseInputs(procdef[3]),
-          outputs: parseOutputs(procdef[3][0])
-        ))
-      else:
-        functions.add FunctionObject(
-          name: procdef[0].strVal,
-          stateMutability: if ispure: pure elif isview: view elif ispayable: payable else: nonpayable,
-          inputs: parseInputs(procdef[3]),
-          outputs: parseOutputs(procdef[3][0])
-        )
-    else:
-      let isanonymous = procdef[4].findChild(it.strVal == "anonymous") != nil
-      doAssert(procdef[3][0].kind == nnkEmpty,
-        "Events can't have return values")
-      events.add EventObject(
-        name: procdef[0].strVal,
-        inputs: parseEventInputs(procdef[3]),
-        anonymous: isanonymous
-      )
-
-  if constructor.isSome:
-    result.add InterfaceObject(kind: InterfaceObjectKind.constructor, constructorObject: constructor.unsafeGet)
-  for function in functions:
-    result.add InterfaceObject(kind: InterfaceObjectKind.function, functionObject: function)
-  for event in events:
-    result.add InterfaceObject(kind: InterfaceObjectKind.event, eventObject: event)
-
-macro contract*(cname: untyped, body: untyped): untyped =
-  var objects = parseContract(body)
-  result = newStmtList()
-  let
-    address = ident "address"
-    client = ident "client"
-    receipt = genSym(nskForVar)
-    receiver = ident "receiver"
-    eventListener = ident "eventListener"
-  result.add quote do:
-    type
-      `cname`* = object
-
-  for obj in objects:
-    case obj.kind:
-    of function:
-      let
-        signature = getSignature(obj.functionObject)
-        procName = ident obj.functionObject.name
-        senderName = ident "sender"
-        output = if obj.functionObject.outputs.len != 1:
-            ident "void"
-          else:
-            obj.functionObject.outputs[0].typ
-      var
-        encodedParams = genSym(nskVar)#newLit("")
-        offset = genSym(nskVar)
-        dataBuf = genSym(nskVar)
-        encodings = genSym(nskVar)
-        encoder = newStmtList()
-      encoder.add quote do:
-        var
-          `offset` = 0
-          `encodedParams` = ""
-          `dataBuf` = ""
-          `encodings`: seq[EncodeResult]
-      for input in obj.functionObject.inputs:
-        let inputName = ident input.name
-        encoder.add quote do:
-          let encoding = encode(`inputName`)
-          `offset` += (if encoding.dynamic:
-            32
-          else:
-            encoding.data.len div 2)
-          `encodings`.add encoding
-      encoder.add quote do:
-        for encoding in `encodings`:
-          if encoding.dynamic:
-            `encodedParams` &= `offset`.toHex(64).toLower
-            `dataBuf` &= encoding.data
-          else:
-            `encodedParams` &= encoding.data
-          `offset` += encoding.data.len div 2
-
-        `encodedParams` &= `dataBuf`
-      var procDef = quote do:
-        proc `procName`*(`senderName`: Sender[`cname`]): ContractCall[`output`] =
-          discard
-      for input in obj.functionObject.inputs:
-        procDef[3].add nnkIdentDefs.newTree(
-          ident input.name,
-          input.typ,
-          newEmptyNode()
-        )
-      procDef[6].add quote do:
-        `encoder`
-        return initContractCall[`output`](
-            `senderName`.web3,
-            ($keccak256.digest(`signature`))[0..<8].toLower & `encodedParams`,
-            `senderName`.contractAddress)
-
-      result.add procDef
-    of event:
-      if not obj.eventObject.anonymous:
-        let callbackIdent = ident "callback"
-        let jsonIdent = ident "j"
-        var
-          params = nnkFormalParams.newTree(newEmptyNode())
-          paramsWithRawData = nnkFormalParams.newTree(newEmptyNode())
-
-          argParseBody = newStmtList()
-          i = 1
-          call = nnkCall.newTree(callbackIdent)
-          callWithRawData = nnkCall.newTree(callbackIdent)
-          offset = ident "offset"
-          inputData = ident "inputData"
-
-        var offsetInited = false
-
-        for input in obj.eventObject.inputs:
-          let param = nnkIdentDefs.newTree(
-            ident input.name,
-            input.typ,
-            newEmptyNode()
-          )
-          params.add param
-          paramsWithRawData.add param
-          let
-            argument = genSym(nskVar)
-            kind = input.typ
-          if input.indexed:
-            argParseBody.add quote do:
-              var `argument`: `kind`
-              discard decode(strip0xPrefix(`jsonIdent`["topics"][`i`].getStr), 0, `argument`)
-            i += 1
-          else:
-            if not offsetInited:
-              argParseBody.add quote do:
-                var `inputData` = strip0xPrefix(`jsonIdent`["data"].getStr)
-                var `offset` = 0
-
-              offsetInited = true
-
-            argParseBody.add quote do:
-              var `argument`: `kind`
-              `offset` += decode(`inputData`, `offset`, `argument`)
-          call.add argument
-          callWithRawData.add argument
-        let
-          eventName = obj.eventObject.name
-          cbident = ident eventName
-          procTy = nnkProcTy.newTree(params, newEmptyNode())
-          signature = getSignature(obj.eventObject)
-
-        # generated with dumpAstGen - produces "{.raises: [], gcsafe.}"
-        let pragmas = nnkPragma.newTree(
-          nnkExprColonExpr.newTree(
-            newIdentNode("raises"),
-            nnkBracket.newTree()
-          ),
-          newIdentNode("gcsafe")
-        )
-
-        procTy[1] = pragmas
-
-        callWithRawData.add jsonIdent
-        paramsWithRawData.add nnkIdentDefs.newTree(
-          jsonIdent,
-          bindSym "JsonNode",
-          newEmptyNode()
-        )
-
-        let procTyWithRawData = nnkProcTy.newTree(paramsWithRawData, newEmptyNode())
-        procTyWithRawData[1] = pragmas
-
-        result.add quote do:
-          type `cbident`* = object
-
-          template eventTopic*(T: type `cbident`): string =
-            "0x" & toLowerAscii($keccak256.digest(`signature`))
-
-          proc subscribe(s: Sender[`cname`],
-                         t: type `cbident`,
-                         options: JsonNode,
-                         `callbackIdent`: `procTy`,
-                         errorHandler: SubscriptionErrorHandler,
-                         withHistoricEvents = true): Future[Subscription] =
-            let options = addAddressAndSignatureToOptions(options, s.contractAddress, eventTopic(`cbident`))
-
-            proc eventHandler(`jsonIdent`: JsonNode) {.gcsafe, raises: [].} =
-              try:
-                `argParseBody`
-                `call`
-              except CatchableError as err:
-                errorHandler err[]
-
-            s.web3.subscribeForLogs(options, eventHandler, errorHandler, withHistoricEvents)
-
-          proc subscribe(s: Sender[`cname`],
-                         t: type `cbident`,
-                         options: JsonNode,
-                         `callbackIdent`: `procTyWithRawData`,
-                         errorHandler: SubscriptionErrorHandler,
-                         withHistoricEvents = true): Future[Subscription] =
-            let options = addAddressAndSignatureToOptions(options, s.contractAddress, eventTopic(`cbident`))
-
-            proc eventHandler(`jsonIdent`: JsonNode) {.gcsafe, raises: [].} =
-              try:
-                `argParseBody`
-                `callWithRawData`
-              except CatchableError as err:
-                errorHandler err[]
-
-            s.web3.subscribeForLogs(options, eventHandler, errorHandler, withHistoricEvents)
-
-    else:
-      discard
-
-  when defined(debugMacros) or defined(debugWeb3Macros):
-    echo result.repr
-
-proc getJsonLogs*(s: Sender,
-                  EventName: type,
+proc getJsonLogs(s: Web3SenderImpl, topic: openarray[byte],
                   fromBlock, toBlock = none(RtBlockIdentifier),
                   blockHash = none(BlockHash)): Future[JsonNode] =
-  mixin eventTopic
-
   var options = newJObject()
   options["address"] = %s.contractAddress
   var topics = newJArray()
-  topics.elems.insert(%eventTopic(EventName), 0)
+  topics.elems.insert(%to0xHex(topic), 0)
   options["topics"] = topics
   if blockHash.isSome:
     doAssert fromBlock.isNone and toBlock.isNone
@@ -566,6 +213,13 @@ proc getJsonLogs*(s: Sender,
 
   s.web3.provider.eth_getLogs(options)
 
+proc getJsonLogs*[TContract](s: Sender[TContract],
+                  EventName: type,
+                  fromBlock, toBlock = none(RtBlockIdentifier),
+                  blockHash = none(BlockHash)): Future[JsonNode] {.inline.} =
+  mixin eventTopic
+  getJsonLogs(s.sender, eventTopic(EventName))
+
 proc nextNonce*(web3: Web3): Future[Quantity] {.async.} =
   if web3.lastKnownNonce.isSome:
     inc web3.lastKnownNonce.get
@@ -585,21 +239,22 @@ proc send*(web3: Web3, c: EthSend): Future[TxHash] {.async.} =
   else:
     return await web3.provider.eth_sendTransaction(c)
 
-proc send*(c: ContractCallBase,
-           value = 0.u256,
-           gas = 3000000'u64,
-           gasPrice = 0): Future[TxHash] {.async.} =
+proc sendData(sender: Web3SenderImpl,
+              data: seq[byte],
+              value: UInt256,
+              gas: uint64,
+              gasPrice: int): Future[TxHash] {.async.} =
   let
-    web3 = c.web3
+    web3 = sender.web3
     gasPrice = if web3.privateKey.isSome() or gasPrice != 0: some(gasPrice.Quantity)
                else: none(Quantity)
     nonce = if web3.privateKey.isSome(): some(await web3.nextNonce())
             else: none(Quantity)
 
     cc = EthSend(
-      data: c.data,
+      data: data,
       `from`: web3.defaultAccount,
-      to: some(c.to),
+      to: some(sender.contractAddress),
       gas: some(Quantity(gas)),
       value: some(value),
       nonce: nonce,
@@ -608,25 +263,32 @@ proc send*(c: ContractCallBase,
 
   return await web3.send(cc)
 
-proc call*[T](c: ContractCall[T],
+proc send*[T](c: ContractInvocation[T, Web3SenderImpl],
+           value = 0.u256,
+           gas = 3000000'u64,
+           gasPrice = 0): Future[TxHash] =
+  sendData(c.sender, c.data, value, gas, gasPrice)
+
+proc call*[T](c: ContractInvocation[T, Web3SenderImpl],
               value = 0.u256,
               gas = 3000000'u64,
               blockNumber = high(uint64)): Future[T] {.async.} =
+  let web3 = c.sender.web3
   var cc: EthCall
   cc.data = some(c.data)
-  cc.source = some(c.web3.defaultAccount)
-  cc.to = some(c.to)
+  cc.source = some(web3.defaultAccount)
+  cc.to = some(c.sender.contractAddress)
   cc.gas = some(Quantity(gas))
   cc.value = some(value)
   let response =
     if blockNumber != high(uint64):
-      await c.web3.provider.eth_call(cc, &"0x{blockNumber:X}")
+      await web3.provider.eth_call(cc, &"0x{blockNumber:X}")
     else:
-      await c.web3.provider.eth_call(cc, "latest")
+      await web3.provider.eth_call(cc, "latest")
 
   if response.len > 0:
     var res: T
-    discard decode(response.toHex, 0, res)
+    discard decode(response, 0, 0, res)
     return res
   else:
     raise newException(CatchableError, "No response from the Web3 provider")
@@ -642,7 +304,7 @@ proc getMinedTransactionReceipt*(web3: Web3, tx: TxHash): Future[ReceiptObject]
       await sleepAsync(500.milliseconds)
   result = r
 
-proc exec*[T](c: ContractCall[T], value = 0.u256, gas = 3000000'u64): Future[T] {.async.} =
+proc exec*[T](c: ContractInvocation[T, Web3SenderImpl], value = 0.u256, gas = 3000000'u64): Future[T] {.async.} =
   let h = await c.send(value, gas)
   let receipt = await c.web3.getMinedTransactionReceipt(h)
 
@@ -676,15 +338,15 @@ proc exec*[T](c: ContractCall[T], value = 0.u256, gas = 3000000'u64): Future[T]
 #echo response
 
 proc contractSender*(web3: Web3, T: typedesc, toAddress: Address): Sender[T] =
-  Sender[T](web3: web3, contractAddress: toAddress)
+  Sender[T](sender: Web3SenderImpl(web3: web3, contractAddress: toAddress))
 
 proc isDeployed*(s: Sender, atBlock: RtBlockIdentifier): Future[bool] {.async.} =
   let
     codeFut = case atBlock.kind
       of bidNumber:
-        s.web3.provider.eth_getCode(s.contractAddress, atBlock.number)
+        s.sender.web3.provider.eth_getCode(s.contractAddress, atBlock.number)
       of bidAlias:
-        s.web3.provider.eth_getCode(s.contractAddress, atBlock.alias)
+        s.sender.web3.provider.eth_getCode(s.contractAddress, atBlock.alias)
     code = await codeFut
 
   # TODO: Check that all methods of the contract are present by
@@ -692,8 +354,5 @@ proc isDeployed*(s: Sender, atBlock: RtBlockIdentifier): Future[bool] {.async.}
   #       https://ethereum.stackexchange.com/questions/11856/how-to-detect-from-web3-if-method-exists-on-a-deployed-contract
   return code.len > 0
 
-proc subscribe*(s: Sender, t: typedesc, cb: proc): Future[Subscription] {.inline.} =
+proc subscribe*[TContract](s: Sender[TContract], t: typedesc, cb: proc): Future[Subscription] {.inline.} =
   subscribe(s, t, newJObject(), cb, SubscriptionErrorHandler nil)
-
-proc `$`*(b: Bool): string =
-  $(StInt[256](b))
diff --git a/web3.nimble b/web3.nimble
index 00e63c9..61524ba 100644
--- a/web3.nimble
+++ b/web3.nimble
@@ -9,7 +9,7 @@
 
 mode = ScriptMode.Verbose
 
-version       = "0.2.0"
+version       = "0.2.2"
 author        = "Status Research & Development GmbH"
 description   = "This is the humble begginings of library similar to web3.[js|py]"
 license       = "MIT or Apache License 2.0"
diff --git a/web3/contract_dsl.nim b/web3/contract_dsl.nim
new file mode 100644
index 0000000..974bb5d
--- /dev/null
+++ b/web3/contract_dsl.nim
@@ -0,0 +1,333 @@
+import
+  std/[macros, strutils, options, json],
+  nimcrypto/keccak,
+  ./[encoding, primitives],
+  stint,
+  stew/byteutils
+
+type
+  ContractInvocation*[TResult, TSender] = object
+    data*: seq[byte]
+    sender*: TSender
+
+  ContractInstance*[TContract, TSender] = object
+    sender*: TSender
+
+  InterfaceObjectKind = enum
+    function, constructor, event
+  MutabilityKind = enum
+    pure, view, nonpayable, payable
+  FunctionInputOutput = object
+    name: string
+    typ: NimNode
+  EventInput = object
+    name: string
+    typ: NimNode
+    indexed: bool
+  FunctionObject = object
+    name: string
+    stateMutability: MutabilityKind
+    inputs: seq[FunctionInputOutput]
+    outputs: seq[FunctionInputOutput]
+  ConstructorObject = object
+    stateMutability: MutabilityKind
+    inputs: seq[FunctionInputOutput]
+    outputs: seq[FunctionInputOutput]
+  EventObject = object
+    name: string
+    inputs: seq[EventInput]
+    anonymous: bool
+
+  InterfaceObject = object
+    case kind: InterfaceObjectKind
+    of function: functionObject: FunctionObject
+    of constructor: constructorObject: ConstructorObject
+    of event: eventObject: EventObject
+
+proc keccak256Bytes(s: string): seq[byte] {.inline.} =
+  @(keccak256.digest(s).data)
+
+proc initContractInvocation[TSender](TResult: typedesc, sender: TSender, data: seq[byte]): ContractInvocation[TResult, TSender] {.inline.} =
+  ContractInvocation[TResult, TSender](data: data, sender: sender)
+
+proc joinStrings(s: varargs[string]): string = join(s)
+
+proc unknownType() = discard # Used for informative errors
+
+template seqType[T](s: typedesc[seq[T]]): typedesc = T
+
+proc typeSignature(T: typedesc): string =
+  when T is string:
+    "string"
+  elif (T is DynamicBytes) or (T is seq[byte]):
+    "bytes"
+  elif T is FixedBytes:
+    "bytes" & $T.N
+  elif T is StUint:
+    "uint" & $T.bits
+  elif T is Address:
+    "address"
+  elif T is bool:
+    "bool"
+  elif T is seq:
+    typeSignature(seqType(T)) & "[]"
+  else:
+    unknownType(T)
+
+proc getSignature(function: FunctionObject | EventObject): NimNode =
+  result = newCall(bindSym"joinStrings")
+  result.add(newLit(function.name & "("))
+  for i, input in function.inputs:
+    result.add(newCall(bindSym"typeSignature", input.typ))
+    if i != function.inputs.high:
+      result.add(newLit(","))
+  result.add(newLit(")"))
+
+proc parseContract(body: NimNode): seq[InterfaceObject] =
+  proc parseOutputs(outputNode: NimNode): seq[FunctionInputOutput] =
+    result.add FunctionInputOutput(typ: (if outputNode.kind == nnkEmpty: ident"void" else: outputNode))
+
+  proc parseInputs(inputNodes: NimNode): seq[FunctionInputOutput] =
+    for i in 1..<inputNodes.len:
+      let input = inputNodes[i]
+      input.expectKind(nnkIdentDefs)
+      let typ = input[^2]
+      for j in 0 .. input.len - 3:
+        let arg = input[j]
+        result.add(FunctionInputOutput(
+          name: $arg,
+          typ: typ,
+        ))
+
+  proc parseEventInputs(inputNodes: NimNode): seq[EventInput] =
+    for i in 1..<inputNodes.len:
+      let input = inputNodes[i]
+      input.expectKind(nnkIdentDefs)
+      let typ = input[^2]
+      for j in 0 .. input.len - 3:
+        let arg = input[j]
+        case typ.kind:
+        of nnkBracketExpr:
+          if $typ[0] == "indexed":
+            result.add EventInput(
+              name: $arg,
+              typ: typ[1],
+              indexed: true
+            )
+          else:
+            result.add EventInput(name: $arg, typ: typ)
+        else:
+          result.add EventInput(name: $arg, typ: typ)
+
+  var
+    constructor: Option[ConstructorObject]
+    functions: seq[FunctionObject]
+    events: seq[EventObject]
+  for procdef in body:
+    doAssert(procdef.kind == nnkProcDef,
+      "Contracts can only be built with procedures")
+    let
+      isconstructor = procdef[4].findChild(it.strVal == "constructor") != nil
+      isevent = procdef[4].findChild(it.strVal == "event") != nil
+    doAssert(not (isconstructor and constructor.isSome),
+      "Contract can only have a single constructor")
+    doAssert(not (isconstructor and isevent),
+      "Can't be both event and constructor")
+    if not isevent:
+      let
+        ispure = procdef[4].findChild(it.strVal == "pure") != nil
+        isview = procdef[4].findChild(it.strVal == "view") != nil
+        ispayable = procdef[4].findChild(it.strVal == "payable") != nil
+      doAssert(not (ispure and isview),
+        "can't be both `pure` and `view`")
+      doAssert(not ((ispure or isview) and ispayable),
+        "can't be both `pure` or `view` while being `payable`")
+      if isconstructor:
+        constructor = some(ConstructorObject(
+          stateMutability: if ispure: pure elif isview: view elif ispayable: payable else: nonpayable,
+          inputs: parseInputs(procdef[3]),
+          outputs: parseOutputs(procdef[3][0])
+        ))
+      else:
+        functions.add FunctionObject(
+          name: procdef[0].strVal,
+          stateMutability: if ispure: pure elif isview: view elif ispayable: payable else: nonpayable,
+          inputs: parseInputs(procdef[3]),
+          outputs: parseOutputs(procdef[3][0])
+        )
+    else:
+      let isanonymous = procdef[4].findChild(it.strVal == "anonymous") != nil
+      doAssert(procdef[3][0].kind == nnkEmpty,
+        "Events can't have return values")
+      events.add EventObject(
+        name: procdef[0].strVal,
+        inputs: parseEventInputs(procdef[3]),
+        anonymous: isanonymous
+      )
+
+  if constructor.isSome:
+    result.add InterfaceObject(kind: InterfaceObjectKind.constructor, constructorObject: constructor.unsafeGet)
+  for function in functions:
+    result.add InterfaceObject(kind: InterfaceObjectKind.function, functionObject: function)
+  for event in events:
+    result.add InterfaceObject(kind: InterfaceObjectKind.event, eventObject: event)
+
+macro contract*(cname: untyped, body: untyped): untyped =
+  var objects = parseContract(body)
+  result = newStmtList()
+  let
+    address = ident "address"
+    client = ident "client"
+    receipt = genSym(nskForVar)
+    receiver = ident "receiver"
+    eventListener = ident "eventListener"
+  result.add quote do:
+    type
+      `cname`* = object
+
+  for obj in objects:
+    case obj.kind:
+    of function:
+      let
+        signature = getSignature(obj.functionObject)
+        procName = ident obj.functionObject.name
+        senderName = ident "sender"
+        output = if obj.functionObject.outputs.len != 1:
+            ident "void"
+          else:
+            obj.functionObject.outputs[0].typ
+        funcParamsTuple = newNimNode(nnkTupleConstr)
+
+      for input in obj.functionObject.inputs:
+        funcParamsTuple.add(ident input.name)
+
+      var procDef = quote do:
+        proc `procName`*[TSender](`senderName`: ContractInstance[`cname`, TSender]): ContractInvocation[`output`, TSender] =
+          discard
+      for input in obj.functionObject.inputs:
+        procDef[3].add nnkIdentDefs.newTree(
+          ident input.name,
+          input.typ,
+          newEmptyNode()
+        )
+      procDef[6].add quote do:
+        return initContractInvocation(
+            `output`, `senderName`.sender,
+            static(keccak256Bytes(`signature`)[0..<4]) & encode(`funcParamsTuple`))
+
+      result.add procDef
+    of event:
+      if not obj.eventObject.anonymous:
+        let callbackIdent = ident "callback"
+        let jsonIdent = ident "j"
+        var
+          params = nnkFormalParams.newTree(newEmptyNode())
+          paramsWithRawData = nnkFormalParams.newTree(newEmptyNode())
+
+          argParseBody = newStmtList()
+          i = 1
+          call = nnkCall.newTree(callbackIdent)
+          callWithRawData = nnkCall.newTree(callbackIdent)
+          offset = ident "offset"
+          inputData = ident "inputData"
+
+        var offsetInited = false
+
+        for input in obj.eventObject.inputs:
+          let param = nnkIdentDefs.newTree(
+            ident input.name,
+            input.typ,
+            newEmptyNode()
+          )
+          params.add param
+          paramsWithRawData.add param
+          let
+            argument = genSym(nskVar)
+            kind = input.typ
+          if input.indexed:
+            argParseBody.add quote do:
+              var `argument`: `kind`
+              discard decode(hexToSeqByte(`jsonIdent`["topics"][`i`].getStr), 0, 0, `argument`)
+            i += 1
+          else:
+            if not offsetInited:
+              argParseBody.add quote do:
+                var `inputData` = hexToSeqByte(`jsonIdent`["data"].getStr)
+                var `offset` = 0
+
+              offsetInited = true
+
+            argParseBody.add quote do:
+              var `argument`: `kind`
+              `offset` += decode(`inputData`, 0, `offset`, `argument`)
+          call.add argument
+          callWithRawData.add argument
+        let
+          eventName = obj.eventObject.name
+          cbident = ident eventName
+          procTy = nnkProcTy.newTree(params, newEmptyNode())
+          signature = getSignature(obj.eventObject)
+
+        # generated with dumpAstGen - produces "{.raises: [], gcsafe.}"
+        let pragmas = nnkPragma.newTree(
+          nnkExprColonExpr.newTree(
+            newIdentNode("raises"),
+            nnkBracket.newTree()
+          ),
+          newIdentNode("gcsafe")
+        )
+
+        procTy[1] = pragmas
+
+        callWithRawData.add jsonIdent
+        paramsWithRawData.add nnkIdentDefs.newTree(
+          jsonIdent,
+          bindSym "JsonNode",
+          newEmptyNode()
+        )
+
+        let procTyWithRawData = nnkProcTy.newTree(paramsWithRawData, newEmptyNode())
+        procTyWithRawData[1] = pragmas
+
+        result.add quote do:
+          type `cbident`* = object
+
+          template eventTopic*(T: type `cbident`): seq[byte] =
+            const r = keccak256Bytes(`signature`)
+            r
+
+          proc subscribe[TSender](s: ContractInstance[`cname`, TSender],
+                         t: type `cbident`,
+                         options: JsonNode,
+                         `callbackIdent`: `procTy`,
+                         errorHandler: SubscriptionErrorHandler,
+                         withHistoricEvents = true): Future[Subscription] =
+            proc eventHandler(`jsonIdent`: JsonNode) {.gcsafe, raises: [].} =
+              try:
+                `argParseBody`
+                `call`
+              except CatchableError as err:
+                errorHandler err[]
+
+            s.sender.subscribeForLogs(options, eventTopic(`cbident`), eventHandler, errorHandler, withHistoricEvents)
+
+          proc subscribe[TSender](s: ContractInstance[`cname`, TSender],
+                         t: type `cbident`,
+                         options: JsonNode,
+                         `callbackIdent`: `procTyWithRawData`,
+                         errorHandler: SubscriptionErrorHandler,
+                         withHistoricEvents = true): Future[Subscription] =
+            proc eventHandler(`jsonIdent`: JsonNode) {.gcsafe, raises: [].} =
+              try:
+                `argParseBody`
+                `callWithRawData`
+              except CatchableError as err:
+                errorHandler err[]
+
+            s.sender.subscribeForLogs(options, eventTopic(`cbident`), eventHandler, errorHandler, withHistoricEvents)
+
+    else:
+      discard
+
+  when defined(debugMacros) or defined(debugWeb3Macros):
+    echo result.repr
diff --git a/web3/encoding.nim b/web3/encoding.nim
index 0339bc7..7c41ba4 100644
--- a/web3/encoding.nim
+++ b/web3/encoding.nim
@@ -8,218 +8,176 @@
 # those terms.
 
 import
-  std/[typetraits, strutils, macros, math]
+  std/macros,
+  stint, ./eth_api_types, stew/[assign2, byteutils]
 
-import
-  stint, stew/byteutils, ./eth_api_types
-
-type
-  EncodeResult* = tuple[dynamic: bool, data: string]
-
-func encode*[bits: static[int]](x: StUint[bits]): EncodeResult =
-  ## Encodes a `StUint` to a textual representation for use in the JsonRPC
-  ## `sendTransaction` call.
-  (dynamic: false, data: '0'.repeat((256 - bits) div 4) & x.dumpHex)
-
-func encode*[bits: static[int]](x: StInt[bits]): EncodeResult =
-  ## Encodes a `StInt` to a textual representation for use in the JsonRPC
-  ## `sendTransaction` call.
-  (dynamic: false,
-  data:
-    if x.isNegative:
-      'f'.repeat((256 - bits) div 4) & x.dumpHex
-    else:
-      '0'.repeat((256 - bits) div 4) & x.dumpHex
-  )
+func encode*[bits: static[int]](x: StUint[bits]): seq[byte] =
+  @(x.toByteArrayBE())
 
-func decode*(input: string, offset: int, to: var StUint): int =
-  let meaningfulLen = to.bits div 8 * 2
-  to = type(to).fromHex(input[offset .. offset + meaningfulLen - 1])
+func encode*[bits: static[int]](x: StInt[bits]): seq[byte] =
+  @(x.toByteArrayBE())
+
+func decode*(input: openarray[byte], baseOffset, offset: int, to: var StUint): int =
+  const meaningfulLen = to.bits div 8
+  let offset = offset + baseOffset
+  to = type(to).fromBytesBE(input.toOpenArray(offset, offset + meaningfulLen - 1))
   meaningfulLen
 
-func decode*[N](input: string, offset: int, to: var StInt[N]): int =
-  let meaningfulLen = N div 8 * 2
-  fromHex(input[offset .. offset + meaningfulLen], to)
+func decode*[N](input: openarray[byte], baseOffset, offset: int, to: var StInt[N]): int =
+  const meaningfulLen = N div 8
+  let offset = offset + baseOffset
+  to = type(to).fromBytesBE(input.toOpenArray(offset, offset + meaningfulLen - 1))
   meaningfulLen
 
-func fixedEncode(a: openArray[byte]): EncodeResult =
+func encodeFixed(a: openArray[byte]): seq[byte] =
   var padding = a.len mod 32
   if padding != 0: padding = 32 - padding
-  result = (dynamic: false, data: "00".repeat(padding) & byteutils.toHex(a))
+  result.setLen(padding) # Zero fill padding
+  result.add(a)
 
-func encode*[N](b: FixedBytes[N]): EncodeResult = fixedEncode(array[N, byte](b))
-func encode*(b: Address): EncodeResult = fixedEncode(array[20, byte](b))
+func encode*[N](b: FixedBytes[N]): seq[byte] = encodeFixed(array[N, byte](b))
+func encode*(b: Address): seq[byte] = encodeFixed(array[20, byte](b))
+func encode*[N](b: array[N, byte]): seq[byte] {.inline.} = encodeFixed(b)
 
-func decodeFixed(input: string, offset: int, to: var openArray[byte]): int =
-  let meaningfulLen = to.len * 2
+func decodeFixed(input: openarray[byte], baseOffset, offset: int, to: var openArray[byte]): int =
+  let meaningfulLen = to.len
   var padding = to.len mod 32
-  if padding != 0: padding = (32 - padding) * 2
-  let offset = offset + padding
-  hexToByteArray(input[offset .. offset + meaningfulLen - 1], to)
+  if padding != 0:
+    padding = 32 - padding
+  let offset = baseOffset + offset + padding
+  if to.len != 0:
+    assign(to, input.toOpenArray(offset, offset + meaningfulLen - 1))
   meaningfulLen + padding
 
-func decode*[N](input: string, offset: int, to: var FixedBytes[N]): int {.inline.} =
-  decodeFixed(input, offset, array[N, byte](to))
+func decode*[N](input: openarray[byte], baseOffset, offset: int, to: var FixedBytes[N]): int {.inline.} =
+  decodeFixed(input, baseOffset, offset, array[N, byte](to))
 
-func decode*(input: string, offset: int, to: var Address): int {.inline.} =
-  decodeFixed(input, offset, array[20, byte](to))
+func decode*(input: openarray[byte], baseOffset, offset: int, to: var Address): int {.inline.} =
+  decodeFixed(input, baseOffset, offset, array[20, byte](to))
 
-func encodeDynamic(v: openArray[byte]): EncodeResult =
-  result.dynamic = true
-  result.data = v.len.toHex(64).toLower
-  for y in v:
-    result.data &= y.toHex.toLower
-  result.data &= "00".repeat(v.len mod 32)
+func encodeDynamic(v: openArray[byte]): seq[byte] =
+  result = encode(v.len.u256)
+  result.add(v)
+  for i in 0 ..< (v.len mod 32):
+    result.add(0)
 
-func encode*(x: DynamicBytes): EncodeResult {.inline.} =
+func encode*(x: DynamicBytes): seq[byte] {.inline.} =
   encodeDynamic(distinctBase x)
 
-func decode*(input: string, offset: int, to: var DynamicBytes): int {.inline.} =
-  var dataOffset, dataLen: UInt256
-  result = decode(input, offset, dataOffset)
-  discard decode(input, dataOffset.truncate(int) * 2, dataLen)
+func encode*(x: seq[byte]): seq[byte] {.inline.} =
+  encodeDynamic(x)
+
+func decode*(input: openarray[byte], baseOffset, offset: int, to: var seq[byte]): int =
+  var dataOffsetBig, dataLenBig: UInt256
+  result = decode(input, baseOffset, offset, dataOffsetBig)
+  let dataOffset = dataOffsetBig.truncate(int)
+  discard decode(input, baseOffset, dataOffset, dataLenBig)
+  let dataLen = dataLenBig.truncate(int)
+  let actualDataOffset = baseOffset + dataOffset + 32
+  to = input[actualDataOffset ..< actualDataOffset + dataLen]
+
+func decode*(input: openarray[byte], baseOffset, offset: int, to: var DynamicBytes): int {.inline.} =
+  var s: seq[byte]
+  result = decode(input, baseOffset, offset, s)
   # TODO: Check data len, and raise?
-  let actualDataOffset = (dataOffset.truncate(int) + 32) * 2
-  to = typeof(to)(hexToSeqByte(input[actualDataOffset ..< actualDataOffset + dataLen.truncate(int) * 2]))
-
-macro makeTypeEnum(): untyped =
-  ## This macro creates all the various types of Solidity contracts and maps
-  ## them to the type used for their encoding. It also creates an enum to
-  ## identify these types in the contract signatures, along with encoder
-  ## functions used in the generated procedures.
-  result = newStmtList()
-  var lastpow2: int
-  for i in countdown(256, 8, 8):
-    let
-      identUint = newIdentNode("Uint" & $i)
-      identInt = newIdentNode("Int" & $i)
-    if ceil(log2(i.float)) == floor(log2(i.float)):
-      lastpow2 = i
-    if i notin [256, 125]: # Int/UInt256/128 are already defined in stint. No need to repeat.
-      result.add quote do:
-        type
-          `identUint`* = StUint[`lastpow2`]
-          `identInt`* = StInt[`lastpow2`]
-  let
-    identUint = ident("Uint")
-    identInt = ident("Int")
-    identBool = ident("Bool")
-  result.add quote do:
-    type
-      `identUint`* = UInt256
-      `identInt`* = Int256
-      `identBool`* = distinct Int256
-
-  for m in countup(8, 256, 8):
-    let
-      identInt = ident("Int" & $m)
-      identUint = ident("Uint" & $m)
-      identFixed = ident "Fixed" & $m
-      identUfixed = ident "Ufixed" & $m
-      identT = ident "T"
-    result.add quote do:
-      # Fixed stuff is not actually implemented yet, these procedures don't
-      # do what they are supposed to.
-      type
-        `identFixed`*[N: static[int]] = distinct `identInt`
-        `identUfixed`*[N: static[int]] = distinct `identUint`
-
-      # func to*(x: `identInt`, `identT`: typedesc[`identFixed`]): `identT` =
-      #   T(x)
-
-      # func to*(x: `identUint`, `identT`: typedesc[`identUfixed`]): `identT` =
-      #   T(x)
-
-      # func encode*[N: static[int]](x: `identFixed`[N]): EncodeResult =
-      #   encode(`identInt`(x) * (10 ^ N).to(`identInt`))
-
-      # func encode*[N: static[int]](x: `identUfixed`[N]): EncodeResult =
-      #   encode(`identUint`(x) * (10 ^ N).to(`identUint`))
-
-      # func decode*[N: static[int]](input: string, to: `identFixed`[N]): `identFixed`[N] =
-      #   decode(input, `identInt`) div / (10 ^ N).to(`identInt`)
-
-      # func decode*[N: static[int]](input: string, to: `identUfixed`[N]): `identFixed`[N] =
-      #   decode(input, `identUint`) div / (10 ^ N).to(`identUint`)
-
-  let
-    identFixed = ident("Fixed")
-    identUfixed = ident("Ufixed")
-  result.add quote do:
-    type
-      `identFixed`* = distinct Int128
-      `identUfixed`* = distinct UInt128
-  for i in 1..256:
-    let
-      identBytes = ident("Bytes" & $i)
-      identResult = ident "result"
-    result.add quote do:
-      type
-        `identBytes`* = FixedBytes[`i`]
-
-  #result.add newEnum(ident "FieldKind", fields, public = true, pure = true)
-
-makeTypeEnum()
-
-func parse*(T: type Bool, val: bool): T =
-  let i = if val: 1 else: 0
-  T i.i256
-
-func `==`*(a: Bool, b: Bool): bool =
-  Int256(a) == Int256(b)
-
-func encode*(x: Bool): EncodeResult = encode(Int256(x))
-func decode*(input: string, offset: int, to: var Bool): int =
-  let meaningfulLen = Int256.bits div 8 * 2
-  to = Bool Int256.fromHex(input[offset .. offset + meaningfulLen - 1])
-  meaningfulLen
+  to = typeof(to)(move(s))
 
-func decode*(input: string, offset: int, obj: var object): int =
-  var offset = offset
-  for field in fields(obj):
-    offset += decode(input, offset, field)
-
-type
-  Encodable = concept x
-    encode(x) is EncodeResult
-
-func encode*(x: seq[Encodable]): EncodeResult =
-  result.dynamic = true
-  result.data = x.len.toHex(64).toLower
-  var
-    offset = 32*x.len
-    data = ""
-  for i in x:
-    let encoded = encode(i)
-    if encoded.dynamic:
-      result.data &= offset.toHex(64).toLower
-      data &= encoded.data
-    else:
-      result.data &= encoded.data
-    offset += encoded.data.len
-  result.data &= data
-
-func decode*[T](input: string, to: seq[T]): seq[T] =
-  var count = input[0..64].decode(StUint)
-  result = newSeq[T](count)
-  for i in 0..count:
-    result[i] = input[i*64 .. (i+1)*64].decode(T)
-
-func encode*(x: openArray[Encodable]): EncodeResult =
-  result.dynamic = false
-  result.data = ""
-  var
-    offset = 32*x.len
-    data = ""
-  for i in x:
-    let encoded = encode(i)
-    if encoded.dynamic:
-      result.data &= offset.toHex(64).toLower
-      data &= encoded.data
-    else:
-      result.data &= encoded.data
-    offset += encoded.data.len
+func decode*(input: openarray[byte], baseOffset, offset: int, obj: var object): int
 
-func decode*[T; I: static int](input: string, to: array[0..I, T]): array[0..I, T] =
-  for i in 0..I:
-    result[i] = input[i*64 .. (i+1)*64].decode(T)
+func decode*[T](input: openarray[byte], baseOffset, offset: int, to: var seq[T]): int {.inline.} =
+  var dataOffsetBig, dataLenBig: UInt256
+  result = decode(input, baseOffset, offset, dataOffsetBig)
+  let dataOffset = dataOffsetBig.truncate(int)
+  discard decode(input, baseOffset, dataOffset, dataLenBig)
+  # TODO: Check data len, and raise?
+  let dataLen = dataLenBig.truncate(int)
+  to.setLen(dataLen)
+  let baseOffset = baseOffset + dataOffset + 32
+  var offset = 0
+  for i in 0 ..< dataLen:
+    offset += decode(input, baseOffset, offset, to[i])
+
+proc isDynamicObject(T: typedesc): bool
+
+template isDynamicType(a: typedesc): bool =
+  when a is seq | openarray | string | DynamicBytes:
+    true
+  elif a is object:
+    const r = isDynamicObject(a)
+    r
+  else:
+    false
+
+proc isDynamicObject(T: typedesc): bool =
+  var a: T
+  for v in fields(a):
+    if isDynamicType(typeof(v)): return true
+  false
+
+func encode*(x: bool): seq[byte] = encode(x.int.u256)
+
+func decode*(input: openarray[byte], baseOffset, offset: int, to: var bool): int =
+  var i: Int256
+  result = decode(input, baseOffset, offset, i)
+  to = not i.isZero()
+
+func decode*(input: openarray[byte], baseOffset, offset: int, obj: var object): int =
+  when isDynamicObject(typeof(obj)):
+    var dataOffsetBig: UInt256
+    result = decode(input, baseOffset, offset, dataOffsetBig)
+    let dataOffset = dataOffsetBig.truncate(int)
+    let offset = baseOffset + dataOffset
+    var offset2 = 0
+    for k, field in fieldPairs(obj):
+      let sz = decode(input, offset, offset2, field)
+      offset2 += sz
+  else:
+    var offset = offset
+    for field in fields(obj):
+      let sz = decode(input, baseOffset, offset, field)
+      offset += sz
+      result += sz
+
+func encode*(x: tuple): seq[byte]
+
+func encode*[T](x: openarray[T]): seq[byte] =
+  result = encode(x.len.u256)
+  when isDynamicType(T):
+    result.setLen((1 + x.len) * 32)
+    for i in 0 ..< x.len:
+      let offset = result.len
+      result &= encode(x[i])
+      result[i .. i + 31] = encode(offset.u256)
+  else:
+    for i in 0 ..< x.len:
+      result &= encode(x[i])
+
+proc getTupleImpl(t: NimNode): NimNode =
+  getTypeImpl(t)[1].getTypeImpl()
+
+macro typeListLen*(t: typedesc[tuple]): int =
+  newLit(t.getTupleImpl().len)
+
+func encode*(x: tuple): seq[byte] =
+  var offsets {.used.}: array[typeListLen(typeof(x)), int]
+  var i = 0
+  for v in fields(x):
+    when isDynamicType(typeof(v)):
+      offsets[i] = result.len
+      result.setLen(result.len + 32)
+    else:
+      result &= encode(v)
+    inc i
+  i = 0
+  for v in fields(x):
+    when isDynamicType(typeof(v)):
+      let offset = result.len
+      let o = offsets[i]
+      result[o .. o + 31] = encode(offset.u256)
+      result &= encode(v)
+    inc i
+
+# Obsolete
+from stew/byteutils import hexToSeqByte
+func decode*(input: string, offset: int, to: var DynamicBytes): int {.inline, deprecated: "Use decode(openarray[byte], ...) instead".} =
+  decode(hexToSeqByte(input), 0, offset div 2, to) * 2