diff --git a/README.md b/README.md
index 1bf1dd1..c6c9255 100644
--- a/README.md
+++ b/README.md
@@ -30,25 +30,26 @@ The goal of this project is to implement a distributed and decentralized system
    - Validators can request the connection information of miners from the subtensor network. This information is validated and
      decrypted locally using the validator's private key.
 
-## Communication Flow
+## Basic Communication Flow
 
 <!--
 @startuml ./assets/diagrams/CommunicationFlow
 participant Validator
 participant Miner
-participant GitHub
-participant Storage
-participant Bittensor
+participant AddressManager
+database Storage
+database Bittensor
 Validator -> Validator: Generate Validator key-pair
-Validator -> GitHub: Publish public key along with HotKey
-GitHub -> Miner: Fetch Validator info
-Miner -> Miner: Encrypt Miner IP/Domain with Validator public key
-Miner -> Storage: Add/update file with encrypted IPs/Domains for Validators
+Validator -> Bittensor: Publish public key along with HotKey
+Bittensor -> Miner: Fetch new Validator info
+Miner -> AddressManager: Generate new address
+Miner -> Miner: Encrypt generated address with Validator public key
+Miner -> Storage: Update file with encrypted addresses for Validators
 Miner -> Bittensor: Publish file location
 Bittensor -> Validator: Fetch file location
 Storage -> Validator: Fetch Miner file
 Validator -> Validator: Decrypt Miner file entry encrypted for given Validator
-Validator -> Miner: Send request using decrypted Miner IP/Domain
+Validator -> Miner: Send request using decrypted Miner address
 @enduml
 -->
 
diff --git a/assets/diagrams/CommunicationFlow.svg b/assets/diagrams/CommunicationFlow.svg
index 29814ea..b4b6b5e 100644
--- a/assets/diagrams/CommunicationFlow.svg
+++ b/assets/diagrams/CommunicationFlow.svg
@@ -1,20 +1,21 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?><svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" contentScriptType="application/ecmascript" contentStyleType="text/css" height="460px" preserveAspectRatio="none" style="width:900px;height:460px;" version="1.1" viewBox="0 0 900 460" width="900px" zoomAndPan="magnify"><defs><filter height="300%" id="f1uzc6cxg0955d" width="300%" x="-1" y="-1"><feGaussianBlur result="blurOut" stdDeviation="2.0"/><feColorMatrix in="blurOut" result="blurOut2" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0"/><feOffset dx="4.0" dy="4.0" in="blurOut2" result="blurOut3"/><feBlend in="SourceGraphic" in2="blurOut3" mode="normal"/></filter></defs><g><line style="stroke: #A80036; stroke-width: 1.0; stroke-dasharray: 5.0,5.0;" x1="47" x2="47" y1="41.0679" y2="417.1281"/><line style="stroke: #A80036; stroke-width: 1.0; stroke-dasharray: 5.0,5.0;" x1="378" x2="378" y1="41.0679" y2="417.1281"/><line style="stroke: #A80036; stroke-width: 1.0; stroke-dasharray: 5.0,5.0;" x1="691.5" x2="691.5" y1="41.0679" y2="417.1281"/><line style="stroke: #A80036; stroke-width: 1.0; stroke-dasharray: 5.0,5.0;" x1="769.5" x2="769.5" y1="41.0679" y2="417.1281"/><line style="stroke: #A80036; stroke-width: 1.0; stroke-dasharray: 5.0,5.0;" x1="853.5" x2="853.5" y1="41.0679" y2="417.1281"/><rect fill="#FEFECE" filter="url(#f1uzc6cxg0955d)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="74" x="8" y="3"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="60" x="15" y="24.9659">Validator</text><rect fill="#FEFECE" filter="url(#f1uzc6cxg0955d)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="74" x="8" y="416.1281"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="60" x="15" y="438.094">Validator</text><rect fill="#FEFECE" filter="url(#f1uzc6cxg0955d)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="54" x="349" y="3"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="40" x="356" y="24.9659">Miner</text><rect fill="#FEFECE" filter="url(#f1uzc6cxg0955d)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="54" x="349" y="416.1281"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="40" x="356" y="438.094">Miner</text><rect fill="#FEFECE" filter="url(#f1uzc6cxg0955d)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="61" x="659.5" y="3"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="47" x="666.5" y="24.9659">GitHub</text><rect fill="#FEFECE" filter="url(#f1uzc6cxg0955d)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="61" x="659.5" y="416.1281"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="47" x="666.5" y="438.094">GitHub</text><rect fill="#FEFECE" filter="url(#f1uzc6cxg0955d)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="66" x="734.5" y="3"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="52" x="741.5" y="24.9659">Storage</text><rect fill="#FEFECE" filter="url(#f1uzc6cxg0955d)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="66" x="734.5" y="416.1281"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="52" x="741.5" y="438.094">Storage</text><rect fill="#FEFECE" filter="url(#f1uzc6cxg0955d)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="75" x="814.5" y="3"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="61" x="821.5" y="24.9659">Bittensor</text><rect fill="#FEFECE" filter="url(#f1uzc6cxg0955d)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="75" x="814.5" y="416.1281"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="61" x="821.5" y="438.094">Bittensor</text><line style="stroke: #A80036; stroke-width: 1.0;" x1="47" x2="89" y1="74.7739" y2="74.7739"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="89" x2="89" y1="74.7739" y2="87.7739"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="48" x2="89" y1="87.7739" y2="87.7739"/><polygon fill="#A80036" points="58,83.7739,48,87.7739,58,91.7739,54,87.7739" style="stroke: #A80036; stroke-width: 1.0;"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="163" x="54" y="68.9649">Generate Validator key-pair</text><polygon fill="#A80036" points="680,115.4799,690,119.4799,680,123.4799,684,119.4799" style="stroke: #A80036; stroke-width: 1.0;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="47" x2="686" y1="119.4799" y2="119.4799"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="221" x="54" y="113.6709">Publish public key along with HotKey</text><polygon fill="#A80036" points="389,147.186,379,151.186,389,155.186,385,151.186" style="stroke: #A80036; stroke-width: 1.0;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="383" x2="691" y1="151.186" y2="151.186"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="116" x="395" y="145.377">Fetch Validator info</text><line style="stroke: #A80036; stroke-width: 1.0;" x1="378" x2="420" y1="182.892" y2="182.892"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="420" x2="420" y1="182.892" y2="195.892"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="379" x2="420" y1="195.892" y2="195.892"/><polygon fill="#A80036" points="389,191.892,379,195.892,389,199.892,385,195.892" style="stroke: #A80036; stroke-width: 1.0;"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="300" x="385" y="177.083">Encrypt Miner IP/Domain with Validator public key</text><polygon fill="#A80036" points="757.5,223.598,767.5,227.598,757.5,231.598,761.5,227.598" style="stroke: #A80036; stroke-width: 1.0;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="378" x2="763.5" y1="227.598" y2="227.598"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="347" x="385" y="221.789">Add/update file with encrypted IPs/Domains for Validators</text><polygon fill="#A80036" points="842,255.304,852,259.304,842,263.304,846,259.304" style="stroke: #A80036; stroke-width: 1.0;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="378" x2="848" y1="259.304" y2="259.304"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="115" x="385" y="253.495">Publish file location</text><polygon fill="#A80036" points="58,287.01,48,291.01,58,295.01,54,291.01" style="stroke: #A80036; stroke-width: 1.0;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="52" x2="853" y1="291.01" y2="291.01"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="104" x="64" y="285.201">Fetch file location</text><polygon fill="#A80036" points="58,318.716,48,322.716,58,326.716,54,322.716" style="stroke: #A80036; stroke-width: 1.0;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="52" x2="768.5" y1="322.716" y2="322.716"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="91" x="64" y="316.907">Fetch Miner file</text><line style="stroke: #A80036; stroke-width: 1.0;" x1="47" x2="89" y1="354.4221" y2="354.4221"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="89" x2="89" y1="354.4221" y2="367.4221"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="48" x2="89" y1="367.4221" y2="367.4221"/><polygon fill="#A80036" points="58,363.4221,48,367.4221,58,371.4221,54,367.4221" style="stroke: #A80036; stroke-width: 1.0;"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="317" x="54" y="348.6131">Decrypt Miner file entry encrypted for given Validator</text><polygon fill="#A80036" points="366,395.1281,376,399.1281,366,403.1281,370,399.1281" style="stroke: #A80036; stroke-width: 1.0;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="47" x2="372" y1="399.1281" y2="399.1281"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="284" x="54" y="393.3191">Send request using decrypted Miner IP/Domain</text><!--MD5=[ff12af85b5c8827b947f8130cb369bd1]
+<?xml version="1.0" encoding="UTF-8" standalone="no"?><svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" contentScriptType="application/ecmascript" contentStyleType="text/css" height="551px" preserveAspectRatio="none" style="width:920px;height:551px;" version="1.1" viewBox="0 0 920 551" width="920px" zoomAndPan="magnify"><defs><filter height="300%" id="fnbmyub97f9g4" width="300%" x="-1" y="-1"><feGaussianBlur result="blurOut" stdDeviation="2.0"/><feColorMatrix in="blurOut" result="blurOut2" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0"/><feOffset dx="4.0" dy="4.0" in="blurOut2" result="blurOut3"/><feBlend in="SourceGraphic" in2="blurOut3" mode="normal"/></filter></defs><g><line style="stroke: #A80036; stroke-width: 1.0; stroke-dasharray: 5.0,5.0;" x1="47" x2="47" y1="68.0679" y2="475.8341"/><line style="stroke: #A80036; stroke-width: 1.0; stroke-dasharray: 5.0,5.0;" x1="378" x2="378" y1="68.0679" y2="475.8341"/><line style="stroke: #A80036; stroke-width: 1.0; stroke-dasharray: 5.0,5.0;" x1="702" x2="702" y1="68.0679" y2="475.8341"/><line style="stroke: #A80036; stroke-width: 1.0; stroke-dasharray: 5.0,5.0;" x1="808" x2="808" y1="68.0679" y2="475.8341"/><line style="stroke: #A80036; stroke-width: 1.0; stroke-dasharray: 5.0,5.0;" x1="880" x2="880" y1="68.0679" y2="475.8341"/><rect fill="#FEFECE" filter="url(#fnbmyub97f9g4)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="74" x="8" y="30"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="60" x="15" y="51.9659">Validator</text><rect fill="#FEFECE" filter="url(#fnbmyub97f9g4)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="74" x="8" y="474.8341"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="60" x="15" y="496.8">Validator</text><rect fill="#FEFECE" filter="url(#fnbmyub97f9g4)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="54" x="349" y="30"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="40" x="356" y="51.9659">Miner</text><rect fill="#FEFECE" filter="url(#fnbmyub97f9g4)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="54" x="349" y="474.8341"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="40" x="356" y="496.8">Miner</text><rect fill="#FEFECE" filter="url(#fnbmyub97f9g4)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="130" x="635" y="30"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="116" x="642" y="51.9659">AddressManager</text><rect fill="#FEFECE" filter="url(#fnbmyub97f9g4)" height="33.0679" style="stroke: #A80036; stroke-width: 1.5;" width="130" x="635" y="474.8341"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="116" x="642" y="496.8">AddressManager</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="52" x="779" y="63.9659">Storage</text><path d="M790,13 C790,3 808,3 808,3 C808,3 826,3 826,13 L826,39 C826,49 808,49 808,49 C808,49 790,49 790,39 L790,13 " fill="#FEFECE" filter="url(#fnbmyub97f9g4)" style="stroke: #000000; stroke-width: 1.5;"/><path d="M790,13 C790,23 808,23 808,23 C808,23 826,23 826,13 " fill="none" style="stroke: #000000; stroke-width: 1.5;"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="52" x="779" y="489.8">Storage</text><path d="M790,503.902 C790,493.902 808,493.902 808,493.902 C808,493.902 826,493.902 826,503.902 L826,529.902 C826,539.902 808,539.902 808,539.902 C808,539.902 790,539.902 790,529.902 L790,503.902 " fill="#FEFECE" filter="url(#fnbmyub97f9g4)" style="stroke: #000000; stroke-width: 1.5;"/><path d="M790,503.902 C790,513.902 808,513.902 808,513.902 C808,513.902 826,513.902 826,503.902 " fill="none" style="stroke: #000000; stroke-width: 1.5;"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="61" x="847" y="63.9659">Bittensor</text><path d="M862.5,13 C862.5,3 880.5,3 880.5,3 C880.5,3 898.5,3 898.5,13 L898.5,39 C898.5,49 880.5,49 880.5,49 C880.5,49 862.5,49 862.5,39 L862.5,13 " fill="#FEFECE" filter="url(#fnbmyub97f9g4)" style="stroke: #000000; stroke-width: 1.5;"/><path d="M862.5,13 C862.5,23 880.5,23 880.5,23 C880.5,23 898.5,23 898.5,13 " fill="none" style="stroke: #000000; stroke-width: 1.5;"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacingAndGlyphs" textLength="61" x="847" y="489.8">Bittensor</text><path d="M862.5,503.902 C862.5,493.902 880.5,493.902 880.5,493.902 C880.5,493.902 898.5,493.902 898.5,503.902 L898.5,529.902 C898.5,539.902 880.5,539.902 880.5,539.902 C880.5,539.902 862.5,539.902 862.5,529.902 L862.5,503.902 " fill="#FEFECE" filter="url(#fnbmyub97f9g4)" style="stroke: #000000; stroke-width: 1.5;"/><path d="M862.5,503.902 C862.5,513.902 880.5,513.902 880.5,513.902 C880.5,513.902 898.5,513.902 898.5,503.902 " fill="none" style="stroke: #000000; stroke-width: 1.5;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="47" x2="89" y1="101.7739" y2="101.7739"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="89" x2="89" y1="101.7739" y2="114.7739"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="48" x2="89" y1="114.7739" y2="114.7739"/><polygon fill="#A80036" points="58,110.7739,48,114.7739,58,118.7739,54,114.7739" style="stroke: #A80036; stroke-width: 1.0;"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="163" x="54" y="95.9649">Generate Validator key-pair</text><polygon fill="#A80036" points="868.5,142.4799,878.5,146.4799,868.5,150.4799,872.5,146.4799" style="stroke: #A80036; stroke-width: 1.0;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="47" x2="874.5" y1="146.4799" y2="146.4799"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="221" x="54" y="140.6709">Publish public key along with HotKey</text><polygon fill="#A80036" points="389,174.186,379,178.186,389,182.186,385,178.186" style="stroke: #A80036; stroke-width: 1.0;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="383" x2="879.5" y1="178.186" y2="178.186"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="144" x="395" y="172.377">Fetch new Validator info</text><polygon fill="#A80036" points="690,205.892,700,209.892,690,213.892,694,209.892" style="stroke: #A80036; stroke-width: 1.0;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="378" x2="696" y1="209.892" y2="209.892"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="133" x="385" y="204.083">Generate new address</text><line style="stroke: #A80036; stroke-width: 1.0;" x1="378" x2="420" y1="241.598" y2="241.598"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="420" x2="420" y1="241.598" y2="254.598"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="379" x2="420" y1="254.598" y2="254.598"/><polygon fill="#A80036" points="389,250.598,379,254.598,389,258.598,385,254.598" style="stroke: #A80036; stroke-width: 1.0;"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="310" x="385" y="235.789">Encrypt generated address with Validator public key</text><polygon fill="#A80036" points="796,282.304,806,286.304,796,290.304,800,286.304" style="stroke: #A80036; stroke-width: 1.0;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="378" x2="802" y1="286.304" y2="286.304"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="304" x="385" y="280.495">Update file with encrypted addresses for Validators</text><polygon fill="#A80036" points="868.5,314.01,878.5,318.01,868.5,322.01,872.5,318.01" style="stroke: #A80036; stroke-width: 1.0;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="378" x2="874.5" y1="318.01" y2="318.01"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="115" x="385" y="312.201">Publish file location</text><polygon fill="#A80036" points="58,345.716,48,349.716,58,353.716,54,349.716" style="stroke: #A80036; stroke-width: 1.0;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="52" x2="879.5" y1="349.716" y2="349.716"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="104" x="64" y="343.907">Fetch file location</text><polygon fill="#A80036" points="58,377.4221,48,381.4221,58,385.4221,54,381.4221" style="stroke: #A80036; stroke-width: 1.0;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="52" x2="807" y1="381.4221" y2="381.4221"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="91" x="64" y="375.6131">Fetch Miner file</text><line style="stroke: #A80036; stroke-width: 1.0;" x1="47" x2="89" y1="413.1281" y2="413.1281"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="89" x2="89" y1="413.1281" y2="426.1281"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="48" x2="89" y1="426.1281" y2="426.1281"/><polygon fill="#A80036" points="58,422.1281,48,426.1281,58,430.1281,54,426.1281" style="stroke: #A80036; stroke-width: 1.0;"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="317" x="54" y="407.3191">Decrypt Miner file entry encrypted for given Validator</text><polygon fill="#A80036" points="366,453.8341,376,457.8341,366,461.8341,370,457.8341" style="stroke: #A80036; stroke-width: 1.0;"/><line style="stroke: #A80036; stroke-width: 1.0;" x1="47" x2="372" y1="457.8341" y2="457.8341"/><text fill="#000000" font-family="sans-serif" font-size="13" lengthAdjust="spacingAndGlyphs" textLength="267" x="54" y="452.0251">Send request using decrypted Miner address</text><!--MD5=[a42300d3263cac5919873b98c8c99d11]
 @startuml ./assets/diagrams/CommunicationFlow
 participant Validator
 participant Miner
-participant GitHub
-participant Storage
-participant Bittensor
+participant AddressManager
+database Storage
+database Bittensor
 Validator -> Validator: Generate Validator key-pair
-Validator -> GitHub: Publish public key along with HotKey
-GitHub -> Miner: Fetch Validator info
-Miner -> Miner: Encrypt Miner IP/Domain with Validator public key
-Miner -> Storage: Add/update file with encrypted IPs/Domains for Validators
+Validator -> Bittensor: Publish public key along with HotKey
+Bittensor -> Miner: Fetch new Validator info
+Miner -> AddressManager: Generate new address
+Miner -> Miner: Encrypt generated address with Validator public key
+Miner -> Storage: Update file with encrypted addresses for Validators
 Miner -> Bittensor: Publish file location
 Bittensor -> Validator: Fetch file location
 Storage -> Validator: Fetch Miner file
 Validator -> Validator: Decrypt Miner file entry encrypted for given Validator
-Validator -> Miner: Send request using decrypted Miner IP/Domain
+Validator -> Miner: Send request using decrypted Miner address
 @enduml
 
 PlantUML version 1.2020.02(Sun Mar 01 11:22:07 CET 2020)
diff --git a/bt_ddos_shield/address.py b/bt_ddos_shield/address.py
index 0209b53..fd4611c 100644
--- a/bt_ddos_shield/address.py
+++ b/bt_ddos_shield/address.py
@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+from dataclasses import dataclass
 from enum import Enum
 
 
@@ -6,49 +7,92 @@ class AddressType(Enum):
     """
     Possible types of address.
     """
-    IP = "ip"         # IPv4 address
-    IPV6 = "ipv6"     # IPv6 address
-    DOMAIN = "domain" # domain name
+    IP = "ip"          # IPv4 address
+    IPV6 = "ipv6"      # IPv6 address
+    DOMAIN = "domain"  # domain name
+    S3 = "s3"          # address identifies S3 object (id is object name)
+    EC2 = "ec2"        # address identifies EC2 instance (id is instance id)
 
 
-class Address(ABC):
+@dataclass
+class Address:
     """
-    Class describing address, which redirects to original miner's server.
+    Class describing some address - domain or IP.
     """
 
-    def __init__(self, address_id, address_type: AddressType, address: str, port: int):
-        """
-        Args:
-            address_id: Identifier (used by AddressManager) of the address. Type depends on the implementation.
-            address_type: Type of the address.
-            address: Address.
-            port: Port of the address.
-        """
-        self.address_id = address_id
-        self.address_type = address_type
-        self.address = address
-        self.port = port
+    address_id: str
+    """ identifier (used by AbstractAddressManager implementation) of the address """
+    address_type: AddressType
+    address: str
+    port: int
+
+    def __repr__(self):
+        return f"Address(id={self.address_id}, type={self.address_type}, address={self.address}:{self.port})"
+
+
+class AddressSerializerException(Exception):
+    pass
+
+
+class AddressDeserializationException(AddressSerializerException):
+    """
+    Exception thrown when deserialization of address data fails.
+    """
+    pass
+
+
+class AbstractAddressSerializer(ABC):
+    """
+    Class used to serialize and deserialize addresses.
+    """
 
     @abstractmethod
-    def encrypt(self) -> bytes:
+    def serialize(self, address: Address) -> bytes:
         """
-        Encrypts address data.
-
-        Returns:
-            bytes: Encrypted address data.
+        Serialize address data. Output format depends on the implementation.
         """
         pass
 
-    @classmethod
     @abstractmethod
-    def decrypt(cls, encrypted_data: bytes) -> Address:
+    def deserialize(self, serialized_data: bytes) -> Address:
         """
-        Create address from encrypted address data.
+        Deserialize address data. Throws AddressDeserializationException if data format is not recognized.
 
         Args:
-            encrypted_data: Encrypted address data.
-
-        Returns:
-            Address: Created address.
+            serialized_data: Data serialized before by serialize method.
         """
         pass
+
+
+class DefaultAddressSerializer(AbstractAddressSerializer):
+    """
+    Address serializer implementation which serialize address to string.
+    """
+
+    encoding: str
+
+    def __init__(self, encoding: str = "utf-8"):
+        """
+        Args:
+            encoding: Encoding used for transforming generated address string to bytes.
+        """
+        self.encoding = encoding
+
+    def serialize(self, address: Address) -> bytes:
+        assert address.address.find(":") == -1, "Address should not contain colon character"
+        address_str: str = f"{address.address_type.value}:{address.address}:{address.port}:{address.address_id}"
+        return address_str.encode(self.encoding)
+
+    def deserialize(self, serialized_data: bytes) -> Address:
+        try:
+            address_str: str = serialized_data.decode(self.encoding)
+            parts = address_str.split(":")
+            if len(parts) < 4:
+                raise AddressDeserializationException(f"Invalid number of parts, address_str='{address_str}'")
+            address_type: AddressType = AddressType(parts[0])
+            address: str = parts[1]
+            port: int = int(parts[2])
+            address_id: str = ":".join(parts[3:])  # there can possibly be some colons in address_id
+            return Address(address_id=address_id, address_type=address_type, address=address, port=port)
+        except Exception as e:
+            raise AddressDeserializationException(f"Failed to deserialize address, error='{e}'") from e
diff --git a/bt_ddos_shield/address_manager.py b/bt_ddos_shield/address_manager.py
index 14e67c4..ce23487 100644
--- a/bt_ddos_shield/address_manager.py
+++ b/bt_ddos_shield/address_manager.py
@@ -1,6 +1,28 @@
+import ipaddress
+import secrets
+import string
+import time
 from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+from ipaddress import IPv4Network, IPv6Network
+from types import MappingProxyType
+from typing import Any, Callable, Optional, Union
 
-from bt_ddos_shield.address import Address
+from botocore.client import BaseClient
+from botocore.exceptions import ClientError
+from route53.connection import Route53Connection
+from route53.hosted_zone import HostedZone
+from route53.resource_record_set import ResourceRecordSet
+
+from bt_ddos_shield.address import Address, AddressType
+from bt_ddos_shield.event_processor import AbstractMinerShieldEventProcessor
+from bt_ddos_shield.state_manager import AbstractMinerShieldStateManager, MinerShieldState
+from bt_ddos_shield.utils import AWSClientFactory, Hotkey
+
+
+class AddressManagerException(Exception):
+    pass
 
 
 class AbstractAddressManager(ABC):
@@ -8,50 +30,795 @@ class AbstractAddressManager(ABC):
     Abstract base class for manager handling public IP/domain addresses assigned to validators.
     """
 
-    def __init__(self, address_id):
+    def hide_original_server(self):
         """
-        Args:
-            address_id: Identifier of the address of original miner's server. All created addresses for validators
-                        should redirect to this address.
+        If method is implemented, it should hide the original server IP address from public access.
+        See auto_hide_original_server in MinerShield options.
         """
-        self.address_id = address_id
+        pass
 
     @abstractmethod
-    def create_address(self) -> Address:
+    def clean_all(self):
         """
-        Create a new address.
-
-        Returns:
-            Address: New address to be used by validator.
+        Clean everything created before by the address manager.
         """
         pass
 
     @abstractmethod
-    def remove_address(self, address_id):
+    def create_address(self, hotkey: Hotkey) -> Address:
         """
