merge: implementation of higher levels

Author: AminRezaei0x443

.gitignore

@@ -1,6 +1,7 @@
 # Created by .ignore support plugin (hsz.mobi)
 # Project
 test_space/
+.build/
 
 # VSCode
 .vscode/

README.md

@@ -1,7 +1,7 @@
 <img align="left" width="64" height="64" src="./assets/dbuilder-icon.png">
 
 # dBuilder.py
-[![PyPI version](https://img.shields.io/badge/dbuilder-0.2.0-informational?style=flat-square&color=FFFF91)](https://pypi.org/project/dbuilder/)
+[![PyPI version](https://img.shields.io/badge/dbuilder-0.7.0-informational?style=flat-square&color=FFFF91)](https://pypi.org/project/dbuilder/)
 [![Telegram](https://img.shields.io/badge/Telegram-@d__builder-informational?style=flat-square&color=0088cc)](https://t.me/d_builder)
 
 dBuilder.py is smart contract development framework in Python for [TON (The Open Network)](https://ton.org). Its purpose is to make the development, testing, and deployment procedures much easier!
@@ -12,67 +12,52 @@ dBuilder.py is smart contract development framework in Python for [TON (The Open
 - Utilize Python's syntax to provide code reuse, understandable, and organized code that is simple to test
 
 ## Overview
-The major goal of dBuilder is to make contract development easier for TON by avoiding the steep learning curve of `FunC`. The present version implements a one-to-one mapping of Python to FunC with no special simplifications. However, the higher layers above the base are still under construction. Currently, [Simple wallet contract](https://github.com/ton-blockchain/ton/blob/master/crypto/smartcont/wallet-code.fc) looks like this in dBuilder:
+dBuilder's main purpose is to make contract building simpler for TON by bypassing the steep learning curve of `FunC`. dBuilder, by exploiting Python's OOP features, will enable you to create with more ease and less worry. In dBuilder, here is how the [Simple wallet contract](https://github.com/ton-blockchain/ton/blob/master/crypto/smartcont/wallet-code.fc) looks:
 
 ```python
-from dbuilder import method, method_id
-from dbuilder.core.loop import while_
-from dbuilder.func.contract import Contract
-from dbuilder.types import Slice
+from dbuilder import *
 
 
 class SimpleWallet(Contract):
+    """
+    Simple Wallet Contract.
+
+    # config
+    get-methods:
+        - seq_no
+        - public_key
+    """
+
+    class Data(Model):
+        seq_no: uint32
+        public_key: uint256
+
+    class ExternalBody(Payload):
+        signature: slice[512]
+        seq_no: uint32
+        valid_until: uint32
+
+    data: Data
+
     def external_receive(
-        self,
+        ctx,
         in_msg: Slice,
     ) -> None:
-        super(SimpleWallet, self).external_receive(
-            in_msg,
-        )
-        signature = in_msg.load_bits_(512)
-        cs = in_msg
-        msg_seqno = cs.load_uint_(32)
-        valid_until = cs.load_uint_(32)
-        self.throw_if(35, valid_until <= self.now())
-        ds = self.get_data().begin_parse()
-        stored_seqno = ds.load_uint_(32)
-        public_key = ds.load_uint_(256)
-        ds.end_parse()
-        self.throw_unless(33, msg_seqno == stored_seqno)
-        self.throw_unless(
-            34,
-            self.check_signature(
-                self.slice_hash(in_msg),
-                signature,
-                public_key,
-            ),
-        )
-        self.accept_message()
-        cs.touch_()
-        with while_(cs.slice_refs()):
-            mode = cs.load_uint_(8)
-            self.send_raw_message(cs.load_ref_(), mode)
-        cs.end_parse()
-        self.set_data(
-            self.begin_cell()
-            .store_uint(stored_seqno + 1, 32)
-            .store_uint(public_key, 256)
-            .end_cell(),
-        )
-
-    @method_id
-    @method
-    def seqno(self) -> int:
-        return self.get_data().begin_parse().preload_uint(32)
-
-    @method_id
-    @method
-    def get_public_key(self) -> int:
-        cs = self.get_data().begin_parse()
-        cs.load_uint_(32)
-        return cs.preload_uint(256)
+        msg = ctx.ExternalBody(in_msg)
+        assert msg.valid_until > std.now(), 35
+        assert msg.seq_no == ctx.data.seq_no, 33
+        assert std.check_signature(
+            msg.hash(after="signature"),
+            msg.signature,
+            ctx.data.public_key,
+        ), 34
+        std.accept_message()
+        while msg.refs():
+            mode = msg >> uint8
+            std.send_raw_message(msg >> Ref[Cell], mode)
+        ctx.data.seq_no += 1
+        ctx.data.save()
 ```
-Full documentation with specifics is being worked on and will be published soon!
 
 ## Quick Start
 
@@ -96,51 +81,24 @@ dbuilder init <project-name>
 dbuilder build
 ```
 
-## Vision
-As previously stated, the key advantage of dBuilder is the simplifications that will be available as higher layers are developed. If you're curious about how Simple wallet contract implementation may appear in the future, here's a look:
-
-```python
-class SimpleWallet(Contract):
-    class Data:
-        seq_no: UInt(32)
-        public_key: UInt(256)
-        getters = [seq_no, public_key]
-
-    class Message:
-        signature: UInt(512)
-        seq_no: UInt(32)
-        valid_until: UInt(32)
-
-    def external_receive(
-        self,
-        in_msg: Slice,
-    ) -> None:
-        msg = Message(in_msg)
-        assert msg.valid_until > self.now(), 35
-        assert msg.seq_no == self.data.seq_no, 33
-        assert self.check_signature(
-            msg.hash(after="signature"),
-            msg.signature,
-            self.data.public_key,
-        ), 34
-        self.accept_message()
+## Standard Contracts Implementation
+- [x] Jetton Implementation ([jetton-impl](https://github.com/decentralized-builder/jetton-impl))
+- [ ] NFT Implementation
+- [ ] DEX Implementation
 
-        with msg.has_ref():
-            mode = msg.uint(8)
-            self.send_raw_message(msg.ref(), mode)
 
-        self.data.seq_no += 1
-        self.data.save()
-```
+## Documentation and Examples
+Full documentation with specifications is being developed and will be available shortly!
+Until then, you may look at standard contracts implementation; they cover the majority of the ideas required; if you're looking for more, take a glance at the 'test/' directory for some demonstrations of dBuilder's capabilities.
 
 ## Roadmap
 
 ### Milestone 1: Python Framework for contract development
 
 - [x] Semi One-to-One mapping of functions and expressions (Base Compiler, Python -> FunC)
-- [ ] First higher layer over the base mappings to simplify type calls (leveraging OOP capabilities)
-- [ ] Second higher layer over the base, simplifying contract developments towards maximizing code reusability and simplicity (leveraging Meta programming capabilities)
-- [ ] Providing standard smart contracts implementation with dBuilder
+- [x] First higher layer over the base mappings to simplify type calls (leveraging OOP capabilities)
+- [x] Second higher layer over the base, simplifying contract developments towards maximizing code reusability and simplicity (leveraging Meta programming capabilities)
+- [x] Providing standard smart contracts implementation with dBuilder
 
 ### Milestone 2: deploying, testing, interaction capabilities
 - [ ] Simple interaction interface with TON Blockchain

dbuilder/__init__.py

@@ -1,4 +1,5 @@
 from dbuilder.ast import *
 from dbuilder.core import *
 from dbuilder.func import *
+from dbuilder.library import *
 from dbuilder.types import *

dbuilder/ast/ast_patcher.py

@@ -7,152 +7,29 @@
 """
 
 import ast
-from typing import Any
 
-
-class Transformer(ast.NodeTransformer):
-    """Transforms the AST to capture assginments."""
-
-    def generic_visit(self, node):
-        ast.NodeTransformer.generic_visit(self, node)
-        return node
-
-    def visit_Return(self, node: ast.Return) -> Any:
-        v = node.value
-        if v is None:
-            v = ast.Constant(None)
-        u_node = ast.Expr(
-            value=ast.Call(
-                func=ast.Attribute(
-                    value=ast.Name(id="self", ctx=ast.Load()),
-                    attr="ret_",
-                    ctx=ast.Load(),
-                ),
-                args=[v],
-                keywords=[],
-            ),
-        )
-        ast.fix_missing_locations(u_node)
-        return u_node
-        pass
-
-    def visit_Assign(self, node):
-        tg = node.targets[0]
-        if isinstance(tg, ast.Tuple):
-            node.targets = [
-                ast.Name(
-                    id="__tmp__",
-                    ctx=ast.Store(),
-                ),
-            ]
-            vars = [v.id for v in tg.dims]
-            e_expr = ast.Assign(
-                targets=[
-                    ast.Tuple(
-                        elts=[
-                            ast.Name(
-                                id=v,
-                                ctx=ast.Store(),
-                            )
-                            for v in vars
-                        ],
-                        ctx=ast.Store(),
-                    ),
-                ],
-                value=ast.Name(
-                    id="__tmp__",
-                    ctx=ast.Load(),
-                ),
-            )
-            l_expr = ast.Call(
-                func=ast.Name(id="hasattr", ctx=ast.Load()),
-                args=[
-                    ast.Name(id="__tmp__", ctx=ast.Load()),
-                    ast.Constant(value="__prep_unpack__", kind=None),
-                ],
-                keywords=[],
-            )
-            r_expr = ast.Call(
-                func=ast.Attribute(
-                    value=ast.Name(id="__tmp__", ctx=ast.Load()),
-                    attr="__prep_unpack__",
-                    ctx=ast.Load(),
-                ),
-                args=[ast.Constant(value=len(vars), kind=None)],
-                keywords=[],
-            )
-
-            p_expr = ast.Expr(
-                value=ast.BoolOp(op=ast.And(), values=[l_expr, r_expr]),
-            )
-            a_expr = ast.Expr(
-                value=ast.Call(
-                    func=ast.Attribute(
-                        value=ast.Name(id="__tmp__", ctx=ast.Load()),
-                        attr="__massign__",
-                        ctx=ast.Load(),
-                    ),
-                    args=[
-                        ast.List(
-                            elts=[
-                                ast.Constant(value=str(v), kind=None)
-                                for v in vars
-                            ],
-                            ctx=ast.Load(),
-                        ),
-                        ast.List(
-                            elts=[
-                                ast.Name(id=str(v), ctx=ast.Load())
-                                for v in vars
-                            ],
-                            ctx=ast.Load(),
-                        ),
-                    ],
-                    keywords=[],
-                ),
-            )
-            nodes = [node, p_expr, e_expr, a_expr]
-        else:
-            target = node.targets[0].id
-            nodes = [node]
-            if isinstance(node.value, ast.Constant):
-                if isinstance(node.value.value, int):
-                    node.value = ast.Call(
-                        func=ast.Attribute(
-                            value=ast.Name(id="self", ctx=ast.Load()),
-                            attr="factory_",
-                            ctx=ast.Load(),
-                        ),
-                        args=[ast.Constant("int"), node.value],
-                        keywords=[],
-                    )
-
-            c_expr = ast.Call(
-                func=ast.Attribute(
-                    value=ast.Name(id=target, ctx=ast.Load()),
-                    attr="__assign__",
-                    ctx=ast.Load(),
-                ),
-                args=[ast.Constant(value=str(target), kind=None)],
-                keywords=[],
-            )
-            if isinstance(node.value, ast.Name):
-                a_expr = ast.Assign(
-                    targets=[ast.Name(id=target, ctx=ast.Store())],
-                    value=c_expr,
-                )
-            else:
-                a_expr = ast.Expr(
-                    value=c_expr,
-                )
-            nodes.append(a_expr)
-        for g_node in nodes:
-            ast.fix_missing_locations(g_node)
-        return nodes
+from dbuilder.ast.patchers import (
+    AssertPatcher,
+    AssignPatcher,
+    IfPatcher,
+    RaisePatcher,
+    ReturnPatcher,
+    UnaryPatcher,
+    WhilePatcher,
+)
 
 
 def patch(node):
-    trans = Transformer()
-    new_node = trans.visit(node)
-    ast.fix_missing_locations(new_node)
+    transformers = [
+        UnaryPatcher(),
+        AssertPatcher(),
+        AssignPatcher(),
+        IfPatcher(),
+        RaisePatcher(),
+        ReturnPatcher(),
+        WhilePatcher(),
+    ]
+    for t in transformers:
+        new_node = t.visit(node)
+        ast.fix_missing_locations(new_node)
     return new_node

dbuilder/ast/bool_dict.py

@@ -0,0 +1,31 @@
+from collections.abc import MutableMapping
+
+
+class BoolDict(MutableMapping):
+    def __init__(self, default_=False, *args, **kwargs):
+        self.store = {}
+        self.default = default_
+        self.update(dict(*args, **kwargs))  # use the free update to set keys
+
+    def has(self, item):
+        return item in self.store
+
+    def __getitem__(self, key):
+        if key not in self.store:
+            return self.default
+        return self.store[self._keytransform(key)]
+
+    def __setitem__(self, key, value):
+        self.store[self._keytransform(key)] = value
+
+    def __delitem__(self, key):
+        del self.store[self._keytransform(key)]
+
+    def __iter__(self):
+        return iter(self.store)
+
+    def __len__(self):
+        return len(self.store)
+
+    def _keytransform(self, key):
+        return key