diff --git a/Pipfile b/Pipfile
index f8ff70f..e88d768 100644
--- a/Pipfile
+++ b/Pipfile
@@ -15,3 +15,5 @@ pytest = "*"
 pycrypto = "==2.6.1"
 scrypt = "==0.8.0"
 aiohttp = "*"
+yarl = "*"
+async-timeout = "*"
diff --git a/Pipfile.lock b/Pipfile.lock
index d581066..9bb2025 100644
--- a/Pipfile.lock
+++ b/Pipfile.lock
@@ -1,7 +1,7 @@
 {
     "_meta": {
         "hash": {
-            "sha256": "9bbf95efabd391e884aa8db4c5f9cc469c24cde90a834a4ebec16a35255d84d3"
+            "sha256": "55e4ddd6347afc52f0d3708765a1e643a5160d6843fd68a78a8315ad0b809868"
         },
         "pipfile-spec": 6,
         "requires": {
@@ -18,38 +18,39 @@
     "default": {
         "aiohttp": {
             "hashes": [
-                "sha256:0419705a36b43c0ac6f15469f9c2a08cad5c939d78bd12a5c23ea167c8253b2b",
-                "sha256:1812fc4bc6ac1bde007daa05d2d0f61199324e0cc893b11523e646595047ca08",
-                "sha256:2214b5c0153f45256d5d52d1e0cafe53f9905ed035a142191727a5fb620c03dd",
-                "sha256:275909137f0c92c61ba6bb1af856a522d5546f1de8ea01e4e726321c697754ac",
-                "sha256:3983611922b561868428ea1e7269e757803713f55b53502423decc509fef1650",
-                "sha256:51afec6ffa50a9da4cdef188971a802beb1ca8e8edb40fa429e5e529db3475fa",
-                "sha256:589f2ec8a101a0f340453ee6945bdfea8e1cd84c8d88e5be08716c34c0799d95",
-                "sha256:789820ddc65e1f5e71516adaca2e9022498fa5a837c79ba9c692a9f8f916c330",
-                "sha256:7a968a0bdaaf9abacc260911775611c9a602214a23aeb846f2eb2eeaa350c4dc",
-                "sha256:7aeefbed253f59ea39e70c5848de42ed85cb941165357fc7e87ab5d8f1f9592b",
-                "sha256:7b2eb55c66512405103485bd7d285a839d53e7fdc261ab20e5bcc51d7aaff5de",
-                "sha256:87bc95d3d333bb689c8d755b4a9d7095a2356108002149523dfc8e607d5d32a4",
-                "sha256:9d80e40db208e29168d3723d1440ecbb06054d349c5ece6a2c5a611490830dd7",
-                "sha256:a1b442195c2a77d33e4dbee67c9877ccbdd3a1f686f91eb479a9577ed8cc326b",
-                "sha256:ab3d769413b322d6092f169f316f7b21cd261a7589f7e31db779d5731b0480d8",
-                "sha256:b066d3dec5d0f5aee6e34e5765095dc3d6d78ef9839640141a2b20816a0642bd",
-                "sha256:b24e7845ae8de3e388ef4bcfcf7f96b05f52c8e633b33cf8003a6b1d726fc7c2",
-                "sha256:c59a953c3f8524a7c86eaeaef5bf702555be12f5668f6384149fe4bb75c52698",
-                "sha256:cf2cc6c2c10d242790412bea7ccf73726a9a44b4c4b073d2699ef3b48971fd95",
-                "sha256:e0c9c8d4150ae904f308ff27b35446990d2b1dfc944702a21925937e937394c6",
-                "sha256:f1839db4c2b08a9c8f9788112644f8a8557e8e0ecc77b07091afabb941dc55d0",
-                "sha256:f3df52362be39908f9c028a65490fae0475e4898b43a03d8aa29d1e765b45e07"
+                "sha256:14821eb8613bfab9118be3c55afc87bf4cef97689896fa0874c6877b117afbeb",
+                "sha256:3a4cdb9ca87c099d8ba5eb91cb8f000b60c21f8c1b50c75e04e8777e903bd278",
+                "sha256:44c9cf24e63576244c13265ef0786b56d6751f5fb722225ecc021d6ecf91b4d2",
+                "sha256:46ace48789865a89992419205024ae451d577876f9919fbb0f22f71189822dea",
+                "sha256:528b0b811b6260a79222b055664b82093d01f35fe5c82521d8659cb2b28b8044",
+                "sha256:5436ca0ed752bb05a399fc07dc86dc23c756db523a3b7d5da46a457eacf4c4b5",
+                "sha256:5a952d4af7de5f78dfb3206dbc352717890b37d447f0bbd4b5969b3c8bb713af",
+                "sha256:6b8c5a00432b8a5a083792006e8fdfb558b8b10019ce254200855264d3a25895",
+                "sha256:756fc336a29c551b02252685f01bc87116bc9b04bbd02c1a6b8a96b3c6ad713b",
+                "sha256:7ac6378ae364d8e5e5260c7224ea4a1965cb6f4719f15d0552349d0b0cc93953",
+                "sha256:7b407c22b0ab473ffe0a7d3231f2084a8ae80fdb64a31842b88d57d6b7bdab7c",
+                "sha256:82a9068d9cb15eb2d99ecf39f8d56b4ed9f931a77a3622a0de747465fd2a7b96",
+                "sha256:834f687b806fbf49cb135b5a208b5c27338e19c219d6e09e9049936e01e8bea8",
+                "sha256:8adda6583ba438a4c70693374e10b60168663ffa6564c5c75d3c7a9055290964",
+                "sha256:8f32a4e157bad9c60ebc38c3bb93fcc907a020b017ddf8f7ab1580390e21940e",
+                "sha256:a8c12f3184c7cad8f66cae6c945d2c97e598b0cb7afd655a5b9471475e67f30e",
+                "sha256:b25c7720c495048ed658086a29925ab485ac7ececf1b346f2b459e5431d85016",
+                "sha256:c77e29243a79e376a1b51d71a13df4a61bc54fd4d9597ce3790b8d82ec6eb44d",
+                "sha256:cf790e61c2af0278f39dcedad9a22532bf81fb029c2cd73b1ceba7bea062c908",
+                "sha256:ef1a36a16e72b6689ce0a6c7fc6bd88837d8fef4590b16bd72817644ae1f414d",
+                "sha256:f5e7d41d924a1d5274060c467539ee0c4f3bab318c1671ad65abd91f6b637baf",
+                "sha256:f72bb19cece43483171264584bbaaf8b97717d9c0f244d1ef4a51df1cdb34085"
             ],
             "index": "pypi",
-            "version": "==3.4.4"
+            "version": "==2.3.10"
         },
         "async-timeout": {
             "hashes": [
-                "sha256:0c3c816a028d47f659d6ff5c745cb2acf1f966da1fe5c19c77a70282b25f4c5f",
-                "sha256:4291ca197d287d274d0b6cb5d6f8f8f82d434ed288f962539ff18cc9012f9ea3"
+                "sha256:00cff4d2dce744607335cba84e9929c3165632da2d27970dbc55802a0c7873d0",
+                "sha256:9093db5b8ddbe4b8f6885d1a6e0ad84ae3155464cbf6877c387605244c285f3c"
             ],
-            "version": "==3.0.1"
+            "index": "pypi",
+            "version": "==2.0.1"
         },
         "atomicwrites": {
             "hashes": [
@@ -98,7 +99,6 @@
             "hashes": [
                 "sha256:a933e3bb13da54383f9e8f35dc4f9cb9eb9b3b78c6b36f311254d6d0d92c6c7c"
             ],
-            "markers": "python_version < '3.7'",
             "version": "==1.1.0"
         },
         "more-itertools": {
@@ -174,37 +174,35 @@
         },
         "pytest": {
             "hashes": [
-                "sha256:10e59f84267370ab20cec9305bafe7505ba4d6b93ecbf66a1cce86193ed511d5",
-                "sha256:8c827e7d4816dfe13e9329c8226aef8e6e75d65b939bc74fda894143b6d1df59"
+                "sha256:630ff1dbe04f469ee78faa5660f712e58b953da7df22ea5d828c9012e134da43",
+                "sha256:a2b5232735dd0b736cbea9c0f09e5070d78fcaba2823a4f6f09d9a81bd19415c"
             ],
             "index": "pypi",
-            "version": "==3.9.1"
+            "version": "==3.10.0"
         },
         "requests": {
             "hashes": [
-                "sha256:63b52e3c866428a224f97cab011de738c36aec0185aa91cfacd418b5d58911d1",
-                "sha256:ec22d826a36ed72a7358ff3fe56cbd4ba69dd7a6718ffd450ff0e9df7a47ce6a"
+                "sha256:99dcfdaaeb17caf6e526f32b6a7b780461512ab3f1d992187801694cba42770c",
+                "sha256:a84b8c9ab6239b578f22d1c21d51b696dcfe004032bb80ea832398d6909d7279"
             ],
             "index": "pypi",
-            "version": "==2.19.1"
+            "version": "==2.20.0"
         },
         "scrypt": {
             "hashes": [
-                "sha256:18ccbc63d87c6f89b753194194bb37aeaf1abc517e4b989461d115c1d93ce128",
-                "sha256:232acdbc3434d2de55def8d5dbf1bc4b9bfc50da7c5741df2a6eebc4e18d3720",
-                "sha256:475ac80239b3d788ae71a09c3019ca915e149aaa339adcdd1c9eef121293dc88",
-                "sha256:4ad7188f2e42dbee2ff1cd72e3da40b170ba41847effbf0d726444f62ae60f3a",
-                "sha256:85919f023148cd9fb01d75ad4e3e061928c298fa6249a0cd6cd469c4b947595e",
-                "sha256:971db040d3963ebe4b919a203fe10d7d6659951d3644066314330983dc175ed4",
-                "sha256:a124719c686f2b5957e392465147fb3fd6077e7c643e9538cab1ee631eb01dde",
-                "sha256:a343c302b3e99dcb7fcbe57aa7919ed761f1568f854291ccebe1b5e6e2c9e509",
-                "sha256:bc131f74a688fa09993c518ca666a2ebd4268b207e039cbab03a034228140d3e",
-                "sha256:c23daecee405cb036845917295c76f8d747fc890158df40cb304b4b3c3640079",
-                "sha256:dc40f0e1a357a49ca62f30f2fc09e92e02c062a656f27949b436b2ba8002d9e1",
-                "sha256:f8239b2d47fa1d40bc27efd231dc7083695d10c1c2ac51a99380360741e0362d"
+                "sha256:3422d11652cd12550540675e9fb54a1de6d60f3cbfedfb067284ef028589e2ee",
+                "sha256:4e3cd639cc83e3f2c2241a01ebef9487c48b1ddf2d78f430d82d8f9ef60c6271",
+                "sha256:59a03822df232a30246b59a3801292a350d19fa636f11ea86df2214f35dade22",
+                "sha256:60e8c96a287ab892d9c7e1523d157ccfbdbe66da0c31738c8ed5732c2eea6a23",
+                "sha256:7e3be5fe70f74a01a83c60da0b010b2fe6c3d3a11b8a1c9532b583c9a440d529",
+                "sha256:ae2fd88756fb4d98ccc5e2639af55eeb80863b3f9f6e0f539e5ce050964cdd5e",
+                "sha256:c0f90cabb8f6eaec05de5ce9aa9a9b67dc63d644e6b803beb1c43ae9b9452b65",
+                "sha256:c37a1f8440d7c621d9f23f3c1f2a28848bc50fefbca581fd7a1b01583a083c07",
+                "sha256:d4a5a4f53450b8ef629bbf1ee4be6105c69936e49b3d8bc621ac2287f0c86020",
+                "sha256:dc9abe69799ca423b938a06ddc33e5873e493ffcd68dbb9ba48396979b210d39"
             ],
             "index": "pypi",
-            "version": "==0.8.6"
+            "version": "==0.8.0"
         },
         "six": {
             "hashes": [
@@ -215,24 +213,29 @@
         },
         "urllib3": {
             "hashes": [
-                "sha256:a68ac5e15e76e7e5dd2b8f94007233e01effe3e50e8daddf69acfd81cb686baf",
-                "sha256:b5725a0bd4ba422ab0e66e89e030c806576753ea3ee08554382c14e685d117b5"
+                "sha256:61bf29cada3fc2fbefad4fdf059ea4bd1b4a86d2b6d15e1c7c0b582b9752fe39",
+                "sha256:de9529817c93f27c8ccbfead6985011db27bd0ddfcdb2d86f3f663385c6a9c22"
             ],
-            "version": "==1.23"
+            "version": "==1.24.1"
         },
         "yarl": {
             "hashes": [
-                "sha256:2556b779125621b311844a072e0ed367e8409a18fa12cbd68eb1258d187820f9",
-                "sha256:4aec0769f1799a9d4496827292c02a7b1f75c0bab56ab2b60dd94ebb57cbd5ee",
-                "sha256:55369d95afaacf2fa6b49c84d18b51f1704a6560c432a0f9a1aeb23f7b971308",
-                "sha256:6c098b85442c8fe3303e708bbb775afd0f6b29f77612e8892627bcab4b939357",
-                "sha256:9182cd6f93412d32e009020a44d6d170d2093646464a88aeec2aef50592f8c78",
-                "sha256:c8cbc21bbfa1dd7d5386d48cc814fe3d35b80f60299cdde9279046f399c3b0d8",
-                "sha256:db6f70a4b09cde813a4807843abaaa60f3b15fb4a2a06f9ae9c311472662daa1",
-                "sha256:f17495e6fe3d377e3faac68121caef6f974fcb9e046bc075bcff40d8e5cc69a4",
-                "sha256:f85900b9cca0c67767bb61b2b9bd53208aaa7373dae633dbe25d179b4bf38aa7"
-            ],
-            "version": "==1.2.6"
+                "sha256:3278209d78d534d59ee44f595e54ee4d3a164fa77319ffbd418b1978edf71748",
+                "sha256:32a52453fc20153e34d2cf99f1a2f4c3d144e320896f1f89b5ee89bb41e877be",
+                "sha256:48f3807855b69414a41e70908e502d6dbf563e3eca22f73d1344aad9270a4ff9",
+                "sha256:4c2d780cb0b669bf027da57a0834d4968ed55c89f1593cfd11be8108bff699e2",
+                "sha256:843c90c7a2756c033e9bb4464f789e21bc33f561c1e6c0ef7569f452b33a761a",
+                "sha256:8765ebd034d0dc812a311b31251dffb434c753fc7124487912a5bca7baeb5c9b",
+                "sha256:a2dda88459cfe50f4f6a225d2f51e3fffb0c3c18f4c3a3ac38d9dc054f8c37b0",
+                "sha256:ac574aa2c45185e038489ff8f3bebd9269dd8327e86c72d9a7f83a1d3ad9eec4",
+                "sha256:ce5963f2451661a435721d8907a824daea52aad6e3bee9b4104e75d19269cdae",
+                "sha256:ceae77215870ecaba555b2e74dd308de9abe6d44b0eecafae6ecef4a14e289f8",
+                "sha256:cec06d4272c2ced65308daf63360daeea5061c030fe28f75e499afd735cee860",
+                "sha256:ee506bc321b455b4a410724ec9c0ad4940932553523c6e7b69f0155269793734",
+                "sha256:fbbb10276d53629c0300cfd4a2092e3bbfa9a5aa95cd49808e01c59492052077"
+            ],
+            "index": "pypi",
+            "version": "==1.2.0"
         }
     },
     "develop": {}
diff --git a/scorum/graphenebase/betting/__init__.py b/scorum/graphenebase/betting/__init__.py
index db41499..08aa1bd 100644
--- a/scorum/graphenebase/betting/__init__.py
+++ b/scorum/graphenebase/betting/__init__.py
@@ -1,4 +1,5 @@
 from .game import Game
 from .market import Market
+from .wincase import Wincase
 
-__all__ = ["Game", "Market"]
+__all__ = ["Game", "Market", "Wincase"]
diff --git a/scorum/graphenebase/betting/game.py b/scorum/graphenebase/betting/game.py
index 0f97c7e..3bd23b9 100644
--- a/scorum/graphenebase/betting/game.py
+++ b/scorum/graphenebase/betting/game.py
@@ -1,13 +1,21 @@
-import struct
-from enum import Enum
+from scorum.graphenebase.objects import GrapheneObject, StaticVariantObject
 
+GAMES = [
+    'soccer_game',
+    'hockey_game'
+]
 
-class Game(Enum):
-    soccer = 0
-    hockey = 1
 
-    def __bytes__(self):
-        return struct.pack("<B", self.value)
+class Game(StaticVariantObject):
+    def __init__(self, game_type):
+        super().__init__(game_type, GAMES)
+        self.name = self.get_name(game_type) + "_game"
+        self.id = self.get_id(self.name)
 
-    def __str__(self):
-        return "{0}".format(self.name)
+
+class Soccer(GrapheneObject):
+    pass
+
+
+class Hockey(GrapheneObject):
+    pass
diff --git a/scorum/graphenebase/betting/market.py b/scorum/graphenebase/betting/market.py
index be85f62..1879577 100644
--- a/scorum/graphenebase/betting/market.py
+++ b/scorum/graphenebase/betting/market.py
@@ -1,50 +1,32 @@
-import json
-import re
 from collections import OrderedDict
 
-from scorum.graphenebase.graphene_types import Id, Uint16
-from scorum.graphenebase.objects import GrapheneObject
+from scorum.graphenebase.graphene_types import Int16
+from scorum.graphenebase.objects import GrapheneObject, StaticVariantObject
 
 MARKETS = [
-    "result_home_market",
-    "result_draw_market",
-    "result_away_market",
-    "round_market",
-    "handicap_market",
-    "correct_score_market",
-    "correct_score_parametrized_market",
-    "goal_market",
-    "total_market",
-    "total_goals_market",
+    "result_home",
+    "result_draw",
+    "result_away",
+    "round_home",
+    "handicap",
+    "correct_score_home",
+    "correct_score_draw",
+    "correct_score_away",
+    "correct_score",
+    "goal_home",
+    "goal_both",
+    "goal_away",
+    "total",
+    "total_goals_home",
+    "total_goals_away"
 ]
 
 
-class Market:
+class Market(StaticVariantObject):
     def __init__(self, market_type):
-        self.market_type = market_type
-        self.name = self.get_market_name(market_type)
-        self.id = self.get_market_id(self.name)
-
-    @staticmethod
-    def get_market_id(name: str):
-        try:
-            return MARKETS.index(name)
-        except ValueError:
-            raise Exception("no such market %s" % name)
-
-    @staticmethod
-    def get_market_name(market_type):
-        """ Take a name of a class, like ResultHome and turn it into method name like result_home_market. """
-        class_name = type(market_type).__name__  # also store name
-        words = re.findall('[A-Z][^A-Z]*', class_name)
-
-        return '_'.join(map(str.lower, words)) + "_market"
-
-    def __bytes__(self):
-        return bytes(Id(self.id)) + bytes(self.market_type)
-
-    def __str__(self):
-        return json.dumps([self.name, self.market_type.toJson()])
+        super().__init__(market_type, MARKETS)
+        self.name = self.get_name(market_type)
+        self.id = self.get_id(self.name)
 
 
 class ResultHome(GrapheneObject):
@@ -59,41 +41,64 @@ class ResultAway(GrapheneObject):
     pass
 
 
-class Round(GrapheneObject):
+class RoundHome(GrapheneObject):
     pass
 
 
 class Handicap(GrapheneObject):
     def __init__(self, threshold=0):
-        self.data = OrderedDict({"threshold": Uint16(threshold)})
+        self.data = OrderedDict([("threshold", Int16(threshold))])
 
         super(Handicap, self).__init__(self.data)
 
 
-class CorrectScore(GrapheneObject):
+class CorrectScoreHome(GrapheneObject):
+    pass
+
+
+class CorrectScoreDraw(GrapheneObject):
+    pass
+
+
+class CorrectScoreAway(GrapheneObject):
     pass
 
 
-class CorrectScoreParametrized(GrapheneObject):
+class CorrectScore(GrapheneObject):
     def __init__(self, home=0, away=0):
-        self.data = OrderedDict({"home": Uint16(home), "away": Uint16(away)})
+        self.data = OrderedDict([("home", Int16(home)), ("away", Int16(away))])
+
+        super(CorrectScore, self).__init__(self.data)
+
 
-        super(CorrectScoreParametrized, self).__init__(self.data)
+class GoalHome(GrapheneObject):
+    pass
 
 
-class Goal(GrapheneObject):
+class GoalBoth(GrapheneObject):
+    pass
+
+
+class GoalAway(GrapheneObject):
     pass
 
 
 class Total(GrapheneObject):
     def __init__(self, threshold=0):
-        self.data = OrderedDict({"threshold": Uint16(threshold)})
+        self.data = OrderedDict([("threshold", Int16(threshold))])
 
         super(Total, self).__init__(self.data)
 
 
-class TotalGoals(GrapheneObject):
+class TotalGoalsHome(GrapheneObject):
+    def __init__(self, threshold=0):
+        self.data = OrderedDict([("threshold", Int16(threshold))])
+
+        super(TotalGoalsHome, self).__init__(self.data)
+
+
+class TotalGoalsAway(GrapheneObject):
     def __init__(self, threshold=0):
-        self.data = OrderedDict({"threshold": Uint16(threshold)})
+        self.data = OrderedDict([("threshold", Int16(threshold))])
 
-        super(TotalGoals, self).__init__(self.data)
+        super(TotalGoalsAway, self).__init__(self.data)
diff --git a/scorum/graphenebase/betting/wincase.py b/scorum/graphenebase/betting/wincase.py
new file mode 100644
index 0000000..490e8fa
--- /dev/null
+++ b/scorum/graphenebase/betting/wincase.py
@@ -0,0 +1,250 @@
+from collections import OrderedDict
+
+from scorum.graphenebase.graphene_types import Int16
+from scorum.graphenebase.objects import GrapheneObject, StaticVariantObject
+
+WINCASES = [
+    "result_home::yes",
+    "result_home::no",
+    "result_draw::yes",
+    "result_draw::no",
+    "result_away::yes",
+    "result_away::no",
+    "round_home::yes",
+    "round_home::no",
+    "handicap::over",
+    "handicap::under",
+    "correct_score_home::yes",
+    "correct_score_home::no",
+    "correct_score_draw::yes",
+    "correct_score_draw::no",
+    "correct_score_away::yes",
+    "correct_score_away::no",
+    "correct_score::yes",
+    "correct_score::no",
+    "goal_home::yes",
+    "goal_home::no",
+    "goal_both::yes",
+    "goal_both::no",
+    "goal_away::yes",
+    "goal_away::no",
+    "total::over",
+    "total::under",
+    "total_goals_home::over",
+    "total_goals_home::under",
+    "total_goals_away::over",
+    "total_goals_away::under"
+]
+
+
+class Wincase(StaticVariantObject):
+    def __init__(self, wincase_type):
+        super().__init__(wincase_type, WINCASES)
+        self.wincase_type = wincase_type
+        self.name = "::".join(self.get_name(wincase_type).rsplit('_', 1))
+        self.id = self.get_id(self.name)
+
+    def __eq__(self, other):
+        return str(self) == str(other)
+
+
+class ResultHomeYes(GrapheneObject):
+    pass
+
+
+class ResultHomeNo(GrapheneObject):
+    pass
+
+
+class ResultDrawYes(GrapheneObject):
+    pass
+
+
+class ResultDrawNo(GrapheneObject):
+    pass
+
+
+class ResultAwayYes(GrapheneObject):
+    pass
+
+
+class ResultAwayNo(GrapheneObject):
+    pass
+
+
+class RoundHomeYes(GrapheneObject):
+    pass
+
+
+class RoundHomeNo(GrapheneObject):
+    pass
+
+
+class HandicapOver(GrapheneObject):
+    def __init__(self, threshold=0):
+        self.data = OrderedDict([("threshold", Int16(threshold))])
+
+        super(HandicapOver, self).__init__(self.data)
+
+
+class HandicapUnder(GrapheneObject):
+    def __init__(self, threshold=0):
+        self.data = OrderedDict([("threshold", Int16(threshold))])
+
+        super(HandicapUnder, self).__init__(self.data)
+
+
+class CorrectScoreHomeYes(GrapheneObject):
+    pass
+
+
+class CorrectScoreHomeNo(GrapheneObject):
+    pass
+
+
+class CorrectScoreDrawYes(GrapheneObject):
+    pass
+
+
+class CorrectScoreDrawNo(GrapheneObject):
+    pass
+
+
+class CorrectScoreAwayYes(GrapheneObject):
+    pass
+
+
+class CorrectScoreAwayNo(GrapheneObject):
+    pass
+
+
+class CorrectScoreYes(GrapheneObject):
+    def __init__(self, home=0, away=0):
+        self.data = OrderedDict([("home", Int16(home)), ("away", Int16(away))])
+
+        super(CorrectScoreYes, self).__init__(self.data)
+
+
+class CorrectScoreNo(GrapheneObject):
+    def __init__(self, home=0, away=0):
+        self.data = OrderedDict([("home", Int16(home)), ("away", Int16(away))])
+
+        super(CorrectScoreNo, self).__init__(self.data)
+
+
+class GoalHomeYes(GrapheneObject):
+    pass
+
+
+class GoalHomeNo(GrapheneObject):
+    pass
+
+
+class GoalBothYes(GrapheneObject):
+    pass
+
+
+class GoalBothNo(GrapheneObject):
+    pass
+
+
+class GoalAwayYes(GrapheneObject):
+    pass
+
+
+class GoalAwayNo(GrapheneObject):
+    pass
+
+
+class TotalOver(GrapheneObject):
+    def __init__(self, threshold=0):
+        self.data = OrderedDict([("threshold", Int16(threshold))])
+
+        super(TotalOver, self).__init__(self.data)
+
+
+class TotalUnder(GrapheneObject):
+    def __init__(self, threshold=0):
+        self.data = OrderedDict([("threshold", Int16(threshold))])
+
+        super(TotalUnder, self).__init__(self.data)
+
+
+class TotalGoalsHomeOver(GrapheneObject):
+    def __init__(self, threshold=0):
+        self.data = OrderedDict([("threshold", Int16(threshold))])
+
+        super(TotalGoalsHomeOver, self).__init__(self.data)
+
+
+class TotalGoalsHomeUnder(GrapheneObject):
+    def __init__(self, threshold=0):
+        self.data = OrderedDict([("threshold", Int16(threshold))])
+
+        super(TotalGoalsHomeUnder, self).__init__(self.data)
+
+
+class TotalGoalsAwayOver(GrapheneObject):
+    def __init__(self, threshold=0):
+        self.data = OrderedDict([("threshold", Int16(threshold))])
+
+        super(TotalGoalsAwayOver, self).__init__(self.data)
+
+
+class TotalGoalsAwayUnder(GrapheneObject):
+    def __init__(self, threshold=0):
+        self.data = OrderedDict([("threshold", Int16(threshold))])
+
+        super(TotalGoalsAwayUnder, self).__init__(self.data)
+
+
+WINCASES_MAP = {
+    "result_home::yes": ResultHomeYes,
+    "result_home::no": ResultHomeNo,
+    "result_draw::yes": ResultDrawYes,
+    "result_draw::no": ResultDrawNo,
+    "result_away::yes": ResultAwayYes,
+    "result_away::no": ResultAwayNo,
+    "round_home::yes": RoundHomeYes,
+    "round_home::no": RoundHomeNo,
+    "handicap::over": HandicapOver,
+    "handicap::under": HandicapUnder,
+    "correct_score_home::yes": CorrectScoreHomeYes,
+    "correct_score_home::no": CorrectScoreHomeNo,
+    "correct_score_draw::yes": CorrectScoreDrawYes,
+    "correct_score_draw::no": CorrectScoreDrawNo,
+    "correct_score_away::yes": CorrectScoreAwayYes,
+    "correct_score_away::no": CorrectScoreAwayNo,
+    "correct_score::yes": CorrectScoreYes,
+    "correct_score::no": CorrectScoreNo,
+    "goal_home::yes": GoalHomeYes,
+    "goal_home::no": GoalHomeNo,
+    "goal_both::yes": GoalBothYes,
+    "goal_both::no": GoalBothNo,
+    "goal_away::yes": GoalAwayYes,
+    "goal_away::no": GoalAwayNo,
+    "total::over": TotalOver,
+    "total::under": TotalUnder,
+    "total_goals_home::over": TotalGoalsHomeOver,
+    "total_goals_home::under": TotalGoalsHomeUnder,
+    "total_goals_away::over": TotalGoalsAwayOver,
+    "total_goals_away::under": TotalGoalsAwayUnder
+}
+
+
+def create_obj_from_json(wc):
+    """
+    :param list wc: Wincase name and type parameters, example ["handicap::over", {"threashold": 1000}]
+    :return: Wincase class object
+    """
+    if len(wc) != 2:
+        raise ValueError("Unexpected json value was given.")
+    name, kwargs = wc
+    return Wincase(WINCASES_MAP[name](**kwargs))
+
+
+def opposite(name: str):
+    idx = WINCASES.index(name)
+    if idx % 2:
+        return WINCASES[idx - 1]
+    return WINCASES[idx + 1]
diff --git a/scorum/graphenebase/graphene_types.py b/scorum/graphenebase/graphene_types.py
index 8f80d19..dda51cb 100644
--- a/scorum/graphenebase/graphene_types.py
+++ b/scorum/graphenebase/graphene_types.py
@@ -72,6 +72,17 @@ def __str__(self):
         return '%d' % self.data
 
 
+class Odds16:
+    def __init__(self, numerator, denominator):
+        self.odds = {"numerator": numerator, "denominator": denominator}
+
+    def __bytes__(self):
+        return bytes(Int16(self.odds["numerator"])) + bytes(Int16(self.odds["denominator"]))
+
+    def __str__(self):
+        return json.dumps(self.odds)
+
+
 class Uint16():
     def __init__(self, d):
         self.data = int(d)
@@ -83,6 +94,17 @@ def __str__(self):
         return '%d' % self.data
 
 
+class Int32():
+    def __init__(self, d):
+        self.data = int(d)
+
+    def __bytes__(self):
+        return struct.pack("<i", int(self.data))
+
+    def __str__(self):
+        return '%d' % self.data
+
+
 class Uint32():
     def __init__(self, d):
         self.data = int(d)
@@ -94,6 +116,17 @@ def __str__(self):
         return '%d' % self.data
 
 
+class Odds32:
+    def __init__(self, numerator, denominator):
+        self.odds = {"numerator": numerator, "denominator": denominator}
+
+    def __bytes__(self):
+        return bytes(Int32(self.odds["numerator"])) + bytes(Int32(self.odds["denominator"]))
+
+    def __str__(self):
+        return json.dumps(self.odds)
+
+
 class Uint64():
     def __init__(self, d):
         self.data = int(d)
@@ -296,7 +329,7 @@ def isempty(self):
         return not bool(bytes(self.data))
 
 
-class Static_variant():
+class StaticVariant:
     def __init__(self, d, type_id):
         self.data = d
         self.type_id = type_id
diff --git a/scorum/graphenebase/objects.py b/scorum/graphenebase/objects.py
index ef2b235..2c06d66 100644
--- a/scorum/graphenebase/objects.py
+++ b/scorum/graphenebase/objects.py
@@ -9,51 +9,6 @@
     from graphene_types import String, Optional, Id, JsonObj
 
 
-class Operation:
-    def __init__(self, op):
-        # if isinstance(op, list) and len(op) == 2:
-        #     if isinstance(op[0], int):
-        #         self.opId = op[0]
-        #         name = self.get_operation_name_for_id(self.opId)
-        #     else:
-        #         self.opId = self.operations().get(op[0], None)
-        #         name = op[0]
-        #         if self.opId is None:
-        #             raise ValueError("Unknown operation")
-        #     self.name = name[0].upper() + name[1:]  # class_name
-        #     try:
-        #         klass = self._getklass(self.name)
-        #     except Exception:
-        #         raise NotImplementedError("Unimplemented Operation %s" % self.name)
-        #     self.op = klass(op[1])
-        # else:
-        self.op = op
-        self.name = type(self.op).__name__  # also store name
-        self.opId = operations[self.to_method_name(self.name)]
-        # self.opId = self.operations()[self.name]
-
-    @staticmethod
-    def to_method_name(class_name: str):
-        """ Take a name of a class, like FeedPublish and turn it into method name like feed_publish. """
-        words = re.findall('[A-Z][^A-Z]*', class_name)
-        return '_'.join(map(str.lower, words))
-        # return 'transfer'
-
-    def operations(self):
-        return operations
-
-    def _getklass(self, name):
-        module = __import__("graphenebase.operations", fromlist=["operations"])
-        class_ = getattr(module, name)
-        return class_
-
-    def __bytes__(self):
-        return bytes(Id(self.opId)) + bytes(self.op)
-
-    def __str__(self):
-        return json.dumps([self.to_method_name(self.name), self.op.toJson()])
-
-
 class GrapheneObject(object):
     """ Core abstraction class
 
@@ -105,5 +60,57 @@ def json(self):
         return self.__json__()
 
 
+class Operation:
+    def __init__(self, op: GrapheneObject):
+        self.op = op
+        self.name = type(self.op).__name__  # also store name
+        self.opId = operations[to_method_name(self.name)].value
+
+    def operations(self):
+        return operations
+
+    def _getklass(self, name):
+        module = __import__("graphenebase.operations", fromlist=["operations"])
+        class_ = getattr(module, name)
+        return class_
+
+    def __bytes__(self):
+        return bytes(Id(self.opId)) + bytes(self.op)
+
+    def __str__(self):
+        return json.dumps([to_method_name(self.name), self.op.toJson()])
+
+
+class StaticVariantObject:
+    def __init__(self, obj_type, objects):
+        self.objects = objects
+        self.obj_type = obj_type
+        self.name = None
+        self.id = None
+
+    def get_id(self, name: str):
+        try:
+            return self.objects.index(name)
+        except ValueError:
+            raise Exception("no such %s %s" % (type(self).__name__, name))
+
+    @staticmethod
+    def get_name(obj_type):
+        """ Take a name of a class, like ClassName and turn it into method name like class_name."""
+        return to_method_name(type(obj_type).__name__)
+
+    def __bytes__(self):
+        return bytes(Id(self.id)) + bytes(self.obj_type)
+
+    def __str__(self):
+        return json.dumps([self.name, self.obj_type.toJson()])
+
+
 def isArgsThisClass(self, args):
     return (len(args) == 1 and type(args[0]).__name__ == type(self).__name__)
+
+
+def to_method_name(class_name: str):
+    """ Take a name of a class, like FeedPublish and turn it into method name like feed_publish. """
+    words = re.findall('[A-Z][^A-Z]*', class_name)
+    return '_'.join(map(str.lower, words))
diff --git a/scorum/graphenebase/operationids.py b/scorum/graphenebase/operationids.py
index 7d1fd5c..e30946c 100644
--- a/scorum/graphenebase/operationids.py
+++ b/scorum/graphenebase/operationids.py
@@ -1,82 +1,130 @@
-operations = {
-    'vote':                                       0,
-    'comment':                                    1,
-    'transfer':                                   2,
-    'transfer_to_scorumpower':                    3,
-    'withdraw_scorumpower':                       4,
-    'account_create_by_committee':                5,
-    'account_create':                             6,
-    'account_create_with_delegation':             7,
-    'account_update':                             8,
-    'witness_update':                             9,
-    'account_witness_vote':                       10,
-    'account_witness_proxy':                      11,
-    'delete_comment':                             12,
-    'comment_options':                            13,
-    'set_withdraw_scorumpower_route_to_account':  14,
-    'set_withdraw_scorumpower_route_to_dev_pool': 15,
-    'prove_authority':                            16,
-    'request_account_recovery':                   17,
-    'recover_account':                            18,
-    'change_recovery_account':                    19,
-    'escrow_approve':                             20,
-    'escrow_dispute':                             21,
-    'escrow_release':                             22,
-    'escrow_transfer':                            23,
-    'decline_voting_rights':                      24,
-    'delegate_scorumpower_shares':                25,
-    'create_budget':                              26,
-    'close_budget':                               27,
-    'proposal_vote':                              28,
-    'proposal_create':                            29,
-    'atomicswap_initiate':                        30,
-    'atomicswap_redeem':                          31,
-    'atomicswap_refund':                          32,
-    'close_budget_by_advertising_moderator':      33,
-    'update_budget':                              34,
+from enum import Enum
+
+
+class AutoNumber(Enum):
+    def __new__(cls):
+        value = len(cls.__members__) if len(cls.__members__) else 0
+        obj = object.__new__(cls)
+        obj._value_ = value
+        return obj
+
+
+class OperationsBase(AutoNumber):
+    def __str__(self):
+        return self.name
+
+    def __int__(self):
+        return self.value
+
+
+class Operations(OperationsBase):
+    vote = ()
+    comment = ()
+
+    transfer = ()
+    transfer_to_scorumpower = ()
+    withdraw_scorumpower = ()
+
+    account_create_by_committee = ()
+    account_create = ()
+    account_create_with_delegation = ()
+    account_update = ()
+
+    witness_update = ()
+    account_witness_vote = ()
+    account_witness_proxy = ()
+
+    delete_comment = ()
+    comment_options = ()
+    set_withdraw_scorumpower_route_to_account = ()
+    set_withdraw_scorumpower_route_to_dev_pool = ()
+
+    prove_authority = ()
+
+    request_account_recovery = ()
+    recover_account = ()
+    change_recovery_account = ()
+    escrow_approve = ()
+    escrow_dispute = ()
+    escrow_release = ()
+    escrow_transfer = ()
+
+    decline_voting_rights = ()
+    delegate_scorumpower_shares = ()
+
+    create_budget = ()
+    close_budget = ()
+
+    proposal_vote = ()
+    proposal_create = ()
+
+    atomicswap_initiate = ()
+    atomicswap_redeem = ()
+    atomicswap_refund = ()
+
+    close_budget_by_advertising_moderator = ()
+    update_budget = ()
 
     # betting
-    "create_game": 48,
-    "cancel_game": 49,
-    "update_game_markets": 50,
-    "update_game_start_time": 51,
-    "post_game_results": 52,
+    create_game = ()
+    cancel_game = ()
+    update_game_markets = ()
+    update_game_start_time = ()
+    post_game_results = ()
+
+    post_bet = ()
+    cancel_pending_bets = ()
+
+    delegate_sp_from_reg_pool = ()
 
     # virtual operations
-    'author_reward':                              35,
-    'comment_benefactor_reward':                  36,
-    'comment_payout_update':                      37,
-    'comment_reward':                             38,
-    'curation_reward':                            39,
-    'hardfork':                                   40,
-    'producer_reward':                            41,
-    'active_sp_holders_reward':                   42,
-    'return_scorumpower_delegation':              43,
-    'shutdown_witness':                           44,
-    'witness_miss_block':                         45,
-    'expired_contract_refund':                    46,
-    'acc_finished_vesting_withdraw':              47,
-    'devpool_finished_vesting_withdraw':          48,
-    'acc_to_acc_vesting_withdraw':                49,
-    'devpool_to_acc_vesting_withdraw':            50,
-    'acc_to_devpool_vesting_withdraw':            51,
-    'devpool_to_devpool_vesting_withdraw':        52,
-    'proposal_virtual_operation':                 53,
-    'budget_outgo_operation':                     54,
-    'budget_owner_income_operation':              55,
-    'active_sp_holders_reward_legacy_operation':  56,
-    'budget_closing_operation':                   57,
-
-    # proposal operations
-    'registration_committee_add_member':          0,
-    'registration_committee_exclude_member':      1,
-    'registration_committee_change_quorum':       2,
-    'development_committee_add_member':           3,
-    'development_committee_exclude_member':       4,
-    'development_committee_change_quorum':        5,
-    'development_committee_withdraw_vesting':     6,
-    'development_committee_transfer':             7,
-    'development_committee_empower_advertising_moderator': 8,
-    'development_committee_change_post_budgets_auction_properties': 9,
-    'development_committee_change_banner_budgets_auction_properties': 10
-}
+    author_reward = ()
+    comment_benefactor_reward = ()
+    comment_payout_update = ()
+    comment_reward = ()
+    curation_reward = ()
+    hardfork = ()
+    producer_reward = ()
+    active_sp_holders_reward = ()
+    return_scorumpower_delegation = ()
+    shutdown_witness = ()
+    witness_miss_block = ()
+    expired_contract_refund = ()
+    acc_finished_vesting_withdraw = ()
+    devpool_finished_vesting_withdraw = ()
+    acc_to_acc_vesting_withdraw = ()
+    devpool_to_acc_vesting_withdraw = ()
+    acc_to_devpool_vesting_withdraw = ()
+    devpool_to_devpool_vesting_withdraw = ()
+    proposal_virtual = ()
+
+    budget_outgo = ()
+    budget_owner_income = ()
+    active_sp_holders_reward_legacy = ()
+    budget_closing = ()
+
+    bets_matched = ()
+    game_status_changed = ()
+    bet_resolved = ()
+    bet_cancelled = ()
+    bet_restored = ()
+    bet_updated = ()
+
+
+class ProposalOperations(OperationsBase):
+    registration_committee_add_member = ()
+    registration_committee_exclude_member = ()
+    registration_committee_change_quorum = ()
+    development_committee_add_member = ()
+    development_committee_exclude_member = ()
+    development_committee_change_quorum = ()
+    development_committee_withdraw_vesting = ()
+    development_committee_transfer = ()
+    development_committee_empower_advertising_moderator = ()
+    development_committee_change_post_budgets_auction_properties = ()
+    development_committee_change_banner_budgets_auction_properties = ()
+    development_committee_empower_betting_moderator = ()
+    development_committee_change_betting_resolve_delay = ()
+
+
+operations = {k: v for Ops in [Operations, ProposalOperations] for k, v in Ops.__members__.items()}
diff --git a/scorum/graphenebase/operations.py b/scorum/graphenebase/operations.py
index b184ad8..665c77f 100644
--- a/scorum/graphenebase/operations.py
+++ b/scorum/graphenebase/operations.py
@@ -4,24 +4,22 @@
 
 try:
     from .account import PublicKey
-    from .betting import Game, Market
+    from .betting import Game, Market, Wincase
     from .chains import default_prefix
     from .graphene_types import (
         Int16, Uint16, Uint32, Int64, String, Array, PointInTime, Bool,
-        Set, Map, BudgetType, Uuid
+        Set, Map, BudgetType, Uuid, Odds32
     )
-    from .objects import GrapheneObject, isArgsThisClass
-    from .objects import Operation
+    from .objects import GrapheneObject, isArgsThisClass, Operation, Optional
 except (ImportError, SystemError):
     from account import PublicKey
-    from betting import Game, Market
+    from betting import Game, Market, Wincase
     from chains import default_prefix
     from graphene_types import (
         Int16, Uint16, Uint32, Int64, String, Array, PointInTime, Bool,
-        Set, Map, BudgetType, Uuid
+        Set, Map, BudgetType, Uuid, Odds32
     )
-    from objects import GrapheneObject, isArgsThisClass
-    from objects import Operation
+    from objects import GrapheneObject, isArgsThisClass, Operation, Optional
 
 asset_precision = {
     "SCR": 9,
@@ -229,6 +227,31 @@ def __init__(self, *args, **kwargs):
             ]))
 
 
+class AccountUpdate(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+            prefix = kwargs.pop("prefix", default_prefix)
+
+            meta = ""
+            if "json_metadata" in kwargs and kwargs["json_metadata"]:
+                if isinstance(kwargs["json_metadata"], dict):
+                    meta = json.dumps(kwargs["json_metadata"])
+                else:
+                    meta = kwargs["json_metadata"]
+            super().__init__(OrderedDict([
+                ('account', String(kwargs["account"])),
+                ('owner', Optional(Permission(kwargs["owner"], prefix=prefix))),
+                ('active', Optional(Permission(kwargs["active"], prefix=prefix))),
+                ('posting', Optional(Permission(kwargs["posting"], prefix=prefix))),
+                ('memo_key', PublicKey(kwargs["memo_key"], prefix=prefix)),
+                ('json_metadata', String(meta)),
+            ]))
+
+
 class AccountCreateByCommittee(GrapheneObject):
     def __init__(self, *args, **kwargs):
         if isArgsThisClass(self, args):
@@ -351,6 +374,19 @@ def __init__(self, *args, **kwargs):
                 ]))
 
 
+class DevelopmentCommitteeEmpowerBettingModerator(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+            super().__init__(
+                OrderedDict([
+                    ('account', String(kwargs['account']))
+                ]))
+
+
 class WitnessProps(GrapheneObject):
     def __init__(self, *args, **kwargs):
         if isArgsThisClass(self, args):
@@ -445,6 +481,21 @@ def __init__(self, *args, **kwargs):
                 ]))
 
 
+class DelegateSpFromRegPool(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+            super(DelegateSpFromRegPool, self).__init__(
+                OrderedDict([
+                    ('reg_committee_member', String(kwargs["reg_committee_member"])),
+                    ('delegatee', String(kwargs["delegatee"])),
+                    ('scorumpower', Amount(kwargs["scorumpower"]))
+                ]))
+
+
 class CreateGame(GrapheneObject):
     def __init__(self, *args, **kwargs):
         if isArgsThisClass(self, args):
@@ -457,14 +508,118 @@ def __init__(self, *args, **kwargs):
 
             super().__init__(
                 OrderedDict([
+                    ('uuid', Uuid(kwargs['uuid'])),
                     ('moderator', String(kwargs['moderator'])),
-                    ('name', String(kwargs["name"])),
-                    ('start', PointInTime(kwargs['start'])),
+                    ('json_metadata', String(kwargs["json_metadata"])),
+                    ('start_time', PointInTime(kwargs['start_time'])),
+                    ('auto_resolve_delay_sec', Uint32(kwargs['auto_resolve_delay_sec'])),
                     ('game', Game(kwargs['game'])),
                     ('markets', Array(markets))
                 ]))
 
 
+class CancelGame(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+
+            super().__init__(
+                OrderedDict([
+                    ('uuid', Uuid(kwargs['uuid'])),
+                    ('moderator', String(kwargs['moderator']))
+                ]))
+
+
+class UpdateGameMarkets(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+
+            markets = [Market(m) for m in kwargs['markets']]
+
+            super().__init__(
+                OrderedDict([
+                    ('uuid', Uuid(kwargs['uuid'])),
+                    ('moderator', String(kwargs['moderator'])),
+                    ('markets', Array(markets))
+                ]))
+
+
+class UpdateGameStartTime(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+
+            super().__init__(
+                OrderedDict([
+                    ('uuid', Uuid(kwargs['uuid'])),
+                    ('moderator', String(kwargs['moderator'])),
+                    ('start_time', PointInTime(kwargs['start_time']))
+                ]))
+
+
+class PostGameResults(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+
+            wincases = [Wincase(w) for w in kwargs['wincases']]
+
+            super().__init__(
+                OrderedDict([
+                    ('uuid', Uuid(kwargs['uuid'])),
+                    ('moderator', String(kwargs['moderator'])),
+                    ('wincases', Array(wincases))
+                ]))
+
+
+class PostBet(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+            numerator, denominator = kwargs['odds']
+            super().__init__(
+                OrderedDict([
+                    ('uuid', Uuid(kwargs['uuid'])),
+                    ('better', String(kwargs['better'])),
+                    ('game_uuid', Uuid(kwargs['game_uuid'])),
+                    ('wincase', Wincase(kwargs['wincase'])),
+                    ('odds', Odds32(numerator, denominator)),
+                    ('stake', Amount(kwargs['stake'])),
+                    ('live', Bool(kwargs['live']))
+                ]))
+
+
+class CancelPendingBets(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+            uuids = [Uuid(u) for u in kwargs['uuids']]
+            super().__init__(
+                OrderedDict([
+                    ('bet_uuids', Array(uuids)),
+                    ('better', String(kwargs['better']))
+                ]))
+
+
 class CloseBudgetByAdvertisingModerator(GrapheneObject):
     def __init__(self, *args, **kwargs):
         if isArgsThisClass(self, args):
@@ -478,3 +633,16 @@ def __init__(self, *args, **kwargs):
                     ('uuid', Uuid(kwargs["uuid"])),
                     ('moderator', String(kwargs["moderator"]))
                 ]))
+
+
+class DevelopmentCommitteeChangeBettingResolveDelay(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+            super().__init__(
+                OrderedDict([
+                    ('delay_sec', Uint32(kwargs['delay_sec']))
+                ]))
diff --git a/scorum/graphenebase/operations_fabric.py b/scorum/graphenebase/operations_fabric.py
index ce52788..f38922d 100644
--- a/scorum/graphenebase/operations_fabric.py
+++ b/scorum/graphenebase/operations_fabric.py
@@ -103,6 +103,43 @@ def account_create_operation(
     )
 
 
+def account_update_operation(
+    account: str,
+    owner: str,
+    active: str,
+    posting: str,
+    memo,
+    json_meta,
+):
+    owner_pubkey = owner if type(owner) is PublicKey else PublicKey(owner)
+    active_pubkey = active if type(active) is PublicKey else PublicKey(active)
+    posting_pubkey = posting if type(posting) is PublicKey else PublicKey(posting)
+    memo_pubkey = memo if type(memo) is PublicKey else PublicKey(memo)
+
+    owner_key_authority = [[str(owner_pubkey), 1]]
+    active_key_authority = [[str(active_pubkey), 1]]
+    posting_key_authority = [[str(posting_pubkey), 1]]
+    owner_accounts_authority = []
+    active_accounts_authority = []
+    posting_accounts_authority = []
+
+    return operations.AccountUpdate(
+        **{
+           'account': account,
+           'owner': {'account_auths': owner_accounts_authority,
+                     'key_auths': owner_key_authority,
+                     'weight_threshold': 1},
+           'active': {'account_auths': active_accounts_authority,
+                      'key_auths': active_key_authority,
+                      'weight_threshold': 1},
+           'posting': {'account_auths': posting_accounts_authority,
+                       'key_auths': posting_key_authority,
+                       'weight_threshold': 1},
+           'memo_key': str(memo_pubkey),
+           'json_metadata': json_meta}
+    )
+
+
 def account_create_by_committee_operation(
     creator: str,
     name: str,
@@ -246,16 +283,76 @@ def delegate_scorumpower(delegator, delegatee, scorumpower):
     )
 
 
-def create_game(moderator, name, game, start, markets):
-    return operations.CreateGame(
-        **{'moderator': moderator,
-           'name': name,
-           'game': game,
-           'start': start,
-           'markets': markets}
+def delegate_sp_from_reg_pool(reg_committee_member, delegatee, scorumpower):
+    return operations.DelegateSpFromRegPool(
+        **{'reg_committee_member': reg_committee_member,
+           'delegatee': delegatee,
+           'scorumpower': str(scorumpower)}
     )
 
 
+def create_game(uuid, moderator, json_metadata, start_time, auto_resolve_delay_sec, game, markets):
+    return operations.CreateGame(**{
+        'uuid': uuid,
+        'moderator': moderator,
+        'json_metadata': json_metadata,
+        'start_time': start_time,
+        'auto_resolve_delay_sec': auto_resolve_delay_sec,
+        'game': game,
+        'markets': markets
+    })
+
+
+def cancel_game(uuid, moderator):
+    return operations.CancelGame(**{
+        'uuid': uuid,
+        'moderator': moderator
+    })
+
+
+def update_game_markets(uuid, moderator, markets):
+    return operations.UpdateGameMarkets(**{
+        'uuid': uuid,
+        'moderator': moderator,
+        'markets': markets
+    })
+
+
+def update_game_start_time(uuid, moderator, start_time):
+    return operations.UpdateGameStartTime(**{
+        'uuid': uuid,
+        'moderator': moderator,
+        'start_time': start_time
+    })
+
+
+def post_game_results(uuid, moderator, wincases):
+    return operations.PostGameResults(**{
+        'uuid': uuid,
+        'moderator': moderator,
+        'wincases': wincases
+    })
+
+
+def post_bet(uuid, better, game_uuid, wincase, odds, stake, live):
+    return operations.PostBet(**{
+        'uuid': uuid,
+        'better': better,
+        'game_uuid': game_uuid,
+        'wincase': wincase,
+        'odds': odds,
+        'stake': stake,
+        'live': live
+    })
+
+
+def cancel_pending_bets(uuids, better):
+    return operations.CancelPendingBets(**{
+        'uuids': uuids,
+        'better': better
+    })
+
+
 def development_committee_empower_advertising_moderator(initiator, moderator, lifetime_sec):
     return operations.ProposalCreate(
         **{
@@ -288,3 +385,23 @@ def close_budget_by_advertising_moderator(uuid, moderator, type):
             "type": type
         }
     )
+
+
+def development_committee_empower_betting_moderator(initiator, moderator, lifetime_sec):
+    return operations.ProposalCreate(
+        **{
+            "creator": initiator,
+            "lifetime_sec": lifetime_sec,
+            "operation": operations.DevelopmentCommitteeEmpowerBettingModerator(**{"account": moderator})
+        }
+    )
+
+
+def development_committee_change_betting_resolve_delay(initiator, delay_sec, lifetime_sec):
+    return operations.ProposalCreate(
+        **{
+            "creator": initiator,
+            "lifetime_sec": lifetime_sec,
+            "operation": operations.DevelopmentCommitteeChangeBettingResolveDelay(**{"delay_sec": delay_sec})
+        }
+    )
diff --git a/setup.py b/setup.py
index 262e544..26be160 100644
--- a/setup.py
+++ b/setup.py
@@ -4,7 +4,7 @@
 
 setup(
     name='scorum',
-    version='0.0.1',
+    version='0.1.0',
     packages=find_packages(exclude=["tests"]),
     long_description=open('README.md').read(),
     install_requires=required
diff --git a/tests/graphenebase/test_betting.py b/tests/graphenebase/test_betting.py
index 2c5fcc4..ae74140 100644
--- a/tests/graphenebase/test_betting.py
+++ b/tests/graphenebase/test_betting.py
@@ -1,70 +1,209 @@
 import pytest
+import json
 
 from binascii import hexlify
 
-from scorum.graphenebase.betting import market, Game, Market
-from scorum.graphenebase.operations import CreateGame
+from scorum.graphenebase.betting import game, Game, market, Market, wincase, Wincase
+from scorum.graphenebase import operations_fabric as ops
+from scorum.graphenebase.signedtransactions import SignedTransaction
 
 
 def to_hex(data):
     return hexlify(bytes(data))
 
 
-def test_serialize_soccer_game_with_empty_markets():
-    op = CreateGame(
-        **{'moderator': "admin",
-           'name': "game name",
-           'start': "2018-08-03T10:12:43",
-           'game': Game.soccer,
-           'markets': []}
+@pytest.mark.parametrize('game_type,val', [
+    (game.Hockey(), b'01'),
+    (game.Soccer(), b'00')
+])
+def test_serialize_game_type_to_hex(game_type, val):
+    assert to_hex(Game(game_type)) == val
+
+
+@pytest.mark.parametrize('market_type, val', [
+    (market.ResultHome(), b'00'),
+    (market.ResultDraw(), b'01'),
+    (market.ResultAway(), b'02'),
+    (market.RoundHome(), b'03'),
+    (market.Handicap(), b'040000'),
+    (market.CorrectScoreHome(), b'05'),
+    (market.CorrectScoreDraw(), b'06'),
+    (market.CorrectScoreAway(), b'07'),
+    (market.CorrectScore(), b'0800000000'),
+    (market.CorrectScore(1, 2), b'0801000200'),
+    (market.GoalHome(), b'09'),
+    (market.GoalBoth(), b'0a'),
+    (market.GoalAway(), b'0b'),
+    (market.Total(), b'0c0000'),
+    (market.TotalGoalsHome(), b'0d0000'),
+    (market.TotalGoalsAway(), b'0e0000')
+])
+def test_serialize_markets_to_hex(market_type, val):
+    assert to_hex(Market(market_type)) == val
+
+
+@pytest.mark.parametrize('wincase_type, val', [
+    (wincase.ResultHomeYes(), b'00'),
+    (wincase.ResultHomeNo(), b'01'),
+    (wincase.ResultDrawYes(), b'02'),
+    (wincase.ResultDrawNo(), b'03'),
+    (wincase.ResultAwayYes(), b'04'),
+    (wincase.ResultAwayNo(), b'05'),
+    (wincase.RoundHomeYes(), b'06'),
+    (wincase.RoundHomeNo(), b'07'),
+    (wincase.HandicapOver(), b'080000'),
+    (wincase.HandicapUnder(), b'090000'),
+    (wincase.CorrectScoreHomeYes(), b'0a'),
+    (wincase.CorrectScoreHomeNo(), b'0b'),
+    (wincase.CorrectScoreDrawYes(), b'0c'),
+    (wincase.CorrectScoreDrawNo(), b'0d'),
+    (wincase.CorrectScoreAwayYes(), b'0e'),
+    (wincase.CorrectScoreAwayNo(), b'0f'),
+    (wincase.CorrectScoreYes(), b'1000000000'),
+    (wincase.CorrectScoreNo(), b'1100000000'),
+    (wincase.GoalHomeYes(), b'12'),
+    (wincase.GoalHomeNo(), b'13'),
+    (wincase.GoalBothYes(), b'14'),
+    (wincase.GoalBothNo(), b'15'),
+    (wincase.GoalAwayYes(), b'16'),
+    (wincase.GoalAwayNo(), b'17'),
+    (wincase.TotalOver(), b'180000'),
+    (wincase.TotalUnder(), b'190000'),
+    (wincase.TotalGoalsHomeOver(), b'1a0000'),
+    (wincase.TotalGoalsHomeUnder(), b'1b0000'),
+    (wincase.TotalGoalsAwayOver(), b'1c0000'),
+    (wincase.TotalGoalsAwayUnder(), b'1d0000')
+])
+def test_serialize_wincases_to_hex(wincase_type, val):
+    assert to_hex(Wincase(wincase_type)) == val
+
+
+@pytest.mark.parametrize('game_type,market_types,result_bin', [
+    (
+        game.Soccer(),
+        [],
+        b'23e629f9aa6b2c46aa8fa836770e7a7a5f0561646d696e027b7d9b2a645b210000000000'
+    ),
+    (
+        game.Soccer(),
+        [market.Total(1000)],
+        b'23e629f9aa6b2c46aa8fa836770e7a7a5f0561646d696e027b7d9b2a645b2100000000010ce803'
+    ),
+    (
+        game.Hockey(),
+        [],
+        b'23e629f9aa6b2c46aa8fa836770e7a7a5f0561646d696e027b7d9b2a645b210000000100'
+    ),
+    (
+        game.Hockey(),
+        [market.CorrectScore(home=1, away=2)],
+        b'23e629f9aa6b2c46aa8fa836770e7a7a5f0561646d696e027b7d9b2a645b2100000001010801000200'
+    )
+])
+def test_serialize_create_game_to_hex(game_type, market_types, result_bin):
+    op = ops.create_game(
+        'e629f9aa-6b2c-46aa-8fa8-36770e7a7a5f', "admin", "{}", "2018-08-03T10:12:43", 33,
+        game_type, market_types
     )
+    signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
+    assert to_hex(signed_ops.data[0]) == result_bin
 
-    assert to_hex(op) == b'0561646d696e0967616d65206e616d659b2a645b0000'
 
+def test_serialize_cancel_game_to_hex():
+    op = ops.cancel_game("e629f9aa-6b2c-46aa-8fa8-36770e7a7a5f", "admin")
+    signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
+    assert to_hex(signed_ops.data[0]) == b'24e629f9aa6b2c46aa8fa836770e7a7a5f0561646d696e'
 
-def test_serialize_soccer_game_with_total_1000():
-    op = CreateGame(
-        **{'moderator': "admin",
-           'name': "game name",
-           'start': "2018-08-03T10:12:43",
-           'game': Game.soccer,
-           'markets': [market.Total(1000)]}
-    )
 
-    assert to_hex(op) == b'0561646d696e0967616d65206e616d659b2a645b000108e803'
+def test_serialize_update_game_markets_to_hex():
+    op = ops.update_game_markets("e629f9aa-6b2c-46aa-8fa8-36770e7a7a5f", "admin", [market.Total(1000)])
+    signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
+    assert to_hex(signed_ops.data[0]) == b'25e629f9aa6b2c46aa8fa836770e7a7a5f0561646d696e010ce803'
 
 
-def test_serialize_hockey_game_with_empty_markets():
-    op = CreateGame(
-        **{'moderator': "admin",
-           'name': "game name",
-           'start': "2018-08-03T10:12:43",
-           'game': Game.hockey,
-           'markets': []}
-    )
+def test_serialize_update_game_start_time_to_hex():
+    op = ops.update_game_start_time("e629f9aa-6b2c-46aa-8fa8-36770e7a7a5f", "admin", "2018-08-03T10:12:43")
+    signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
+    assert to_hex(signed_ops.data[0]) == b'26e629f9aa6b2c46aa8fa836770e7a7a5f0561646d696e9b2a645b'
 
-    assert to_hex(op) == b'0561646d696e0967616d65206e616d659b2a645b0100'
 
+def test_serialize_development_committee_empower_betting_moderator_to_hex():
+    op = ops.development_committee_empower_betting_moderator("initdelegate", "alice", 86400)
+    signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
 
-@pytest.mark.parametrize('game,val', [
-    (Game.hockey, b'01'),
-    (Game.soccer, b'00')
+    result_bin = b'1d0c696e697464656c6567617465805101000b05616c696365'
+    assert hexlify(bytes(signed_ops.data[0])) == result_bin
+
+
+def test_serialize_development_committee_change_betting_resolve_delay_to_hex():
+    op = ops.development_committee_change_betting_resolve_delay("initdelegate", 10, 86400)
+    signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
+
+    result_bin = b'1d0c696e697464656c6567617465805101000c0a000000'
+    assert hexlify(bytes(signed_ops.data[0])) == result_bin
+
+
+@pytest.mark.parametrize('wincase_types,result_bin', [
+    ([wincase.ResultHomeYes()], b'27e629f9aa6b2c46aa8fa836770e7a7a5f0561646d696e0100'),
+    ([wincase.HandicapOver(1000)], b'27e629f9aa6b2c46aa8fa836770e7a7a5f0561646d696e0108e803'),
+    ([wincase.TotalOver()], b'27e629f9aa6b2c46aa8fa836770e7a7a5f0561646d696e01180000'),
+    ([wincase.CorrectScoreYes(home=1, away=2)], b'27e629f9aa6b2c46aa8fa836770e7a7a5f0561646d696e011001000200'),
 ])
-def test_serialize_game_type(game, val):
-    assert to_hex(game) == val
+def test_serialize_post_game_results_to_hex(wincase_types, result_bin):
+    op = ops.post_game_results("e629f9aa-6b2c-46aa-8fa8-36770e7a7a5f", "admin", wincase_types)
+    signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
+    assert hexlify(bytes(signed_ops.data[0])) == result_bin
+
+
+@pytest.mark.parametrize('wincase_type,odds,result_bin', [
+    (
+        wincase.CorrectScoreYes(17, 23),
+        [1, 2],
+        b'28e629f9aa6b2c46aa8fa836770e7a7a5f0561646d696ee629f9aa6b2c46aa8fa836770e7a7a5f1011001700010000000200000000e40'
+        b'b5402000000095343520000000001'
+    ),
+    (
+        wincase.HandicapOver(-500),
+        [3, 2],
+        b'28e629f9aa6b2c46aa8fa836770e7a7a5f0561646d696ee629f9aa6b2c46aa8fa836770e7a7a5f080cfe030000000200000000e40'
+        b'b5402000000095343520000000001'
+    ),
+    (
+        wincase.RoundHomeNo(),
+        [4, 7],
+        b'28e629f9aa6b2c46aa8fa836770e7a7a5f0561646d696ee629f9aa6b2c46aa8fa836770e7a7a5f07040000000700000000e40'
+        b'b5402000000095343520000000001'
+    )
+])
+def test_serialize_post_bet_to_hex(wincase_type, odds, result_bin):
+    uuid = "e629f9aa-6b2c-46aa-8fa8-36770e7a7a5f"
+    op = ops.post_bet(uuid, "admin", uuid, wincase_type, odds, "10.000000000 SCR", True)
+    signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
+    assert hexlify(bytes(signed_ops.data[0])) == result_bin
+
+
+def test_serialize_cancel_pending_bets_to_hex():
+    uuid = "e629f9aa-6b2c-46aa-8fa8-36770e7a7a5f"
+    result_bin = b'2901e629f9aa6b2c46aa8fa836770e7a7a5f0561646d696e'
+    op = ops.cancel_pending_bets([uuid], "admin")
+    signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
+    assert hexlify(bytes(signed_ops.data[0])) == result_bin
+
+
+@pytest.mark.parametrize('wc', [
+    wincase.HandicapOver(-1000),
+    wincase.CorrectScoreNo(3, 4),
+    wincase.ResultDrawYes(),
+    wincase.TotalGoalsAwayOver(500)
+])
+def test_get_wincase_obj_from_json(wc):
+    assert Wincase(wc) == wincase.create_obj_from_json(json.loads(str(Wincase(wc))))
 
 
-@pytest.mark.parametrize('market_type, val', [
-    (market.ResultHome, b'00'),
-    (market.ResultDraw, b'01'),
-    (market.ResultAway, b'02'),
-    (market.Round, b'03'),
-    (market.Handicap, b'040000'),
-    (market.CorrectScore, b'05'),
-    (market.CorrectScoreParametrized, b'0600000000'),
-    (market.Goal, b'07'),
-    (market.Total, b'080000'),
-    (market.TotalGoals, b'090000')
+@pytest.mark.parametrize('name, expected', [
+    ("result_home::yes", "result_home::no"),
+    ("total_goals_away::under", "total_goals_away::over"),
+    ("correct_score_draw::no", "correct_score_draw::yes")
 ])
-def test_serialize_markets(market_type, val):
-    assert to_hex(Market(market_type())) == val
+def test_get_wincase_opposite(name, expected):
+    assert expected == wincase.opposite(name)
diff --git a/tests/graphenebase/test_operations.py b/tests/graphenebase/test_operations.py
new file mode 100644
index 0000000..169097e
--- /dev/null
+++ b/tests/graphenebase/test_operations.py
@@ -0,0 +1,28 @@
+import pytest
+
+from scorum.graphenebase.operationids import Operations, ProposalOperations, operations
+
+
+@pytest.mark.parametrize('name, op', [
+    ('transfer', Operations.transfer),
+    ('hardfork', Operations.hardfork),
+    ('bets_matched', Operations.bets_matched),
+    ('registration_committee_add_member', ProposalOperations.registration_committee_add_member)
+])
+def test_string_to_operation(name, op):
+    assert operations[name] == op
+
+
+@pytest.mark.parametrize('name, value', [
+    ('transfer', 2),
+    ('bets_matched', 65),
+    ('registration_committee_add_member', 0)
+])
+def test_serialize(name, value):
+    x = operations[name]
+
+    assert x.value == value
+    assert x.name == name
+
+    assert int(x) == value
+    assert str(x) == name
diff --git a/tests/graphenebase/test_serialization.py b/tests/graphenebase/test_serialization.py
index e3c9d05..73f5d9a 100644
--- a/tests/graphenebase/test_serialization.py
+++ b/tests/graphenebase/test_serialization.py
@@ -5,11 +5,7 @@
 from scorum.graphenebase.graphene_types import BudgetType
 from scorum.graphenebase.amount import Amount
 from scorum.graphenebase.signedtransactions import SignedTransaction
-from scorum.graphenebase.operations_fabric import (
-    devpool_withdraw_vesting, create_budget_operation, development_committee_empower_advertising_moderator,
-    close_budget_by_advertising_moderator, development_committee_change_budgets_auction_properties,
-    update_budget_operation, close_budget_operation
-)
+from scorum.graphenebase import operations_fabric as ops
 
 
 def test_serialize_banner_to_string():
@@ -42,7 +38,7 @@ def test_serialize_post_to_byte():
     ]
 )
 def test_serialize_create_budget_to_byte(budget_type, result_bin):
-    op = create_budget_operation(
+    op = ops.create_budget_operation(
         "6DCD3132-E5DF-480A-89A8-91984BCA0A09", "initdelegate", "{}", Amount("10.000000000 SCR"),
         "2018-08-03T10:12:43", "2018-08-03T10:13:13", budget_type
     )
@@ -51,7 +47,7 @@ def test_serialize_create_budget_to_byte(budget_type, result_bin):
 
 
 def test_serialize_devpool_withdraw_vesting_proposal_create_to_byte():
-    op = devpool_withdraw_vesting("initdelegate", Amount("10.000000000 SP"), 86400)
+    op = ops.devpool_withdraw_vesting("initdelegate", Amount("10.000000000 SP"), 86400)
     signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
 
     result_bin = b'1d0c696e697464656c6567617465805101000600e40b54020000000953500000000000'
@@ -59,7 +55,7 @@ def test_serialize_devpool_withdraw_vesting_proposal_create_to_byte():
 
 
 def test_serialize_development_committee_empower_advertising_moderator_to_byte():
-    op = development_committee_empower_advertising_moderator("initdelegate", "alice", 86400)
+    op = ops.development_committee_empower_advertising_moderator("initdelegate", "alice", 86400)
     signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
 
     result_bin = b'1d0c696e697464656c6567617465805101000805616c696365'
@@ -74,7 +70,7 @@ def test_serialize_development_committee_empower_advertising_moderator_to_byte()
     ]
 )
 def test_serialize_close_budget_by_advertising_moderator_to_byte(budget_type, result_bin):
-    op = close_budget_by_advertising_moderator("6DCD3132-E5DF-480A-89A8-91984BCA0A09", "initdelegate", budget_type)
+    op = ops.close_budget_by_advertising_moderator("6DCD3132-E5DF-480A-89A8-91984BCA0A09", "initdelegate", budget_type)
     signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
     assert hexlify(bytes(signed_ops.data[0])) == result_bin
 
@@ -87,7 +83,7 @@ def test_serialize_close_budget_by_advertising_moderator_to_byte(budget_type, re
     ]
 )
 def test_serialize_development_committee_change_budgets_auction_properties_to_byte(budget_type, result_bin):
-    op = development_committee_change_budgets_auction_properties("initdelegate", 86400, [90, 50], budget_type)
+    op = ops.development_committee_change_budgets_auction_properties("initdelegate", 86400, [90, 50], budget_type)
     signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
     assert hexlify(bytes(signed_ops.data[0])) == result_bin
 
@@ -102,7 +98,7 @@ def test_serialize_development_committee_change_budgets_auction_properties_to_by
     ]
 )
 def test_serialize_update_budget_to_byte(budget_type, result_bin):
-    op = update_budget_operation(
+    op = ops.update_budget_operation(
         "6DCD3132-E5DF-480A-89A8-91984BCA0A09", "initdelegate", "{\"meta\": \"some_meta\"}", budget_type
     )
     signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
@@ -117,6 +113,25 @@ def test_serialize_update_budget_to_byte(budget_type, result_bin):
     ]
 )
 def test_serialize_close_budget_to_byte(budget_type, result_bin):
-    op = close_budget_operation("6DCD3132-E5DF-480A-89A8-91984BCA0A09", "initdelegate", budget_type)
+    op = ops.close_budget_operation("6DCD3132-E5DF-480A-89A8-91984BCA0A09", "initdelegate", budget_type)
+    signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
+    assert hexlify(bytes(signed_ops.data[0])) == result_bin
+
+
+def test_serialize_delegate_sp_from_reg_pool():
+    op = ops.delegate_sp_from_reg_pool("initdelegate", "alice", Amount("10.000000000 SP"))
+    signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
+
+    result_bin = b'2a0c696e697464656c656761746505616c69636500e40b54020000000953500000000000'
+    assert hexlify(bytes(signed_ops.data[0])) == result_bin
+
+
+@pytest.mark.skip("Expected 'result_bin' is incorrect")
+def test_serialize_account_update_to_hex():
+    key = "5HwcXSqU8iU7xobfXv3z872HHjCsx8fMfyScq7tcEB2dMaaWMct"
+    op = ops.account_update_operation("alice", key, key, key, key, "{}")
     signed_ops = SignedTransaction.cast_operations_to_array_of_opklass([op])
+
+    result_bin = b'2a0c696e697464656c656761746505616c69636500e40b54020000000953500000000000'
     assert hexlify(bytes(signed_ops.data[0])) == result_bin
+