-        Remove address.
-
-        Args:
-            address_id: Identifier of the address to remove.
+        Create and return a new address redirecting to Miner server to be used by validator identified by hotkey.
         """
         pass
 
     @abstractmethod
-    def address_exists(self, address_id) -> bool:
+    def remove_address(self, address: Address):
+        pass
+
+    @abstractmethod
+    def validate_addresses(self, addresses: MappingProxyType[Hotkey, Address]) -> set[Hotkey]:
         """
-        Check if address exists.
+        Validate if given addresses exist and are working properly.
 
         Args:
-            address_id: Identifier of the address to check.
+            addresses: Dictionary of addresses to validate (validator HotKey -> Address).
 
-            Returns:
-                bool: If address exists.
+        Returns:
+            set[Hotkey]: Set of HotKeys of validators with invalid addresses.
         """
         pass
 
-    def hide_original_server(self):
+
+@dataclass
+class AwsEC2InstanceData:
+    instance_id: str
+    vpc_id: str
+    subnet_id: str
+    private_ip: str
+    security_groups: list[dict[str, str]]
+
+
+@dataclass
+class AwsSubnetData:
+    subnet_id: str
+    availability_zone: str
+    cidr_block: str
+
+
+@dataclass
+class AwsVpcData:
+    vpc_id: str
+    cidr_block: str
+    subnets: list[AwsSubnetData]
+
+
+@dataclass
+class AwsELBData:
+    id: str
+    dns_name: str
+    hosted_zone_id: str
+
+
+class AwsObjectTypes(Enum):
+    WAF = 'WAF'
+    ELB = 'ELB'
+    SUBNET = 'SUBNET'
+    DNS_ENTRY = 'DNS_ENTRY'
+    TARGET_GROUP = 'TARGET_GROUP'
+    SECURITY_GROUP = 'SECURITY_GROUP'
+
+
+class AwsAddressManager(AbstractAddressManager):
+    """
+    Address manager using AWS Route53 service to manage DNS records and ELB for handling access to Miner server.
+    """
+
+    miner_instance_id: str
+    """ ID of miner EC2 instance in AWS. All traffic will be redirected to this instance. """
+    miner_instance: AwsEC2InstanceData
+    miner_instance_port: int
+    """ Port where miner server is working. """
+    waf_client: BaseClient
+    waf_arn: Optional[str]
+    elb_client: BaseClient
+    elb_data: Optional[AwsELBData]
+    ec2_client: BaseClient
+    hosted_zone_id: str
+    """ ID of hosted zone in Route53 where addresses are located. """
+    hosted_zone: HostedZone
+    route53_client: Route53Connection
+    route53_boto_client: BaseClient
+    event_processor: AbstractMinerShieldEventProcessor
+    state_manager: AbstractMinerShieldStateManager
+
+    HOSTED_ZONE_ID_KEY: str = 'aws_hosted_zone_id'
+    INSTANCE_PORT_KEY: str = 'ec2_instance_port'
+    INSTANCE_ID_KEY: str = 'ec2_instance_id'
+
+    def __init__(self, aws_client_factory: AWSClientFactory,
+                 miner_address: Address, hosted_zone_id: str, event_processor: AbstractMinerShieldEventProcessor,
+                 state_manager: AbstractMinerShieldStateManager):
         """
-        If method is implemented, it should hide the original server IP address from public access.
-        See auto_hide_original_server in MinerShield options.
+        Initialize AWS address manager. miner_address can be passed as EC2 type (then AWS instance_id should be set in
+        address field) or as IP/IPV6 (then we try to find EC2 instance with this IP, which should be private IP
+        address of EC2 instance) - where port means destination port and address_id is ignored.
         """
-        pass
+        self.event_processor = event_processor
+        self.state_manager = state_manager
+
+        self.waf_client = aws_client_factory.boto3_client('wafv2')
+        self.waf_arn = None
+        self.elb_client = aws_client_factory.boto3_client('elbv2')
+        self.elb_data = None
+        self.route53_client = aws_client_factory.route53_client()
+        self.hosted_zone_id = hosted_zone_id
+        self.hosted_zone = self.route53_client.get_hosted_zone_by_id(hosted_zone_id)
+        self.route53_boto_client = aws_client_factory.boto3_client('route53')
+        self.ec2_client = aws_client_factory.boto3_client('ec2')
+        self._initialize_miner_instance(miner_address)
+
+    def _initialize_miner_instance(self, miner_address: Address):
+        if miner_address.address_type == AddressType.EC2:
+            self.miner_instance_id = miner_address.address
+        elif miner_address.address_type in (AddressType.IP, AddressType.IPV6):
+            if miner_address.address_type == AddressType.IPV6:
+                # TODO implement IPv6 support
+                raise AddressManagerException('IPv6 is not yet supported')
+            self.miner_instance_id = self._find_ec2_instance_id_by_ip(miner_address.address)
+        else:
+            raise AddressManagerException('Miner address should be of type EC2 or IP')
+        self.miner_instance = self._get_ec2_instance_data(self.miner_instance_id)
+        self.miner_instance_port = miner_address.port
+
+    def _find_ec2_instance_id_by_ip(self, ip_address: str) -> str:
+        response: dict[str, Any] = self.ec2_client.describe_instances(Filters=[{'Name': 'private-ip-address',
+                                                                                'Values': [ip_address]}])
+        if not response['Reservations']:
+            raise AddressManagerException(f'No EC2 instance found with private IP address {ip_address}')
+        return response['Reservations'][0]['Instances'][0]['InstanceId']
+
+    def clean_all(self):
+        created_objects: MappingProxyType[str, frozenset[str]] = \
+            self.state_manager.get_state().address_manager_created_objects
+
+        self._delete_route53_records(self.hosted_zone_id)
+
+        # Order of removal is important
+        cleaned: bool = True
+        cleaned = self._clean_aws_objects(created_objects, AwsObjectTypes.WAF,
+                                          self._remove_firewall) and cleaned
+        cleaned = self._clean_aws_objects(created_objects, AwsObjectTypes.ELB,
+                                          self._remove_elb) and cleaned
+        cleaned = self._clean_aws_objects(created_objects, AwsObjectTypes.SECURITY_GROUP,
+                                          self._remove_security_group) and cleaned
+        cleaned = self._clean_aws_objects(created_objects, AwsObjectTypes.TARGET_GROUP,
+                                          self._remove_target_group) and cleaned
+        cleaned = self._clean_aws_objects(created_objects, AwsObjectTypes.SUBNET,
+                                          self._remove_subnet) and cleaned
+        if not cleaned:
+            raise AddressManagerException('Failed to clean all AWS objects that are no longer needed')
+
+    @classmethod
+    def _clean_aws_objects(cls, created_objects: MappingProxyType[str, frozenset[str]], object_type: AwsObjectTypes,
+                           remove_method: Callable[[str], bool]) -> bool:
+        if object_type.value not in created_objects:
+            return True
+        cleaned: bool = True
+        for object_id in created_objects[object_type.value]:
+            cleaned = remove_method(object_id) and cleaned
+        return cleaned
+
+    def create_address(self, hotkey: Hotkey) -> Address:
+        self._validate_manager_state()
+
+        new_address_domain_id: str = f'{self._generate_subdomain(hotkey)}.{self.hosted_zone.name}'
+        new_address_domain: str = new_address_domain_id[:-1]  # Cut '.' from the end for working address
+        record_id: str = self._add_route53_record(new_address_domain_id, self.hosted_zone)
+
+        try:
+            self._add_domain_rule_to_firewall(self.waf_arn, new_address_domain)
+        except Exception as e:
+            self._delete_route53_record_by_id(record_id, self.hosted_zone)
+            raise e
+
+        return Address(address_id=record_id, address_type=AddressType.DOMAIN,
+                       address=new_address_domain, port=self.miner_instance_port)
+
+    @classmethod
+    def _generate_subdomain(cls, hotkey: Hotkey) -> str:
+        return f'{hotkey[:8]}_{secrets.token_urlsafe(16)}'.lower()
+
+    def remove_address(self, address: Address):
+        self._validate_manager_state()
+        self._remove_domain_rule_from_firewall(self.waf_arn, address.address)
+        self._delete_route53_record_by_id(address.address_id, self.hosted_zone)
+
+    def validate_addresses(self, addresses: MappingProxyType[Hotkey, Address]) -> set[Hotkey]:
+        if self._validate_manager_state():
+            return {hotkey for hotkey, _ in addresses.items()}
+
+        if not addresses:
+            return set()
+
+        zone_addresses_ids: set[str] = {record_set.name for record_set in self.hosted_zone.record_sets}
+        waf_data: dict[str, Any] = self._get_firewall_info(self.waf_arn)
+        rules: list[dict[str, Any]] = waf_data['WebACL']['Rules']
+
+        invalid_hotkeys: set[Hotkey] = set()
+        for hotkey, address in addresses.items():
+            if address.address_id not in zone_addresses_ids:
+                invalid_hotkeys.add(hotkey)
+                continue
+
+            rule: Optional[dict[str, Any]] = self._find_rule(rules, address.address)
+            if rule is None:
+                invalid_hotkeys.add(hotkey)
+        return invalid_hotkeys
+
+    def _validate_manager_state(self) -> bool:
+        """ Returns if we should invalidate all addresses created before. """
+        ret: bool = self._handle_shielded_instance_change()
+        ret = self._handle_hosted_zone_change() or ret
+        self.elb_data = self._create_elb_if_needed(self.miner_instance, self.miner_instance_port)
+        self.waf_arn = self._create_firewall_if_needed()
+        return ret
+
+    def _handle_shielded_instance_change(self) -> bool:
+        state: MinerShieldState = self.state_manager.get_state()
+
+        id_changed: bool = False
+        old_id: Optional[str] = None
+        if self.INSTANCE_ID_KEY in state.address_manager_state:
+            old_id = state.address_manager_state[self.INSTANCE_ID_KEY]
+            if old_id != self.miner_instance_id:
+                id_changed = True
+        else:
+            id_changed = True
+
+        port_changed: bool = False
+        old_port: Optional[int] = None
+        if self.INSTANCE_PORT_KEY in state.address_manager_state:
+            old_port = int(state.address_manager_state[self.INSTANCE_PORT_KEY])
+            if old_port != self.miner_instance_port:
+                port_changed = True
+        else:
+            port_changed = True
+
+        recreate_needed: bool = id_changed or port_changed
+        if recreate_needed:
+            # If shielded instance ID or port changed, we need to recreate ELB. Maybe we can try to change only
+            # needed objects, but changing ELB is the easiest way and this operation should happen rarely.
+            self.event_processor.event('Shielded EC2 instance ID changed from {old_id}:{old_port} to '
+                                       '{new_id}:{new_port}', old_id=old_id, old_port=old_port,
+                                       new_id=self.miner_instance_id, new_port=self.miner_instance_port)
+            self.clean_all()
+
+        if id_changed:
+            self.state_manager.update_address_manager_state(self.INSTANCE_ID_KEY, self.miner_instance_id)
+        if port_changed:
+            self.state_manager.update_address_manager_state(self.INSTANCE_PORT_KEY, str(self.miner_instance_port))
+
+        return recreate_needed
+
+    def _handle_hosted_zone_change(self) -> bool:
+        state: MinerShieldState = self.state_manager.get_state()
+        zone_changed: bool = False
+        if self.HOSTED_ZONE_ID_KEY in state.address_manager_state:
+            old_zone_id: str = state.address_manager_state[self.HOSTED_ZONE_ID_KEY]
+            if old_zone_id != self.hosted_zone_id:
+                # If hosted zone changed, we need to clean all previous route53 addresses
+                self.event_processor.event('Route53 hosted zone changed from {old_id} to {new_id}',
+                                           old_id=old_zone_id,
+                                           new_id=self.hosted_zone_id)
+                self._delete_route53_records(old_zone_id)
+                zone_changed = True
+        else:
+            zone_changed = True
+
+        if zone_changed:
+            self.state_manager.update_address_manager_state(self.HOSTED_ZONE_ID_KEY, self.hosted_zone_id)
+        return zone_changed
+
+    def _get_ec2_instance_data(self, instance_id: str) -> AwsEC2InstanceData:
+        response: dict[str, Any] = self.ec2_client.describe_instances(InstanceIds=[instance_id])
+        instance_data: dict[str, Any] = response['Reservations'][0]['Instances'][0]
+        return AwsEC2InstanceData(instance_id=instance_id, vpc_id=instance_data['VpcId'],
+                                  subnet_id=instance_data['SubnetId'], private_ip=instance_data['PrivateIpAddress'],
+                                  security_groups=instance_data['SecurityGroups'])
+
+    def _get_vpc_data(self, vpc_id: str) -> AwsVpcData:
+        response: dict[str, Any] = self.ec2_client.describe_vpcs(VpcIds=[vpc_id])
+        vpc_data: dict[str, Any] = response['Vpcs'][0]
+        cidr_block: str = vpc_data['CidrBlock']
+
+        response = self.ec2_client.describe_subnets(Filters=[{'Name': 'vpc-id', 'Values': [vpc_id]}])
+        subnets: list[AwsSubnetData] = [AwsSubnetData(subnet_id=subnet['SubnetId'],
+                                                      availability_zone=subnet['AvailabilityZone'],
+                                                      cidr_block=subnet['CidrBlock'])
+                                        for subnet in response['Subnets']]
+        return AwsVpcData(vpc_id=vpc_id, cidr_block=cidr_block, subnets=subnets)
+
+    def _get_subnet_data(self, subnet_id: str) -> AwsSubnetData:
+        response: dict[str, Any] = self.ec2_client.describe_subnets(SubnetIds=[subnet_id])
+        subnet_data: dict[str, Any] = response['Subnets'][0]
+        return AwsSubnetData(subnet_id=subnet_id, availability_zone=subnet_data['AvailabilityZone'],
+                             cidr_block=subnet_data['CidrBlock'])
+
+    def _add_route53_record(self, record_id: str, hosted_zone: HostedZone) -> str:
+        # Route53Connection doesn't handle alias records properly, so we use boto3 client directly
+        self.route53_boto_client.change_resource_record_sets(
+            HostedZoneId=hosted_zone.id,
+            ChangeBatch={
+                'Changes': [
+                    {
+                        'Action': 'CREATE',
+                        'ResourceRecordSet': {
+                            'Name': record_id,
+                            'Type': 'A',
+                            'AliasTarget': {
+                                'HostedZoneId': self.elb_data.hosted_zone_id,
+                                'DNSName': self.elb_data.dns_name,
+                                'EvaluateTargetHealth': False
+                            }
+                        }
+                    }
+                ]
+            }
+        )
+        self.event_processor.event('Added Route53 record {name} to hosted zone {zone_id}',
+                                   name=record_id, zone_id=hosted_zone.id)
+        try:
+            self.state_manager.add_address_manager_created_object(AwsObjectTypes.DNS_ENTRY.value, record_id)
+        except Exception as e:
+            self._delete_route53_record_by_id(record_id, hosted_zone)
+            raise e
+
+        # There is no ID for Route53 addresses, so we use domain name as an ID.
+        return record_id
+
+    def _delete_route53_record_by_id(self, record_id: str, hosted_zone: HostedZone):
+        for record_set in hosted_zone.record_sets:
+            if record_set.name == record_id:
+                self._delete_route53_record(record_set, hosted_zone)
+                return
+
+    def _delete_route53_record(self, record_set: ResourceRecordSet, hosted_zone: HostedZone):
+        # Route53Connection doesn't handle alias records properly, so we use boto3 client directly
+        response: dict[str, Any] = self.route53_boto_client.list_resource_record_sets(
+            HostedZoneId=hosted_zone.id,
+            StartRecordName=record_set.name,
+            StartRecordType=record_set.rrset_type,
+            MaxItems='1'
+        )
+        record_set_data: dict[str, Any] = response['ResourceRecordSets'][0]
+
+        self.route53_boto_client.change_resource_record_sets(
+            HostedZoneId=hosted_zone.id,
+            ChangeBatch={
+                'Changes': [
+                    {
+                        'Action': 'DELETE',
+                        'ResourceRecordSet': record_set_data
+                    }
+                ]
+            }
+        )
+        self.event_processor.event('Deleted Route53 record {name} from hosted zone {zone_id}',
+                                   name=record_set.name, zone_id=hosted_zone.id)
+        self.state_manager.del_address_manager_created_object(AwsObjectTypes.DNS_ENTRY.value, record_set.name)
+
+    @classmethod
+    def _generate_random_alnum_string(cls, length: int) -> str:
+        characters = string.ascii_letters + string.digits
+        return ''.join(secrets.choice(characters) for _ in range(length))
+
+    def _create_subnet(self, vpc_id: str, cidr_block: str, availability_zone: str) -> AwsSubnetData:
+        response: dict[str, Any] = self.ec2_client.create_subnet(VpcId=vpc_id, CidrBlock=cidr_block,
+                                                                 AvailabilityZone=availability_zone)
+        subnet = AwsSubnetData(subnet_id=response['Subnet']['SubnetId'], availability_zone=availability_zone,
+                               cidr_block=cidr_block)
+        self.event_processor.event('Created AWS subnet {id} with cidr={cidr} in {az} availability zone',
+                                   id=subnet.subnet_id, cidr=subnet.cidr_block, az=subnet.availability_zone)
+        try:
+            self.state_manager.add_address_manager_created_object(AwsObjectTypes.SUBNET.value, subnet.subnet_id)
+        except Exception as e:
+            self._remove_subnet(subnet.subnet_id)
+            raise e
+        return subnet
+
+    def _remove_subnet(self, subnet_id: str) -> bool:
+        self.ec2_client.delete_subnet(SubnetId=subnet_id)
+        self.event_processor.event('Deleted AWS subnet {id}', id=subnet_id)
+        self.state_manager.del_address_manager_created_object(AwsObjectTypes.SUBNET.value, subnet_id)
+        return True
+
+    def _create_target_group(self, miner_vpc: AwsVpcData, miner_instance_id: str, miner_instance_port: int) -> str:
+        group_name: str = f'miner-target-group-{self._generate_random_alnum_string(8)}'
+        # Health check can't be disabled, when targeting instance - as for now we use traffic-port
+        response: dict[str, Any] = self.elb_client.create_target_group(Name=group_name, Protocol='HTTP',
+                                                                       Port=miner_instance_port, VpcId=miner_vpc.vpc_id,
+                                                                       HealthCheckPort='traffic-port',
+                                                                       TargetType='instance')
+        target_group_id: str = response['TargetGroups'][0]['TargetGroupArn']
+        self.event_processor.event('Created AWS TargetGroup, name={name}, id={id}',
+                                   name=group_name, id=target_group_id)
+
+        try:
+            self.elb_client.register_targets(TargetGroupArn=target_group_id, Targets=[{'Id': miner_instance_id,
+                                                                                       'Port': miner_instance_port}])
+            self.state_manager.add_address_manager_created_object(AwsObjectTypes.TARGET_GROUP.value, target_group_id)
+        except Exception as e:
+            self._remove_target_group(target_group_id)
+            raise e
+
+        return target_group_id
+
+    def _remove_target_group(self, target_group_id: str) -> bool:
+        old_instance_id: str = self.state_manager.get_state().address_manager_state[self.INSTANCE_ID_KEY]
+        self.elb_client.deregister_targets(TargetGroupArn=target_group_id, Targets=[{'Id': old_instance_id}])
+
+        retries_count: int = 20
+        error_code: str = ''
+        for _ in range(retries_count):
+            try:
+                self.elb_client.delete_target_group(TargetGroupArn=target_group_id)
+                break
+            except ClientError as e:
+                error_code = e.response['Error']['Code']
+                if error_code == 'ResourceInUse':
+                    time.sleep(6)  # wait for target group to be deregistered
+                else:
+                    raise e
+        else:
+            # It happens quite often and sometimes AWS waits for many minutes before allowing to remove target group.
+            # But we don't want to wait for so long - 2 minutes is long enough.
+            # If it happens during tests, user should remove target group later manually using AWS panel to not leave
+            # unneeded objects in AWS.
+            self.event_processor.event('Failed to remove AWS TargetGroup {id}, error={error_code}',
+                                       id=target_group_id, error_code=error_code)
+            return False
+
+        self.event_processor.event('Deleted AWS TargetGroup {id}', id=target_group_id)
+        self.state_manager.del_address_manager_created_object(AwsObjectTypes.TARGET_GROUP.value, target_group_id)
+        return True
+
+    def _create_elb(self, miner_instance: AwsEC2InstanceData, bonus_subnet: AwsSubnetData, target_group_id: str,
+                    security_group_id: str) -> str:
+        elb_name: str = f'miner-elb-{self._generate_random_alnum_string(8)}'
+        subnets: list[str] = [miner_instance.subnet_id, bonus_subnet.subnet_id]
+        response: dict[str, Any] = self.elb_client.create_load_balancer(Name=elb_name, Subnets=subnets,
+                                                                        SecurityGroups=[security_group_id],
+                                                                        Scheme='internet-facing', Type='application')
+        elb_info: dict[str, Any] = response['LoadBalancers'][0]
+        elb_id: str = elb_info['LoadBalancerArn']
+        self.event_processor.event('Created AWS ELB, name={name}, id={id}', name=elb_name, id=elb_id)
+
+        try:
+            self.elb_client.create_listener(LoadBalancerArn=elb_id, Protocol='HTTP', Port=80,
+                                            DefaultActions=[{'Type': 'forward', 'TargetGroupArn': target_group_id}])
+            self.state_manager.add_address_manager_created_object(AwsObjectTypes.ELB.value, elb_id)
+        except Exception as e:
+            self._remove_elb(elb_id)
+            raise e
+
+        return elb_id
+
+    def _remove_elb(self, elb_id: str) -> bool:
+        self.elb_client.delete_load_balancer(LoadBalancerArn=elb_id)
+        self.event_processor.event('Deleted AWS ELB {id}', id=elb_id)
+        self.state_manager.del_address_manager_created_object(AwsObjectTypes.ELB.value, elb_id)
+        return True
+
+    def _get_elb_info(self, elb_id: str) -> AwsELBData:
+        response: dict[str, Any] = self.elb_client.describe_load_balancers(LoadBalancerArns=[elb_id])
+        elb_info: dict[str, Any] = response['LoadBalancers'][0]
+        return AwsELBData(id=elb_info['LoadBalancerArn'], dns_name=elb_info['DNSName'],
+                          hosted_zone_id=elb_info['CanonicalHostedZoneId'])
+
+    def _create_security_group(self, miner_vpc: AwsVpcData, miner_instance_port: int) -> str:
+        group_name: str = f'miner-security-group-{self._generate_random_alnum_string(8)}'
+        response: dict[str, Any] = \
+            self.ec2_client.create_security_group(GroupName=group_name,
+                                                  Description='Security group for miner instance',
+                                                  VpcId=miner_vpc.vpc_id)
+        security_group_id: str = response['GroupId']
+        self.event_processor.event('Created AWS SecurityGroup, name={name}, id={id}',
+                                   name=group_name, id=security_group_id)
+
+        try:
+            self.ec2_client.authorize_security_group_ingress(
+                GroupId=security_group_id,
+                IpPermissions=[{
+                    'FromPort': 80, 'ToPort': miner_instance_port, 'IpProtocol': 'tcp',
+                    'IpRanges': [{'CidrIp': '0.0.0.0/0'}]
+                }]
+            )
+            self.state_manager.add_address_manager_created_object(AwsObjectTypes.SECURITY_GROUP.value,
+                                                                  security_group_id)
+        except Exception as e:
+            self._remove_security_group(security_group_id)
+            raise e
+
+        return security_group_id
+
+    def _remove_security_group(self, security_group_id: str) -> bool:
+        retries_count: int = 20
+        error_code: str = ''
+        for _ in range(retries_count):
+            try:
+                self.ec2_client.delete_security_group(GroupId=security_group_id)
+                break
+            except ClientError as e:
+                error_code = e.response['Error']['Code']
+                if error_code == 'DependencyViolation':
+                    time.sleep(6)  # wait for ELB to be removed
+                else:
+                    raise e
+        else:
+            # It happens quite often and sometimes AWS waits for many minutes before allowing to remove security group.
+            # But we don't want to wait for so long - 2 minutes is long enough.
+            # If it happens during tests, user should remove security group later manually using AWS panel to not leave
+            # unneeded objects in AWS.
+            self.event_processor.event('Failed to remove AWS SecurityGroup {id}, error={error_code}',
+                                       id=security_group_id, error_code=error_code)
+            return False
+
+        self.event_processor.event('Deleted AWS SecurityGroup {id}', id=security_group_id)
+        self.state_manager.del_address_manager_created_object(AwsObjectTypes.SECURITY_GROUP.value, security_group_id)
+        return True
+
+    def _delete_route53_records(self, hosted_zone_id: str):
+        address_manager_created_objects: MappingProxyType[str, frozenset[str]] = \
+            self.state_manager.get_state().address_manager_created_objects
+        if AwsObjectTypes.DNS_ENTRY.value not in address_manager_created_objects:
+            return
+
+        created_entries: frozenset[str] = \
+            self.state_manager.get_state().address_manager_created_objects[AwsObjectTypes.DNS_ENTRY.value]
+        hosted_zone = self.route53_client.get_hosted_zone_by_id(hosted_zone_id)
+        for record_set in hosted_zone.record_sets:
+            if record_set.name in created_entries:
+                self._delete_route53_record(record_set, hosted_zone)
+
+        # Clean from state entries without working address
+        address_manager_created_objects = self.state_manager.get_state().address_manager_created_objects
+        if AwsObjectTypes.DNS_ENTRY.value not in address_manager_created_objects:
+            return
+        for created_entry in address_manager_created_objects[AwsObjectTypes.DNS_ENTRY.value]:
+            self.state_manager.del_address_manager_created_object(AwsObjectTypes.DNS_ENTRY.value, created_entry)
+
+    def _create_firewall(self) -> str:
+        waf_name: str = f'miner-waf-{self._generate_random_alnum_string(8)}'
+        response: dict[str, Any] = self.waf_client.create_web_acl(
+            Name=waf_name,
+            Scope='REGIONAL',
+            DefaultAction={'Block': {}},
+            Rules=[],
+            VisibilityConfig={
+                'SampledRequestsEnabled': True,
+                'CloudWatchMetricsEnabled': True,
+                'MetricName': waf_name
+            })
+        waf_arn: str = response['Summary']['ARN']
+        self.event_processor.event('Created AWS WAF, name={name}, id={id}', name=waf_name, id=waf_arn)
+
+        retries_count: int = 10
+        error_code: str = ''
+        for _ in range(retries_count):
+            try:
+                self.waf_client.associate_web_acl(WebACLArn=waf_arn, ResourceArn=self.elb_data.id)
+                self.event_processor.event('Associated AWS WAF {waf_id} to ELB {elb_id}',
+                                           waf_id=waf_arn, elb_id=self.elb_data.id)
+                break
+            except ClientError as e:
+                error_code = e.response['Error']['Code']
+                time.sleep(6)  # wait for WAF to be created
+        else:
+            self._remove_firewall(waf_arn)
+            raise AddressManagerException(f'Failed to associate AWS WAF {waf_arn} with ELB, error={error_code}')
+
+        try:
+            self.state_manager.add_address_manager_created_object(AwsObjectTypes.WAF.value, waf_arn)
+        except Exception as e:
+            self._remove_firewall(waf_arn)
+            raise e
+
+        return waf_arn
+
+    def _remove_firewall(self, waf_arn: str) -> bool:
+        created_objects: MappingProxyType[str, frozenset[str]] = \
+            self.state_manager.get_state().address_manager_created_objects
+
+        if AwsObjectTypes.ELB.value in created_objects:
+            assert len(created_objects[AwsObjectTypes.ELB.value]) == 1, "only one ELB should be created"
+            elb_id: str = next(iter(created_objects[AwsObjectTypes.ELB.value]))
+            self.waf_client.disassociate_web_acl(ResourceArn=elb_id)
+
+        waf_data: dict[str, Any] = self._get_firewall_info(waf_arn)
+        acl_data: dict[str, Any] = waf_data['WebACL']
+        waf_id: str = acl_data['Id']
+        lock_token = waf_data['LockToken']
+
+        retries_count: int = 20
+        error_code: str = ''
+        for _ in range(retries_count):
+            try:
+                self.waf_client.delete_web_acl(Name=acl_data['Name'], Id=waf_id, Scope='REGIONAL', LockToken=lock_token)
+                break
+            except ClientError as e:
+                error_code = e.response['Error']['Code']
+                if error_code == 'WAFAssociatedItemException':
+                    time.sleep(6)  # wait for ELB disassociating
+                else:
+                    raise e
+        else:
+            # It happens quite often and sometimes AWS waits for many minutes before allowing to remove WAF.
+            # But we don't want to wait for so long - 2 minutes is long enough.
+            # If it happens during tests, user should remove WAF later manually using AWS panel to not leave
+            # unneeded objects in AWS.
+            self.event_processor.event('Failed to remove AWS WAF {id}, error={error_code}',
+                                       id=waf_id, error_code=error_code)
+            return False
+
+        self.event_processor.event('Deleted AWS WAF {id}', id=waf_arn)
+        self.state_manager.del_address_manager_created_object(AwsObjectTypes.WAF.value, waf_arn)
+        return True
+
+    def _get_firewall_info(self, waf_arn: str) -> dict[str, Any]:
+        waf_name: str = self._get_name_from_waf_arn(waf_arn)
+        waf_id: str = self._get_id_from_waf_arn(waf_arn)
+        return self.waf_client.get_web_acl(Name=waf_name, Id=waf_id, Scope='REGIONAL')
+
+    def _update_web_acl(self, waf_data: dict[str, Any], rules: list[dict[str, Any]]):
+        acl_data: dict[str, Any] = waf_data['WebACL']
+        lock_token = waf_data['LockToken']
+        self.waf_client.update_web_acl(Name=acl_data['Name'], Id=acl_data['Id'], Scope='REGIONAL',
+                                       DefaultAction=acl_data['DefaultAction'], Rules=rules,
+                                       VisibilityConfig=acl_data['VisibilityConfig'], LockToken=lock_token)
+
+    def _add_domain_rule_to_firewall(self, waf_arn: str, domain: str):
+        waf_data: dict[str, Any] = self._get_firewall_info(waf_arn)
+        rules: list[dict[str, Any]] = waf_data['WebACL']['Rules']
+        rule_name: str = f'miner-waf-rule-{self._generate_random_alnum_string(8)}'
+        priority: int = rules[-1]['Priority'] + 1 if rules else 1
+        rule = {
+            'Name': rule_name,
+            'Priority': priority,
+            'Statement': {
+                'ByteMatchStatement': {
+                    'SearchString': domain,
+                    'FieldToMatch': {
+                        'SingleHeader': {
+                            'Name': 'host'
+                        }
+                    },
+                    'TextTransformations': [
+                        {
+                            'Priority': 0,
+                            'Type': 'NONE'
+                        }
+                    ],
+                    'PositionalConstraint': 'EXACTLY'
+                }
+            },
+            'Action': {
+                'Allow': {}
+            },
+            'VisibilityConfig': {
+                'SampledRequestsEnabled': True,
+                'CloudWatchMetricsEnabled': True,
+                'MetricName': rule_name
+            }
+        }
+        rules.append(rule)
+        self._update_web_acl(waf_data, rules)
+        self.event_processor.event('Added rule {rule_name} to AWS WAF {waf_id}, domain={domain}',
+                                   rule_name=rule_name, waf_id=waf_arn, domain=domain)
+
+    def _remove_domain_rule_from_firewall(self, waf_arn: str, domain: str):
+        waf_data: dict[str, Any] = self._get_firewall_info(waf_arn)
+        rules: list[dict[str, Any]] = waf_data['WebACL']['Rules']
+        rule: Optional[dict[str, Any]] = self._find_rule(rules, domain)
+        if rule is None:
+            return
+        rules.remove(rule)
+        self._update_web_acl(waf_data, rules)
+        self.event_processor.event('Removed rule {rule_name} from AWS WAF {waf_id}, domain={domain}',
+                                   rule_name=rule['Name'], waf_id=waf_arn, domain=domain)
+
+    @classmethod
+    def _find_rule(cls, rules: list[dict[str, Any]], domain: str) -> Optional[dict[str, Any]]:
+        for rule in rules:
+            try:
+                rule_domain: str = rule['Statement']['ByteMatchStatement']['SearchString'].decode()
+            except KeyError:
+                continue
+            if rule_domain == domain:
+                return rule
+        return None
+
+    @classmethod
+    def _get_id_from_waf_arn(cls, waf_arn: str) -> str:
+        return waf_arn.split('/')[-1]
+
+    @classmethod
+    def _get_name_from_waf_arn(cls, waf_arn: str) -> str:
+        return waf_arn.split('/')[-2]
+
+    @classmethod
+    def _get_available_cidr(cls, vpc: AwsVpcData, subnet_mask: int) -> str:
+        vpc_network: Union[IPv4Network, IPv6Network] = ipaddress.ip_network(vpc.cidr_block)
+        subnets_cidrs: list[str] = [subnet.cidr_block for subnet in vpc.subnets]
+
+        # Find the first available subnet that does not overlap with existing subnets
+        for subnet in vpc_network.subnets(new_prefix=subnet_mask):
+            if not any(ipaddress.ip_network(used_cidr).overlaps(subnet) for used_cidr in subnets_cidrs):
+                return str(subnet)
+
+        raise AddressManagerException('No available CIDR block found for the new subnet')
+
+    def _create_bonus_subnet_if_needed(self, miner_vpc: AwsVpcData, miner_subnet: AwsSubnetData,
+                                       created_objects: MappingProxyType[str, frozenset[str]]) -> AwsSubnetData:
+        if AwsObjectTypes.SUBNET.value in created_objects:
+            assert len(created_objects[AwsObjectTypes.SUBNET.value]) == 1, "only one subnet should be created"
+            bonus_subnet_id: str = next(iter(created_objects[AwsObjectTypes.SUBNET.value]))
+            return self._get_subnet_data(bonus_subnet_id)
+
+        for subnet in miner_vpc.subnets:
+            if subnet.availability_zone != miner_subnet.availability_zone:
+                bonus_subnet_availability_zone: str = subnet.availability_zone
+                break
+        else:
+            raise AddressManagerException("Miner instance VPC doesn't have subnet in different availability zone")
+
+        # Create new subnet in the same VPC as miner instance, because ELB needs at least two subnets in different AZs
+        min_elb_subnet_mask: int = 27  # 27 as specified in documentation
+        bonus_subnet_cidr: str = self._get_available_cidr(miner_vpc, min_elb_subnet_mask)
+        bonus_subnet: AwsSubnetData = self._create_subnet(miner_vpc.vpc_id, bonus_subnet_cidr,
+                                                          bonus_subnet_availability_zone)
+        return bonus_subnet
+
+    def _create_target_group_if_needed(self, miner_vpc: AwsVpcData, miner_instance_id: str, miner_instance_port: int,
+                                       created_objects: MappingProxyType[str, frozenset[str]]) -> str:
+        if AwsObjectTypes.TARGET_GROUP.value in created_objects:
+            assert len(created_objects[AwsObjectTypes.TARGET_GROUP.value]) == 1, "only one group should be created"
+            target_group_id: str = next(iter(created_objects[AwsObjectTypes.TARGET_GROUP.value]))
+            return target_group_id
+
+        return self._create_target_group(miner_vpc, miner_instance_id, miner_instance_port)
+
+    def _create_security_group_if_needed(self, miner_vpc, miner_instance_port: int,
+                                         created_objects: MappingProxyType[str, frozenset[str]]) -> str:
+        if AwsObjectTypes.SECURITY_GROUP.value in created_objects:
+            assert len(created_objects[AwsObjectTypes.SECURITY_GROUP.value]) == 1, "only one group should be created"
+            security_group_id: str = next(iter(created_objects[AwsObjectTypes.SECURITY_GROUP.value]))
+            return security_group_id
+
+        return self._create_security_group(miner_vpc, miner_instance_port)
+
+    def _create_elb_if_needed(self, miner_instance: AwsEC2InstanceData, miner_port: int) -> AwsELBData:
+        created_objects: MappingProxyType[str, frozenset[str]] = \
+            self.state_manager.get_state().address_manager_created_objects
+
+        if AwsObjectTypes.ELB.value in created_objects:
+            assert len(created_objects[AwsObjectTypes.ELB.value]) == 1, "only one ELB should be created"
+            return self._get_elb_info(next(iter(created_objects[AwsObjectTypes.ELB.value])))
+
+        miner_vpc: AwsVpcData = self._get_vpc_data(miner_instance.vpc_id)
+        miner_subnet: AwsSubnetData = self._get_subnet_data(miner_instance.subnet_id)
+        bonus_subnet: AwsSubnetData = self._create_bonus_subnet_if_needed(miner_vpc, miner_subnet, created_objects)
+        target_group_id: str = self._create_target_group_if_needed(miner_vpc, miner_instance.instance_id,
+                                                                   miner_port, created_objects)
+        security_group_id: str = self._create_security_group_if_needed(miner_vpc, miner_port,
+                                                                       created_objects)
+        elb_id: str = self._create_elb(miner_instance, bonus_subnet, target_group_id, security_group_id)
+        return self._get_elb_info(elb_id)
+
+    def _create_firewall_if_needed(self) -> str:
+        created_objects: MappingProxyType[str, frozenset[str]] = \
+            self.state_manager.get_state().address_manager_created_objects
+        if AwsObjectTypes.WAF.value in created_objects:
+            assert len(created_objects[AwsObjectTypes.WAF.value]) == 1, "only one firewall should be created"
+            return next(iter(created_objects[AwsObjectTypes.WAF.value]))
+
+        return self._create_firewall()
diff --git a/bt_ddos_shield/blockchain_manager.py b/bt_ddos_shield/blockchain_manager.py
index 9d926f2..093ad2f 100644
--- a/bt_ddos_shield/blockchain_manager.py
+++ b/bt_ddos_shield/blockchain_manager.py
@@ -1,17 +1,58 @@
 from abc import ABC, abstractmethod
+from typing import Optional
+
+from bt_ddos_shield.address import (
+    AbstractAddressSerializer,
+    Address,
+    AddressDeserializationException,
+)
+from bt_ddos_shield.utils import Hotkey
+
+
+class BlockchainManagerException(Exception):
+    pass
 
 
 class AbstractBlockchainManager(ABC):
     """
