Add result handling for function selection.

eth_abi_utils.nim

@@ -22,6 +22,7 @@ type
         constant*: bool
         payable*: bool
         method_id*: string
+        method_sig*: string
 
 
 proc generate_method_sig*(func_sig: FunctionSignature, v2_sig: bool = false): string =
@@ -82,14 +83,14 @@ proc generate_function_signature*(proc_def: NimNode): FunctionSignature =
             discard
             # raise newException(Exception, "unknown func type" & treeRepr(child))
 
-    echo "method_sig: " & generate_method_sig(func_sig)
+    # echo "method_sig: " & generate_method_sig(func_sig)
     
     # var s = newSeq[byte]()
     # var method_hash = generate_method_id(func_sig)
     # for i in method_hash:
     #     s.add(i)
     # echo "method_hash" & toHex(method_hash)
-
+    func_sig.method_sig = generate_method_sig(func_sig)
     func_sig.method_id = generate_method_id(func_sig)
 
     return func_sig

eth_macros.nim

@@ -128,7 +128,7 @@ proc handleContractInterface(stmts: NimNode): NimNode =
                 )
             )
             call_and_copy_block.add(
-                nnkLetSection.newTree(  # let c: uint256 = Uint256.fromBytesBE(b)
+                nnkLetSection.newTree(  # let c: uint256 = Uint256.fromBytesBE(b), TODO: handle different types.
                     nnkIdentDefs.newTree(
                         newIdentNode(tmp_var_converted),
                         newIdentNode(param.var_type),
@@ -144,12 +144,71 @@ proc handleContractInterface(stmts: NimNode): NimNode =
             )
             call_to_func.add(newIdentNode(tmp_var_converted))
             start_offset += static_param_size
-        # Add final function call.
-        call_and_copy_block.add(call_to_func)
 
-        # echo "⬇️⬇️⬇️⬇️⬇️"
-        # echo treeRepr(call_and_copy_block)
-        # echo "⬆️⬆️⬆️⬆️⬆️"
+        # Handle returned data from function.
+        if len(func_sig.outputs) == 0:
+            # Add final function call.
+            call_and_copy_block.add(call_to_func)
+            call_and_copy_block.add(
+                nnkStmtList.newTree(
+                    nnkCall.newTree(
+                        newIdentNode("finish"),
+                        newNilLit(),
+                        newLit(0)
+                    )
+                )
+            )
+        elif len(func_sig.outputs) == 1:
+            var assign_result_block = nnkAsgn.newTree()
+            var param = func_sig.outputs[0]
+            var idx = 0
+            # create placeholder variables
+            var tmp_var_res_name = fmt"{func_sig.name}_result_{idx}"
+            var tmp_var_res_name_array = tmp_var_res_name & "_arr"
+            call_and_copy_block.add(
+                nnkVarSection.newTree(
+                    nnkIdentDefs.newTree(
+                        nnkPragmaExpr.newTree(
+                            newIdentNode(tmp_var_res_name),
+                            nnkPragma.newTree(
+                                newIdentNode("noinit")
+                            )
+                        ),
+                        newIdentNode(param.var_type),
+                        newEmptyNode()
+                    )
+                )
+            )
+            assign_result_block.add(newIdentNode(tmp_var_res_name))
+            assign_result_block.add(call_to_func)
+            call_and_copy_block.add(assign_result_block)
+            call_and_copy_block.add(
+                nnkVarSection.newTree(
+                    nnkIdentDefs.newTree(
+                      newIdentNode(tmp_var_res_name_array),
+                      newEmptyNode(),
+                      nnkDotExpr.newTree(
+                        newIdentNode(tmp_var_res_name),
+                        newIdentNode("toByteArrayBE")
+                      )
+                    )
+                  )
+            )
+            call_and_copy_block.add(
+                nnkCall.newTree(
+                    newIdentNode("finish"),
+                    nnkCommand.newTree(
+                        newIdentNode("addr"),
+                        newIdentNode(tmp_var_res_name_array)
+                    ),
+                    newLit(get_byte_size_of(param.var_type))
+                )
+            )
+        else:
+            raise newException(
+                Exception, 
+                "Can only handle function with a single variable output ATM."
+            )
 
         selector_CaseStmt.add(
             nnkOfBranch.newTree(  # of 0x<>'u32:

examples/wrc202.nim

@@ -26,11 +26,22 @@ expandMacros:
         #   discard
         # else:
         #   revert(nil, 0)
+
+      # dumpAstGen:  
+        # var res {.noinit.}: uint256
+      dumpAstGen:
+        var res = hello(a)
+        var res_a = res.toByteArrayBE
+        finish(addr res_a, 256)
+        # finish(nil, 0)
       return (123).stuint(256)
 
     proc world(a: uint256, b: uint256): uint256  {.discardable.} =
         return (456).stuint(256)
 
+    proc do_nothing(a: uint256, b: uint256) =
+      discard
+
     # func addition(a: uint256, b: uint256): uint256 =
     #   return a + b