diff --git a/qa/rpc-tests/cryptoconditions.py b/qa/rpc-tests/cryptoconditions.py
index cb83b7243..1d2f68777 100755
--- a/qa/rpc-tests/cryptoconditions.py
+++ b/qa/rpc-tests/cryptoconditions.py
@@ -3,6 +3,7 @@
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.authproxy import JSONRPCException
 from test_framework.util import assert_equal, assert_greater_than, \
@@ -11,6 +12,8 @@ from test_framework.util import assert_equal, assert_greater_than, \
 
 import time
 from decimal import Decimal
+from random import choice
+from string import ascii_uppercase
 
 def assert_success(result):
     assert_equal(result['result'], 'success')
@@ -18,6 +21,11 @@ def assert_success(result):
 def assert_error(result):
     assert_equal(result['result'], 'error')
 
+def generate_random_string(length):
+    random_string = ''.join(choice(ascii_uppercase) for i in range(length))
+    return random_string
+
+
 class CryptoConditionsTest (BitcoinTestFramework):
 
     def setup_chain(self):
@@ -470,7 +478,6 @@ class CryptoConditionsTest (BitcoinTestFramework):
         result = rpc.tokenbalance(tokenid,randompubkey)
         assert_equal(result["balance"], 1)
 
-
     def run_rewards_tests(self):
         rpc     = self.nodes[0]
         result = rpc.rewardsaddress()
@@ -581,6 +588,51 @@ class CryptoConditionsTest (BitcoinTestFramework):
         result = rpc.rewardsunlock("STUFF", fundingtxid, locktxid)
         assert_error(result)
 
+    def run_oracles_tests(self):
+        rpc = self.nodes[0]
+        result = rpc.oraclesaddress()
+        assert_success(result)
+        for x in ['OraclesCCaddress', 'Oraclesmarker', 'myCCaddress', 'myaddress']:
+            assert_equal(result[x][0], 'R')
+
+        result = rpc.oraclesaddress(self.pubkey)
+        assert_success(result)
+        for x in ['OraclesCCaddress', 'Oraclesmarker', 'myCCaddress', 'myaddress']:
+            assert_equal(result[x][0], 'R')
+
+        # there are no oracles created yet
+        result = rpc.oracleslist()
+        assert_equal(result, [])
+
+        # looking up non-existent oracle should return error.
+        result = rpc.oraclesinfo("none")
+        assert_error(result)
+
+        # attempt to create oracle with not valid data type should return error
+        result = rpc.oraclescreate("Test", "Test", "Test")
+        assert_error(result)
+
+        # attempt to create oracle with description > 32 symbols should return error
+        too_long_name = generate_random_string(33)
+        result = rpc.oraclescreate(too_long_name, "Test", "s")
+
+
+        # attempt to create oracle with description > 4096 symbols should return error
+        too_long_description = generate_random_string(4100)
+        result = rpc.oraclescreate("Test", too_long_description, "s")
+        assert_error(result)
+
+        # valid creating oracles of different types
+        # using such naming to re-use it for data publishing / reading (e.g. oracle_s for s type)
+        valid_formats = ["s", "S", "d", "D", "c", "C", "t", "T", "i", "I", "l", "L", "h", "Ihh"]
+        for f in valid_formats:
+            result = rpc.oraclescreate("Test", "Test", f)
+            assert_success(result)
+            globals()["oracle_{}".format(f)] = self.send_and_mine(result['hex'])
+
+
+
+
 
     def run_test (self):
         print("Mining blocks...")
@@ -594,11 +646,12 @@ class CryptoConditionsTest (BitcoinTestFramework):
         print("Importing privkey")
         rpc.importprivkey(self.privkey)
 
-#       self.run_faucet_tests()
+        #self.run_faucet_tests()
         self.run_rewards_tests()
         self.run_dice_tests()
         self.run_token_tests()
         self.run_faucet_tests()
+        self.run_oracles_tests()
 
 
 if __name__ == '__main__':
diff --git a/src/cc/oracles.cpp b/src/cc/oracles.cpp
index 6db1d0b6c..7cccad0f6 100644
--- a/src/cc/oracles.cpp
+++ b/src/cc/oracles.cpp
@@ -859,6 +859,13 @@ UniValue OracleInfo(uint256 origtxid)
     CMutableTransaction mtx; CTransaction regtx,tx; std::string name,description,format; uint256 hashBlock,txid,oracletxid,batontxid; CPubKey pk; struct CCcontract_info *cp,C; int64_t datafee,funding; char str[67],markeraddr[64],numstr[64],batonaddr[64]; std::vector <uint8_t> data;
     cp = CCinit(&C,EVAL_ORACLES);
     CCtxidaddr(markeraddr,origtxid);
+    if ( GetTransaction(origtxid,tx,hashBlock,false) == 0 )
+    {
+        fprintf(stderr,"cant find oracleid\n");
+        result.push_back(Pair("result","error"));
+        result.push_back(Pair("error","cant find oracleid"));
+        return(result);
+    }
     if ( GetTransaction(origtxid,tx,hashBlock,false) != 0 )
     {
         if ( tx.vout.size() > 0 && DecodeOraclesCreateOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,name,description,format) == 'C' )
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index e7c8e2bdd..c7d4f8a16 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -5733,6 +5733,24 @@ UniValue oraclescreate(const UniValue& params, bool fHelp)
         ERR_RESULT("oracles format must be <= 4096 characters");
         return(result);
     }
+    // list of oracle valid formats from oracles.cpp -> oracle_format
+    const UniValue valid_formats[13] = {"s","S","d","D","c","C","t","T","i","I","l","L","h"};
+    const UniValue header_type = "Ihh";
+    // checking if oracle data type is valid
+    bool is_valid_format = false;
+    for ( int i = 0; i < 13; ++i ) {
+        if ( valid_formats[i].get_str() == format ) {
+            is_valid_format = true;
+        }
+    }
+    // additional check for special Ihh data type
+    if ( format == header_type.get_str() ) {
+        is_valid_format = true;
+    }
+    if ( !is_valid_format ) {
+        ERR_RESULT("oracles format not valid");
+        return(result);
+    }
     hex = OracleCreate(0,name,description,format);
     if ( hex.size() > 0 )
     {