-    Abstract base class for manager handling publishing blocks to blockchain.
+    Abstract base class for manager handling publishing address to blockchain.
     """
 
+    miner_hotkey: Hotkey
+    address_serializer: AbstractAddressSerializer
+
+    def __init__(self, miner_hotkey: Hotkey, address_serializer: AbstractAddressSerializer):
+        self.miner_hotkey = miner_hotkey
+        self.address_serializer = address_serializer
+
+    def put_miner_manifest_address(self, address: Address):
+        """
+        Put miner manifest address to blockchain.
+        """
+        self.put(self.miner_hotkey, self.address_serializer.serialize(address))
+
+    def get_miner_manifest_address(self) -> Optional[Address]:
+        """
+        Get miner manifest address from blockchain or None if not found or not valid.
+        """
+        serialized_address: Optional[bytes] = self.get(self.miner_hotkey)
+        if serialized_address is None:
+            return None
+        try:
+            return self.address_serializer.deserialize(serialized_address)
+        except AddressDeserializationException:
+            return None
+
     @abstractmethod
-    def publish(self, data: bytes):
+    def put(self, hotkey: Hotkey, data: bytes):
+        """
+        Put data to blockchain for given user identified by hotkey.
         """
-        Puts data to blockchain.
+        pass
 
-        Args:
-            data: Data.
+    @abstractmethod
+    def get(self, hotkey: Hotkey) -> Optional[bytes]:
+        """
+        Get data from blockchain for given user identified by hotkey or None if not found.
         """
         pass
diff --git a/bt_ddos_shield/encryption.py b/bt_ddos_shield/encryption.py
deleted file mode 100644
index 4737d52..0000000
--- a/bt_ddos_shield/encryption.py
+++ /dev/null
@@ -1,70 +0,0 @@
-import json
-from ecies import encrypt, decrypt
-
-
-class EncryptionError(Exception):
-    pass
-
-
-class DecryptionError(Exception):
-    pass
-
-
-class EncryptionManager:
-
-    @staticmethod
-    def encrypt_data(
-        public_key: str, data: dict, encoding: str = "utf-8"
-    ) -> bytes:
-        """
-        Encrypts the given data as a dictionary using the provided public key.
-
-        Args:
-            public_key (str): The public key in string format that will be used to encrypt the data.
-            data (dict): The data to be encrypted, represented as a dictionary.
-            encoding (str): Encoding format for the string representation of the data (default: 'utf-8').
-
-        Returns:
-            bytes: The encrypted data in bytes format.
-        """
-        if not isinstance(public_key, str):
-            raise TypeError(f"Public key must be of type str: {public_key}")
-
-        if not isinstance(data, dict):
-            raise TypeError(f"Data must be of type dict: {data}")
-
-        try:
-            data_str = json.dumps(data).encode(encoding=encoding)
-            encrypted_data = encrypt(public_key, data_str)
-            return encrypted_data
-        except Exception as e:
-            raise EncryptionError(f"Encryption failed: {e}")
-
-    @staticmethod
-    def decrypt_data(
-        private_key: str, encrypted_data: bytes, encoding: str = "utf-8"
-    ) -> dict:
-        """
-        Decrypts the given encrypted data using the provided private key.
-
-        Args:
-            private_key (str): The private key in string format used for decryption.
-            encrypted_data (bytes): The encrypted data to be decrypted.
-            encoding (str): Encoding format for the string representation of the data (default: 'utf-8').
-
-        Returns:
-            dict: The decrypted data, converted back to a dictionary.
-        """
-        if not isinstance(private_key, str):
-            raise TypeError(f"Private key must be of type str: {private_key}")
-
-        if not isinstance(encrypted_data, bytes):
-            raise TypeError(f"Encrypted data must be of type bytes: {encrypted_data}")
-
-        try:
-            decrypted_data = decrypt(private_key, encrypted_data)
-            decrypted_str = decrypted_data.decode(encoding=encoding)
-            decrypted_dict = json.loads(decrypted_str)
-            return decrypted_dict
-        except Exception as e:
-            raise DecryptionError(f"Decryption failed: {e}")
diff --git a/bt_ddos_shield/encryption_manager.py b/bt_ddos_shield/encryption_manager.py
new file mode 100644
index 0000000..a9fcefc
--- /dev/null
+++ b/bt_ddos_shield/encryption_manager.py
@@ -0,0 +1,56 @@
+from abc import ABC, abstractmethod
+
+import ecies
+
+from bt_ddos_shield.utils import PrivateKey, PublicKey
+
+
+class EncryptionManagerException(Exception):
+    pass
+
+
+class EncryptionError(EncryptionManagerException):
+    pass
+
+
+class DecryptionError(EncryptionManagerException):
+    pass
+
+
+class AbstractEncryptionManager(ABC):
+    """
+    Abstract base class for manager handling manifest file encryption.
+    """
+
+    @abstractmethod
+    def encrypt(self, public_key: PublicKey, data: bytes) -> bytes:
+        """
+        Encrypts given data using the provided public key.
+        """
+        pass
+
+    @abstractmethod
+    def decrypt(self, private_key: PrivateKey, data: bytes) -> bytes:
+        """
+        Decrypts given data using the provided private key.
+        """
+        pass
+
+
+class ECIESEncryptionManager(AbstractEncryptionManager):
+    """
+    Encryption manager implementation using ECIES algorithm. Public and private keys are Ethereum (secp256k1) keys
+    in hex format.
+    """
+
+    def encrypt(self, public_key: PublicKey, data: bytes) -> bytes:
+        try:
+            return ecies.encrypt(public_key, data)
+        except Exception as e:
+            raise EncryptionError(f"Encryption failed: {e}") from e
+
+    def decrypt(self, private_key: PrivateKey, data: bytes) -> bytes:
+        try:
+            return ecies.decrypt(private_key, data)
+        except Exception as e:
+            raise DecryptionError(f"Decryption failed: {e}") from e
diff --git a/bt_ddos_shield/event_processor.py b/bt_ddos_shield/event_processor.py
index b398942..0286076 100644
--- a/bt_ddos_shield/event_processor.py
+++ b/bt_ddos_shield/event_processor.py
@@ -1,28 +1,63 @@
+import traceback
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
+from datetime import datetime
+from sys import stdout
+from typing import Any
 
 
-@dataclass
-class Event:
+class MinerShieldEvent:
     """
     Class describing event, which happened in the shield.
     """
 
-    event_description: str       # Description of the event.
-    exception: Exception = None  # Exception which caused the event.
+    date: datetime            # Date of the event.
+    template: str             # Template of the event.
+    exception: Exception      # Exception which caused the event.
+    metadata: dict[str, Any]  # Additional metadata.
+    description: str          # Description of the event (template filled with metadata).
 
+    def __init__(self, template: str, exception: Exception = None, **metadata):
+        """
+        Args:
+            template: Template of the event (used to generate description).
+            exception: Exception which caused the event.
+            metadata: Additional metadata (used also to generate description).
+        """
+        self.date = datetime.now()
+        self.template = template
+        self.exception = exception
+        self.metadata = metadata
+        self.description = template.format(**metadata)
 
-class AbstractEventProcessor(ABC):
+
+class AbstractMinerShieldEventProcessor(ABC):
     """
     Abstract base class for processor handling events generated by shield.
     """
 
-    @abstractmethod
-    def add_event(self, event: Event):
+    def event(self, template: str, exception: Exception = None, **kwargs):
         """
-        Add new event to be handled by processor.
+        Add event to event processor.
 
         Args:
-            event: Event to add.
+            template: Description template to be filled using kwargs.
+            exception: Exception to be attached to event.
+            kwargs: Event params. Used also to fill template.
         """
+        return self._add_event(MinerShieldEvent(template, exception, **kwargs))
+
+    @abstractmethod
+    def _add_event(self, event: MinerShieldEvent):
         pass
+
+
+class PrintingMinerShieldEventProcessor(AbstractMinerShieldEventProcessor):
+    """
+    Event processor which logs events to console.
+    """
+
+    def _add_event(self, event: MinerShieldEvent):
+        print(f"{event.date}: MinerShieldEvent: {event.description}\nMetadata: {event.metadata}")
+        if event.exception is not None:
+            print("Exception happened:")
+            traceback.print_exception(event.exception, file=stdout)
diff --git a/bt_ddos_shield/manifest_manager.py b/bt_ddos_shield/manifest_manager.py
index 4960535..e7cd05c 100644
--- a/bt_ddos_shield/manifest_manager.py
+++ b/bt_ddos_shield/manifest_manager.py
@@ -1,7 +1,120 @@
+import base64
+import hashlib
+import json
 from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Any, Optional
 
-from bt_ddos_shield.address import Address
-from bt_ddos_shield.miner_shield import Hotkey
+from botocore.client import BaseClient
+from botocore.exceptions import ClientError
+
+from bt_ddos_shield.address import (
+    AbstractAddressSerializer,
+    Address,
+    AddressDeserializationException,
+    AddressType,
+)
+from bt_ddos_shield.encryption_manager import AbstractEncryptionManager
+from bt_ddos_shield.utils import AWSClientFactory, Hotkey, PrivateKey, PublicKey
+
+
+class ManifestManagerException(Exception):
+    pass
+
+
+class ManifestDeserializationException(ManifestManagerException):
+    """
+    Exception thrown when deserialization of manifest data fails.
+    """
+    pass
+
+
+class ManifestNotFoundException(ManifestManagerException):
+    """
+    Exception thrown when manifest file is not found under given address.
+    """
+    pass
+
+
+@dataclass
+class Manifest:
+    """
+    Class representing manifest file containing encrypted addresses for validators.
+    """
+
+    encrypted_address_mapping: dict[Hotkey, bytes]
+    """ Mapping with addresses for validators (validator HotKey -> encrypted address) """
+    md5_hash: str
+    """ MD5 hash of the manifest data """
+
+
+class AbstractManifestSerializer(ABC):
+    """
+    Class used to serialize and deserialize manifest file.
+    """
+
+    @abstractmethod
+    def serialize(self, manifest: Manifest) -> bytes:
+        """
+        Serialize manifest. Output format depends on the implementation.
+        """
+        pass
+
+    @abstractmethod
+    def deserialize(self, serialized_data: bytes) -> Manifest:
+        """
+        Deserialize manifest. Throws ManifestDeserializationException if data format is not recognized.
+        """
+        pass
+
+
+class JsonManifestSerializer(AbstractManifestSerializer):
+    """
+    Manifest serializer implementation which serialize manifest to Json.
+    """
+
+    encoding: str
+
+    def __init__(self, encoding: str = "utf-8"):
+        """
+        Args:
+            encoding: Encoding used for transforming Json string to bytes.
+        """
+        self.encoding = encoding
+
+    def serialize(self, manifest: Manifest) -> bytes:
+        data: dict = {
+            "encrypted_address_mapping": manifest.encrypted_address_mapping,
+            "md5_hash": manifest.md5_hash
+        }
+        json_str: str = json.dumps(data, default=self._custom_encoder)
+        return json_str.encode(encoding=self.encoding)
+
+    def deserialize(self, serialized_data: bytes) -> Manifest:
+        try:
+            json_str: str = serialized_data.decode(encoding=self.encoding)
+            data = json.loads(json_str, object_hook=self._custom_decoder)
+            return Manifest(data["encrypted_address_mapping"], data["md5_hash"])
+        except Exception as e:
+            raise ManifestDeserializationException(f"Failed to deserialize manifest data: {e}") from e
+
+    @staticmethod
+    def _custom_encoder(obj: Any) -> Any:
+        if isinstance(obj, Hotkey):
+            return str(obj)
+
+        if isinstance(obj, bytes):
+            return base64.b64encode(obj).decode()
+
+    @staticmethod
+    def _custom_decoder(json_mapping: dict[str, Any]) -> Any:
+        if "encrypted_address_mapping" in json_mapping:
+            decoded_mapping: dict[Hotkey, bytes] = {}
+            for hotkey, encoded_address in json_mapping["encrypted_address_mapping"].items():
+                decoded_mapping[Hotkey(hotkey)] = base64.b64decode(encoded_address.encode())
+            json_mapping["encrypted_address_mapping"] = decoded_mapping
+        return json_mapping
 
 
 class AbstractManifestManager(ABC):
@@ -9,28 +122,145 @@ class AbstractManifestManager(ABC):
     Abstract base class for manager handling publishing manifest file containing encrypted addresses for validators.
     """
 
-    def add_mapping_file(self, address_mapping: dict[Hotkey, Address]) -> Address:
+    address_serializer: AbstractAddressSerializer
+    manifest_serializer: AbstractManifestSerializer
+    encryption_manager: AbstractEncryptionManager
+
+    def __init__(self, address_serializer: AbstractAddressSerializer, manifest_serializer: AbstractManifestSerializer,
+                 encryption_manager: AbstractEncryptionManager):
+        self.address_serializer = address_serializer
+        self.manifest_serializer = manifest_serializer
+        self.encryption_manager = encryption_manager
+
+    def upload_manifest(self, manifest: Manifest) -> Address:
+        data: bytes = self.manifest_serializer.serialize(manifest)
+        return self._put_manifest_file(data)
+
+    def create_manifest(self, address_mapping: MappingProxyType[Hotkey, Address],
+                        validators_public_keys: MappingProxyType[Hotkey, PublicKey]) -> Manifest:
         """
-        Adds a mapping as file with encrypted addresses to the storage.
+        Create manifest with encrypted addresses for validators.
 
         Args:
-            address_mapping: A dictionary containing the address mapping (validator HotKey -> Address).
+            address_mapping: Dictionary containing address mapping (validator HotKey -> Address).
+            validators_public_keys: Dictionary containing public keys of validators (validator HotKey -> PublicKey).
+        """
+        encrypted_address_mapping: dict[Hotkey, bytes] = {}
+        md5_hash = hashlib.md5()
+
+        for hotkey, address in address_mapping.items():
+            public_key: PublicKey = validators_public_keys[hotkey]
+            serialized_address: bytes = self.address_serializer.serialize(address)
+            encrypted_address_mapping[hotkey] = self.encryption_manager.encrypt(public_key, serialized_address)
+
+            md5_hash.update(hotkey.encode())
+            public_key_bytes: bytes = public_key.encode() if isinstance(public_key, str) else public_key
+            md5_hash.update(public_key_bytes)
+            md5_hash.update(serialized_address)
+
+        return Manifest(encrypted_address_mapping, md5_hash.hexdigest())
+
+    def get_manifest(self, address: Address) -> Manifest:
+        """
+        Get manifest file from given address and deserialize it. Throws ManifestDeserializationException if data format
+        is not recognized.
+        """
+        raw_data: bytes = self._get_manifest_file(address)
+        return self.manifest_serializer.deserialize(raw_data)
+
+    def get_address_for_validator(self, manifest: Manifest, validator_hotkey: Hotkey,
+                                  validator_private_key: PrivateKey) -> Address:
+        """
+        Get address for validator identified by hotkey from manifest. Decrypts address using validator's private key.
+        """
+        encrypted_address: bytes = manifest.encrypted_address_mapping[validator_hotkey]
+        decrypted_address: bytes = self.encryption_manager.decrypt(validator_private_key, encrypted_address)
+        return self.address_serializer.deserialize(decrypted_address)
+
+    @abstractmethod
+    def _put_manifest_file(self, data: bytes) -> Address:
+        """
+        Put manifest file into the storage. Should remove old manifest file if it exists.
 
         Returns:
-            Address: Address where file is put.
+            Address: Address for accessing file.
         """
-        # TODO - add implementation (encrypt with EncryptionManager and call put_file)
         pass
 
     @abstractmethod
-    def _put_file(self, data: bytes) -> Address:
+    def _get_manifest_file(self, address: Address) -> bytes:
+        """
+        Get manifest file from given address. Should throw ManifestNotFoundException if file is not found.
         """
-        Puts a file into the storage.
+        pass
 
-        Args:
-            data: File contents.
 
-        Returns:
-            Address: Address where file is put.
+class S3ManifestManager(AbstractManifestManager):
+    """
+    Manifest manager using AWS S3 service to manage file.
+    """
+
+    MANIFEST_FILE_NAME: str = "miner_manifest.json"
+
+    bucket_name: Optional[str]
+    aws_client_factory: AWSClientFactory
+    _s3_client: Optional[BaseClient]
+
+    def __init__(self, address_serializer: AbstractAddressSerializer, manifest_serializer: AbstractManifestSerializer,
+                 encryption_manager: AbstractEncryptionManager,
+                 aws_client_factory: AWSClientFactory, bucket_name: Optional[str] = None):
         """
-        pass
+        Creates S3ManifestManager instance. bucket_name and aws_region_name inside aws_client_factory can be None when
+        used on Validator side and in such case these fields will be initialized from address when getting manifest
+        file.
+        """
+        super().__init__(address_serializer, manifest_serializer, encryption_manager)
+        self.aws_client_factory = aws_client_factory
+        self.bucket_name = bucket_name
+        self._s3_client = None
+
+    def _init_client_from_address(self, address: Address):
+        region_name, bucket_name, _ = self._deserialize_manifest_address(address)
+        if self.aws_client_factory.set_aws_region_name(region_name):
+            self._s3_client = None
+        self.bucket_name = bucket_name
+
+    @property
+    def s3_client(self):
+        if self._s3_client is None:
+            self._s3_client = self.aws_client_factory.boto3_client("s3")
+        return self._s3_client
+
+    def _put_manifest_file(self, data: bytes) -> Address:
+        file_key: str = self.MANIFEST_FILE_NAME
+        self.s3_client.put_object(Bucket=self.bucket_name, Key=file_key, Body=data)
+        serialized_address: str = self._serialize_manifest_address(self.aws_client_factory.aws_region_name,
+                                                                   self.bucket_name, file_key)
+        return Address(address_id=file_key, address_type=AddressType.S3, address=serialized_address, port=0)
+
+    def _get_manifest_file(self, address: Address) -> bytes:
+        self._init_client_from_address(address)
+        try:
+            response = self.s3_client.get_object(Bucket=self.bucket_name, Key=address.address_id)
+            return response['Body'].read()
+        except ClientError as e:
+            if e.response['Error']['Code'] == "NoSuchKey":
+                raise ManifestNotFoundException(f"File {address.address_id} not found")
+            raise e
+
+    @classmethod
+    def _serialize_manifest_address(cls, region_name: str, bucket_name: str, file_key: str) -> str:
+        return f"{region_name}/{bucket_name}/{file_key}"
+
+    @classmethod
+    def _deserialize_manifest_address(cls, address: Address) -> tuple[str, str, str]:
+        if address.address_type != AddressType.S3:
+            raise AddressDeserializationException(f"Invalid address type, address='{address}'")
+        parts = address.address.split("/")
+        if len(parts) != 3:
+            raise AddressDeserializationException(f"Invalid number of parts, address='{address}'")
+
+        region_name = parts[0]
+        bucket_name = parts[1]
+        file_key = parts[2]
+        return region_name, bucket_name, file_key
diff --git a/bt_ddos_shield/message.py b/bt_ddos_shield/message.py
deleted file mode 100644
index f5e7de9..0000000
--- a/bt_ddos_shield/message.py
+++ /dev/null
@@ -1,8 +0,0 @@
-class Message:
-    @staticmethod
-    def create_message():
-        pass
-
-    @staticmethod
-    def validate_message():
-        pass
diff --git a/bt_ddos_shield/miner_shield.py b/bt_ddos_shield/miner_shield.py
index 5c36f7f..b96bff0 100644
--- a/bt_ddos_shield/miner_shield.py
+++ b/bt_ddos_shield/miner_shield.py
@@ -1,74 +1,631 @@
+import os
+import re
+import threading
+from abc import ABC, abstractmethod
 from dataclasses import dataclass
+from queue import Queue
+from time import sleep
+from types import MappingProxyType
+from typing import Optional
 
-from bt_ddos_shield.blockchain_manager import AbstractBlockchainManager
-from bt_ddos_shield.event_processor import AbstractEventProcessor
-from bt_ddos_shield.address_manager import AbstractAddressManager
-from bt_ddos_shield.validators_manager import AbstractValidatorsManager
-from bt_ddos_shield.manifest_manager import AbstractManifestManager
-from bt_ddos_shield.state_manager import AbstractMinerShieldStateManager
-
+from tests.test_blockchain_manager import MemoryBlockchainManager
 
-Hotkey = str # type of Hotkey
+from bt_ddos_shield.address import AbstractAddressSerializer, Address, AddressType, DefaultAddressSerializer
+from bt_ddos_shield.address_manager import AbstractAddressManager, AwsAddressManager
+from bt_ddos_shield.blockchain_manager import AbstractBlockchainManager
+from bt_ddos_shield.encryption_manager import AbstractEncryptionManager, ECIESEncryptionManager
+from bt_ddos_shield.event_processor import AbstractMinerShieldEventProcessor, PrintingMinerShieldEventProcessor
+from bt_ddos_shield.manifest_manager import (
+    AbstractManifestManager,
+    AbstractManifestSerializer,
+    JsonManifestSerializer,
+    Manifest,
+    ManifestDeserializationException,
+    ManifestNotFoundException,
+    S3ManifestManager,
+)
+from bt_ddos_shield.state_manager import (
+    AbstractMinerShieldStateManager,
+    MinerShieldState,
+    SQLAlchemyMinerShieldStateManager,
+)
+from bt_ddos_shield.utils import AWSClientFactory, Hotkey, PublicKey
+from bt_ddos_shield.validators_manager import AbstractValidatorsManager, MemoryValidatorsManager
 
 
 @dataclass
 class MinerShieldOptions:
     """
-        A class to represent the configuration options for the MinerShield.
+    A class to represent the configuration options for the MinerShield.
+    """
+
+    auto_hide_original_server: bool = False
+    """
+    If True, the original server will be hidden after some time after shield gets enabled. Method hide_original_server
+    in AddressManager will be called.
     """
 
-    auto_hide_original_server: bool = False # If True, the original server will be hidden after some time after shield
-                                            # gets enabled. Method hide_original_server in AddressManager will be called.
+    auto_hide_delay_sec: int = 1200
+    """ Time in seconds after which the original server will be hidden if auto_hide_original_server is set to True. """
+
+    retry_delay_sec: int = 5
+    """ Time in seconds to wait before retrying failed task. """
+
+    validate_interval_sec: int = 120
+    """
+    Time in seconds between cyclic calls of validate task. It checks if every part of shield is working
+    correctly.
+    """
 
-    auto_hide_delay_sec: int = 600          # Time in seconds after which the original server will be hidden if
-                                            # auto_hide_original_server is set to True.
+
+class MinerShieldException(Exception):
+    pass
+
+
+class MinerShieldDisabledException(MinerShieldException):
+    """
+    Exception raised when shield is disabled and user want to schedule some action to it.
+    """
+    pass
 
 
 class MinerShield:
     """
-    Main class to be used by Miner to shield himself from DDoS. Call enable() to start the shield.
+    Main class to be used by Miner to shield himself from DDoS. Call enable() to start the shield. No methods in
+    managers should be called directly. All operations are done by worker thread. After starting shield user can
+    schedule tasks to be executed asynchronously.
     """
 
-    def __init__(self, validators_manager: AbstractValidatorsManager, address_manager: AbstractAddressManager,
-                 manifest_manager: AbstractManifestManager, blockchain_manager: AbstractBlockchainManager,
-                 state_manager: AbstractMinerShieldStateManager, event_processor: AbstractEventProcessor,
-                 options: MinerShieldOptions):
-        """
-        Initialize the MinerShield class.
+    miner_hotkey: Hotkey  # hotkey of shielded miner
+    worker_thread: Optional[threading.Thread]  # main thread executing tasks
+    task_queue: Queue['AbstractMinerShieldTask']  # queue of tasks to be executed
+    run: bool  # flag meaning if shield is running
+    finishing: bool  # flag meaning if shield should finish its work
+    ticker: threading.Event  # ticker to be used in ticker_thread
+    ticker_thread: Optional[threading.Thread]  # thread used to schedule validate operation cyclically
+    validators_manager: AbstractValidatorsManager  # used to manage validators and their keys
+    address_manager: AbstractAddressManager  # used to manage public IP/domain addresses assigned to validators
+    manifest_manager: AbstractManifestManager  # used to manage publishing manifest file
+    blockchain_manager: AbstractBlockchainManager  # used to manage blockchain operations
+    state_manager: AbstractMinerShieldStateManager  # used to manage state of the shield
+    event_processor: AbstractMinerShieldEventProcessor  # used to handle events generated by the shield
+    options: MinerShieldOptions  # configuration options for shield
 
-        Args:
-            validators_manager: Instance of AbstractValidatorsManager to manage validators and their keys.
-            address_manager: Instance of AbstractAddressManager to manage public IP/domain addresses assigned to validators.
-            manifest_manager: Instance of AbstractManifestManager to manage publishing manifest file.
-            blockchain_manager: Instance of AbstractBlockchainManager to manage blockchain operations.
-            state_manager: Instance of AbstractMinerShieldStateManager to manage state of the shield.
-            event_processor: Instance of AbstractEventProcessor to handle events generated by the shield.
-            options: Instance of MinerShieldOptions.
-        """
-        pass
+    def __init__(self, miner_hotkey: Hotkey, validators_manager: AbstractValidatorsManager,
+                 address_manager: AbstractAddressManager, manifest_manager: AbstractManifestManager,
+                 blockchain_manager: AbstractBlockchainManager, state_manager: AbstractMinerShieldStateManager,
+                 event_processor: AbstractMinerShieldEventProcessor, options: MinerShieldOptions):
+        self.miner_hotkey = miner_hotkey
+        self.validators_manager = validators_manager
+        self.address_manager = address_manager
+        self.manifest_manager = manifest_manager
+        self.blockchain_manager = blockchain_manager
+        self.state_manager = state_manager
+        self.event_processor = event_processor
+        self.options = options
+
+        self.worker_thread = None
+        self.task_queue = Queue()
+        self.run = False
+        self.finishing = False
+        self.ticker = threading.Event()
+        self.ticker_thread = None
 
     def enable(self):
         """
-        Enable shield. It asynchronously starts the shield, which consists of such steps:
+        Enable shield. It starts worker thread, which will do such steps if run for the first time:
         1. Fetch validators keys.
         2. Creates addresses for all validators.
         3. Save manifest file.
         4. Publish link to manifest file to blockchain.
         5. Eventually close public access to original IP after some time.
 
-        It puts events to event_manager after each step. Current state is managed by state_manager. If shielding
-        process had been interrupted it is continued from the last step.
+        It puts events to event_manager after each finished operation. Current state is managed by state_manager.
+        If any error occurs it is retried forever until shield is disabled.
 
-        When shield is running, changing validators set triggers shield reconfiguration.
+        When shield is running, user can schedule tasks to be processed by worker.
         """
-        pass
+        if self.worker_thread is not None:
+            # already started
+            return
+
+        self.finishing = False
+        self.ticker.clear()
+        self.run = True
+        self._add_task(MinerShieldInitializeTask())
+        self.worker_thread = threading.Thread(target=self._worker_function)
+        self.worker_thread.start()
+
+    def disable(self):
+        """
+        Disable shield. It stops worker thread after finishing current task. Function blocks until worker is stopped.
+        """
+        self._add_task(MinerShieldDisableTask())
+
+        self.finishing = True
+        self.ticker.set()
+
+        if self.worker_thread is not None:
+            self.worker_thread.join()
+            self.worker_thread = None
+
+        self.task_queue = Queue()  # Clear task queue
+
+        if self.ticker_thread is not None:
+            self.ticker_thread.join()
+            self.ticker_thread = None
 
     def ban_validator(self, validator_hotkey: Hotkey):
         """
-        Ban a validator by its hotkey. Function blocks execution until manifest file is updated and info about file
-        is published to Bittensor.
+        Ban a validator by its hotkey. Task will be executed by worker. It will update manifest file and publish info
+        about new file version to blockchain.
+        """
+        self._add_task(MinerShieldBanValidatorTask(validator_hotkey))
 
-        Args:
-            validator_hotkey: The hotkey of the validator.
+    def _add_task(self, task: 'AbstractMinerShieldTask'):
+        """
+        Add task to task queue. It will be handled by _worker_function.
+        """
+        if not self.run:
+            raise MinerShieldDisabledException()
+
+        self.task_queue.put(task)
+
+    def _worker_function(self):
+        """
+        Function called in separate thread by enable() to start the shield. It is handling events put to task_queue.
+        """
+        self._event("Starting shield")
+
+        while self.run:
+            task: AbstractMinerShieldTask = self.task_queue.get()
+            try_count: int = 1
+
+            while self.run:
+                self._event("Handling task {task}, try {try_count}", task=task, try_count=try_count)
+
+                try:
+                    task.run(self)
+                    self._event("Task {task} finished successfully", task=task)
+                    break
+                except Exception as e:
+                    self._event("Error during handling task {task}", e, task=task)
+
+                    if self.finishing:
+                        break
+
+                    try_count += 1
+                    sleep(self.options.retry_delay_sec)
+
+        self._event("Stopping shield")
+
+    def _ticker_function(self):
+        while not self.ticker.wait(self.options.validate_interval_sec):
+            self._add_task(MinerShieldValidateStateTask())
+
+    def _handle_initialize(self):
+        self._handle_validate_state(first_run=True)
+        self.ticker_thread = threading.Thread(target=self._ticker_function)
+        self.ticker_thread.start()
+
+    def _reload_state(self, first_run: bool):
+        try:
+            self.state_manager.get_state(reload=True)
+            self._event("State reloaded")
+        except Exception as e:
+            self._event("Error during reloading state", e)
+            if first_run:
+                # We cannot continue without initial shield state
+                raise e
+
+    def _reload_validators(self, first_run: bool) -> bool:
+        """
+        Reload validators from validators manager.
+
+        Returns:
+             bool: If validators set is different from one currently stored in shield state.
+        """
+        try:
+            self.validators_manager.reload_validators()
+            fetched_validators: MappingProxyType[Hotkey, PublicKey] = self.validators_manager.get_validators()
+
+            deprecated_validators, new_validators, changed_validators = \
+                self._calculate_validators_diff(self.state_manager.get_state(), fetched_validators)
+            validators_changed: bool = bool(deprecated_validators) or bool(new_validators) or bool(changed_validators)
+
+            self._event("Validators reloaded, got {validators_count} validators, "
+                        "validators_changed={validators_changed}",
+                        validators_count=len(fetched_validators), validators_changed=validators_changed)
+
+            return validators_changed
+        except Exception as e:
+            self._event("Error during reloading validators", e)
+            if first_run:
+                # We cannot continue without initial validators state
+                raise e
+
+        return False
+
+    def _validate_addresses(self, first_run: bool) -> bool:
+        """
+        Validate addresses used by validators. Remove validators with invalid addresses from shield state - they will
+        be added again with new addresses in a moment.
+
+        Returns:
+             bool: If any validators were removed.
+        """
+        validators_changed: bool = False
+        try:
+            current_state: MinerShieldState = self.state_manager.get_state()
+            invalid_addresses: set[Hotkey] = self.address_manager.validate_addresses(current_state.validators_addresses)
+            if invalid_addresses:
+                self._event("Removing invalid addresses for given validators: {invalid_addresses}",
+                            invalid_addresses=invalid_addresses)
+                for validator in invalid_addresses:
+                    self.state_manager.remove_validator(validator)
+                    validators_changed = True
+        except Exception as e:
+            self._event("Error during validating addresses", e)
+            if first_run:
+                # We cannot continue without initializing address_manager
+                raise e
+            # If error happens later, just proceed. It is only validation, and it will be called again
+            # by _ticker_function.
+
+        return validators_changed
+
+    def _validate_manifest_file(self) -> bool:
+        """
+        Validate manifest file by comparing uploaded content with expected one. Returns if it is valid.
+        """
+        try:
+            current_state: MinerShieldState = self.state_manager.get_state()
+            if current_state.manifest_address is None:
+                return False
+            new_manifest: Manifest = self.manifest_manager.create_manifest(current_state.validators_addresses,
+                                                                           current_state.known_validators)
+            current_manifest: Manifest = self.manifest_manager.get_manifest(current_state.manifest_address)
+            same_content: bool = new_manifest.md5_hash == current_manifest.md5_hash
+            self._event("Manifest file validation finished, same content={same_content}",
+                        same_content=same_content)
+            return same_content
+        except (ManifestNotFoundException, ManifestDeserializationException):
+            return False
+        except Exception as e:
+            self._event("Error during validating manifest file", e)
+            # if error happened, assume that manifest file is valid - it is only validation, and it will be called
+            # again by _ticker_function
+            return True
+
+    def _handle_validate_state(self, first_run: bool = False):
+        """
+        Refresh all data and validate current state of shield. If shield is not yet fully working, it will finish
+        startup process. If something is wrong, it will be fixed.
+        """
+        self._reload_state(first_run)
+        validators_changed: bool = self._reload_validators(first_run)
+        if self._validate_addresses(first_run):
+            validators_changed = True
+
+        if validators_changed:
+            self._add_task(MinerShieldValidatorsChangedTask())
+            # do not validate manifest, because it will be updated in the moment
+            return
+
+        if not self._validate_manifest_file():
+            self._add_task(MinerShieldUpdateManifestTask())
+            # do not validate manifest info, because it will be updated in the moment
+            return
+
+        # this will validate manifest info and will publish new one only if needed
+        self._add_task(MinerShieldPublishManifestTask())
+
+    def _handle_disable(self):
+        self.run = False
+
+    @classmethod
+    def _calculate_validators_diff(cls, current_state: MinerShieldState,
+                                   fetched_validators: MappingProxyType[Hotkey, PublicKey]):
+        """
+        Calculates difference between newly fetched validators set and one saved in state and returns validators
+        which should be removed, added or updated.
+        """
+        # remove banned validators from fetched validators
+        fetched_not_banned_validators: dict[Hotkey, PublicKey] = dict(fetched_validators)
+        for banned_validator in current_state.banned_validators.keys():
+            fetched_not_banned_validators.pop(banned_validator, None)
+
+        # calculate difference between current state and fetched validators
+        deprecated_validators = current_state.known_validators.keys() - fetched_not_banned_validators.keys()
+        new_validators = fetched_not_banned_validators.keys() - current_state.known_validators.keys()
+        common_validators = fetched_not_banned_validators.keys() & current_state.known_validators.keys()
+        changed_validators = {
+            k: fetched_not_banned_validators[k] for k in common_validators
+            if fetched_not_banned_validators[k] != current_state.known_validators[k]
+        }
+
+        return deprecated_validators, new_validators, changed_validators
+
+    def _handle_deprecated_validators(self, current_state: MinerShieldState, deprecated_validators: set[Hotkey]):
+        for validator in deprecated_validators:
+            self._event("Removing validator {validator}", validator=validator)
+
+            active_validator_addresses = current_state.validators_addresses
+            if validator in active_validator_addresses:
+                self.address_manager.remove_address(active_validator_addresses[validator])
+
+            self.state_manager.remove_validator(validator)
+
+    def _handle_new_validators(self, fetched_validators: MappingProxyType[Hotkey, PublicKey],
+                               new_validators: set[Hotkey]):
+        for validator in new_validators:
+            self._event("Adding validator {validator}", validator=validator)
+
+            new_address: Address = self.address_manager.create_address(validator)
+
+            try:
+                self.state_manager.add_validator(validator, fetched_validators[validator], new_address)
+            except Exception as e:
+                self.address_manager.remove_address(new_address)
+                raise e
+
+    def _handle_changed_validators(self, changed_validators: dict[Hotkey, PublicKey]):
+        for validator, new_key in changed_validators.items():
+            self._event("Updating validator {validator}", validator=validator)
+            self.state_manager.update_validator_public_key(validator, new_key)
+
+    def _handle_validators_change(self):
+        current_state: MinerShieldState = self.state_manager.get_state()
+        fetched_validators: MappingProxyType[Hotkey, PublicKey] = self.validators_manager.get_validators()
+
+        deprecated_validators, new_validators, changed_validators = \
+            self._calculate_validators_diff(current_state, fetched_validators)
+
+        self._event(
+            "Handling validators change, deprecated_validators count={deprecated_validators_count}"
+            ", new_validators count={new_validators_count}, changed_validators count={changed_validators_count}",
+            deprecated_validators_count=len(deprecated_validators), new_validators_count=len(new_validators),
+            changed_validators_count=len(changed_validators)
+        )
+
+        self._handle_deprecated_validators(current_state, deprecated_validators)
+        self._handle_new_validators(fetched_validators, new_validators)
+        self._handle_changed_validators(changed_validators)
+
+        if deprecated_validators or new_validators or changed_validators:
+            # if anything changed update manifest file and publish new version to blockchain
+            self._add_task(MinerShieldUpdateManifestTask())
+
+    def _handle_ban_validator(self, validator_hotkey: Hotkey):
+        """
+        Ban validator by its hotkey. If something changed, MinerShieldValidatorsChangedTask will apply asynchronously
+        this change where needed.
+        """
+        self.state_manager.add_banned_validator(validator_hotkey)
+        self._event("Validator {validator_hotkey} added to banned set", validator_hotkey=validator_hotkey)
+        self._add_task(MinerShieldValidatorsChangedTask())
+
+    def _handle_update_manifest(self):
+        """
+        Update manifest file and schedule publishing it to blockchain.
+        """
+        current_state: MinerShieldState = self.state_manager.get_state()
+        manifest: Manifest = self.manifest_manager.create_manifest(current_state.validators_addresses,
+                                                                   current_state.known_validators)
+        address: Address = self.manifest_manager.upload_manifest(manifest)
+        self.state_manager.set_manifest_address(address)
+        self._event("Manifest updated, new address: {address}", address=address)
+        self._add_task(MinerShieldPublishManifestTask())
+
+    def _handle_publish_manifest(self):
+        """
+        Publish info about current manifest file to blockchain if it is not already there.
+        """
+        expected_address: Address = self.state_manager.get_state().manifest_address
+        current_address: Address = self.blockchain_manager.get_miner_manifest_address()
+        if current_address == expected_address:
+            self._event("Manifest address already published")
+        else:
+            self.blockchain_manager.put_miner_manifest_address(expected_address)
+            self._event("Manifest published")
+
+    def _event(self, template: str, exception: Exception = None, **kwargs):
+        return self.event_processor.event(template, exception, **kwargs)
+
+
+class AbstractMinerShieldTask(ABC):
+    """
+    Task to be executed by shield worker.
+    """
+
+    NAME_DELETER = re.compile(r'^MinerShield(.*)Task$')
+
+    @abstractmethod
+    def run(self, miner_shield: MinerShield):
+        """
+        Run task in miner_shield context.
         """
         pass
+
+    def __repr__(self):
+        return self.NAME_DELETER.sub(r'\1', self.__class__.__name__)
+
+
+class MinerShieldInitializeTask(AbstractMinerShieldTask):
+    def run(self, miner_shield: MinerShield):
+        # noinspection PyProtectedMember
+        miner_shield._handle_initialize()
+
+
+class MinerShieldDisableTask(AbstractMinerShieldTask):
+    def run(self, miner_shield: MinerShield):
+        # noinspection PyProtectedMember
+        miner_shield._handle_disable()
+
+
+class MinerShieldValidateStateTask(AbstractMinerShieldTask):
+    def run(self, miner_shield: MinerShield):
+        # noinspection PyProtectedMember
+        miner_shield._handle_validate_state()
+
+
+class MinerShieldValidatorsChangedTask(AbstractMinerShieldTask):
+    def run(self, miner_shield: MinerShield):
+        # noinspection PyProtectedMember
+        miner_shield._handle_validators_change()
+
+
+class MinerShieldBanValidatorTask(AbstractMinerShieldTask):
+    def __init__(self, validator_hotkey: Hotkey):
+        self.validator_hotkey = validator_hotkey
+
+    def run(self, miner_shield: MinerShield):
+        # noinspection PyProtectedMember
+        miner_shield._handle_ban_validator(self.validator_hotkey)
+
+
+class MinerShieldUpdateManifestTask(AbstractMinerShieldTask):
+    def run(self, miner_shield: MinerShield):
+        # noinspection PyProtectedMember
+        miner_shield._handle_update_manifest()
+
+
+class MinerShieldPublishManifestTask(AbstractMinerShieldTask):
+    def run(self, miner_shield: MinerShield):
+        # noinspection PyProtectedMember
+        miner_shield._handle_publish_manifest()
+
+
+class MinerShieldFactory:
+    """
+    Factory class to create proper MinerShield instance basing on set environmental variables.
+    """
+
+    @classmethod
+    def create_miner_shield(cls, validators: Optional[dict[Hotkey, PublicKey]] = None) -> MinerShield:
+        """
+        Create MinerShield instance basing on set environmental variables.
+
+        List of required env variables:
+        - MINER_HOTKEY: Hotkey of shielded miner.
+        - AWS_MINER_INSTANCE_ID or AWS_MINER_INSTANCE_IP: AWS instance ID or IP of miner machine.
+        - MINER_INSTANCE_PORT: Port on which miner instance is listening.
+        - AWS_ACCESS_KEY_ID: AWS access key ID.
+        - AWS_SECRET_ACCESS_KEY: AWS secret access key.
+        - AWS_REGION_NAME: AWS region name.
+        - AWS_S3_BUCKET_NAME: AWS S3 bucket name.
+        - AWS_ROUTE53_HOSTED_ZONE_ID: AWS Route53 hosted zone ID for creating DNS entries for validators.
+        - SQL_ALCHEMY_DB_URL: URL to SQL database to store shield state.
+
+        Optional env variables:
+        - AUTO_HIDE_ORIGINAL_SERVER: If set, original server will be hidden after some time after shield gets enabled.
+        - AUTO_HIDE_DELAY_SEC: Time in seconds after which the original server will be hidden.
+
+        Args:
+            validators: Dictionary containing validators hotkeys and their public keys.
+        """
+        miner_hotkey: Hotkey = os.getenv('MINER_HOTKEY')
+        if not miner_hotkey:
+            raise MinerShieldException("MINER_HOTKEY env is not set")
+
+        validators_manager: AbstractValidatorsManager = cls.create_validators_manager(validators)
+        event_processor: AbstractMinerShieldEventProcessor = cls.create_event_processor()
+        state_manager: AbstractMinerShieldStateManager = cls.create_state_manager()
+        aws_client_factory: AWSClientFactory = cls.create_aws_client_factory()
+        address_manager: AbstractAddressManager = cls.create_address_manager(aws_client_factory, event_processor,
+                                                                             state_manager)
+        encryption_manager: AbstractEncryptionManager = cls.create_encryption_manager()
+        manifest_manager: AbstractManifestManager = cls.create_manifest_manager(encryption_manager, aws_client_factory)
+        blockchain_manager: AbstractBlockchainManager = cls.create_blockchain_manager(miner_hotkey)
+
+        options: MinerShieldOptions = MinerShieldOptions()
+        options.auto_hide_original_server = os.getenv('AUTO_HIDE_ORIGINAL_SERVER') is not None
+        options.auto_hide_delay_sec = int(os.getenv('AUTO_HIDE_DELAY_SEC', str(options.auto_hide_delay_sec)))
+
+        return MinerShield(miner_hotkey, validators_manager, address_manager, manifest_manager, blockchain_manager,
+                           state_manager, event_processor, options)
+
+    @classmethod
+    def create_validators_manager(cls, validators: Optional[dict[Hotkey, PublicKey]]) -> AbstractValidatorsManager:
+        if validators is None:
+            raise MinerShieldException("validators param is not set")
+        return MemoryValidatorsManager(validators)
+
+    @classmethod
+    def create_event_processor(cls) -> AbstractMinerShieldEventProcessor:
+        return PrintingMinerShieldEventProcessor()
+
+    @classmethod
+    def create_state_manager(cls) -> AbstractMinerShieldStateManager:
+        sql_alchemy_db_url: str = os.getenv('SQL_ALCHEMY_DB_URL')
+        if not sql_alchemy_db_url:
+            raise MinerShieldException("SQL_ALCHEMY_DB_URL env is not set")
+        return SQLAlchemyMinerShieldStateManager(sql_alchemy_db_url)
+
+    @classmethod
+    def create_aws_client_factory(cls) -> AWSClientFactory:
+        aws_access_key_id: str = os.getenv('AWS_ACCESS_KEY_ID')
+        aws_secret_access_key: str = os.getenv('AWS_SECRET_ACCESS_KEY')
+        aws_region_name: str = os.getenv('AWS_REGION_NAME')
+        if not aws_access_key_id or not aws_secret_access_key or not aws_region_name:
+            raise MinerShieldException("AWS credentials are not set")
+        return AWSClientFactory(aws_access_key_id, aws_secret_access_key, aws_region_name)
+
+    @classmethod
+    def load_miner_aws_address(cls):
+        miner_instance_id: str = os.getenv('AWS_MINER_INSTANCE_ID')
+        miner_instance_ip: str = os.getenv('AWS_MINER_INSTANCE_IP')
+        if miner_instance_id:
+            address = miner_instance_id
+            address_type = AddressType.EC2
+        elif miner_instance_ip:
+            address = miner_instance_ip
+            address_type = AddressType.IP
+        else:
+            raise MinerShieldException("AWS_MINER_INSTANCE_ID or AWS_MINER_INSTANCE_IP env is not set")
+
+        miner_instance_port: str = os.getenv('MINER_INSTANCE_PORT')
+        if not miner_instance_port:
+            raise MinerShieldException("MINER_INSTANCE_PORT env is not set")
+
+        return Address(address_id="miner", address_type=address_type, address=address, port=int(miner_instance_port))
+
+    @classmethod
+    def create_address_manager(cls, aws_client_factory: Optional[AWSClientFactory],
+                               event_processor: AbstractMinerShieldEventProcessor,
+                               state_manager: AbstractMinerShieldStateManager) -> AbstractAddressManager:
+        if aws_client_factory:
+            return cls.create_aws_address_manager(aws_client_factory, event_processor, state_manager)
+        else:
+            raise MinerShieldException("Cannot create address manager")
+
+    @classmethod
+    def create_aws_address_manager(cls, aws_client_factory: AWSClientFactory,
+                                   event_processor: AbstractMinerShieldEventProcessor,
+                                   state_manager: AbstractMinerShieldStateManager) -> AbstractAddressManager:
+        miner_address: Address = cls.load_miner_aws_address()
+        aws_route53_hosted_zone_id: str = os.getenv('AWS_ROUTE53_HOSTED_ZONE_ID')
+        if not aws_route53_hosted_zone_id:
+            raise MinerShieldException("AWS_ROUTE53_HOSTED_ZONE_ID env is not set")
+        return AwsAddressManager(aws_client_factory, miner_address, aws_route53_hosted_zone_id, event_processor,
+                                 state_manager)
+
+    @classmethod
+    def create_encryption_manager(cls) -> AbstractEncryptionManager:
+        return ECIESEncryptionManager()
+
+    @classmethod
+    def create_manifest_manager(cls, encryption_manager: AbstractEncryptionManager,
+                                aws_client_factory: AWSClientFactory) -> AbstractManifestManager:
+        bucket_name: str = os.getenv('AWS_S3_BUCKET_NAME')
+        if not bucket_name:
+            raise MinerShieldException("AWS_S3_BUCKET_NAME env is not set")
+        address_serializer: AbstractAddressSerializer = DefaultAddressSerializer()
+        manifest_serializer: AbstractManifestSerializer = JsonManifestSerializer()
+        return S3ManifestManager(address_serializer, manifest_serializer, encryption_manager, aws_client_factory,
+                                 bucket_name)
+
+    @classmethod
+    def create_blockchain_manager(cls, miner_hotkey: Hotkey) -> AbstractBlockchainManager:
+        # TODO: waiting for implementation of blockchain manager
+        return MemoryBlockchainManager(miner_hotkey)
diff --git a/bt_ddos_shield/state_manager.py b/bt_ddos_shield/state_manager.py
index c313946..550992b 100644
--- a/bt_ddos_shield/state_manager.py
+++ b/bt_ddos_shield/state_manager.py
@@ -1,78 +1,482 @@
 from abc import ABC, abstractmethod
+from collections import defaultdict
 from datetime import datetime
-from enum import Enum
+from types import MappingProxyType
+from typing import Optional, Union
 
-from bt_ddos_shield.address import Address
-from bt_ddos_shield.miner_shield import Hotkey
+from sqlalchemy import (
+    CheckConstraint,
+    Column,
+    DateTime,
+    Engine,
+    ForeignKey,
+    Integer,
+    PrimaryKeyConstraint,
+    String,
+    create_engine,
+)
+from sqlalchemy.engine import url
+from sqlalchemy.orm import DeclarativeBase, sessionmaker
 
-
-class MinerShieldPhase(Enum):
-    """
-    Possible phases of shield.
-    """
-    DISABLED = "disabled"                         # disabled - initial state
-    MANIFEST_PUBLISHED = "manifest_published"     # manifest is saved to storage
-    MANIFEST_BROADCASTED = "manifest_broadcasted" # info about manifest is published to blockchain
-    ENABLED = "enabled"                           # shield is enabled
+from bt_ddos_shield.address import Address, AddressType
+from bt_ddos_shield.utils import Hotkey, PublicKey
 
 
 class MinerShieldState:
-    """
-    Class representing state of MinerShield.
-    """
+    _known_validators: dict[Hotkey, PublicKey]
+    _banned_validators: dict[Hotkey, datetime]
+    _validators_addresses: dict[Hotkey, Address]
+    _manifest_address: Optional[Address]
+    _address_manager_state: dict[str, str]
+    _address_manager_created_objects: dict[str, frozenset[str]]
 
-    phase: MinerShieldPhase                   # current phase of the shield
-    banned_validators: dict[Hotkey, datetime] # banned validators with ban time (HotKey -> time of ban)
-    active_addresses: dict[Hotkey, Address]   # active addresses (validator HotKey -> Address created for him)
+    def __init__(self, known_validators: dict[Hotkey, PublicKey], banned_validators: dict[Hotkey, datetime],
+                 validators_addresses: dict[Hotkey, Address], manifest_address: Optional[Address],
+                 address_manager_state: dict[str, str],
+                 address_manager_created_objects: dict[str, frozenset[str]]):
+        super().__setattr__('_known_validators', known_validators)
+        super().__setattr__('_banned_validators', banned_validators)
+        super().__setattr__('_validators_addresses', validators_addresses)
+        super().__setattr__('_manifest_address', manifest_address)
+        super().__setattr__('_address_manager_state', address_manager_state)
+        super().__setattr__('_address_manager_created_objects', address_manager_created_objects)
 
-    def __init__(self):
-        self.phase = MinerShieldPhase.DISABLED
-        self.banned_validators = {}
-        self.active_addresses = {}
+    @property
+    def known_validators(self) -> MappingProxyType[Hotkey, PublicKey]:
+        """
+        Get dictionary of known validators - maps validator HotKey -> validator public key.
+        """
+        return MappingProxyType(self._known_validators)
+
+    @property
+    def banned_validators(self) -> MappingProxyType[Hotkey, datetime]:
+        """
+        Get dictionary of banned validators - maps validator HotKey -> time of ban.
+        """
+        return MappingProxyType(self._banned_validators)
+
+    @property
+    def validators_addresses(self) -> MappingProxyType[Hotkey, Address]:
+        """
+        Get dictionary of active addresses (validator HotKey -> Address created for him).
+        """
+        return MappingProxyType(self._validators_addresses)
+
+    @property
+    def manifest_address(self) -> Optional[Address]:
+        """
+        Get manifest file address. If manifest file is not yet uploaded, return None.
+        """
+        return self._manifest_address
+
+    @property
+    def address_manager_state(self) -> MappingProxyType[str, str]:
+        """
+        Get address manager state (key -> value).
+        """
+        return MappingProxyType(self._address_manager_state)
+
+    @property
+    def address_manager_created_objects(self) -> MappingProxyType[str, frozenset[str]]:
+        """
+        Get objects already created by address manager (object_type -> set of object_ids).
+        """
+        return MappingProxyType(self._address_manager_created_objects)
+
+    def __setattr__(self, key, value):
+        raise AttributeError("State is immutable")
+
+    def __delattr__(self, item):
+        raise AttributeError("State is immutable")
+
+    def __eq__(self, other):
+        if not isinstance(other, MinerShieldState):
+            return False
+
+        return self._known_validators == other._known_validators and \
+            self._banned_validators == other._banned_validators and \
+            self._validators_addresses == other._validators_addresses and \
+            self._manifest_address == other._manifest_address and \
+            self._address_manager_state == other._address_manager_state and \
+            self._address_manager_created_objects == other._address_manager_created_objects
 
 
 class AbstractMinerShieldStateManager(ABC):
     """
-    Abstract base class for manager handling state of MinerShield.
+    Abstract base class for manager handling state of MinerShield. Each change in state should be instantly
+    saved to storage.
     """
+    current_miner_shield_state: Optional[MinerShieldState]
+
+    def __init__(self):
+        self.current_miner_shield_state = None
+
+    def get_state(self, reload: bool = False) -> MinerShieldState:
+        """
+        Get current state of MinerShield. If state is not loaded, it is loaded first.
+        """
+        if reload or self.current_miner_shield_state is None:
+            self.current_miner_shield_state = self._load_state_from_storage()
+
+        return self.current_miner_shield_state
 
-    current_miner_shield_state: MinerShieldState
+    @abstractmethod
+    def add_validator(self, validator_hotkey: Hotkey, validator_public_key: PublicKey, redirect_address: Address):
+        """
+        Add validator together with his public key and address (created for him) redirecting to Miner server.
+        """
+        pass
 
     @abstractmethod
-    def load_state(self):
+    def update_validator_public_key(self, validator_hotkey: Hotkey, validator_public_key: PublicKey):
         pass
 
     @abstractmethod
-    def save_state(self):
+    def add_banned_validator(self, validator_hotkey: Hotkey):
         pass
 
     @abstractmethod
-    def ban_validator(self, validator_hotkey: Hotkey):
+    def remove_validator(self, validator_hotkey: Hotkey):
         """
-        Add validator to the list of banned validators.
-
-        Args:
-            validator_hotkey: The hotkey of the validator.
+        Remove validator from the sets of known validators and active addresses.
         """
         pass
 
     @abstractmethod
-    def remove_validator(self, validator_hotkey: Hotkey):
-        """
-        Remove validator from the lists of banned validators or active addresses.
+    def set_manifest_address(self, manifest_address: Address):
+        pass
 
-        Args:
-            validator_hotkey: The hotkey of the validator.
+    @abstractmethod
+    def update_address_manager_state(self, key: str, value: Optional[str]):
+        """
+        Update address manager state (key -> value). If value is None, remove key from state.
         """
         pass
 
     @abstractmethod
-    def add_address(self, validator_hotkey: Hotkey, address: Address):
+    def add_address_manager_created_object(self, obj_type: str, obj_id: str):
+        pass
+
+    @abstractmethod
+    def del_address_manager_created_object(self, obj_type: str, obj_id: str):
+        pass
+
+    @abstractmethod
+    def _load_state_from_storage(self) -> MinerShieldState:
+        pass
+
+    def _update_state(self,
+                      known_validators: Optional[dict[Hotkey, PublicKey]] = None,
+                      banned_validators: Optional[dict[Hotkey, datetime]] = None,
+                      validators_addresses: Optional[dict[Hotkey, Address]] = None,
+                      manifest_address: Optional[Address] = None,
+                      address_manager_state: Optional[dict[str, str]] = None,
+                      address_manager_created_objects: Optional[dict[str, frozenset[str]]] = None):
+        """
+        Create new updated state with given new values and set it as current state. If value for field is None,
+        it is copied from current state.
+        """
+        self.current_miner_shield_state = \
+            MinerShieldState(dict(self.current_miner_shield_state.known_validators)
+                             if known_validators is None else known_validators,
+                             dict(self.current_miner_shield_state.banned_validators)
+                             if banned_validators is None else banned_validators,
+                             dict(self.current_miner_shield_state.validators_addresses)
+                             if validators_addresses is None else validators_addresses,
+                             manifest_address or self.current_miner_shield_state.manifest_address,
+                             dict(self.current_miner_shield_state.address_manager_state)
+                             if address_manager_state is None else address_manager_state,
+                             dict(self.current_miner_shield_state.address_manager_created_objects)
+                             if address_manager_created_objects is None else address_manager_created_objects)
+
+    def _state_add_validator(self, validator_hotkey: Hotkey, validator_public_key: PublicKey,
+                             redirect_address: Address):
+        """
+        Add new validator to current state. Should be called only after updating state in storage.
+        """
+        known_validators: dict[Hotkey, PublicKey] = dict(self.current_miner_shield_state.known_validators)
+        assert validator_hotkey not in known_validators, "storage should not allow adding same validator"
+        known_validators[validator_hotkey] = validator_public_key
+
+        validators_addresses: dict[Hotkey, Address] = dict(self.current_miner_shield_state.validators_addresses)
+        assert validator_hotkey not in validators_addresses, "storage should not allow adding same validator"
+        validators_addresses[validator_hotkey] = redirect_address
+
+        self._update_state(known_validators=known_validators, validators_addresses=validators_addresses)
+
+    def _state_update_validator_public_key(self, validator_hotkey: Hotkey, validator_public_key: PublicKey):
+        """
+        Update validator in current state. Should be called only after updating state in storage.
+        """
+        known_validators: dict[Hotkey, PublicKey] = dict(self.current_miner_shield_state.known_validators)
+        assert validator_hotkey in known_validators, "updating storage should fail when validator does not exists"
+        known_validators[validator_hotkey] = validator_public_key
+        self._update_state(known_validators=known_validators)
+
+    def _state_add_banned_validator(self, validator_hotkey: Hotkey, ban_time: datetime):
+        """
+        Add new banned validator to current state. Should be called only after updating state in storage.
         """
-        Add new address to state.
+        banned_validators: dict[Hotkey, datetime] = dict(self.current_miner_shield_state.banned_validators)
+        assert validator_hotkey not in banned_validators, "time should be updated only when adding new ban"
+        banned_validators[validator_hotkey] = ban_time
+        self._update_state(banned_validators=banned_validators)
 
+    def _state_remove_validator(self, validator_hotkey: Hotkey):
+        """
+        Remove validator from current state. Should be called only after updating state in storage.
+        """
+        known_validators: dict[Hotkey, PublicKey] = dict(self.current_miner_shield_state.known_validators)
+        assert validator_hotkey in known_validators, "storage should not allow removing non-existent validator"
+        known_validators.pop(validator_hotkey)
+        validators_addresses: dict[Hotkey, Address] = dict(self.current_miner_shield_state.validators_addresses)
+        assert validator_hotkey in validators_addresses, "storage should not allow removing non-existent validator"
+        validators_addresses.pop(validator_hotkey)
+        self._update_state(known_validators=known_validators, validators_addresses=validators_addresses)
+
+    def _state_set_manifest_address(self, manifest_address: Address):
+        """
+        Update manifest address in current state. Should be called only after updating state in storage.
+        """
+        self._update_state(manifest_address=manifest_address)
+
+    def _state_update_address_manager_state(self, key: str, value: Optional[str]):
+        """
+        Updates AddressManager state in current shield state. Should be called only after updating state in storage.
+        """
+        address_manager_state: dict[str, str] = dict(self.current_miner_shield_state.address_manager_state)
+        if value is None:
+            address_manager_state.pop(key, None)
+        else:
+            address_manager_state[key] = value
+        self._update_state(address_manager_state=address_manager_state)
+
+    def _state_add_address_manager_created_object(self, obj_type: str, obj_id: str):
+        """
+        Add object to objects created by AddressManager. Should be called only after updating state in storage.
+        """
+        address_manager_created_objects: dict[str, frozenset[str]] = \
+            dict(self.current_miner_shield_state.address_manager_created_objects)
+        if obj_type not in address_manager_created_objects:
+            address_manager_created_objects[obj_type] = frozenset([obj_id])
+        else:
+            address_manager_created_objects[obj_type] = address_manager_created_objects[obj_type] | frozenset([obj_id])
+        self._update_state(address_manager_created_objects=address_manager_created_objects)
+
+    def _state_del_address_manager_created_object(self, obj_type: str, obj_id: str):
+        """
+        Remove object from objects created by AddressManager. Should be called only after updating state in storage.
+        """
+        address_manager_created_objects: dict[str, frozenset[str]] = \
+            dict(self.current_miner_shield_state.address_manager_created_objects)
+        if obj_type not in address_manager_created_objects:
+            return
+        address_manager_created_objects[obj_type] = \
+            frozenset(o for o in address_manager_created_objects[obj_type] if o != obj_id)
+        if not address_manager_created_objects[obj_type]:
+            address_manager_created_objects.pop(obj_type)
+        self._update_state(address_manager_created_objects=address_manager_created_objects)
+
+
+class MinerShieldStateDeclarativeBase(DeclarativeBase):
+    pass
+
+
+class SqlValidator(MinerShieldStateDeclarativeBase):
+    __tablename__ = 'validators'
+    hotkey = Column(String, primary_key=True)
+    public_key = Column(String, nullable=False)
+    address_id = Column(String, ForeignKey('addresses.address_id', ondelete='CASCADE'), nullable=False)
+
+
+class SqlAddress(MinerShieldStateDeclarativeBase):
+    __tablename__ = 'addresses'
+    address_id = Column(String, primary_key=True)
+    address_type = Column(String, nullable=False)
+    address = Column(String, nullable=False)
+    port = Column(Integer, nullable=False)
+
+
+class SqlBannedValidator(MinerShieldStateDeclarativeBase):
+    __tablename__ = 'banned_validators'
+    hotkey = Column(String, primary_key=True)
+    ban_time = Column(DateTime, nullable=False)
+
+
+class SqlManifest(MinerShieldStateDeclarativeBase):
+    __tablename__ = 'manifest'
+    id = Column(Integer, primary_key=True, default=1)
+    address_id = Column(String, ForeignKey('addresses.address_id', ondelete='CASCADE'), nullable=False)
+    __table_args__ = (
+        CheckConstraint('id = 1', name='single_row_check'),
+    )
+
+
+class SqlAddressManagerState(MinerShieldStateDeclarativeBase):
+    __tablename__ = 'address_manager_state'
+    key = Column(String, primary_key=True)
+    value = Column(String, nullable=False)
+
+
+class SqlAddressManagerCreatedObjects(MinerShieldStateDeclarativeBase):
+    __tablename__ = 'address_manager_created_objects'
+    object_type = Column(String, nullable=False)
+    object_id = Column(String, nullable=False)
+    __table_args__ = (
+        PrimaryKeyConstraint('object_type', 'object_id', name='pk_object_type_object_id'),
+    )
+
+
+class SQLAlchemyMinerShieldStateManager(AbstractMinerShieldStateManager):
+    """
+    StateManager implementation using SQLAlchemy.
+    """
+
+    engine: Engine
+    session_maker: sessionmaker
+
+    def __init__(self, db_url: Union[str, url.URL]):
+        """
         Args:
-            validator_hotkey: The hotkey of the validator.
-            address: Address to add.
+            db_url: URL of database to connect to. Should be in format accepted by SQLAlchemy - see create_engine doc.
         """
-        pass
+        super().__init__()
+        self.engine = create_engine(db_url)
+        MinerShieldStateDeclarativeBase.metadata.create_all(self.engine)
+        self.session_maker = sessionmaker(bind=self.engine)
+
+    def clear_tables(self):
+        MinerShieldStateDeclarativeBase.metadata.drop_all(self.engine)
+        MinerShieldStateDeclarativeBase.metadata.create_all(self.engine)
+
+    def add_validator(self, validator_hotkey: Hotkey, validator_public_key: PublicKey, redirect_address: Address):
+        with self.session_maker() as session:
+            session.add(SqlValidator(hotkey=validator_hotkey, public_key=validator_public_key,
+                                     address_id=redirect_address.address_id))
+            session.add(SqlAddress(address_id=redirect_address.address_id,
+                                   address_type=redirect_address.address_type.value,
+                                   address=redirect_address.address, port=redirect_address.port))
+            session.commit()
+
+        self._state_add_validator(validator_hotkey, validator_public_key, redirect_address)
+
+    def update_validator_public_key(self, validator_hotkey: Hotkey, validator_public_key: PublicKey):
+        with self.session_maker() as session:
+            validator = session.query(SqlValidator).filter_by(hotkey=validator_hotkey).one()
+            validator.public_key = validator_public_key
+            session.commit()
+
+        self._state_update_validator_public_key(validator_hotkey, validator_public_key)
+
+    def add_banned_validator(self, validator_hotkey: Hotkey):
+        if validator_hotkey in self.current_miner_shield_state.banned_validators:
+            # do not update ban time
+            return
+
+        ban_time: datetime = datetime.now()
+
+        with self.session_maker() as session:
+            session.add(SqlBannedValidator(hotkey=validator_hotkey, ban_time=ban_time))
+            session.commit()
+
+        self._state_add_banned_validator(validator_hotkey, ban_time)
+
+    def remove_validator(self, validator_hotkey: Hotkey):
+        with self.session_maker() as session:
+            validator = session.query(SqlValidator).filter_by(hotkey=validator_hotkey).one()
+            session.delete(validator)
+            session.commit()
+
+        self._state_remove_validator(validator_hotkey)
+
+    def set_manifest_address(self, manifest_address: Address):
+        with self.session_maker() as session:
+            manifest = session.query(SqlManifest).first()
+            if manifest is not None:
+                db_address = session.query(SqlAddress).filter_by(address_id=manifest.address_id).one()
+                session.delete(db_address)
+
+            session.add(SqlAddress(address_id=manifest_address.address_id,
+                                   address_type=manifest_address.address_type.value,
+                                   address=manifest_address.address, port=manifest_address.port))
+
+            if manifest is None:
+                session.add(SqlManifest(address_id=manifest_address.address_id))
+            else:
+                manifest.address_id = manifest_address.address_id
+
+            session.commit()
+
+        self._state_set_manifest_address(manifest_address)
+
+    def update_address_manager_state(self, key: str, value: Optional[str]):
+        with self.session_maker() as session:
+            if value is None:
+                # Remove the key from the database if the value is None
+                session.query(SqlAddressManagerState).filter_by(key=key).delete()
+            else:
+                # Insert or update the key-value pair in the database
+                state = session.query(SqlAddressManagerState).filter_by(key=key).one_or_none()
+                if state is None:
+                    session.add(SqlAddressManagerState(key=key, value=value))
+                else:
+                    state.value = value
+            session.commit()
+
+        self._state_update_address_manager_state(key, value)
+
+    def add_address_manager_created_object(self, obj_type: str, obj_id: str):
+        with self.session_maker() as session:
+            session.add(SqlAddressManagerCreatedObjects(object_type=obj_type, object_id=obj_id))
+            session.commit()
+
+        self._state_add_address_manager_created_object(obj_type, obj_id)
+
+    def del_address_manager_created_object(self, obj_type: str, obj_id: str):
+        with self.session_maker() as session:
+            session.query(SqlAddressManagerCreatedObjects).filter_by(object_type=obj_type, object_id=obj_id).delete()
+            session.commit()
+
+        self._state_del_address_manager_created_object(obj_type, obj_id)
+
+    def _load_state_from_storage(self) -> MinerShieldState:
+        with self.session_maker() as session:
+            # noinspection PyTypeChecker
+            known_validators: dict[Hotkey, PublicKey] = \
+                {v.hotkey: v.public_key for v in session.query(SqlValidator).all()}
+            # noinspection PyTypeChecker
+            banned_validators: dict[Hotkey, datetime] = \
+                {b.hotkey: b.ban_time for b in session.query(SqlBannedValidator).all()}
+            # noinspection PyTypeChecker
+            validators_addresses: dict[Hotkey, Address] = \
+                {v.hotkey: self._load_address(session, v.address_id) for v in session.query(SqlValidator).all()}
+
+            manifest_address: Optional[Address] = None
+            manifest_record = session.query(SqlManifest).first()
+            if manifest_record is not None:
+                # noinspection PyTypeChecker
+                manifest_address = self._load_address(session, manifest_record.address_id)
+
+            # noinspection PyTypeChecker
+            address_manager_state: dict[str, str] = \
+                {s.key: s.value for s in session.query(SqlAddressManagerState).all()}
+
+            tmp_address_manager_created_objects: defaultdict[str, set[str]] = defaultdict(set)
+            for obj in session.query(SqlAddressManagerCreatedObjects).all():
+                # noinspection PyTypeChecker
+                tmp_address_manager_created_objects[obj.object_type].add(obj.object_id)
+
+        address_manager_created_objects: dict[str, frozenset[str]] = {}
+        for obj_type in tmp_address_manager_created_objects:
+            address_manager_created_objects[obj_type] = frozenset(tmp_address_manager_created_objects[obj_type])
+
+        return MinerShieldState(known_validators, banned_validators, validators_addresses, manifest_address,
+                                address_manager_state, address_manager_created_objects)
+
+    @classmethod
+    def _load_address(cls, session, address_id: str) -> Address:
+        db_address = session.query(SqlAddress).filter_by(address_id=address_id).one()
+        return Address(address_id=db_address.address_id,
+                       address_type=AddressType(db_address.address_type),
+                       address=db_address.address,
+                       port=db_address.port)
diff --git a/bt_ddos_shield/utils.py b/bt_ddos_shield/utils.py
index e69de29..7d79a71 100644
--- a/bt_ddos_shield/utils.py
+++ b/bt_ddos_shield/utils.py
@@ -0,0 +1,41 @@
+from typing import Optional, TypeAlias
+
+import boto3
+import route53
+from botocore.client import BaseClient
+from route53.connection import Route53Connection
+
+Hotkey: TypeAlias = str
+PublicKey: TypeAlias = str
+PrivateKey: TypeAlias = str
+
+
+class AWSClientFactory:
+    aws_access_key_id: str
+    aws_secret_access_key: str
+    aws_region_name: Optional[str]
+
+    def __init__(self, aws_access_key_id: str, aws_secret_access_key: str, aws_region_name: Optional[str] = None):
+        """
+        Args:
+            aws_access_key_id: AWS access key ID.
+            aws_secret_access_key: AWS secret access key.
+            aws_region_name: AWS region name. If not known, it can be set later using set_aws_region_name method.
+        """
+        self.aws_access_key_id = aws_access_key_id
+        self.aws_secret_access_key = aws_secret_access_key
+        self.aws_region_name = aws_region_name
+
+    def set_aws_region_name(self, aws_region_name: str) -> bool:
+        """ Set AWS region name. Returns if region name was changed. """
+        if self.aws_region_name == aws_region_name:
+            return False
+        self.aws_region_name = aws_region_name
+        return True
+
+    def boto3_client(self, service_name: str) -> BaseClient:
+        return boto3.client(service_name, aws_access_key_id=self.aws_access_key_id,
+                            aws_secret_access_key=self.aws_secret_access_key, region_name=self.aws_region_name)
+
+    def route53_client(self) -> Route53Connection:
+        return route53.connect(self.aws_access_key_id, self.aws_secret_access_key)
diff --git a/bt_ddos_shield/validator.py b/bt_ddos_shield/validator.py
index 1bdd5a6..f7ec5bb 100644
--- a/bt_ddos_shield/validator.py
+++ b/bt_ddos_shield/validator.py
@@ -1,6 +1,128 @@
+import asyncio
+import os
+from collections import namedtuple
+from dataclasses import dataclass
+from typing import Optional
+
+from tests.test_blockchain_manager import MemoryBlockchainManager
+
+from bt_ddos_shield.address import AbstractAddressSerializer, Address, AddressType, DefaultAddressSerializer
+from bt_ddos_shield.blockchain_manager import AbstractBlockchainManager
+from bt_ddos_shield.encryption_manager import AbstractEncryptionManager, ECIESEncryptionManager
+from bt_ddos_shield.manifest_manager import (
+    AbstractManifestManager,
+    AbstractManifestSerializer,
+    JsonManifestSerializer,
+    Manifest,
+    S3ManifestManager,
+)
+from bt_ddos_shield.utils import AWSClientFactory, Hotkey, PrivateKey
+
+
+@dataclass
+class ValidatorOptions:
+    retry_delay_sec: int = 10
+    """ Time in seconds to wait before retrying fetching miner address. """
+
+
+MinerAddress = namedtuple('MinerAddress', ['domain', 'port'])
+
+
 class Validator:
-    def __init__(self):
-        pass
+    """
+    Validator class used to retrieve address of miner shielded by MinerShield.
+    """
+
+    _validator_hotkey: Hotkey
+    _validator_private_key: PrivateKey
+    _blockchain_manager: AbstractBlockchainManager
+    _manifest_manager: AbstractManifestManager
+    _options: ValidatorOptions
+
+    def __init__(self, validator_hotkey: Hotkey, validator_private_key: PrivateKey,
+                 blockchain_manager: AbstractBlockchainManager, manifest_manager: AbstractManifestManager,
+                 options: ValidatorOptions):
+        self._validator_hotkey = validator_hotkey
+        self._validator_private_key = validator_private_key
+        self._blockchain_manager = blockchain_manager
+        self._manifest_manager = manifest_manager
+        self._options = options
+
+    async def fetch_miner_address(self) -> MinerAddress:
+        while True:
+            miner_manifest_address: Optional[Address] = self._blockchain_manager.get_miner_manifest_address()
+            if miner_manifest_address is not None:
+                break
+
+            await asyncio.sleep(self._options.retry_delay_sec)
+
+        manifest: Manifest = self._manifest_manager.get_manifest(miner_manifest_address)
+        address: Address = self._manifest_manager.get_address_for_validator(manifest, self._validator_hotkey,
+                                                                            self._validator_private_key)
+        assert address.address_type == AddressType.DOMAIN
+        return MinerAddress(domain=address.address, port=address.port)
+
+
+class ValidatorFactoryException(Exception):
+    pass
+
+
+class ValidatorFactory:
+    """
+    Factory class to create proper Validator instance basing on set environmental variables.
+    """
+
+    @classmethod
+    def create_validator(cls) -> Validator:
+        """
+        Create Validator instance basing on set environmental variables.
+
+        List of required env variables:
+        - MINER_HOTKEY: Hotkey of shielded miner.
+        - VALIDATOR_HOTKEY: Hotkey of validator.
+        - VALIDATOR_PRIVATE_KEY: Hex representation of secp256k1 private key of validator.
+        - AWS_ACCESS_KEY_ID: AWS access key ID.
+        - AWS_SECRET_ACCESS_KEY: AWS secret access key.
+        """
+        miner_hotkey: Hotkey = os.getenv('MINER_HOTKEY')
+        if not miner_hotkey:
+            raise ValidatorFactoryException("MINER_HOTKEY env is not set")
+
+        validator_hotkey: Hotkey = os.getenv('VALIDATOR_HOTKEY')
+        if not validator_hotkey:
+            raise ValidatorFactoryException("VALIDATOR_HOTKEY env is not set")
+
+        validator_private_key: PrivateKey = os.getenv('VALIDATOR_PRIVATE_KEY')
+        if not validator_private_key:
+            raise ValidatorFactoryException("VALIDATOR_PRIVATE_KEY env is not set")
+
+        aws_client_factory: AWSClientFactory = cls.create_aws_client_factory()
+        encryption_manager: AbstractEncryptionManager = cls.create_encryption_manager()
+        manifest_manager: AbstractManifestManager = cls.create_manifest_manager(encryption_manager, aws_client_factory)
+        blockchain_manager: AbstractBlockchainManager = cls.create_blockchain_manager(miner_hotkey)
+        options: ValidatorOptions = ValidatorOptions()
+        return Validator(validator_hotkey, validator_private_key, blockchain_manager, manifest_manager, options)
+
+    @classmethod
+    def create_aws_client_factory(cls) -> AWSClientFactory:
+        aws_access_key_id: str = os.getenv('AWS_ACCESS_KEY_ID')
+        aws_secret_access_key: str = os.getenv('AWS_SECRET_ACCESS_KEY')
+        if not aws_access_key_id or not aws_secret_access_key:
+            raise ValidatorFactoryException("AWS credentials are not set")
+        return AWSClientFactory(aws_access_key_id, aws_secret_access_key)
+
+    @classmethod
+    def create_encryption_manager(cls) -> AbstractEncryptionManager:
+        return ECIESEncryptionManager()
+
+    @classmethod
+    def create_manifest_manager(cls, encryption_manager: AbstractEncryptionManager,
+                                aws_client_factory: AWSClientFactory) -> AbstractManifestManager:
+        address_serializer: AbstractAddressSerializer = DefaultAddressSerializer()
+        manifest_serializer: AbstractManifestSerializer = JsonManifestSerializer()
+        return S3ManifestManager(address_serializer, manifest_serializer, encryption_manager, aws_client_factory)
 
-    def fetch_and_decrypt_message(self):
-        pass
+    @classmethod
+    def create_blockchain_manager(cls, miner_hotkey: Hotkey) -> AbstractBlockchainManager:
+        # TODO: waiting for implementation of blockchain manager
+        return MemoryBlockchainManager(miner_hotkey)
diff --git a/bt_ddos_shield/validators_manager.py b/bt_ddos_shield/validators_manager.py
index d1c2268..4c87ed4 100644
--- a/bt_ddos_shield/validators_manager.py
+++ b/bt_ddos_shield/validators_manager.py
@@ -1,6 +1,7 @@
 from abc import ABC, abstractmethod
+from types import MappingProxyType
 
-from bt_ddos_shield.miner_shield import Hotkey
+from bt_ddos_shield.utils import Hotkey, PublicKey
 
 
 class AbstractValidatorsManager(ABC):
@@ -9,18 +10,35 @@ class AbstractValidatorsManager(ABC):
     """
 
     @abstractmethod
-    def get_validators(self) -> dict[Hotkey, str]:
+    def get_validators(self) -> MappingProxyType[Hotkey, PublicKey]:
         """
-        Get cached dictionary of validators - maps HotKey of validator to public key.
+        Get cached dictionary of validators.
+
+        Returns:
+            dict[Hotkey, PublicKey]: Mapping HotKey of validator -> his public key.
         """
         pass
 
     @abstractmethod
-    def refresh_validators(self) -> bool:
+    def reload_validators(self):
         """
-        Refresh validators dictionary. Blocks code execution until new validators set is fetched.
-
-        Returns:
-            bool: True if validators set is different after refreshing.
+        Reload validators dictionary. Blocks code execution until new validators set is fetched.
         """
         pass
+
+
+class MemoryValidatorsManager(AbstractValidatorsManager):
+    """
+    Validators manager implementation which stores fixed validators in memory.
+    """
+
+    validators: dict[Hotkey, PublicKey]
+
+    def __init__(self, validators: dict[Hotkey, PublicKey]):
+        self.validators = dict(validators)
+
+    def get_validators(self) -> MappingProxyType[Hotkey, PublicKey]:
+        return MappingProxyType(self.validators)
+
+    def reload_validators(self):
+        pass
diff --git a/pyproject.toml b/pyproject.toml
index a50247a..e35f5c1 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -9,6 +9,9 @@ readme = "README.md"
 python = "^3.12"
 boto3 = "^1.35.27"
 eciespy = "^0.4.2"
+pytest = "^8.3.4"
+sqlalchemy = "^2.0.36"
+route53 = "^1.0.1"
 
 
 [build-system]
diff --git a/tests/test_address.py b/tests/test_address.py
new file mode 100644
index 0000000..5f6831a
--- /dev/null
+++ b/tests/test_address.py
@@ -0,0 +1,15 @@
+from bt_ddos_shield.address import Address, AddressType, DefaultAddressSerializer
+
+
+class TestAddress:
+    """
+    Test suite for the address.
+    """
+
+    def test_default_serializer(self):
+        default_serializer = DefaultAddressSerializer()
+        address: Address = Address(address_id='some_id', address_type=AddressType.DOMAIN, address='some_addr', port=80)
+        serialized_address: bytes = default_serializer.serialize(address)
+        deserialized_address: Address = default_serializer.deserialize(serialized_address)
+
+        assert address == deserialized_address, "Deserialized data should match the original data"
diff --git a/tests/test_address_manager.py b/tests/test_address_manager.py
new file mode 100644
index 0000000..16b798f
--- /dev/null
+++ b/tests/test_address_manager.py
@@ -0,0 +1,197 @@
+from types import MappingProxyType
+
+import pytest
+from bt_ddos_shield.address import Address, AddressType
+from bt_ddos_shield.address_manager import AbstractAddressManager, AwsAddressManager, AwsObjectTypes
+from bt_ddos_shield.event_processor import PrintingMinerShieldEventProcessor
+from bt_ddos_shield.state_manager import MinerShieldState
+from bt_ddos_shield.utils import AWSClientFactory, Hotkey
+from tests.test_credentials import (
+    aws_access_key_id,
+    aws_region_name,
+    aws_route53_hosted_zone_id,
+    aws_route53_other_hosted_zone_id,
+    aws_secret_access_key,
+    miner_instance_id,
+    miner_instance_ip,
+    miner_instance_port,
+)
+from tests.test_state_manager import MemoryMinerShieldStateManager
+
+
+def get_miner_address_from_credentials(address_type: AddressType, port: int = miner_instance_port) -> Address:
+    if address_type == AddressType.EC2:
+        return Address(address_id="miner", address_type=AddressType.EC2, address=miner_instance_id,
+                       port=port)
+    elif address_type == AddressType.IP:
+        return Address(address_id="miner", address_type=AddressType.IP, address=miner_instance_ip,
+                       port=port)
+    else:
+        raise ValueError("Invalid address type")
+
+
+class MemoryAddressManager(AbstractAddressManager):
+    id_counter: int
+    known_addresses: dict[str, Address]
+    invalid_addresses: set[Hotkey]
+
+    def __init__(self):
+        self.id_counter = 0
+        self.known_addresses = {}
+        self.invalid_addresses = set()
+
+    def clean_all(self):
+        self.id_counter = 0
+        self.known_addresses.clear()
+        self.invalid_addresses.clear()
+
+    def create_address(self, hotkey: Hotkey) -> Address:
+        address = Address(address_id=str(self.id_counter), address_type=AddressType.DOMAIN,
+                          address=f"addr{self.id_counter}.com", port=80)
+        self.known_addresses[address.address_id] = address
+        self.id_counter += 1
+        return address
+
+    def remove_address(self, address: Address):
+        self.known_addresses.pop(address.address_id, None)
+
+    def validate_addresses(self, addresses: MappingProxyType[Hotkey, Address]) -> set[Hotkey]:
+        for hotkey in self.invalid_addresses:
+            if hotkey in addresses:
+                self.known_addresses.pop(addresses[hotkey].address_id, None)
+        return self.invalid_addresses
+
+
+class TestAddressManager:
+    """
+    Test suite for the address manager.
+    """
+
+    def create_aws_address_manager(self, port: int = miner_instance_port,
+                                   hosted_zone_id: str = aws_route53_hosted_zone_id,
+                                   create_state_manager: bool = True) -> AwsAddressManager:
+        miner_address: Address = get_miner_address_from_credentials(AddressType.IP, port)
+        if create_state_manager:
+            self.state_manager: MemoryMinerShieldStateManager = MemoryMinerShieldStateManager()
+        aws_client_factory: AWSClientFactory = AWSClientFactory(aws_access_key_id, aws_secret_access_key,
+                                                                aws_region_name)
+        return AwsAddressManager(aws_client_factory=aws_client_factory, miner_address=miner_address,
+                                 hosted_zone_id=hosted_zone_id, event_processor=PrintingMinerShieldEventProcessor(),
+                                 state_manager=self.state_manager)
+
+    @pytest.fixture
+    def address_manager(self):
+        manager = self.create_aws_address_manager()
+        yield manager
+        manager.clean_all()
+
+    def test_create_elb(self, address_manager: AwsAddressManager):
+        """ Test creating ELB by AwsAddressManager class. """
+
+        # This triggers creation of ELB
+        address_manager.validate_addresses(MappingProxyType({}))
+
+        state: MinerShieldState = self.state_manager.get_state()
+        address_manager_state: MappingProxyType[str, str] = state.address_manager_state
+        assert address_manager_state[address_manager.HOSTED_ZONE_ID_KEY] == aws_route53_hosted_zone_id
+        assert address_manager_state[address_manager.INSTANCE_ID_KEY] == miner_instance_id
+        assert int(address_manager_state[address_manager.INSTANCE_PORT_KEY]) == miner_instance_port
+        created_objects: MappingProxyType[str, frozenset[str]] = state.address_manager_created_objects
+        assert len(created_objects[AwsObjectTypes.WAF.value]) == 1
+        assert len(created_objects[AwsObjectTypes.ELB.value]) == 1
+        assert len(created_objects[AwsObjectTypes.SUBNET.value]) == 1
+        assert len(created_objects[AwsObjectTypes.TARGET_GROUP.value]) == 1
+        assert len(created_objects[AwsObjectTypes.SECURITY_GROUP.value]) == 1
+        assert AwsObjectTypes.DNS_ENTRY.value not in created_objects
+
+        reloaded_state: MinerShieldState = self.state_manager.get_state(reload=True)
+        assert reloaded_state == state
+
+        # Call clean_all and check if everything was removed
+        address_manager.clean_all()
+        state = self.state_manager.get_state()
+        created_objects = state.address_manager_created_objects
+        assert AwsObjectTypes.WAF.value not in created_objects
+        assert AwsObjectTypes.ELB.value not in created_objects
+        assert AwsObjectTypes.SUBNET.value not in created_objects
+        assert AwsObjectTypes.TARGET_GROUP.value not in created_objects
+        assert AwsObjectTypes.SECURITY_GROUP.value not in created_objects
+        assert AwsObjectTypes.DNS_ENTRY.value not in created_objects
+
+    def test_handle_address(self, address_manager: AwsAddressManager):
+        """ Create address, validate it and remove created address. """
+        address1: Address = address_manager.create_address("validator1")
+        address2: Address = address_manager.create_address("validator2")
+        invalid_address: Address = Address(address_id="invalid", address_type=AddressType.DOMAIN,
+                                           address="invalid.com", port=80)
+        mapping: dict[Hotkey, Address] = {Hotkey("hotkey1"): address1,
+                                          Hotkey("hotkey2"): address2,
+                                          Hotkey("invalid"): invalid_address}
+        invalid_addresses: set[Hotkey] = address_manager.validate_addresses(MappingProxyType(mapping))
+        assert invalid_addresses == {Hotkey("invalid")}
+
+        state: MinerShieldState = self.state_manager.get_state()
+        created_objects: MappingProxyType[str, frozenset[str]] = state.address_manager_created_objects
+        assert len(created_objects[AwsObjectTypes.ELB.value]) == 1, "ELB should be created before adding address"
+        assert len(created_objects[AwsObjectTypes.DNS_ENTRY.value]) == 2
+
+        address_manager.remove_address(address1)
+        state = self.state_manager.get_state()
+        created_objects: MappingProxyType[str, frozenset[str]] = state.address_manager_created_objects
+        assert len(created_objects[AwsObjectTypes.ELB.value]) == 1
+        assert len(created_objects[AwsObjectTypes.DNS_ENTRY.value]) == 1
+        invalid_addresses = address_manager.validate_addresses(MappingProxyType(mapping))
+        assert invalid_addresses == {Hotkey("hotkey1"), Hotkey("invalid")}
+
+    def test_miner_instance_change(self, address_manager: AwsAddressManager):
+        """ Test changing Miner instance when initializing shield. """
+        address: Address = address_manager.create_address("validator1")
+        hotkey: Hotkey = "hotkey"
+        mapping: dict[Hotkey, Address] = {hotkey: address}
+        invalid_addresses: set[Hotkey] = address_manager.validate_addresses(MappingProxyType(mapping))
+        assert invalid_addresses == set()
+
+        state: MinerShieldState = self.state_manager.get_state()
+        created_objects: MappingProxyType[str, frozenset[str]] = state.address_manager_created_objects
+        assert len(created_objects[AwsObjectTypes.DNS_ENTRY.value]) == 1
+        assert len(created_objects[AwsObjectTypes.ELB.value]) == 1, "ELB should be created before adding address"
+        elb_id: str = next(iter(created_objects[AwsObjectTypes.ELB.value]))
+
+        # Create new manager with different port - ELB should be recreated
+        address_manager = self.create_aws_address_manager(port=miner_instance_port + 1, create_state_manager=False)
+        invalid_addresses = address_manager.validate_addresses(MappingProxyType(mapping))
+        assert invalid_addresses == {hotkey}
+
+        state = self.state_manager.get_state()
+        created_objects: MappingProxyType[str, frozenset[str]] = state.address_manager_created_objects
+        assert AwsObjectTypes.DNS_ENTRY.value not in created_objects, "DNS entry should be removed"
+        assert len(created_objects[AwsObjectTypes.ELB.value]) == 1
+        new_elb_id: str = next(iter(created_objects[AwsObjectTypes.ELB.value]))
+        assert new_elb_id != elb_id
+
+    def test_hosted_zone_id_change(self, address_manager: AwsAddressManager):
+        """ Test changing hosted zone id when initializing shield. """
+        address: Address = address_manager.create_address("validator1")
+        hotkey: Hotkey = "hotkey"
+        mapping: dict[Hotkey, Address] = {hotkey: address}
+        invalid_addresses: set[Hotkey] = address_manager.validate_addresses(MappingProxyType(mapping))
+        assert invalid_addresses == set()
+
+        state: MinerShieldState = self.state_manager.get_state()
+        created_objects: MappingProxyType[str, frozenset[str]] = state.address_manager_created_objects
+        assert len(created_objects[AwsObjectTypes.DNS_ENTRY.value]) == 1
+        assert len(created_objects[AwsObjectTypes.ELB.value]) == 1, "ELB should be created before adding address"
+        elb_id: str = next(iter(created_objects[AwsObjectTypes.ELB.value]))
+
+        # Create new manager with different hosted zone - only addresses should be removed
+        address_manager = self.create_aws_address_manager(hosted_zone_id=aws_route53_other_hosted_zone_id,
+                                                          create_state_manager=False)
+        invalid_addresses = address_manager.validate_addresses(MappingProxyType(mapping))
+        assert invalid_addresses == {hotkey}
+
+        state = self.state_manager.get_state()
+        created_objects: MappingProxyType[str, frozenset[str]] = state.address_manager_created_objects
+        assert AwsObjectTypes.DNS_ENTRY.value not in created_objects, "DNS entry should be removed"
+        assert len(created_objects[AwsObjectTypes.ELB.value]) == 1
+        new_elb_id: str = next(iter(created_objects[AwsObjectTypes.ELB.value]))
+        assert new_elb_id == elb_id
diff --git a/tests/test_blockchain_manager.py b/tests/test_blockchain_manager.py
new file mode 100644
index 0000000..ccdc20f
--- /dev/null
+++ b/tests/test_blockchain_manager.py
@@ -0,0 +1,33 @@
+import threading
+from typing import Optional
+
+from bt_ddos_shield.address import DefaultAddressSerializer
+from bt_ddos_shield.blockchain_manager import AbstractBlockchainManager
+from bt_ddos_shield.utils import Hotkey
+
+
+class MemoryBlockchainManager(AbstractBlockchainManager):
+    known_data: dict[Hotkey, bytes]
+    put_counter: int
+
+    def __init__(self, miner_hotkey: Hotkey):
+        super().__init__(miner_hotkey, DefaultAddressSerializer())
+        self.known_data = {}
+        self.put_counter = 0
+        self._lock = threading.Lock()
+
+    def put(self, hotkey: Hotkey, data: bytes):
+        with self._lock:
+            self.known_data[hotkey] = data
+            self.put_counter += 1
+
+    def get(self, hotkey: Hotkey) -> Optional[bytes]:
+        with self._lock:
+            return self.known_data.get(hotkey)
+
+
+class TestBlockchainManager:
+    """
+    Test suite for the blockchain manager.
+    """
+    pass
diff --git a/tests/test_credentials.py b/tests/test_credentials.py
new file mode 100644
index 0000000..b3609c5
--- /dev/null
+++ b/tests/test_credentials.py
@@ -0,0 +1,14 @@
+# When running integration tests, the following values will be used. Fill it with your own values.
+aws_access_key_id: str = ""
+aws_secret_access_key: str = ""
+aws_region_name: str = ""
+aws_s3_bucket_name: str = ""
+sql_alchemy_db_url: str = ""
+aws_route53_hosted_zone_id: str = ""
+aws_route53_other_hosted_zone_id: str = ""
+
+# either miner_instance_id or miner_instance_ip should be used
+miner_instance_id: str = ""
+miner_instance_ip: str = ""
+
+miner_instance_port: int = 80
diff --git a/tests/test_encryption.py b/tests/test_encryption.py
deleted file mode 100644
index 8c3711c..0000000
--- a/tests/test_encryption.py
+++ /dev/null
@@ -1,169 +0,0 @@
-import pytest
-
-from bt_ddos_shield.encryption import (
-    EncryptionManager,
-    EncryptionError,
-    DecryptionError,
-)
-from ecies.utils import generate_eth_key
-
-# Generate a valid pair of public and private keys for testing
-eth_k = generate_eth_key()
-private_key = eth_k.to_hex()
-public_key = eth_k.public_key.to_hex()
-
-# Sample test data
-valid_test_data = {
-    "name": "John",
-    "age": 32,
-    "github": {"login": "John", "events": [1, 2, 3]},
-}
-empty_data_dict = {}
-non_encrypted_bytes = b"This is not encrypted"
-empty_byte = b""
-invalid_key_type = 123
-invalid_string_data = "invalid_data"
-
-# Pre-encrypt valid data for decryption tests.
-pre_encrypted_data = EncryptionManager.encrypt_data(
-    public_key=public_key, data=valid_test_data
-)
-
-
-class TestEncryptionManager:
-    """
-    Test suite for the EncryptionManager class.
-    """
-
-    def test_encrypt_data_valid(self):
-        """
-        Test encryption with valid public key and data.
-        Ensures the returned encrypted data is of bytes type.
-        """
-        encrypted_data = EncryptionManager.encrypt_data(
-            public_key=public_key, data=valid_test_data
-        )
-        assert isinstance(
-            encrypted_data, bytes
-        ), "Encrypted dta should be of type bytes"
-
-    def test_encrypt_data_invalid_public_key(self):
-        """
-        Test encryption with an invalid public key (string that doesn't represent a valid key).
-        Expects EncryptionError to be raised.
-        """
-        with pytest.raises(EncryptionError):
-            EncryptionManager.encrypt_data(
-                public_key=invalid_string_data, data=valid_test_data
-            )
-
-    def test_encrypt_data_invalid_data_type(self):
-        """
-        Test encryption with an invalid data type (non-dict data).
-        Expects TypeError to be raised.
-        """
-        with pytest.raises(TypeError):
-            EncryptionManager.encrypt_data(
-                public_key=public_key, data=invalid_string_data
-            )
-
-    def test_encrypt_data_invalid_public_key_type(self):
-        """
-        Test encryption with a public key of invalid type (e.g., integer).
-        Expects TypeError to be raised.
-        """
-        with pytest.raises(TypeError):
-            EncryptionManager.encrypt_data(
-                public_key=invalid_key_type, data=valid_test_data
-            )
-
-    def test_encrypt_data_empty_data(self):
-        """
-        Test encryption with an empty dictionary.
-        Expects encryption to succeed and return data of type bytes.
-        """
-        encrypted_empty_data = EncryptionManager.encrypt_data(
-            public_key=public_key, data=empty_data_dict
-        )
-        assert isinstance(
-            encrypted_empty_data, bytes
-        ), "Encrypted data should be of type bytes for an empty dict"
-
-    def test_decrypt_data_valid(self):
-        """
-        Test decryption with valid private key and encrypted data.
-        Ensures that the decrypted data matches the original dictionary.
-        """
-        decrypted_data = EncryptionManager.decrypt_data(
-            private_key=private_key, encrypted_data=pre_encrypted_data
-        )
-        assert isinstance(decrypted_data, dict), "Decrypted data should be of type dict"
-        assert (
-            decrypted_data == valid_test_data
-        ), "Decrypted data should match the original data"
-
-    def test_decrypt_data_empty_data(self):
-        """
-        Test decryption with an empty dictionary.
-        Expects that the decrypted data matches the original dictionary.
-        """
-        encrypted_empty_data = EncryptionManager.encrypt_data(
-            public_key=public_key, data=empty_data_dict
-        )
-        decrypted_data = EncryptionManager.decrypt_data(
-            private_key=private_key, encrypted_data=encrypted_empty_data
-        )
-        assert isinstance(decrypted_data, dict), "Decrypted data should be of type dict"
-        assert (
-            decrypted_data == empty_data_dict
-        ), "Decrypted data should match the original data"
-
-    def test_decrypt_data_invalid_private_key(self):
-        """
-        Test decryption with an invalid private key (string that doesn't represent a valid key).
-        Expects DecryptionError to be raised.
-        """
-        with pytest.raises(DecryptionError):
-            EncryptionManager.decrypt_data(
-                private_key=invalid_string_data, encrypted_data=pre_encrypted_data
-            )
-
-    def test_decrypt_data_invalid_encrypted_data(self):
-        """
-        Test decryption with invalid encrypted data (non-encrypted bytes).
-        Expects DecryptionError to be raised.
-        """
-        with pytest.raises(DecryptionError):
-            EncryptionManager.decrypt_data(
-                private_key=private_key, encrypted_data=non_encrypted_bytes
-            )
-
-    def test_decrypt_data_invalid_private_key_type(self):
-        """
-        Test decryption with a private key of invalid type (e.g., integer).
-        Expects TypeError to be raised.
-        """
-        with pytest.raises(TypeError):
-            EncryptionManager.decrypt_data(
-                private_key=invalid_key_type, encrypted_data=pre_encrypted_data
-            )
-
-    def test_decrypt_data_invalid_encrypted_data_type(self):
-        """
-        Test decryption with encrypted data of invalid type (e.g., integer).
-        Expects TypeError to be raised.
-        """
-        with pytest.raises(TypeError):
-            EncryptionManager.decrypt_data(
-                private_key=private_key, encrypted_data=invalid_key_type
-            )
-
-    def test_decrypt_data_empty_encrypted_data(self):
-        """
-        Test decryption with empty encrypted data (empty byte string).
-        Expects DecryptionError to be raised.
-        """
-        with pytest.raises(DecryptionError):
-            EncryptionManager.decrypt_data(
-                private_key=private_key, encrypted_data=empty_byte
-            )
diff --git a/tests/test_encryption_manager.py b/tests/test_encryption_manager.py
new file mode 100644
index 0000000..7d61f46
--- /dev/null
+++ b/tests/test_encryption_manager.py
@@ -0,0 +1,72 @@
+import pytest
+from bt_ddos_shield.encryption_manager import (
+    DecryptionError,
+    ECIESEncryptionManager,
+    EncryptionError,
+)
+from ecies.utils import generate_eth_key
+
+
+def generate_key_pair() -> tuple[str, str]:
+    """
+    Generate a pair of private and public Ethereum (secp256k1) keys in hex format.
+    """
+    eth_k = generate_eth_key()
+    private_key: str = eth_k.to_hex()
+    public_key: str = eth_k.public_key.to_hex()
+    return private_key, public_key
+
+
+# Sample test data
+valid_test_data = b"encrypted_address"
+non_encrypted_bytes = b"This is not encrypted"
+invalid_key = "invalid_key"
+
+
+class TestEncryptionManager:
+    """
+    Test suite for the EncryptionManager class.
+    """
+
+    encryption_manager = ECIESEncryptionManager()
+    private_key, public_key = generate_key_pair()
+
+    def test_encrypt_data_valid(self):
+        """
+        Test encryption with valid public key and data.
+        """
+        self.encryption_manager.encrypt(public_key=self.public_key, data=valid_test_data)
+
+    def test_encrypt_data_invalid_public_key(self):
+        """
+        Test encryption with an invalid public key (string that doesn't represent a valid key).
+        Expects EncryptionError to be raised.
+        """
+        with pytest.raises(EncryptionError):
+            self.encryption_manager.encrypt(public_key=invalid_key, data=valid_test_data)
+
+    def test_decrypt_data_valid(self):
+        """
+        Test decryption with valid private key and encrypted data.
+        Ensures that the decrypted data matches the original one.
+        """
+        encrypted_data = self.encryption_manager.encrypt(public_key=self.public_key, data=valid_test_data)
+        decrypted_data = self.encryption_manager.decrypt(private_key=self.private_key, data=encrypted_data)
+        assert decrypted_data == valid_test_data, "Decrypted data should match the original data"
+
+    def test_decrypt_data_invalid_private_key(self):
+        """
+        Test decryption with an invalid private key (string that doesn't represent a valid key).
+        Expects DecryptionError to be raised.
+        """
+        encrypted_data = self.encryption_manager.encrypt(public_key=self.public_key, data=valid_test_data)
+        with pytest.raises(DecryptionError):
+            self.encryption_manager.decrypt(private_key=invalid_key, data=encrypted_data)
+
+    def test_decrypt_data_invalid_encrypted_data(self):
+        """
+        Test decryption with invalid encrypted data (non-encrypted bytes).
+        Expects DecryptionError to be raised.
+        """
+        with pytest.raises(DecryptionError):
+            self.encryption_manager.decrypt(private_key=self.private_key, data=non_encrypted_bytes)
diff --git a/tests/test_manifest_manager.py b/tests/test_manifest_manager.py
new file mode 100644
index 0000000..ec0d879
--- /dev/null
+++ b/tests/test_manifest_manager.py
@@ -0,0 +1,89 @@
+from typing import Optional
+
+import pytest
+from bt_ddos_shield.address import Address, AddressType, DefaultAddressSerializer
+from bt_ddos_shield.encryption_manager import ECIESEncryptionManager
+from bt_ddos_shield.manifest_manager import (
+    AbstractManifestManager,
+    JsonManifestSerializer,
+    Manifest,
+    ManifestNotFoundException,
+    S3ManifestManager,
+)
+from bt_ddos_shield.utils import AWSClientFactory, Hotkey
+from tests.test_credentials import (
+    aws_access_key_id,
+    aws_region_name,
+    aws_s3_bucket_name,
+    aws_secret_access_key,
+)
+
+
+class MemoryManifestManager(AbstractManifestManager):
+    default_address: Address
+    stored_file: Optional[bytes]
+    put_counter: int
+
+    def __init__(self):
+        super().__init__(DefaultAddressSerializer(), JsonManifestSerializer(), ECIESEncryptionManager())
+        self.default_address = Address(address_id='default_id', address_type=AddressType.DOMAIN,
+                                       address='manifest.com', port=80)
+        self.stored_file = None
+        self.put_counter = 0
+
+    def _put_manifest_file(self, data: bytes) -> Address:
+        self.stored_file = data
+        self.put_counter += 1
+        return self.default_address
+
+    def _get_manifest_file(self, address: Address) -> bytes:
+        if self.stored_file is None or address != self.default_address:
+            raise ManifestNotFoundException(f"Manifest file not found under address: {address}")
+        return self.stored_file
+
+
+class TestManifestManager:
+    """
+    Test suite for the manifest manager.
+    """
+
+    def test_json_serializer(self):
+        manifest_serializer = JsonManifestSerializer()
+        mapping: dict[Hotkey, bytes] = {Hotkey('validator1'): b'address1', Hotkey('validator2'): b'address2'}
+        md5_hash: str = "some_hash"
+        manifest: Manifest = Manifest(mapping, md5_hash)
+        json_data: bytes = manifest_serializer.serialize(manifest)
+        deserialized_manifest: Manifest = manifest_serializer.deserialize(json_data)
+
+        assert manifest == deserialized_manifest
+
+    def test_s3_put_get(self):
+        """ Test S3ManifestManager class. Put manifest file, get it and check if it was stored correctly. """
+        aws_client_factory: AWSClientFactory = AWSClientFactory(aws_access_key_id, aws_secret_access_key,
+                                                                aws_region_name)
+        manifest_manager = S3ManifestManager(aws_client_factory=aws_client_factory, bucket_name=aws_s3_bucket_name,
+                                             address_serializer=DefaultAddressSerializer(),
+                                             manifest_serializer=JsonManifestSerializer(),
+                                             encryption_manager=ECIESEncryptionManager())
+
+        data: bytes = b'some_data'
+        address: Address = manifest_manager._put_manifest_file(data)
+        retrieved_data: bytes = manifest_manager._get_manifest_file(address)
+        assert retrieved_data == data
+
+        other_data: bytes = b'other_data'
+        address: Address = manifest_manager._put_manifest_file(other_data)
+        retrieved_data: bytes = manifest_manager._get_manifest_file(address)
+        assert retrieved_data == other_data
+
+        validator_aws_client_factory: AWSClientFactory = AWSClientFactory(aws_access_key_id, aws_secret_access_key)
+        validator_manifest_manager = S3ManifestManager(address_serializer=DefaultAddressSerializer(),
+                                                       manifest_serializer=JsonManifestSerializer(),
+                                                       encryption_manager=ECIESEncryptionManager(),
+                                                       aws_client_factory=validator_aws_client_factory)
+        retrieved_data: bytes = validator_manifest_manager._get_manifest_file(address)
+        assert retrieved_data == other_data
+
+        address.address_id = 'xxx'
+        with pytest.raises(ManifestNotFoundException):
+            manifest_manager._get_manifest_file(address)
diff --git a/tests/test_miner_shield.py b/tests/test_miner_shield.py
new file mode 100644
index 0000000..0370b0d
--- /dev/null
+++ b/tests/test_miner_shield.py
@@ -0,0 +1,311 @@
+import os
+from time import sleep
+from typing import Optional
+
+from bt_ddos_shield.address import Address
+from bt_ddos_shield.address_manager import AbstractAddressManager
+from bt_ddos_shield.blockchain_manager import AbstractBlockchainManager
+from bt_ddos_shield.event_processor import PrintingMinerShieldEventProcessor
+from bt_ddos_shield.manifest_manager import AbstractManifestManager, Manifest
+from bt_ddos_shield.miner_shield import MinerShield, MinerShieldFactory, MinerShieldOptions
+from bt_ddos_shield.state_manager import MinerShieldState, SQLAlchemyMinerShieldStateManager
+from bt_ddos_shield.utils import Hotkey, PublicKey
+from bt_ddos_shield.validators_manager import MemoryValidatorsManager
+from tests.test_address_manager import MemoryAddressManager
+from tests.test_blockchain_manager import MemoryBlockchainManager
+from tests.test_credentials import (
+    aws_access_key_id,
+    aws_region_name,
+    aws_route53_hosted_zone_id,
+    aws_s3_bucket_name,
+    aws_secret_access_key,
+    miner_instance_ip,
+    miner_instance_port,
+    sql_alchemy_db_url,
+)
+from tests.test_encryption_manager import generate_key_pair
+from tests.test_manifest_manager import MemoryManifestManager
+from tests.test_state_manager import MemoryMinerShieldStateManager
+
+
+class TestMinerShield:
+    """
+    Test suite for the MinerShield class.
+    """
+
+    MINER_HOTKEY: Hotkey = "miner"
+    VALIDATOR_1_HOTKEY: Hotkey = "validator1"
+    VALIDATOR_1_PUBLICKEY: PublicKey = generate_key_pair()[1]
+    VALIDATOR_2_HOTKEY: Hotkey = "validator2"
+    VALIDATOR_2_PUBLICKEY: PublicKey = generate_key_pair()[1]
+    VALIDATOR_3_HOTKEY: Hotkey = "validator3"
+    VALIDATOR_3_PUBLICKEY: PublicKey = generate_key_pair()[1]
+    VALIDATOR_3_OTHER_PUBLICKEY: PublicKey = generate_key_pair()[1]
+    VALIDATOR_4_HOTKEY: Hotkey = "validator4"
+    VALIDATOR_4_PUBLICKEY: PublicKey = generate_key_pair()[1]
+    OTHER_VALIDATOR_HOTKEY: Hotkey = "other_validator"
+    DEFAULT_VALIDATORS = {VALIDATOR_1_HOTKEY: VALIDATOR_1_PUBLICKEY, VALIDATOR_2_HOTKEY: VALIDATOR_2_PUBLICKEY,
+                          VALIDATOR_3_HOTKEY: VALIDATOR_3_PUBLICKEY}
+
+    @classmethod
+    def create_memory_validators_manager(cls, validators: Optional[dict[Hotkey, PublicKey]] = None)\
+            -> MemoryValidatorsManager:
+        if validators is None:
+            validators = cls.DEFAULT_VALIDATORS
+        return MemoryValidatorsManager(dict(validators))
+
+    def create_default_shield(self, validate_interval_sec: int = 2):
+        self.validators_manager: MemoryValidatorsManager = self.create_memory_validators_manager()
+        self.address_manager: MemoryAddressManager = MemoryAddressManager()
+        self.manifest_manager: MemoryManifestManager = MemoryManifestManager()
+        self.blockchain_manager: MemoryBlockchainManager = MemoryBlockchainManager(self.MINER_HOTKEY)
+        self.state_manager: MemoryMinerShieldStateManager = MemoryMinerShieldStateManager()
+        self.shield = MinerShield(self.MINER_HOTKEY, self.validators_manager, self.address_manager,
+                                  self.manifest_manager, self.blockchain_manager, self.state_manager,
+                                  PrintingMinerShieldEventProcessor(),
+                                  MinerShieldOptions(retry_delay_sec=1, validate_interval_sec=validate_interval_sec))
+        self.shield.enable()
+        assert self.shield.run
+
+    def test_start_stop_with_exception(self):
+        """
+        Test if shield is properly starting and stopping when exception is thrown during initialization.
+        """
+        state_manager = None  # set state_manager to None to force exception during initialization
+
+        # noinspection PyTypeChecker
+        shield = MinerShield(self.MINER_HOTKEY, self.create_memory_validators_manager(), MemoryAddressManager(),
+                             MemoryManifestManager(), MemoryBlockchainManager(self.MINER_HOTKEY),
+                             state_manager, PrintingMinerShieldEventProcessor(), MinerShieldOptions(retry_delay_sec=1))
+        shield.enable()
+        assert shield.run
+        sleep(1)
+        shield.disable()
+        assert not shield.run
+
+    def test_full_flow(self):
+        """
+        Test if shield is properly starting from scratch and fully enabling protection using mock memory managers.
+        """
+        self.create_default_shield()
+        sleep(2 + 2*self.shield.options.validate_interval_sec)  # give some time to make sure validate is called
+
+        try:
+            state: MinerShieldState = self.state_manager.get_state()
+            assert self.validators_manager.get_validators() == self.DEFAULT_VALIDATORS
+            assert state.known_validators == self.validators_manager.get_validators()
+            assert state.banned_validators == {}
+            assert state.validators_addresses.keys() == self.validators_manager.get_validators().keys()
+            assert state.manifest_address == self.manifest_manager.default_address
+            assert list(state.validators_addresses.values()) == list(self.address_manager.known_addresses.values())
+            assert self.address_manager.id_counter == len(state.validators_addresses)
+            assert self.manifest_manager.stored_file is not None
+            assert self.manifest_manager.put_counter == 1
+            manifest_address: Address = self.manifest_manager.default_address
+            manifest: Manifest = self.manifest_manager.get_manifest(manifest_address)
+            assert manifest.encrypted_address_mapping.keys() == state.validators_addresses.keys()
+            assert self.blockchain_manager.get_miner_manifest_address() == manifest_address
+            assert self.blockchain_manager.put_counter == 1
+        finally:
+            self.shield.disable()
+            assert not self.shield.run
+
+    def test_integration(self):
+        """
+        Test if shield is properly starting from scratch and fully enabling protection using real managers.
+        """
+        os.environ["MINER_HOTKEY"] = self.MINER_HOTKEY
+        os.environ["AWS_MINER_INSTANCE_IP"] = miner_instance_ip
+        os.environ["MINER_INSTANCE_PORT"] = str(miner_instance_port)
+        os.environ["AWS_ACCESS_KEY_ID"] = aws_access_key_id
+        os.environ["AWS_SECRET_ACCESS_KEY"] = aws_secret_access_key
+        os.environ["AWS_REGION_NAME"] = aws_region_name
+        os.environ["AWS_S3_BUCKET_NAME"] = aws_s3_bucket_name
+        os.environ["AWS_ROUTE53_HOSTED_ZONE_ID"] = aws_route53_hosted_zone_id
+        os.environ["SQL_ALCHEMY_DB_URL"] = sql_alchemy_db_url
+        shield: MinerShield = MinerShieldFactory.create_miner_shield(self.DEFAULT_VALIDATORS)
+
+        assert isinstance(shield.state_manager, SQLAlchemyMinerShieldStateManager)
+        state_manager: SQLAlchemyMinerShieldStateManager = shield.state_manager  # type: ignore
+        state_manager.clear_tables()
+
+        assert isinstance(shield.validators_manager, MemoryValidatorsManager)
+        validators_manager: MemoryValidatorsManager = shield.validators_manager  # type: ignore
+
+        manifest_manager: AbstractManifestManager = shield.manifest_manager
+        blockchain_manager: AbstractBlockchainManager = shield.blockchain_manager
+        address_manager: AbstractAddressManager = shield.address_manager
+
+        # Shorten validate_interval_sec and retry_delay_sec to speed up tests
+        shield.options.validate_interval_sec = 10
+        shield.options.retry_delay_sec = 1
+
+        shield.enable()
+        assert shield.run
+
+        # Give some time to make sure everything is initialized and validate is called
+        sleep(120 + 2*shield.options.validate_interval_sec)
+
+        try:
+            state: MinerShieldState = state_manager.get_state()
+            assert validators_manager.get_validators() == self.DEFAULT_VALIDATORS
+            assert state.known_validators == validators_manager.get_validators()
+            assert state.banned_validators == {}
+            assert state.validators_addresses.keys() == validators_manager.get_validators().keys()
+            assert state.manifest_address is not None
+            manifest: Manifest = manifest_manager.get_manifest(state.manifest_address)
+            assert manifest.encrypted_address_mapping.keys() == state.validators_addresses.keys()
+            assert blockchain_manager.get_miner_manifest_address() == state.manifest_address
+
+            reloaded_state: MinerShieldState = state_manager.get_state(reload=True)
+            assert reloaded_state == state
+
+            # Remove all validators to clean up everything (except S3 file) and check if validate loop is running.
+            validators_manager.validators.clear()
+            sleep(10 + shield.options.validate_interval_sec)
+
+            state = state_manager.get_state()
+            assert state.known_validators == {}
+            assert state.validators_addresses == {}
+            manifest: Manifest = manifest_manager.get_manifest(state.manifest_address)
+            assert manifest.encrypted_address_mapping == {}
+            assert blockchain_manager.get_miner_manifest_address() == state.manifest_address
+
+            reloaded_state: MinerShieldState = state_manager.get_state(reload=True)
+            assert reloaded_state == state
+        finally:
+            shield.disable()
+            assert not shield.run
+            address_manager.clean_all()
+
+    def test_ban_validator(self):
+        """
+        Test if shield is properly banning validators.
+        """
+        # Use long validate_interval_sec to avoid race conditions between manipulating data due to validation
+        # and accessing state in tests.
+        self.create_default_shield(validate_interval_sec=600)
+        sleep(2)
+
+        try:
+            state: MinerShieldState = self.state_manager.get_state()
+            assert state.known_validators == self.validators_manager.get_validators()
+            assert state.banned_validators == {}
+
+            # shield is working, ban single validator
+
+            expected_validators: dict[Hotkey, PublicKey] = dict(self.validators_manager.get_validators())
+            expected_validators.pop(self.VALIDATOR_1_HOTKEY)
+            banned_validators: set[Hotkey] = {self.VALIDATOR_1_HOTKEY}
+            self.shield.ban_validator(self.VALIDATOR_1_HOTKEY)
+            sleep(2)
+
+            state = self.state_manager.get_state()
+            assert state.known_validators == expected_validators
+            assert state.banned_validators.keys() == banned_validators
+            assert self.manifest_manager.put_counter == 2
+            assert self.blockchain_manager.put_counter == 1  # file is put under same address
+
+            # check banning non-existing validator
+
+            self.shield.ban_validator(self.OTHER_VALIDATOR_HOTKEY)
+            banned_validators.add(self.OTHER_VALIDATOR_HOTKEY)
+            sleep(2)
+
+            state = self.state_manager.get_state()
+            assert state.known_validators == expected_validators
+            assert state.banned_validators.keys() == banned_validators
+            assert self.manifest_manager.put_counter == 2  # known validators haven't changed
+        finally:
+            self.shield.disable()
+
+    def test_reloading_validators(self):
+        """
+        Test if shield is properly handling changing validators set during runtime.
+        """
+        self.create_default_shield(validate_interval_sec=5)
+        sleep(2)
+
+        try:
+            # add VALIDATOR_4 and remove VALIDATOR_2 - changes should be reflected in the state after validation runs
+            self.validators_manager.validators.pop(self.VALIDATOR_2_HOTKEY)
+            self.validators_manager.validators[self.VALIDATOR_4_HOTKEY] = self.VALIDATOR_4_PUBLICKEY
+            expected_validators: dict[Hotkey, PublicKey] = dict(self.DEFAULT_VALIDATORS)
+            expected_validators.pop(self.VALIDATOR_2_HOTKEY)
+            expected_validators[self.VALIDATOR_4_HOTKEY] = self.VALIDATOR_4_PUBLICKEY
+            state: MinerShieldState = self.state_manager.get_state()
+            expected_address_id_counter: int = len(state.validators_addresses)
+            assert self.address_manager.id_counter == expected_address_id_counter
+            assert state.known_validators != expected_validators  # need to wait
+            assert self.manifest_manager.put_counter == 1
+
+            # wait for validation and check results
+            sleep(self.shield.options.validate_interval_sec)
+            state = self.state_manager.get_state()
+            assert state.known_validators == expected_validators
+            assert state.validators_addresses.keys() == state.known_validators.keys()
+            assert list(state.validators_addresses.values()) == list(self.address_manager.known_addresses.values())
+            expected_address_id_counter += 1  # +1 for new validator
+            assert self.address_manager.id_counter == expected_address_id_counter
+            assert self.manifest_manager.put_counter == 2
+
+            # change public key of single validator - changes should be reflected in the state after validation runs
+            self.validators_manager.validators[self.VALIDATOR_3_HOTKEY] = self.VALIDATOR_3_OTHER_PUBLICKEY
+            expected_validators[self.VALIDATOR_3_HOTKEY] = self.VALIDATOR_3_OTHER_PUBLICKEY
+            state = self.state_manager.get_state()
+            assert state.known_validators != expected_validators  # need to wait
+
+            # wait for validation and check results
+            sleep(self.shield.options.validate_interval_sec)
+            state = self.state_manager.get_state()
+            assert state.known_validators == expected_validators
+            assert self.address_manager.id_counter == expected_address_id_counter
+            assert self.manifest_manager.put_counter == 3
+        finally:
+            self.shield.disable()
+
+    def test_validate_addresses(self):
+        """
+        Test if shield is properly handling validating addresses during runtime.
+        """
+        self.create_default_shield(validate_interval_sec=5)
+        sleep(2)
+
+        try:
+            expected_address_id_counter: int = len(self.DEFAULT_VALIDATORS)
+
+            # set invalid address manually - new address should be created after validation runs
+            self.address_manager.invalid_addresses = {self.VALIDATOR_1_HOTKEY}
+            state: MinerShieldState = self.state_manager.get_state()
+            assert self.address_manager.id_counter == expected_address_id_counter
+            old_address = state.validators_addresses.get(self.VALIDATOR_1_HOTKEY)
+            assert self.address_manager.known_addresses.get(old_address.address_id) == old_address
+
+            # wait for validation and check results
+            expected_address_id_counter += 1  # +1 for regenerating address
+            sleep(self.shield.options.validate_interval_sec)
+            state = self.state_manager.get_state()
+            assert self.address_manager.id_counter == expected_address_id_counter
+            assert self.manifest_manager.put_counter == 2
+            new_address = state.validators_addresses.get(self.VALIDATOR_1_HOTKEY)
+            assert old_address != new_address
+            assert self.address_manager.known_addresses.get(new_address.address_id) == new_address
+            assert self.address_manager.known_addresses.get(old_address.address_id, None) is None
+        finally:
+            self.shield.disable()
+
+    def test_validate_manifest_file(self):
+        """
+        Test if shield is properly handling validating manifest file during runtime.
+        """
+        self.create_default_shield(validate_interval_sec=5)
+        sleep(2)
+
+        try:
+            # change file contents manually - file should be overwritten after validation runs
+            assert self.manifest_manager.put_counter == 1
+            self.manifest_manager.stored_file = b'xxx'
+            sleep(self.shield.options.validate_interval_sec)
+            assert self.manifest_manager.put_counter == 2
+        finally:
+            self.shield.disable()
diff --git a/tests/test_state_manager.py b/tests/test_state_manager.py
new file mode 100644
index 0000000..e60ec63
--- /dev/null
+++ b/tests/test_state_manager.py
@@ -0,0 +1,215 @@
+from datetime import datetime
+from time import sleep
+from typing import Optional
+
+import pytest
+from bt_ddos_shield.address import Address, AddressType
+from bt_ddos_shield.state_manager import (
+    AbstractMinerShieldStateManager,
+    MinerShieldState,
+    SQLAlchemyMinerShieldStateManager,
+)
+from bt_ddos_shield.utils import Hotkey, PublicKey
+from sqlalchemy.exc import IntegrityError, NoResultFound
+from tests.test_credentials import sql_alchemy_db_url
+
+
+class MemoryMinerShieldStateManager(AbstractMinerShieldStateManager):
+    def __init__(self):
+        super().__init__()
+        self.current_miner_shield_state = MinerShieldState(known_validators={}, banned_validators={},
+                                                           validators_addresses={}, manifest_address=None,
+                                                           address_manager_state={},
+                                                           address_manager_created_objects={})
+
+    def add_validator(self, validator_hotkey: Hotkey, validator_public_key: PublicKey, redirect_address: Address):
+        self._state_add_validator(validator_hotkey, validator_public_key, redirect_address)
+
+    def update_validator_public_key(self, validator_hotkey: Hotkey, validator_public_key: PublicKey):
+        self._state_update_validator_public_key(validator_hotkey, validator_public_key)
+
+    def add_banned_validator(self, validator_hotkey: Hotkey):
+        if validator_hotkey in self.current_miner_shield_state.banned_validators:
+            return
+        self._state_add_banned_validator(validator_hotkey, datetime.now())
+
+    def remove_validator(self, validator_hotkey: Hotkey):
+        self._state_remove_validator(validator_hotkey)
+
+    def set_manifest_address(self, manifest_address: Address):
+        self._state_set_manifest_address(manifest_address)
+
+    def update_address_manager_state(self, key: str, value: Optional[str]):
+        self._state_update_address_manager_state(key, value)
+
+    def add_address_manager_created_object(self, obj_type: str, obj_id: str):
+        self._state_add_address_manager_created_object(obj_type, obj_id)
+
+    def del_address_manager_created_object(self, obj_type: str, obj_id: str):
+        self._state_del_address_manager_created_object(obj_type, obj_id)
+
+    def _load_state_from_storage(self) -> MinerShieldState:
+        return self.current_miner_shield_state
+
+
+class TestMinerShieldStateManager:
+    """
+    Test suite for the state manager.
+    """
+
+    @classmethod
+    def create_db_state_manager(cls) -> SQLAlchemyMinerShieldStateManager:
+        state_manager = SQLAlchemyMinerShieldStateManager(sql_alchemy_db_url)
+        state_manager.clear_tables()
+        state_manager.get_state()
+        return state_manager
+
+    def test_active_validators(self):
+        validator1_hotkey = "validator1"
+        validator1_publickey = "publickey1"
+        validator1_address = Address(address_id="validator1_id", address_type=AddressType.IP,
+                                     address="1.2.3.4", port=80)
+
+        validator2_hotkey = "validator2"
+        validator2_publickey = "publickey2"
+        validator2_new_publickey = "new_publickey2"
+        validator2_address = Address(address_id="validator2_id", address_type=AddressType.IP,
+                                     address="2.3.4.5", port=81)
+
+        state_manager = self.create_db_state_manager()
+
+        state_manager.add_validator(validator1_hotkey, validator1_publickey, validator1_address)
+        # can't add again same address
+        with pytest.raises(IntegrityError):
+            state_manager.add_validator(validator2_hotkey, validator2_publickey, validator1_address)
+        state_manager.add_validator(validator2_hotkey, validator2_publickey, validator2_address)
+        # can't add again same validator
+        with pytest.raises(IntegrityError):
+            state_manager.add_validator(validator1_hotkey, validator1_publickey, validator1_address)
+
+        state_manager.update_validator_public_key(validator2_hotkey, validator2_new_publickey)
+
+        state_manager.remove_validator(validator1_hotkey)
+        with pytest.raises(NoResultFound):
+            state_manager.remove_validator(validator1_hotkey)
+
+        with pytest.raises(NoResultFound):
+            state_manager.update_validator_public_key(validator1_hotkey, validator2_new_publickey)
+
+        state: MinerShieldState = state_manager.get_state()
+        assert state.known_validators == {validator2_hotkey: validator2_new_publickey}
+        assert state.validators_addresses == {validator2_hotkey: validator2_address}
+
+        reloaded_state: MinerShieldState = state_manager.get_state(reload=True)
+        assert state == reloaded_state
+
+    def test_banned_validators(self):
+        banned_validator_hotkey = "banned_validator"
+
+        state_manager = self.create_db_state_manager()
+
+        state_manager.add_banned_validator(banned_validator_hotkey)
+        ban_time: datetime = state_manager.get_state().banned_validators[banned_validator_hotkey]
+        sleep(2)
+        state_manager.add_banned_validator(banned_validator_hotkey)
+        assert ban_time == state_manager.get_state().banned_validators[banned_validator_hotkey], \
+            "first ban time should not change"
+
+        state: MinerShieldState = state_manager.get_state()
+        assert state.banned_validators == {banned_validator_hotkey: ban_time}
+
+        reloaded_state: MinerShieldState = state_manager.get_state(reload=True)
+        assert state == reloaded_state
+
+    def test_manifest_address(self):
+        manifest_address1 = Address(address_id="manifest", address_type=AddressType.IP,
+                                    address="1.2.3.4", port=80)
+        manifest_address2 = Address(address_id="manifest", address_type=AddressType.IP,
+                                    address="2.3.4.5", port=81)
+
+        state_manager = self.create_db_state_manager()
+        state_manager.set_manifest_address(manifest_address1)
+        state_manager.set_manifest_address(manifest_address2)
+        state: MinerShieldState = state_manager.get_state()
+        assert state.manifest_address == manifest_address2
+
+        reloaded_state: MinerShieldState = state_manager.get_state(reload=True)
+        assert state == reloaded_state
+
+    def test_address_manager_state(self):
+        key1 = "key1"
+        value1 = "value1"
+        key2 = "key2"
+        value2 = "value2"
+        key3 = "key3"
+
+        state_manager = self.create_db_state_manager()
+
+        # Add key-value pairs to the address manager state
+        state_manager.update_address_manager_state(key1, value1)
+        state_manager.update_address_manager_state(key2, value2)
+
+        state: MinerShieldState = state_manager.get_state()
+        assert state.address_manager_state == {key1: value1, key2: value2}
+
+        # Update an existing key
+        new_value1 = "new_value1"
+        state_manager.update_address_manager_state(key1, new_value1)
+        state = state_manager.get_state()
+        assert state.address_manager_state == {key1: new_value1, key2: value2}
+
+        # Remove a key
+        state_manager.update_address_manager_state(key2, None)
+        state = state_manager.get_state()
+        assert state.address_manager_state == {key1: new_value1}
+
+        # Ensure a non-existent key is not present
+        state_manager.update_address_manager_state(key3, None)
+        state = state_manager.get_state()
+        assert key3 not in state.address_manager_state
+
+        reloaded_state: MinerShieldState = state_manager.get_state(reload=True)
+        assert state == reloaded_state
+
+    def test_address_manager_created_objects(self):
+        object_type1 = "type1"
+        object_id1 = "id1"
+        object_type2 = "type2"
+        object_id2 = "id2"
+        object_id3 = "id3"
+
+        state_manager = self.create_db_state_manager()
+
+        # Add objects to the address manager created objects
+        state_manager.add_address_manager_created_object(object_type1, object_id1)
+        state_manager.add_address_manager_created_object(object_type2, object_id2)
+
+        state: MinerShieldState = state_manager.get_state()
+        assert state.address_manager_created_objects == {object_type1: {object_id1}, object_type2: {object_id2}}
+
+        # Add another object to an existing type
+        state_manager.add_address_manager_created_object(object_type2, object_id3)
+        state = state_manager.get_state()
+        assert state.address_manager_created_objects == {object_type1: {object_id1},
+                                                         object_type2: {object_id2, object_id3}}
+
+        reloaded_state = state_manager.get_state(reload=True)
+        assert state == reloaded_state
+
+        # Remove an object
+        state_manager.del_address_manager_created_object(object_type2, object_id2)
+        state = state_manager.get_state()
+        assert state.address_manager_created_objects == {object_type1: {object_id1}, object_type2: {object_id3}}
+
+        # Ensure a non-existent object is not present
+        state_manager.del_address_manager_created_object(object_type2, "non_existent_id")
+        state = state_manager.get_state()
+        assert state.address_manager_created_objects == {object_type1: {object_id1}, object_type2: {object_id3}}
+
+        # Remove last object of given type
+        state_manager.del_address_manager_created_object(object_type2, object_id3)
+        state = state_manager.get_state()
+        assert state.address_manager_created_objects == {object_type1: {object_id1}}
+
+        reloaded_state: MinerShieldState = state_manager.get_state(reload=True)
+        assert state == reloaded_state
diff --git a/tests/test_validator.py b/tests/test_validator.py
new file mode 100644
index 0000000..c05d34d
--- /dev/null
+++ b/tests/test_validator.py
@@ -0,0 +1,73 @@
+import asyncio
+import os
+from urllib.parse import urlparse
+
+from bt_ddos_shield.address_manager import AbstractAddressManager
+from bt_ddos_shield.miner_shield import MinerShield, MinerShieldFactory
+from bt_ddos_shield.state_manager import SQLAlchemyMinerShieldStateManager
+from bt_ddos_shield.utils import Hotkey
+from bt_ddos_shield.validator import MinerAddress, Validator, ValidatorFactory
+from tests.test_credentials import (
+    aws_access_key_id,
+    aws_region_name,
+    aws_route53_hosted_zone_id,
+    aws_s3_bucket_name,
+    aws_secret_access_key,
+    miner_instance_ip,
+    miner_instance_port,
+    sql_alchemy_db_url,
+)
+from tests.test_encryption_manager import generate_key_pair
+
+
+class TestValidator:
+    """
+    Test suite for the Validator class.
+    """
+
+    MINER_HOTKEY: Hotkey = "miner"
+    VALIDATOR_HOTKEY: Hotkey = "validator"
+
+    def test_full_flow(self):
+        """
+        Test if validator is working using real managers and real shield.
+        """
+        validator_private_key, validator_public_key = generate_key_pair()
+        validators = {self.VALIDATOR_HOTKEY: validator_public_key}
+
+        os.environ["MINER_HOTKEY"] = self.MINER_HOTKEY
+        os.environ["AWS_ACCESS_KEY_ID"] = aws_access_key_id
+        os.environ["AWS_SECRET_ACCESS_KEY"] = aws_secret_access_key
+
+        os.environ["VALIDATOR_HOTKEY"] = self.VALIDATOR_HOTKEY
+        os.environ["VALIDATOR_PRIVATE_KEY"] = validator_private_key
+        validator: Validator = ValidatorFactory.create_validator()
+
+        os.environ["AWS_MINER_INSTANCE_IP"] = miner_instance_ip
+        os.environ["MINER_INSTANCE_PORT"] = str(miner_instance_port)
+        os.environ["AWS_REGION_NAME"] = aws_region_name
+        os.environ["AWS_S3_BUCKET_NAME"] = aws_s3_bucket_name
+        os.environ["AWS_ROUTE53_HOSTED_ZONE_ID"] = aws_route53_hosted_zone_id
+        os.environ["SQL_ALCHEMY_DB_URL"] = sql_alchemy_db_url
+        shield: MinerShield = MinerShieldFactory.create_miner_shield(validators)
+
+        assert isinstance(shield.state_manager, SQLAlchemyMinerShieldStateManager)
+        state_manager: SQLAlchemyMinerShieldStateManager = shield.state_manager  # type: ignore
+        state_manager.clear_tables()
+
+        address_manager: AbstractAddressManager = shield.address_manager
+
+        # TODO: Connect blockchain managers because there is only MemoryBlockchainManager as for now
+        validator._blockchain_manager = shield.blockchain_manager
+
+        shield.enable()
+        assert shield.run
+
+        try:
+            miner_address: MinerAddress = asyncio.run(asyncio.wait_for(validator.fetch_miner_address(), timeout=60))
+            urlparse(miner_address.domain)
+            assert miner_address.port == miner_instance_port
+        finally:
+            shield.disable()
+            assert not shield.run
+            address_manager.clean_all()