diff --git a/.gitignore b/.gitignore
index 6d5abbc..4691172 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,5 +13,8 @@
 /GUI/Front/.idea
 /GUI/Front/*.go
 *.css
+*.js
+*.html
 
 test/
+*.map
diff --git a/GUI/App/Background/tracker.go b/GUI/App/Background/tracker.go
index d79b74d..619e24a 100644
--- a/GUI/App/Background/tracker.go
+++ b/GUI/App/Background/tracker.go
@@ -6,24 +6,29 @@ import (
 	"github.com/brokenbydefault/Nanollet/Storage"
 	"github.com/brokenbydefault/Nanollet/Numbers"
 	"github.com/brokenbydefault/Nanollet/Node"
-	"net"
 	"github.com/brokenbydefault/Nanollet/Node/Packets"
 	"time"
+	"github.com/brokenbydefault/Nanollet/Node/Peer"
 )
 
 var Connection Node.Node
 
 func init() {
-	Connection = &Node.Server{
-		Peers:          &Storage.PeerStorage,
-		Transactions:   &Storage.TransactionStorage,
-		Header:         Storage.Configuration.Node.Header,
-		PublishHandler: PublishHandler,
+	Connection = Node.NewServer(
+		Storage.Configuration.Node.Header,
+		&Storage.PeerStorage,
+		&Storage.TransactionStorage,
+	)
+
+	Handler := Node.NewHandler(Connection)
+	Handler.PublishHandler = PublishHandler
+
+	if err := Handler.Start(); err != nil {
+		panic(err)
 	}
-	go Connection.Start()
 }
 
-func PublishHandler(srv *Node.Server, _ *net.UDPAddr, rHeader *Packets.Header, msg []byte) {
+func PublishHandler(node Node.Node, _ *Peer.Peer, rHeader *Packets.Header, msg []byte) {
 	packet := new(Packets.PushPackage)
 
 	if err := packet.Decode(rHeader, msg); err != nil {
@@ -40,7 +45,7 @@ func PublishHandler(srv *Node.Server, _ *net.UDPAddr, rHeader *Packets.Header, m
 		return
 	}
 
-	srv.Transactions.Add(packet.Transaction)
+	node.Transactions().Add(packet.Transaction)
 }
 
 func StartAddress(w *DOM.Window) error {
diff --git a/GUI/App/DOM/change.go b/GUI/App/DOM/change.go
index 94828a1..bd00721 100644
--- a/GUI/App/DOM/change.go
+++ b/GUI/App/DOM/change.go
@@ -1,5 +1,3 @@
-// +build !js
-
 package DOM
 
 import (
diff --git a/GUI/App/DOM/get.go b/GUI/App/DOM/get.go
index 6c40d4e..108d0cb 100644
--- a/GUI/App/DOM/get.go
+++ b/GUI/App/DOM/get.go
@@ -2,6 +2,12 @@
 
 package DOM
 
+import (
+	"bytes"
+	"os"
+	"io"
+)
+
 func (el *Element) GetAttr(name string) (result string, err error) {
 	return el.el.Attr(name)
 }
@@ -55,3 +61,36 @@ func (dom *DOM) GetBytesValueOf(css string) (result []byte, err error) {
 	return input.GetBytesValue()
 }
 
+func (el *Element) GetFile() (io.Reader, error) {
+	input, err := el.GetStringValue()
+	if err != nil || input == "" {
+		return nil, ErrInvalidElement
+	}
+
+	file, err := os.Open(input[7:])
+	if err != nil {
+		return nil, err
+	}
+
+	defer file.Close()
+
+	if stat, err := file.Stat(); err != nil || stat.IsDir() {
+		return nil, ErrInvalidElement
+	}
+
+	r := bytes.NewBuffer(nil)
+	if _, err := io.Copy(r, file); err != nil {
+		return nil, err
+	}
+
+	return r, nil
+}
+
+func (dom *DOM) GetFileOf(css string) (io.Reader, error) {
+	input, err := dom.SelectFirstElement(css)
+	if err != nil {
+		return nil, err
+	}
+
+	return input.GetFile()
+}
diff --git a/GUI/App/DOM/get_js.go b/GUI/App/DOM/get_js.go
index 5786ad7..19c11a2 100644
--- a/GUI/App/DOM/get_js.go
+++ b/GUI/App/DOM/get_js.go
@@ -5,6 +5,9 @@ package DOM
 import (
 	"honnef.co/go/js/dom"
 	"strings"
+	"io"
+	"bytes"
+	"github.com/gopherjs/gopherjs/js"
 )
 
 func (el *Element) GetAttr(name string) (result string, err error) {
@@ -25,11 +28,20 @@ func (el *Element) GetText() (result string, err error) {
 }
 
 func (el *Element) GetStringValue() (result string, err error) {
-	if strings.ToUpper(el.el.TagName()) == "TEXTAREA" {
-		return el.el.(*dom.HTMLTextAreaElement).Value, nil
+	if e, ok := el.el.(*dom.HTMLTextAreaElement); ok {
+		return e.Value, nil
 	}
 
-	return el.el.(*dom.HTMLInputElement).Value, nil
+	e, ok := el.el.(*dom.HTMLInputElement)
+	if !ok {
+		return "", nil
+	}
+
+	if t := strings.ToUpper(e.Type); (t == "CHECKBOX" || t == "OPTION") && !e.Checked {
+		return "", nil
+	}
+
+	return e.Value, nil
 }
 
 func (dom *DOM) GetStringValueOf(css string) (result string, err error) {
@@ -54,3 +66,28 @@ func (dom *DOM) GetBytesValueOf(css string) (result []byte, err error) {
 
 	return input.GetBytesValue()
 }
+
+func (el *Element) GetFile() (io.Reader, error) {
+	input, ok := el.el.(*dom.HTMLInputElement)
+	if !ok {
+		return nil, ErrInvalidElement
+	}
+
+	var b = make(chan io.Reader)
+	fileReader := js.Global.Get("FileReader").New()
+	fileReader.Set("onload", func() {
+		b <- bytes.NewReader(js.Global.Get("Uint8Array").New(fileReader.Get("result")).Interface().([]byte))
+	})
+	fileReader.Call("readAsArrayBuffer", input.Files()[0].Object)
+
+	return <-b, nil
+}
+
+func (dom *DOM) GetFileOf(css string) (io.Reader, error) {
+	input, err := dom.SelectFirstElement(css)
+	if err != nil {
+		return nil, err
+	}
+
+	return input.GetFile()
+}
diff --git a/GUI/App/DOM/init.go b/GUI/App/DOM/init.go
index e2da26f..6e27a4c 100644
--- a/GUI/App/DOM/init.go
+++ b/GUI/App/DOM/init.go
@@ -9,7 +9,7 @@ func (w *Window) InitApplication(app Application) {
 	w.StartApplication(app)
 
 	if !app.HaveSidebar() {
-		button, err := w.root.SelectFirstElement(`.control button[id="`+ app.Name() +`"]`)
+		button, err := w.root.SelectFirstElement(`.control button[id="`+ strings.Title(app.Name()) +`"]`)
 		if err == nil {
 			DestroyHTML(button.el)
 		}
@@ -17,9 +17,9 @@ func (w *Window) InitApplication(app Application) {
 		return
 	}
 
-	button, err := w.root.SelectFirstElement(`.control button[id="`+ app.Name() +`"]`)
+	button, err := w.root.SelectFirstElement(`.control button[id="`+ strings.Title(app.Name()) +`"]`)
 	if err != nil {
-		panic(fmt.Sprintf("element %s was not found", `.control button[id="`+ app.Name() +`"]`))
+		panic(fmt.Sprintf("element %s was not found", `.control button[id="`+ strings.Title(app.Name()) +`"]`))
 	}
 
 	button.On(Click, func(class string) {
@@ -52,7 +52,7 @@ func (w *Window) ViewApplication(app Application) error {
 		el.SetAttr("class", "")
 	}
 
-	w.root.ApplyForAll(".application#"+app.Name()+" button", ShowElement)
+	w.root.ApplyForAll(".application#"+strings.Title(app.Name())+" button", ShowElement)
 
 	return w.ViewPage(app.Pages()[0])
 }
diff --git a/GUI/App/DOM/modifier_js.go b/GUI/App/DOM/modifier_js.go
index c4d2f95..e4761c4 100644
--- a/GUI/App/DOM/modifier_js.go
+++ b/GUI/App/DOM/modifier_js.go
@@ -19,6 +19,9 @@ func (el *Element) SetText(text string) error {
 }
 
 func (el *Element) SetValue(value string) error {
+	if _, ok := el.el.(*dom.HTMLTextAreaElement); ok {
+		el.SetText(value)
+	}
 	el.el.SetNodeValue(value)
 	return nil
 }
diff --git a/GUI/App/account.go b/GUI/App/account.go
index 05efc95..983e136 100644
--- a/GUI/App/account.go
+++ b/GUI/App/account.go
@@ -1,5 +1,3 @@
-// +build !js
-
 package App
 
 import (
@@ -99,7 +97,7 @@ func (c *PageGenerate) OnContinue(w *DOM.Window, dom *DOM.DOM, _ string) {
 		panic(err)
 	}
 
-	Storage.PermanentStorage.AddSeedFY(sf)
+	Storage.PersistentStorage.AddSeedFY(sf)
 
 	w.ViewPage(new(PagePassword))
 }
@@ -131,7 +129,7 @@ func (c *PageImport) OnContinue(w *DOM.Window, dom *DOM.DOM, _ string) {
 		return
 	}
 
-	Storage.PermanentStorage.AddSeedFY(sf)
+	Storage.PersistentStorage.AddSeedFY(sf)
 
 	w.ViewPage(new(PagePassword))
 	dom.ApplyFor(".seed", DOM.ClearValue)
@@ -154,7 +152,7 @@ func (c *PagePassword) OnContinue(w *DOM.Window, dom *DOM.DOM, _ string) {
 		return
 	}
 
-	seedfy := Storage.PermanentStorage.SeedFY
+	seedfy := Storage.PersistentStorage.SeedFY
 
 	need2FA, err := dom.GetStringValueOf(".ask2fa")
 	if err == nil && need2FA != "" {
@@ -177,7 +175,10 @@ func (c *PageMFA) Name() string {
 
 func (c *PageMFA) OnView(w *DOM.Window, dom *DOM.DOM) {
 	sk := Ephemeral.NewEphemeral()
-	requester, response := TwoFactor.NewRequesterServer(&sk, Storage.PermanentStorage.AllowedKeys)
+	requester, response, err := TwoFactor.NewRequesterServer(&sk, Storage.PersistentStorage.AllowedKeys)
+	if err != nil {
+		panic(err)
+	}
 
 	qr, err := requester.QRCode(300, color.RGBA{220, 220, 223, 1})
 	if err != nil {
@@ -191,7 +192,7 @@ func (c *PageMFA) OnView(w *DOM.Window, dom *DOM.DOM) {
 	go func() {
 		for resp := range response {
 			//@TODO Notify the user to allow or not the key
-			Storage.PermanentStorage.AddAllowedKey(resp.Capsule.Device)
+			Storage.PersistentStorage.AddAllowedKey(resp.Capsule.Device)
 			Storage.AccessStorage.Token = resp.Capsule.Token
 
 			c.OnContinue(w, dom, "")
@@ -207,7 +208,7 @@ func (c *PageMFA) OnContinue(w *DOM.Window, dom *DOM.DOM, _ string) {
 		return
 	}
 
-	seedfy := Storage.PermanentStorage.SeedFY
+	seedfy := Storage.PersistentStorage.SeedFY
 
 	Storage.AccessStorage.Seed = seedfy.RecoverSeed(Storage.AccessStorage.Password, Storage.AccessStorage.Token[:])
 	copy(Storage.AccessStorage.Token[:], make([]byte, len(Storage.AccessStorage.Token)))
diff --git a/GUI/App/nanofy.go b/GUI/App/nanofy.go
index 9e441a4..12731ef 100644
--- a/GUI/App/nanofy.go
+++ b/GUI/App/nanofy.go
@@ -1,5 +1,3 @@
-// +build !js
-
 package App
 
 import (
@@ -8,7 +6,6 @@ import (
 	"github.com/brokenbydefault/Nanollet/GUI/App/DOM"
 	"github.com/brokenbydefault/Nanollet/Storage"
 	"github.com/brokenbydefault/Nanollet/Wallet"
-	"os"
 	"github.com/brokenbydefault/Nanollet/Node"
 	"github.com/brokenbydefault/Nanollet/Block"
 )
@@ -41,23 +38,12 @@ func (c *PageSign) OnView(w *DOM.Window, dom *DOM.DOM) {
 }
 
 func (c *PageSign) OnContinue(w *DOM.Window, dom *DOM.DOM, _ string) {
-	filePath, err := dom.GetStringValueOf(".filepath")
-	if filePath == "" || err != nil {
-		return
-	}
-
-	file, err := os.Open(filePath[7:])
+	file, err := dom.GetFileOf(".filepath")
 	if err != nil {
 		DOM.UpdateNotification(w, "There was a problem opening the file")
 		return
 	}
 
-	stats, err := file.Stat()
-	if err != nil || stats.IsDir() {
-		DOM.UpdateNotification(w, "There was a problem opening the file")
-		return
-	}
-
 	previous, ok := Storage.TransactionStorage.GetByHash(&Storage.AccountStorage.Frontier)
 	if !ok {
 		DOM.UpdateNotification(w, "Previous block not found")
@@ -102,10 +88,8 @@ func (c *PageVerify) OnView(w *DOM.Window, dom *DOM.DOM) {
 }
 
 func (c *PageVerify) OnContinue(w *DOM.Window, dom *DOM.DOM, _ string) {
-
 	addr, _ := dom.GetStringValueOf(".address")
-	filePath, err := dom.GetStringValueOf(".filepath")
-	if addr == "" || filePath == "" || err != nil {
+	if addr == "" {
 		return
 	}
 
@@ -115,18 +99,12 @@ func (c *PageVerify) OnContinue(w *DOM.Window, dom *DOM.DOM, _ string) {
 		return
 	}
 
-	file, err := os.Open(filePath[7:])
+	file, err := dom.GetFileOf(".filepath")
 	if err != nil {
 		DOM.UpdateNotification(w, "There was a problem opening the file")
 		return
 	}
 
-	stats, err := file.Stat()
-	if err != nil || stats.IsDir() {
-		DOM.UpdateNotification(w, "Only files can be signed")
-		return
-	}
-
 	txs, err := Node.GetHistory(Background.Connection, &pk, nil)
 	if err != nil {
 		DOM.UpdateNotification(w, "There was a problem retrieving the information")
diff --git a/GUI/App/nanollet.go b/GUI/App/nanollet.go
index 706c1f6..dda32e9 100644
--- a/GUI/App/nanollet.go
+++ b/GUI/App/nanollet.go
@@ -1,5 +1,3 @@
-// +build !js
-
 package App
 
 import (
@@ -70,20 +68,19 @@ func (c *PageWallet) OnContinue(w *DOM.Window, dom *DOM.DOM, _ string) {
 	var dest Wallet.PublicKey
 	switch {
 	case Wallet.Address(addrOrAlias).IsValid():
-		if dest, err = Wallet.Address(addrOrAlias).GetPublicKey(); err != nil {
-			DOM.UpdateNotification(w, "The address is wrong")
-			return
-		}
+		dest, err = Wallet.Address(addrOrAlias).GetPublicKey()
 	case OpenCAP.Address(addrOrAlias).IsValid():
-		if dest, err = OpenCAP.Address(addrOrAlias).GetPublicKey(); err != nil {
-			DOM.UpdateNotification(w, "The address was not found")
-			return
-		}
+		dest, err = OpenCAP.Address(addrOrAlias).GetPublicKey()
 	default:
 		DOM.UpdateNotification(w, "The address invalid or it's not supported")
 		return
 	}
 
+	if err != nil {
+		DOM.UpdateNotification(w, "The address is wrong or was not found")
+		return
+	}
+
 	if !Util.StringIsNumeric(whole) || !Util.StringIsNumeric(decimal) {
 		DOM.UpdateNotification(w, "The given amount is incorrect")
 		return
@@ -179,6 +176,11 @@ func (c *PageRepresentative) OnContinue(w *DOM.Window, dom *DOM.DOM, _ string) {
 		return
 	}
 
+	if Util.IsEmpty(Storage.AccountStorage.Frontier[:]) {
+		Storage.AccountStorage.Representative = representative
+		return
+	}
+
 	blk, err := Block.CreateUniversalChangeBlock(&Storage.AccountStorage.SecretKey, representative, Storage.AccountStorage.Balance, Storage.AccountStorage.Frontier)
 	if err != nil {
 		DOM.UpdateNotification(w, "There was a problem creating a block")
diff --git a/GUI/App/settings.go b/GUI/App/settings.go
index f1ac7db..04a3541 100644
--- a/GUI/App/settings.go
+++ b/GUI/App/settings.go
@@ -34,7 +34,7 @@ func (c *PageSeed) OnView(w *DOM.Window, dom *DOM.DOM) {
 		return
 	}
 
-	seedbox.SetValue(Storage.PermanentStorage.SeedFY.String())
+	seedbox.SetValue(Storage.PersistentStorage.SeedFY.String())
 }
 
 func (c *PageSeed) OnContinue(w *DOM.Window, dom *DOM.DOM, action string) {
diff --git a/GUI/Front/html/0_base.html b/GUI/Front/html/0_base.html
index 713f03c..4290fa2 100644
--- a/GUI/Front/html/0_base.html
+++ b/GUI/Front/html/0_base.html
@@ -3,7 +3,7 @@
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
     <title>Nanollet</title>
 
-    <link rel="stylesheet" type="text/css" href="../css/style.css">
+    <link rel="stylesheet" type="text/css" href="Nanollet.css">
 </head>
 <body class="notconnected">
 
@@ -15,11 +15,11 @@
     <section class="account">
         <div class="box">
             <icon class="icon-coins"></icon>
-            <div class="ammount"> </div>
+            <div class="ammount"></div>
         </div>
         <div class="box">
             <icon class="icon-nodes"></icon>
-            <div class="nodes"> </div>
+            <div class="nodes"></div>
         </div>
         <button role="window-close">
             <icon id="end" class="icon-exit"></icon>
@@ -28,13 +28,24 @@
 </header>
 
 <section class="control">
+{{range .Menu}}
+    <button id="{{.Title | ToTitle}}"><span class="title">{{.Title | ToTitle}}</span><span class="pointer"></span></button>
+    <aside class="application" id="{{.Title | ToTitle}}">
+        {{range .Pages}}
+        <button class="{{. | ToTitle }}"><span class="block"><icon class="icon-{{. | ToLower }}"></icon><span class="title">{{. | ToTitle}}</span><span
+                class="pointer"></span></span></button>
+        {{end}}
+    </aside>
+{{end}}
 </section>
 
 <section class="dynamic">
+{{range .App}}
+    {{.}}
+{{end}}
 </section>
 
 <section class="notification">
-    <!--<button class="notification"></button>-->
 </section>
 <!--
     Custom Input - DropZone:
@@ -63,6 +74,8 @@
         }
       }
     }
+
 </script>
+<script src="Nanollet.js" type="application/javascript"></script>
 </body>
 </html>
\ No newline at end of file
diff --git a/GUI/Generator/gen.go b/GUI/Generator/gen.go
index fdca629..6443e6a 100644
--- a/GUI/Generator/gen.go
+++ b/GUI/Generator/gen.go
@@ -9,14 +9,14 @@ package main
 import (
 	"github.com/brokenbydefault/Nanollet/Util"
 	"github.com/kib357/less-go"
-	"golang.org/x/net/html"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"
-	"text/template"
+	"text/template" // We use text/template instead of html/template because we are merging htmls with htmls.
 	"github.com/brokenbydefault/Nanollet/Storage"
 	"bytes"
+	"golang.org/x/net/html"
 )
 
 func main() {
@@ -105,6 +105,12 @@ func generateCSS() {
 		strc.Data = "`" + Util.FileToString("GUI/Front/css/style.css") + "`"
 	}
 
+	hf, err := os.Create("Nanollet.css")
+	if err == nil {
+		hf.Write([]byte(Util.FileToString("GUI/Front/css/style.css")))
+		hf.Close()
+	}
+
 	store, _ := os.Create("GUI/Front/css.go")
 	cssTemplate.Execute(store, strc)
 }
@@ -130,33 +136,24 @@ func generateHTML() {
 	strc := htmlStruct{}
 	strc.IsDebug = Storage.Configuration.DebugStatus
 
-	base, err := os.Open("GUI/Front/html/0_base.html")
-	if err != nil {
-		panic(err)
-	}
-
-	defer base.Close()
-
-	htm, err := html.Parse(base)
+	raw, err := ioutil.ReadFile("GUI/Front/html/0_base.html")
 	if err != nil {
 		panic(err)
 	}
 
-	section, ok := getElement(htm, "", []html.Attribute{{
-		Key: "class",
-		Val: "dynamic",
-	}})
-	if !ok {
-		panic("not found")
-	}
-
-	controlBar, ok := getElement(htm, "", []html.Attribute{{
-		Key: "class",
-		Val: "control",
-	}})
-	if !ok {
-		panic("not found")
-	}
+	t := template.Must(template.New("base").Funcs(template.FuncMap{
+		"ToUpper": strings.ToUpper,
+		"ToTitle": strings.Title,
+		"ToLower": strings.ToLower,
+	}).Parse(string(raw)))
+
+	result := struct {
+		App []string
+		Menu []struct {
+			Title string
+			Pages  []string
+		}
+	}{}
 
 	pages, _ := filepath.Glob("GUI/Front/html/*")
 	for _, path := range pages {
@@ -164,130 +161,60 @@ func generateHTML() {
 			continue
 		}
 
-		file, err := os.Open(path)
+		file, err := ioutil.ReadFile(path)
 		if err != nil {
 			panic(err)
 		}
 
-		apphtml, err := html.Parse(file)
+		apphtml, err := html.Parse(bytes.NewReader(file))
 		if err != nil {
 			panic(err)
 		}
 
+		result.App = append(result.App, string(file))
+
 		app, ok := getElement(apphtml, "", []html.Attribute{
 			{Key: "application"},
 		})
 
-		addChild(section[0], app[0])
-
 		// Ignore if the app is not intended to be in the sidebar
 		if len(app[0].Attr) > 1 && app[0].Attr[1].Key == "no-sidebar" {
 			continue
 		}
 
-		// Sidebar button of the APP (e.g "Nanollet", "Nanofy")
-		addChild(controlBar[0], &html.Node{
-			FirstChild: &html.Node{
-				FirstChild: &html.Node{
-					Type: html.TextNode,
-					Data: strings.Title(app[0].Attr[0].Val),
-				},
-				Type: html.ElementNode,
-				Data: "span",
-				Attr: []html.Attribute{{
-					Key: "class",
-					Val: "title",
-				}},
-				NextSibling: &html.Node{
-					Type: html.ElementNode,
-					Data: "span",
-					Attr: []html.Attribute{{
-						Key: "class",
-						Val: "pointer",
-					}},
-				},
-			},
-			Type: html.ElementNode,
-			Data: "button",
-			Attr: []html.Attribute{{
-				Key: "id",
-				Val: app[0].Attr[0].Val,
-			}},
-		})
-
 		// Sidebar button for each page of the APP (e.g "Send", "Receive")
-		subMenu := &html.Node{
-			Type: html.ElementNode,
-			Data: "aside",
-			Attr: []html.Attribute{{
-				Key: "class",
-				Val: "application",
-			}, {
-				Key: "id",
-				Val: app[0].Attr[0].Val,
-			}},
-		}
-
 		s, ok := getElement(app[0], "section", nil)
 		if !ok {
 			panic("section not found")
 		}
+
+		var pages []string
 		for _, v := range s {
-			addChild(subMenu, &html.Node{
-				Type: html.ElementNode,
-				Data: "button",
-				Attr: []html.Attribute{{
-					Key: "class",
-					Val: strings.Title(v.Attr[0].Val),
-				}},
-				FirstChild: &html.Node{
-					Type: html.ElementNode,
-					Data: "span",
-					Attr: []html.Attribute{{
-						Key: "class",
-						Val: "block",
-					}},
-					FirstChild: &html.Node{
-						Type: html.ElementNode,
-						Data: "icon",
-						Attr: []html.Attribute{{
-							Key: "class",
-							Val: "icon-" + v.Attr[0].Val,
-						}},
-						NextSibling: &html.Node{
-							FirstChild: &html.Node{
-								Type: html.TextNode,
-								Data: strings.Title(v.Attr[0].Val),
-							},
-							Type: html.ElementNode,
-							Data: "span",
-							Attr: []html.Attribute{{
-								Key: "class",
-								Val: "title",
-							}},
-							NextSibling: &html.Node{
-								Type: html.ElementNode,
-								Data: "span",
-								Attr: []html.Attribute{{
-									Key: "class",
-									Val: "pointer",
-								}},
-							},
-						},
-					},
-				},
-			})
+			pages = append(pages, v.Attr[0].Val)
 		}
 
-		addChild(controlBar[0], subMenu)
-
-		file.Close()
+		result.Menu = append(result.Menu, struct {
+			Title string
+			Pages  []string
+		}{
+			app[0].Attr[0].Val,
+			pages,
+		})
 	}
 
 	b := bytes.NewBuffer(nil)
-	html.Render(b, htm)
+	if err := t.Execute(b, result); err != nil {
+		panic(err)
+	}
+
 	strc.HTML = "`" + b.String() + "`"
 
+	hf, err := os.Create("Nanollet.html")
+	if err == nil {
+		hf.Write(b.Bytes())
+		hf.Close()
+	}
+
 	store, _ := os.Create("GUI/Front/html.go")
 	htmlTemplate.Execute(store, strc)
 }
diff --git a/GUI/window.go b/GUI/window.go
index cd6b84f..b5373a7 100644
--- a/GUI/window.go
+++ b/GUI/window.go
@@ -8,18 +8,18 @@ import (
 	"github.com/brokenbydefault/Nanollet/Storage"
 	"github.com/sciter-sdk/go-sciter"
 	"github.com/sciter-sdk/go-sciter/window"
-	"path/filepath"
 	"github.com/brokenbydefault/Nanollet/Wallet"
 	"github.com/brokenbydefault/Nanollet/GUI/App/Background"
 	"github.com/brokenbydefault/Nanollet/GUI/App/DOM"
 )
 
 func init() {
-	if err := Storage.ArbitraryStorage.WriteFile("sciter.link", Front.Sciter); err != nil {
+	path, err := Storage.Engine.Write("sciter.link", Front.Sciter)
+	if err != nil {
 		panic(err)
 	}
 
-	sciter.SetDLL(filepath.Join(Storage.ArbitraryStorage.Path, "sciter.link"))
+	sciter.SetDLL(path)
 }
 
 func Start() {
@@ -35,7 +35,7 @@ func Start() {
 	}
 
 	w.LoadHtml(Front.HTML, "/")
-	w.SetCSS(Front.CSSStyle, "style.css", "text/css")
+	w.SetCSS(Front.CSSStyle, "Nanollet.css", "text/css")
 
 	win := DOM.NewWindow(w)
 	win.InitApplication(new(App.NanolletApp))
@@ -44,7 +44,7 @@ func Start() {
 	win.InitApplication(new(App.SettingsApp))
 	win.ViewApplication(new(App.AccountApp))
 
-	if Storage.PermanentStorage.SeedFY != *new(Wallet.SeedFY) {
+	if Storage.PersistentStorage.SeedFY != *new(Wallet.SeedFY) {
 		win.ViewPage(new(App.PagePassword))
 	}
 
diff --git a/GUI/window_js.go b/GUI/window_js.go
new file mode 100644
index 0000000..76b32dc
--- /dev/null
+++ b/GUI/window_js.go
@@ -0,0 +1,27 @@
+// +build js
+
+package GUI
+
+import (
+	"github.com/brokenbydefault/Nanollet/GUI/App"
+	"github.com/brokenbydefault/Nanollet/Storage"
+	"github.com/brokenbydefault/Nanollet/Wallet"
+	"github.com/brokenbydefault/Nanollet/GUI/App/Background"
+	"github.com/brokenbydefault/Nanollet/GUI/App/DOM"
+	"honnef.co/go/js/dom"
+)
+
+func Start() {
+	win := DOM.NewWindow(dom.GetWindow())
+	win.InitApplication(new(App.NanolletApp))
+	win.InitApplication(new(App.NanofyApp))
+	win.InitApplication(new(App.AccountApp))
+	win.InitApplication(new(App.SettingsApp))
+	win.ViewApplication(new(App.AccountApp))
+
+	if Storage.PersistentStorage.SeedFY != *new(Wallet.SeedFY) {
+		win.ViewPage(new(App.PagePassword))
+	}
+
+	go Background.UpdateNodeCount(win)
+}
diff --git a/Node/Packets/keepalive.go b/Node/Packets/keepalive.go
index 53af6dd..e4f4f95 100644
--- a/Node/Packets/keepalive.go
+++ b/Node/Packets/keepalive.go
@@ -1,7 +1,6 @@
 package Packets
 
 import (
-	"net"
 	"github.com/brokenbydefault/Nanollet/Node/Peer"
 )
 
@@ -38,8 +37,8 @@ func (p *KeepAlivePackage) Encode(dst []byte) (n int, err error) {
 
 	bi := 0
 	for _, peer := range p.List[:max] {
-		bi += copy(dst[bi:], peer.UDP.IP)
-		bi += copy(dst[bi:], []byte{byte(peer.UDP.Port), byte(peer.UDP.Port << 8)})
+		bi += copy(dst[bi:], peer.IP)
+		bi += copy(dst[bi:], []byte{byte(peer.Port), byte(peer.Port << 8)})
 	}
 
 	return KeepAlivePackageSize, nil
@@ -68,7 +67,7 @@ func (p *KeepAlivePackage) Decode(_ *Header, src []byte) (err error) {
 		be := bi + PeerSize
 		dataPeer := src[bi:be]
 
-		p.List = append(p.List, Peer.NewPeer(dataPeer[:net.IPv6len], int(dataPeer[16])|int(dataPeer[17])<<8))
+		p.List = append(p.List, Peer.NewPeer(dataPeer[:16], int(dataPeer[16])|int(dataPeer[17])<<8))
 
 		bi = be
 	}
diff --git a/Node/Peer/peer.go b/Node/Peer/peer.go
index b40b4c8..e20ed3d 100644
--- a/Node/Peer/peer.go
+++ b/Node/Peer/peer.go
@@ -2,7 +2,6 @@ package Peer
 
 import (
 	"net"
-	"strings"
 	"errors"
 	"strconv"
 	"time"
@@ -27,8 +26,8 @@ var (
 )
 
 type Peer struct {
-	UDP *net.UDPAddr
-	TCP *net.TCPAddr
+	IP   []byte
+	Port int
 
 	LastSeen  time.Time
 	PublicKey Wallet.PublicKey
@@ -38,10 +37,8 @@ type Peer struct {
 
 func NewPeer(ip net.IP, port int) (peer *Peer) {
 	peer = &Peer{
-		UDP: &net.UDPAddr{
-			IP:   ip,
-			Port: port,
-		},
+		IP:       ip,
+		Port:     port,
 		LastSeen: time.Now(),
 	}
 
@@ -52,12 +49,21 @@ func NewPeer(ip net.IP, port int) (peer *Peer) {
 
 func NewPeersFromString(hosts ...string) (peers []*Peer) {
 	for _, host := range hosts {
-		if ip, port, err := parseIP(host); err == nil {
-			peers = append(peers, NewPeer(ip, port))
+
+		iph, porth, err := net.SplitHostPort(host)
+		if err != nil {
+			continue
+		}
+
+		port, err := strconv.Atoi(porth)
+		if err != nil {
 			continue
 		}
 
-		if ips, port, err := parseHost(host); err == nil {
+		if ip := net.ParseIP(iph); ip != nil {
+			peers = append(peers, NewPeer(ip, port))
+		} else {
+			ips, _ := Util.LookupIP(iph)
 			for _, ip := range ips {
 				peers = append(peers, NewPeer(ip, port))
 			}
@@ -90,62 +96,3 @@ func (p *Peer) IsKnow() bool {
 
 	return true
 }
-
-func (p *Peer) String() string {
-	if p.UDP != nil {
-		return p.UDP.String()
-	}
-
-	if p.TCP != nil {
-		return p.TCP.String()
-	}
-
-	return ""
-}
-
-func parseHost(s string) (ips []net.IP, port int, err error) {
-	split := strings.Split(s, ":")
-	if len(split) < 2 {
-		return ips, port, ErrIncompleteData
-	}
-
-	port, err = parsePort(split[1])
-	if err != nil {
-		return ips, port, err
-	}
-
-	ips, err = net.LookupIP(split[0])
-	if err != nil {
-		return ips, port, ErrInvalidIP
-	}
-
-	return ips, port, nil
-}
-
-func parseIP(s string) (ip net.IP, port int, err error) {
-	split := strings.Split(s, ":")
-	if len(split) < 2 {
-		return ip, port, ErrIncompleteData
-	}
-
-	port, err = parsePort(split[1])
-	if err != nil {
-		return ip, port, err
-	}
-
-	ip = net.ParseIP(split[0])
-	if ip == nil {
-		return ip, port, ErrInvalidIP
-	}
-
-	return ip, port, nil
-}
-
-func parsePort(s string) (port int, err error) {
-	port, err = strconv.Atoi(s)
-	if err != nil || port > 65535 {
-		return 0, ErrInvalidPort
-	}
-
-	return port, nil
-}
diff --git a/Node/default.go b/Node/default.go
deleted file mode 100644
index a1de7d7..0000000
--- a/Node/default.go
+++ /dev/null
@@ -1,104 +0,0 @@
-package Node
-
-import (
-	"net"
-	"time"
-	"github.com/brokenbydefault/Nanollet/Node/Peer"
-	"github.com/brokenbydefault/Nanollet/Node/Packets"
-	"github.com/brokenbydefault/Nanollet/Util"
-	"github.com/brokenbydefault/Nanollet/Storage"
-)
-
-func NewServer(header Packets.Header) *Server {
-	return &Server{
-		Peers:        &Storage.PeerStorage,
-		Transactions: &Storage.TransactionStorage,
-
-		Header: header,
-
-		KeepAliveHandler:  defaultKeepAliveHandler,
-		HandshakeHandler:  defaultHandshakeHandler,
-		PublishHandler:    defaultPublishHandler,
-		ConfirmACKHandler: defaultConfirmACKHandler,
-	}
-}
-
-func defaultKeepAliveHandler(srv *Server, dest *net.UDPAddr, rHeader *Packets.Header, msg []byte) {
-	packet := new(Packets.KeepAlivePackage)
-
-	if err := packet.Decode(rHeader, msg); err != nil {
-		return
-	}
-
-	if peer, ok := srv.Peers.Get(dest.IP); ok {
-		peer.LastSeen = time.Now()
-		rHeader.Encode(peer.Header[:])
-	}
-
-	for _, peer := range packet.List {
-		if srv.Peers.Add(peer) == 1 {
-			srv.SendUDPTo(Packets.NewHandshakePackage(peer.Challenge[:], nil), peer)
-		}
-	}
-
-}
-
-func defaultHandshakeHandler(srv *Server, dest *net.UDPAddr, rHeader *Packets.Header, msg []byte) {
-	packet := new(Packets.HandshakePackage)
-
-	if err := packet.Decode(rHeader, msg); err != nil {
-		return
-	}
-
-	if rHeader.ExtensionType.Is(Packets.Response) {
-		if peer, ok := srv.Peers.Get(dest.IP); ok {
-			if packet.PublicKey.IsValidSignature(peer.Challenge[:], &packet.Signature) {
-				peer.PublicKey = packet.PublicKey
-			}
-		}
-	}
-
-	if rHeader.ExtensionType.Is(Packets.Challenge) {
-		if peer, ok := srv.Peers.Get(dest.IP); !ok || !peer.IsKnow() {
-			peer = Peer.NewPeer(dest.IP, dest.Port)
-
-			if srv.Peers.Add(peer) == 1 {
-				srv.SendUDPTo(Packets.NewHandshakePackage(peer.Challenge[:], packet.Challenge[:]), peer)
-			}
-		} else {
-			srv.SendUDPTo(Packets.NewHandshakePackage(nil, packet.Challenge[:]), peer)
-		}
-
-	}
-}
-
-func defaultPublishHandler(srv *Server, dest *net.UDPAddr, rHeader *Packets.Header, msg []byte) {
-	packet := new(Packets.PushPackage)
-
-	if err := packet.Decode(rHeader, msg); err != nil {
-		return
-	}
-
-	if !packet.Transaction.IsValidPOW() {
-		return
-	}
-
-	srv.Transactions.Add(packet.Transaction)
-}
-
-func defaultConfirmACKHandler(srv *Server, dest *net.UDPAddr, rHeader *Packets.Header, msg []byte) {
-	packet := new(Packets.ConfirmACKPackage)
-
-	if err := packet.Decode(rHeader, msg); err != nil {
-		return
-	}
-
-	for _, hash := range packet.Hashes {
-		srv.Transactions.AddVotes(&hash, &packet.PublicKey, Util.BytesToUint(packet.Sequence[:], Util.BigEndian))
-	}
-}
-
-func defaultConfirmReqHandler(srv *Server, dest *net.UDPAddr, rHeader *Packets.Header, msg []byte) {
-	//@TODO create support to Confirm_Req
-	//NO-OP
-}
diff --git a/Node/handler.go b/Node/handler.go
new file mode 100644
index 0000000..da1eb35
--- /dev/null
+++ b/Node/handler.go
@@ -0,0 +1,254 @@
+package Node
+
+import (
+	"time"
+	"github.com/brokenbydefault/Nanollet/Node/Peer"
+	"github.com/brokenbydefault/Nanollet/Node/Packets"
+	"github.com/brokenbydefault/Nanollet/Util"
+	"github.com/brokenbydefault/Nanollet/Storage"
+	"context"
+)
+
+type RawUDP struct {
+	Raw    []byte
+	Source *Peer.Peer
+}
+
+type RawTCP struct {
+	Raw    []byte
+	Source *Peer.Peer
+}
+
+type Node interface {
+	ListenUDP() (ch <-chan RawUDP, err error)
+	ListenTCP() (ch <-chan RawTCP, err error)
+
+	SendUDPTo(packet Packets.PacketUDP, dest *Peer.Peer) (err error)
+	SendUDP(packet Packets.PacketUDP) (err error)
+
+	SendTCPTo(request Packets.PacketTCP, responseType Packets.MessageType, dest *Peer.Peer) (packet Packets.PacketTCP, err error)
+	SendTCP(request Packets.PacketTCP, responseType Packets.MessageType) (packets <-chan Packets.PacketTCP, cancel context.CancelFunc)
+
+	Peers() *Storage.PeersBox
+	Transactions() *Storage.TransactionBox
+}
+
+type HandlerFunc func(Node Node, dest *Peer.Peer, rHeader *Packets.Header, msg []byte)
+type SenderFunc func(Node Node)
+
+type HandlerGroup struct {
+	Node Node
+
+	KeepAliveHandler  HandlerFunc
+	HandshakeHandler  HandlerFunc
+	PublishHandler    HandlerFunc
+	ConfirmACKHandler HandlerFunc
+	ConfirmReqHandler HandlerFunc
+
+	KeepAliveSender SenderFunc
+	VoteSender      SenderFunc
+}
+
+func NewHandler(node Node) *HandlerGroup {
+	return &HandlerGroup{
+		Node: node,
+
+		KeepAliveHandler:  defaultKeepAliveHandler,
+		HandshakeHandler:  defaultHandshakeHandler,
+		PublishHandler:    defaultPublishHandler,
+		ConfirmACKHandler: defaultConfirmACKHandler,
+		ConfirmReqHandler: defaultConfirmReqHandler,
+
+		KeepAliveSender: defaultKeepAliveSender,
+		VoteSender:      defaultVoteSender,
+	}
+}
+
+// Start will listen the Node and use the defined Handlers on the HandlerGroup
+func (hg *HandlerGroup) Start() error {
+	if err := hg.listenUDP(); err != nil {
+		return err
+	}
+
+	if err := hg.listenTCP(); err != nil {
+		return err
+	}
+
+	hg.KeepAliveSender(hg.Node)
+	hg.VoteSender(hg.Node)
+
+	return nil
+}
+
+func (hg *HandlerGroup) listenTCP() error {
+	// NO-OP
+	return nil
+}
+
+func (hg *HandlerGroup) listenUDP() error {
+	ch, err := hg.Node.ListenUDP()
+	if err != nil {
+		return err
+	}
+
+	go func() {
+		for raw := range ch {
+			r := raw
+			go hg.readUDP(r)
+		}
+	}()
+
+	return nil
+}
+
+func (hg *HandlerGroup) readUDP(raw RawUDP) {
+	header := new(Packets.Header)
+
+	if err := header.Decode(raw.Raw[:Packets.HeaderSize]); err != nil {
+		return
+	}
+
+	raw.Raw = raw.Raw[Packets.HeaderSize:]
+	if peer, ok := hg.Node.Peers().Get(raw.Source.IP); ok && peer.IsKnow() && peer.IsActive() {
+		switch header.MessageType {
+		case Packets.KeepAlive:
+			hg.KeepAliveHandler(hg.Node, raw.Source, header, raw.Raw)
+		case Packets.Publish:
+			hg.PublishHandler(hg.Node, raw.Source, header, raw.Raw)
+		case Packets.ConfirmReq:
+			hg.ConfirmReqHandler(hg.Node, raw.Source, header, raw.Raw)
+		case Packets.ConfirmACK:
+			hg.ConfirmACKHandler(hg.Node, raw.Source, header, raw.Raw)
+		case Packets.NodeHandshake:
+			hg.HandshakeHandler(hg.Node, raw.Source, header, raw.Raw)
+		}
+	} else {
+		switch header.MessageType {
+		case Packets.Publish:
+			hg.PublishHandler(hg.Node, raw.Source, header, raw.Raw)
+		case Packets.ConfirmACK:
+			hg.ConfirmACKHandler(hg.Node, raw.Source, header, raw.Raw)
+		case Packets.NodeHandshake:
+			hg.HandshakeHandler(hg.Node, raw.Source, header, raw.Raw)
+		}
+	}
+}
+
+func defaultKeepAliveHandler(node Node, dest *Peer.Peer, rHeader *Packets.Header, msg []byte) {
+	packet := new(Packets.KeepAlivePackage)
+
+	if err := packet.Decode(rHeader, msg); err != nil {
+		return
+	}
+
+	if peer, ok := node.Peers().Get(dest.IP); ok {
+		peer.LastSeen = time.Now()
+		rHeader.Encode(peer.Header[:])
+	}
+
+	for _, peer := range packet.List {
+		if node.Peers().Add(peer) == 1 {
+			node.SendUDPTo(Packets.NewHandshakePackage(peer.Challenge[:], nil), peer)
+		}
+	}
+
+}
+
+func defaultHandshakeHandler(node Node, dest *Peer.Peer, rHeader *Packets.Header, msg []byte) {
+	packet := new(Packets.HandshakePackage)
+
+	if err := packet.Decode(rHeader, msg); err != nil {
+		return
+	}
+
+	if rHeader.ExtensionType.Is(Packets.Response) {
+		if peer, ok := node.Peers().Get(dest.IP); ok {
+			if packet.PublicKey.IsValidSignature(peer.Challenge[:], &packet.Signature) {
+				peer.PublicKey = packet.PublicKey
+			}
+		}
+	}
+
+	if rHeader.ExtensionType.Is(Packets.Challenge) {
+
+		if peer, ok := node.Peers().Get(dest.IP); !ok || !peer.IsKnow() {
+			peer = Peer.NewPeer(dest.IP, dest.Port)
+
+			if node.Peers().Add(peer) == 1 {
+				node.SendUDPTo(Packets.NewHandshakePackage(peer.Challenge[:], packet.Challenge[:]), peer)
+			}
+		} else {
+			node.SendUDPTo(Packets.NewHandshakePackage(nil, packet.Challenge[:]), peer)
+		}
+
+	}
+}
+
+func defaultPublishHandler(node Node, _ *Peer.Peer, rHeader *Packets.Header, msg []byte) {
+	packet := new(Packets.PushPackage)
+
+	if err := packet.Decode(rHeader, msg); err != nil {
+		return
+	}
+
+	if !packet.Transaction.IsValidPOW() {
+		return
+	}
+
+	node.Transactions().Add(packet.Transaction)
+}
+
+func defaultConfirmACKHandler(node Node, _ *Peer.Peer, rHeader *Packets.Header, msg []byte) {
+	packet := new(Packets.ConfirmACKPackage)
+
+	if err := packet.Decode(rHeader, msg); err != nil {
+		return
+	}
+
+	for _, hash := range packet.Hashes {
+		node.Transactions().AddVotes(&hash, &packet.PublicKey, Util.BytesToUint(packet.Sequence[:], Util.BigEndian))
+	}
+}
+
+func defaultConfirmReqHandler(_ Node, _ *Peer.Peer, _ *Packets.Header, _ []byte) {
+	//@TODO create support to Confirm_Req
+	//NO-OP
+}
+
+func defaultKeepAliveSender(node Node) {
+	go func() {
+		for range time.Tick(1 * time.Second) {
+
+			keepAlivePacket := Packets.NewKeepAlivePackage(node.Peers().GetRandom(Packets.KeepAlivePackageNPeers))
+
+			all := node.Peers().GetAll()
+			for _, peer := range all {
+				if !peer.IsActive() {
+					node.Peers().Remove(peer)
+				}
+
+				if !peer.IsKnow() {
+					node.SendUDPTo(Packets.NewHandshakePackage(peer.Challenge[:], nil), peer)
+				}
+
+				node.SendUDPTo(keepAlivePacket, peer)
+			}
+		}
+	}()
+}
+
+func defaultVoteSender(node Node) {
+	go func() {
+		for tx := range node.Transactions().Listen() {
+
+			// If already exist one block after this, we ignore.
+			// That's because if the next block gets approved, this block is also valid.
+			hash := tx.Hash()
+			if _, ok := node.Transactions().GetByPreviousHash(&hash); ok {
+				continue
+			}
+
+			node.SendUDP(Packets.NewConfirmReqPackage(tx.Transaction))
+		}
+	}()
+}
diff --git a/Node/nano.go b/Node/nano.go
index 2890cbe..bb2fec2 100644
--- a/Node/nano.go
+++ b/Node/nano.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package Node
 
 import (
@@ -15,66 +17,73 @@ var (
 	ErrTCPNotAvailable = errors.New("this node doesn't support TCP")
 )
 
-type Node interface {
-	Start()
-
-	SendUDPTo(packet Packets.PacketUDP, dest *Peer.Peer) (err error)
-	SendUDP(packet Packets.PacketUDP) (err error)
-
-	// SendTCPTo sends a package to specific peer, this peer must accept TCP.
-	SendTCPTo(request Packets.PacketTCP, responseType Packets.MessageType, dest *Peer.Peer) (packet Packets.PacketTCP, err error)
-	SendTCP(request Packets.PacketTCP, responseType Packets.MessageType) (packets <-chan Packets.PacketTCP, cancel context.CancelFunc)
-}
-
 type Server struct {
 	udp *net.UDPConn
 	//TCP *net.TCPListener
-	Peers        *Storage.PeersBox
-	Transactions *Storage.TransactionBox
 
-	Header Packets.Header
-
-	KeepAliveHandler  func(con *Server, dest *net.UDPAddr, rHeader *Packets.Header, msg []byte)
-	HandshakeHandler  func(con *Server, dest *net.UDPAddr, rHeader *Packets.Header, msg []byte)
-	PublishHandler    func(con *Server, dest *net.UDPAddr, rHeader *Packets.Header, msg []byte)
-	ConfirmACKHandler func(con *Server, dest *net.UDPAddr, rHeader *Packets.Header, msg []byte)
-	ConfirmReqHandler func(con *Server, dest *net.UDPAddr, rHeader *Packets.Header, msg []byte)
+	Peer        *Storage.PeersBox
+	Transaction *Storage.TransactionBox
+	Header      Packets.Header
 }
 
-func (srv Server) Start() {
-	if srv.KeepAliveHandler == nil {
-		srv.KeepAliveHandler = defaultKeepAliveHandler
+func NewServer(Header Packets.Header, Peer *Storage.PeersBox, Tx *Storage.TransactionBox) Node {
+	return &Server{
+		Peer:        Peer,
+		Transaction: Tx,
+		Header:      Header,
 	}
+}
 
-	if srv.HandshakeHandler == nil {
-		srv.HandshakeHandler = defaultHandshakeHandler
-	}
+func (srv *Server) Peers() *Storage.PeersBox {
+	return srv.Peer
+}
 
-	if srv.PublishHandler == nil {
-		srv.HandshakeHandler = defaultPublishHandler
-	}
+func (srv *Server) Transactions() *Storage.TransactionBox {
+	return srv.Transaction
+}
 
-	if srv.ConfirmACKHandler == nil {
-		srv.ConfirmACKHandler = defaultConfirmACKHandler
-	}
+func (srv *Server) ListenTCP() (ch <-chan RawTCP, err error) {
+	// no-op
+	return nil, nil
+}
 
-	if srv.ConfirmReqHandler == nil {
-		srv.ConfirmReqHandler = defaultConfirmReqHandler
+func (srv *Server) ListenUDP() (ch <-chan RawUDP, err error) {
+	if srv.udp == nil {
+		srv.initUDP()
 	}
 
-	srv.startServer()
-	srv.listenUDP()
-	srv.keepAlive()
-	srv.keepAskVotes()
+	c := make(chan RawUDP, 1<<15)
+
+	go func() {
+		for {
+			b := make([]byte, Packets.HeaderSize+Packets.MessageSize)
+			end, dest, err := srv.udp.ReadFromUDP(b)
+			if err != nil {
+				continue
+			}
+
+			c <- RawUDP{
+				Raw:    b[:end],
+				Source: Peer.NewPeer(dest.IP, dest.Port),
+			}
+		}
+	}()
+
+	return c, nil
 }
 
 // SendUDPTo sends a package to specific peer, this peer must accept UDP.
 func (srv *Server) SendUDPTo(packet Packets.PacketUDP, dest *Peer.Peer) (err error) {
+	if dest == nil {
+		return
+	}
+
 	if srv.udp == nil {
-		srv.startServer()
+		srv.initUDP()
 	}
 
-	if _, err := srv.udp.WriteTo(Packets.EncodePacketUDP(srv.Header, packet), dest.UDP); err != nil {
+
+	if _, err := srv.udp.WriteTo(Packets.EncodePacketUDP(srv.Header, packet), &net.UDPAddr{IP: dest.IP, Port: dest.Port}); err != nil {
 		return err
 	}
 
@@ -83,7 +92,7 @@ func (srv *Server) SendUDPTo(packet Packets.PacketUDP, dest *Peer.Peer) (err err
 
 // SendUDP sends a package to all known active peer.
 func (srv *Server) SendUDP(packet Packets.PacketUDP) (err error) {
-	for _, dest := range srv.Peers.GetAll() {
+	for _, dest := range srv.Peer.GetAll() {
 		srv.SendUDPTo(packet, dest)
 	}
 
@@ -93,13 +102,13 @@ func (srv *Server) SendUDP(packet Packets.PacketUDP) (err error) {
 
 // SendTCPTo sends a package to specific peer, this peer must accept TCP.
 func (srv *Server) SendTCPTo(request Packets.PacketTCP, responseType Packets.MessageType, dest *Peer.Peer) (packet Packets.PacketTCP, err error) {
-	if dest == nil || dest.UDP == nil {
+	if dest == nil {
 		return packet, ErrTCPNotAvailable
 	}
 
 	packet = Packets.DecodeResponsePacketTCP(responseType)
 
-	tcp, err := net.DialTCP("tcp", nil, &net.TCPAddr{IP: dest.UDP.IP, Port: dest.UDP.Port})
+	tcp, err := net.DialTCP("tcp", nil, &net.TCPAddr{IP: dest.IP, Port: dest.Port})
 	if err != nil {
 		return packet, err
 	}
@@ -121,7 +130,7 @@ func (srv *Server) SendTCPTo(request Packets.PacketTCP, responseType Packets.Mes
 
 // SendTCP sends a package to one random known peer.
 func (srv *Server) SendTCP(request Packets.PacketTCP, responseType Packets.MessageType) (packets <-chan Packets.PacketTCP, cancel context.CancelFunc) {
-	peers := srv.Peers.GetRandom(0)
+	peers := srv.Peer.GetRandom(0)
 
 	ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(10*time.Second))
 	c := make(chan Packets.PacketTCP, len(peers))
@@ -154,12 +163,13 @@ func (srv *Server) sendTCPToContext(ctx context.Context, request Packets.PacketT
 
 	packet = Packets.DecodeResponsePacketTCP(responseType)
 
-	tcp, err := dialer.DialContext(ctx, "tcp", dest.String())
+	addr := &net.TCPAddr{IP: dest.IP, Port: dest.Port}
+	tcp, err := dialer.DialContext(ctx, "tcp", addr.String())
 	if err != nil {
 		return packet, err
 	}
 
-	tcp.SetReadDeadline(time.Now().Add(2 * time.Second))
+	tcp.SetReadDeadline(time.Now().Add(10 * time.Second))
 	defer tcp.Close()
 
 	if err := Packets.EncodePacketTCP(srv.Header, request, tcp); err != nil {
@@ -173,97 +183,7 @@ func (srv *Server) sendTCPToContext(ctx context.Context, request Packets.PacketT
 	return packet, nil
 }
 
-func (srv *Server) keepAlive() {
-	msg := func() {
-		keepAlivePacket := Packets.NewKeepAlivePackage(srv.Peers.GetRandom(Packets.KeepAlivePackageNPeers))
-
-		all := srv.Peers.GetAll()
-		for _, peer := range all  {
-			if !peer.IsActive() {
-				srv.Peers.Remove(peer)
-			}
-
-			if !peer.IsKnow() {
-				srv.SendUDPTo(Packets.NewHandshakePackage(peer.Challenge[:], nil), peer)
-			}
-
-			srv.SendUDPTo(keepAlivePacket, peer)
-		}
-
-	}
-
-	go func() {
-		for range time.Tick(5 * time.Second) {
-			msg()
-		}
-	}()
-
-	msg()
-}
-
-func (srv *Server) keepAskVotes() {
-	go func() {
-		for tx := range srv.Transactions.Listen() {
-
-			// If already exist one block after this, we ignore.
-			// That's because if the next block gets approved, this block is also valid.
-			hash := tx.Hash()
-			if _, ok := srv.Transactions.GetByPreviousHash(&hash); ok {
-				continue
-			}
-
-			srv.SendUDP(Packets.NewConfirmReqPackage(tx.Transaction))
-		}
-	}()
-}
-
-func (srv *Server) listenUDP() {
-	go func() {
-		for {
-			b := make([]byte, Packets.HeaderSize+Packets.MessageSize)
-			h := new(Packets.Header)
-
-			end, dest, err := srv.udp.ReadFromUDP(b)
-			if err != nil {
-				continue
-			}
-
-			go func() {
-				if err := h.Decode(b[:Packets.HeaderSize]); err != nil {
-					return
-				}
-
-				b = b[Packets.HeaderSize:end]
-				if peer, ok := srv.Peers.Get(dest.IP); ok && peer.IsKnow() && peer.IsActive() {
-					switch h.MessageType {
-					case Packets.KeepAlive:
-						srv.KeepAliveHandler(srv, dest, h, b)
-					case Packets.Publish:
-						srv.PublishHandler(srv, dest, h, b)
-					case Packets.ConfirmReq:
-						srv.ConfirmReqHandler(srv, dest, h, b)
-					case Packets.ConfirmACK:
-						srv.ConfirmACKHandler(srv, dest, h, b)
-					case Packets.NodeHandshake:
-						srv.HandshakeHandler(srv, dest, h, b)
-					}
-				} else {
-					switch h.MessageType {
-					case Packets.Publish:
-						srv.PublishHandler(srv, dest, h, b)
-					case Packets.ConfirmACK:
-						srv.ConfirmACKHandler(srv, dest, h, b)
-					case Packets.NodeHandshake:
-						srv.HandshakeHandler(srv, dest, h, b)
-					}
-				}
-			}()
-
-		}
-	}()
-}
-
-func (srv *Server) startServer() {
+func (srv *Server) initUDP() {
 	udp, err := net.ListenUDP("udp", nil)
 	if udp == nil || err != nil {
 		panic(err)
diff --git a/Node/nano_js.go b/Node/nano_js.go
new file mode 100644
index 0000000..36a2ca9
--- /dev/null
+++ b/Node/nano_js.go
@@ -0,0 +1,84 @@
+// +build js, !android
+
+package Node
+
+import (
+	"github.com/brokenbydefault/Nanollet/Node/Packets"
+	"github.com/brokenbydefault/Nanollet/Node/Peer"
+	"github.com/brokenbydefault/Nanollet/Storage"
+	"errors"
+	"context"
+)
+
+var (
+	ErrTCPNotAvailable = errors.New("this node doesn't support TCP")
+)
+
+type Server struct {
+	Peer        *Storage.PeersBox
+	Transaction *Storage.TransactionBox
+	Header      Packets.Header
+}
+
+func NewServer(Header Packets.Header, Peer *Storage.PeersBox, Tx *Storage.TransactionBox) Node {
+	return &Server{
+		Peer:        Peer,
+		Transaction: Tx,
+		Header:      Header,
+	}
+}
+
+func (srv *Server) Peers() *Storage.PeersBox {
+	return srv.Peer
+}
+
+func (srv *Server) Transactions() *Storage.TransactionBox {
+	return srv.Transaction
+}
+
+func (srv *Server) ListenTCP() (ch <-chan RawTCP, err error) {
+	// no-op
+	return nil, nil
+}
+
+func (srv *Server) ListenUDP() (ch <-chan RawUDP, err error) {
+	c := make(chan RawUDP, 1<<15)
+	return c, nil
+}
+
+// SendUDPTo sends a package to specific peer, this peer must accept UDP.
+func (srv *Server) SendUDPTo(packet Packets.PacketUDP, dest *Peer.Peer) (err error) {
+	if dest == nil {
+		return
+	}
+
+	return nil
+}
+
+// SendUDP sends a package to all known active peer.
+func (srv *Server) SendUDP(packet Packets.PacketUDP) (err error) {
+	return nil
+}
+
+// SendTCPTo sends a package to specific peer, this peer must accept TCP.
+func (srv *Server) SendTCPTo(request Packets.PacketTCP, responseType Packets.MessageType, dest *Peer.Peer) (packet Packets.PacketTCP, err error) {
+	if dest == nil {
+		return packet, ErrTCPNotAvailable
+	}
+
+	return packet, nil
+}
+
+// SendTCP sends a package to one random known peer.
+func (srv *Server) SendTCP(request Packets.PacketTCP, responseType Packets.MessageType) (packets <-chan Packets.PacketTCP, cancel context.CancelFunc) {
+
+	return nil, cancel
+}
+
+func (srv *Server) sendTCPToContext(ctx context.Context, request Packets.PacketTCP, responseType Packets.MessageType, dest *Peer.Peer) (packet Packets.PacketTCP, err error) {
+	return packet, nil
+}
+
+func (srv *Server) initUDP() {
+
+}
diff --git a/Node/nano_mobile.go b/Node/nano_mobile.go
new file mode 100644
index 0000000..6329b3d
--- /dev/null
+++ b/Node/nano_mobile.go
@@ -0,0 +1,82 @@
+// +build js, android
+
+package Node
+
+import (
+	"net"
+	"github.com/brokenbydefault/Nanollet/Node/Packets"
+	"github.com/brokenbydefault/Nanollet/Node/Peer"
+	"github.com/brokenbydefault/Nanollet/Storage"
+	"errors"
+	"context"
+)
+
+var (
+	ErrTCPNotAvailable = errors.New("this node doesn't support TCP")
+)
+
+type Server struct {
+	Peer        *Storage.PeersBox
+	Transaction *Storage.TransactionBox
+	Header      Packets.Header
+}
+
+func NewServer(Header Packets.Header, Peer *Storage.PeersBox, Tx *Storage.TransactionBox) Node {
+	return &Server{
+		Peer:        Peer,
+		Transaction: Tx,
+		Header:      Header,
+	}
+}
+
+func (srv *Server) Peers() *Storage.PeersBox {
+	return srv.Peer
+}
+
+func (srv *Server) Transactions() *Storage.TransactionBox {
+	return srv.Transaction
+}
+
+func (srv *Server) ListenTCP() (ch <-chan RawTCP, err error) {
+	// no-op
+	return nil, nil
+}
+
+func (srv *Server) ListenUDP() (ch <-chan RawUDP, err error) {
+	c := make(chan RawUDP, 1<<15)
+	return c, nil
+}
+
+// SendUDPTo sends a package to specific peer, this peer must accept UDP.
+func (srv *Server) SendUDPTo(packet Packets.PacketUDP, dest *Peer.Peer) (err error) {
+
+	return nil
+}
+
+// SendUDP sends a package to all known active peer.
+func (srv *Server) SendUDP(packet Packets.PacketUDP) (err error) {
+	return nil
+}
+
+// SendTCPTo sends a package to specific peer, this peer must accept TCP.
+func (srv *Server) SendTCPTo(request Packets.PacketTCP, responseType Packets.MessageType, dest *Peer.Peer) (packet Packets.PacketTCP, err error) {
+	if dest == nil {
+		return packet, ErrTCPNotAvailable
+	}
+
+	return packet, nil
+}
+
+// SendTCP sends a package to one random known peer.
+func (srv *Server) SendTCP(request Packets.PacketTCP, responseType Packets.MessageType) (packets <-chan Packets.PacketTCP, cancel context.CancelFunc) {
+
+	return nil, cancel
+}
+
+func (srv *Server) sendTCPToContext(ctx context.Context, request Packets.PacketTCP, responseType Packets.MessageType, dest *Peer.Peer) (packet Packets.PacketTCP, err error) {
+	return packet, nil
+}
+
+func (srv *Server) initUDP() {
+
+}
diff --git a/OpenCAP/address.go b/OpenCAP/address.go
index 7b49623..f5808a5 100644
--- a/OpenCAP/address.go
+++ b/OpenCAP/address.go
@@ -8,7 +8,6 @@ import (
 	"net/http"
 	"encoding/json"
 	"errors"
-	"net"
 	"time"
 	"github.com/brokenbydefault/Nanollet/Util"
 )
@@ -108,7 +107,7 @@ func (addr Address) LookupHost() string {
 		return ""
 	}
 
-	_, srvAddrs, err := net.LookupSRV("opencap", "tcp", host)
+	_, srvAddrs, err := Util.LookupSRV("opencap", "tcp", host)
 	if err != nil || len(srvAddrs) < 1 {
 		return ""
 	}
diff --git a/Storage/config.go b/Storage/config.go
index 29beb39..fca8993 100644
--- a/Storage/config.go
+++ b/Storage/config.go
@@ -17,6 +17,7 @@ type Config struct {
 		Quorum         Peer.Quorum
 		//DefaultPrefixes       []string
 		MinimumAmount *Numbers.RawAmount
+		UnitAmount     Numbers.UnitBase
 	}
 
 	Node struct {
@@ -38,6 +39,7 @@ var Live = Config{
 		Representative Wallet.PublicKey
 		Quorum         Peer.Quorum
 		MinimumAmount  *Numbers.RawAmount
+		UnitAmount     Numbers.UnitBase
 	}{
 		Representative: Wallet.Address("xrb_1ywcdyz7djjdaqbextj4wh1db3wykze5ueh9wnmbgrcykg3t5k1se7zyjf95").MustGetPublicKey(),
 		Quorum: Peer.Quorum{
@@ -63,10 +65,11 @@ var Live = Config{
 				Wallet.Address("xrb_1x7biz69cem95oo7gxkrw6kzhfywq4x5dupw4z1bdzkb74dk9kpxwzjbdhhs").MustGetPublicKey(),
 				Wallet.Address("xrb_1ninja7rh37ehfp9utkor5ixmxyg8kme8fnzc4zty145ibch8kf5jwpnzr3r").MustGetPublicKey(),
 			},
-			Common: 30,
-			Fork:   50,
+			Common: 50,
+			Fork:   60,
 		},
 		MinimumAmount: Numbers.NewRawFromBytes([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD3, 0xC2, 0x1B, 0xCE, 0xCC, 0xED, 0xA1, 0x00, 0x00, 0x00}),
+		UnitAmount:    Numbers.MegaXRB,
 	},
 
 	Node: struct {
@@ -102,6 +105,7 @@ var Beta = Config{
 		Representative Wallet.PublicKey
 		Quorum         Peer.Quorum
 		MinimumAmount  *Numbers.RawAmount
+		UnitAmount     Numbers.UnitBase
 	}{
 		Representative: Wallet.Address("xrb_1ywcdyz7djjdaqbextj4wh1db3wykze5ueh9wnmbgrcykg3t5k1se7zyjf95").MustGetPublicKey(),
 		Quorum: Peer.Quorum{
@@ -119,6 +123,7 @@ var Beta = Config{
 			Fork:   60,
 		},
 		MinimumAmount: Numbers.NewRawFromBytes([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD3, 0xC2, 0x1B, 0xCE, 0xCC, 0xED, 0xA1, 0x00, 0x00, 0x00}),
+		UnitAmount:    Numbers.MegaXRB,
 	},
 
 	Node: struct {
diff --git a/Storage/general.go b/Storage/general.go
new file mode 100644
index 0000000..35055cd
--- /dev/null
+++ b/Storage/general.go
@@ -0,0 +1,39 @@
+package Storage
+
+import "github.com/brokenbydefault/Nanollet/Wallet"
+
+var Engine FileStorage
+var PersistentStorage Persistent
+
+type Persistent struct {
+	SeedFY      Wallet.SeedFY
+	AllowedKeys []Wallet.PublicKey
+}
+
+func (p *Persistent) AddSeedFY(seedfy Wallet.SeedFY) {
+	p.SeedFY = seedfy
+	Engine.Save(p)
+}
+
+func (p *Persistent) AddAllowedKey(newKey Wallet.PublicKey) {
+	for _, key := range p.AllowedKeys {
+		if key == newKey {
+			return
+		}
+	}
+
+	if p.AllowedKeys == nil {
+		p.AllowedKeys = []Wallet.PublicKey{newKey}
+	} else {
+		p.AllowedKeys = append(p.AllowedKeys, newKey)
+	}
+
+	Engine.Save(p)
+}
+
+type FileStorage interface {
+	Save(*Persistent)
+	Load(*Persistent)
+	Write(name string, data []byte) (path string, err error)
+	Read(name string) (data []byte, err error)
+}
diff --git a/Storage/peers.go b/Storage/peers.go
index 375296b..e85807e 100644
--- a/Storage/peers.go
+++ b/Storage/peers.go
@@ -138,7 +138,7 @@ func (h *PeersBox) Add(peers ...*Peer.Peer) (n int) {
 
 	for _, peer := range peers {
 		if h.Count() < 1024 {
-			if _, old := h.list.LoadOrStore(string(peer.UDP.IP), peer); !old {
+			if _, old := h.list.LoadOrStore(string(peer.IP), peer); !old {
 				n++
 			}
 		}
@@ -157,6 +157,6 @@ func (h *PeersBox) Remove(peers ...*Peer.Peer) {
 			break
 		}
 
-		h.list.Delete(string(peer.UDP.IP))
+		h.list.Delete(string(peer.IP))
 	}
 }
diff --git a/Storage/storage.go b/Storage/storage.go
index 9c2f079..de3e63d 100644
--- a/Storage/storage.go
+++ b/Storage/storage.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package Storage
 
 import (
@@ -6,83 +8,69 @@ import (
 	"encoding/gob"
 	"github.com/brokenbydefault/Nanollet/Util"
 	"bytes"
+	"path/filepath"
 )
 
-var ArbitraryStorage = configdir.New("BrokenByDefault", Configuration.Storage.Folder).QueryFolders(configdir.Global)[0]
+func init() {
+	Engine = &DesktopStorage{
+		dir: configdir.New("BrokenByDefault", Configuration.Storage.Folder).QueryFolders(configdir.Global)[0],
+	}
 
-var PermanentStorage Persistent
+	Engine.Load(&PersistentStorage)
+}
 
-type Persistent struct {
-	SeedFY      Wallet.SeedFY
-	AllowedKeys []Wallet.PublicKey
+type DesktopStorage struct {
+	dir *configdir.Config
 }
 
-func init() {
-	PermanentStorage.Load()
+func (s *DesktopStorage) Save(from *Persistent) {
+	b := new(bytes.Buffer)
+	if err := gob.NewEncoder(b).Encode(from); err != nil {
+		panic(err)
+	}
+
+	s.dir.WriteFile("storage.nanollet", b.Bytes())
 }
 
-func (p *Persistent) Load() {
-	if ArbitraryStorage.Exists("storage.nanollet") {
-		r, err := ArbitraryStorage.ReadFile("storage.nanollet")
+func (s *DesktopStorage) Load(to *Persistent) {
+	if s.dir.Exists("storage.nanollet") {
+		r, err := s.dir.ReadFile("storage.nanollet")
 		if err != nil {
 			return
 		}
 
-		if err := gob.NewDecoder(bytes.NewReader(r)).Decode(p); err != nil {
+		if err := gob.NewDecoder(bytes.NewReader(r)).Decode(to); err != nil {
 			panic(err)
 		}
-	} else if ArbitraryStorage.Exists("mfa.dat") || ArbitraryStorage.Exists("wallet.dat") {
-		p.loadLegacy(ArbitraryStorage)
-		p.Save()
+	} else if s.dir.Exists("mfa.dat") || s.dir.Exists("wallet.dat") {
+		s.loadLegacy(to)
+		s.Save(to)
 	}
 }
 
-func (p *Persistent) Save() {
-
-	b := new(bytes.Buffer)
-	if err := gob.NewEncoder(b).Encode(p); err != nil {
-		panic(err)
-	}
+func (s *DesktopStorage) Write(name string, data []byte) (path string, err error) {
+	return filepath.Join(s.dir.Path, name), s.dir.WriteFile(name, data)
+}
 
-	ArbitraryStorage.WriteFile("storage.nanollet", b.Bytes())
+func (s *DesktopStorage) Read(name string) ([]byte, error) {
+	return s.dir.ReadFile(name)
 }
 
 // Backward compatibility for Nanollet 1.0 and Nanollet 2.0
-func (p *Persistent) loadLegacy(files *configdir.Config) {
-	if files.Exists("mfa.dat") {
-		if file, err := files.ReadFile("mfa.dat"); err == nil {
+func (s *DesktopStorage) loadLegacy(to *Persistent) {
+	if s.dir.Exists("mfa.dat") {
+		if file, err := s.dir.ReadFile("mfa.dat"); err == nil {
 			if b, ok := Util.SecureHexDecode(string(file)); ok && len(b) == 32 {
-				p.AddAllowedKey(Wallet.NewPublicKey(b))
+				to.AddAllowedKey(Wallet.NewPublicKey(b))
 			}
 		}
 	}
 
-	if files.Exists("wallet.dat") {
-		if data, err := files.ReadFile("wallet.dat"); err == nil {
+	if s.dir.Exists("wallet.dat") {
+		if data, err := s.dir.ReadFile("wallet.dat"); err == nil {
 			if seedfy, err := Wallet.ReadSeedFY(string(data)); err == nil {
-				p.SeedFY = seedfy
+				to.SeedFY = seedfy
 			}
 		}
 	}
 }
-
-func (p *Persistent) AddSeedFY(seedfy Wallet.SeedFY) {
-	p.SeedFY = seedfy
-	p.Save()
-}
-
-func (p *Persistent) AddAllowedKey(newKey Wallet.PublicKey) {
-	for _, key := range p.AllowedKeys {
-		if key == newKey {
-			return
-		}
-	}
-
-	if p.AllowedKeys == nil {
-		p.AllowedKeys = []Wallet.PublicKey{newKey}
-	} else {
-		p.AllowedKeys = append(p.AllowedKeys, newKey)
-	}
-
-	p.Save()
-}
diff --git a/Storage/storage_js.go b/Storage/storage_js.go
new file mode 100644
index 0000000..8770d5e
--- /dev/null
+++ b/Storage/storage_js.go
@@ -0,0 +1,74 @@
+// +build js
+
+package Storage
+
+import (
+	"encoding/gob"
+	"github.com/brokenbydefault/Nanollet/Util"
+	"bytes"
+	"github.com/gopherjs/gopherjs/js"
+	"github.com/Inkeliz/goco/nativestorage"
+)
+
+func init() {
+	Engine = &JSStorage{}
+	Engine.Load(&PersistentStorage)
+}
+
+type JSStorage struct{}
+
+func (s *JSStorage) Save(from *Persistent) {
+	b := new(bytes.Buffer)
+	if err := gob.NewEncoder(b).Encode(from); err != nil {
+		panic(err)
+	}
+
+	// Prevent save binary directly on LocalStorage and so on.
+	bHex := Util.SecureHexEncode(b.Bytes())
+
+	switch {
+	case js.Global.Get("NativeStorage") != js.Undefined:
+		nativestorage.SetItem("storage.nanollet", bHex)
+	case js.Global.Get("localStorage") != js.Undefined:
+		js.Global.Get("localStorage").Call("setItem", "storage.nanollet", bHex)
+	default:
+		panic("Unsupported storage available")
+	}
+}
+
+func (s *JSStorage) Load(to *Persistent) {
+	var bHex string
+
+	switch {
+	case js.Global.Get("NativeStorage") != js.Undefined:
+		bHex, _ = nativestorage.GetString("storage.nanollet")
+	case js.Global.Get("localStorage") != js.Undefined:
+		obj := js.Global.Get("localStorage").Call("getItem", "storage.nanollet")
+		if obj != nil {
+			bHex = obj.String()
+		}
+	default:
+		panic("Unsupported storage available")
+	}
+
+	if bHex == "" {
+		return
+	}
+
+	b, _ := Util.SecureHexDecode(bHex)
+
+	if err := gob.NewDecoder(bytes.NewReader(b)).Decode(to); err != nil {
+		panic(err)
+	}
+
+}
+
+func (s *JSStorage) Write(name string, data []byte) (path string, err error) {
+	// No-op
+	return "", nil
+}
+
+func (s *JSStorage) Read(name string) ([]byte, error) {
+	// No-op
+	return nil, nil
+}
diff --git a/TwoFactor/network.go b/TwoFactor/network.go
index 36cc4b3..284c908 100644
--- a/TwoFactor/network.go
+++ b/TwoFactor/network.go
@@ -9,10 +9,10 @@ import (
 	"github.com/brokenbydefault/Nanollet/TwoFactor/Ephemeral"
 )
 
-func NewRequesterServer(sk *Ephemeral.SecretKey, allowedDevices []Wallet.PublicKey) (Request, <-chan *Envelope) {
+func NewRequesterServer(sk *Ephemeral.SecretKey, allowedDevices []Wallet.PublicKey) (req Request, ch <-chan *Envelope, err error) {
 	tcp, err := net.ListenTCP("tcp", &net.TCPAddr{IP: getIP()})
 	if err != nil {
-		panic(err)
+		return req, nil, err
 	}
 
 	c := make(chan *Envelope, 1)
@@ -20,7 +20,7 @@ func NewRequesterServer(sk *Ephemeral.SecretKey, allowedDevices []Wallet.PublicK
 
 	addr := tcp.Addr().(*net.TCPAddr)
 
-	return NewRequester(sk.PublicKey(), addr.IP, addr.Port), c
+	return NewRequester(sk.PublicKey(), addr.IP, addr.Port), c, nil
 }
 
 func ReplyRequest(device *Wallet.SecretKey, token Token, request Request) error {
diff --git a/TwoFactor/network_js.go b/TwoFactor/network_js.go
index 7ed1b3c..4f18213 100644
--- a/TwoFactor/network_js.go
+++ b/TwoFactor/network_js.go
@@ -8,11 +8,13 @@ import (
 	"encoding/binary"
 	"github.com/brokenbydefault/Nanollet/Wallet"
 	"github.com/jaracil/goco/chrome/tcpsockets"
+	"errors"
 )
 
-//func NewRequesterServer(sk *Ephemeral.SecretKey, allowedDevices []Wallet.PublicKey) (Request, <-chan Envelope) {
-// no-op
-//}
+func NewRequesterServer(sk *Ephemeral.SecretKey, allowedDevices []Wallet.PublicKey) (req Request, ch <-chan Envelope, err error) {
+	// NO-OP
+	return req, nil, errors.New("not supported")
+}
 
 func ReplyRequest(device *Wallet.SecretKey, token Token, request Request) error {
 	sk := Ephemeral.NewEphemeral()
diff --git a/Util/dns.go b/Util/dns.go
new file mode 100644
index 0000000..4314380
--- /dev/null
+++ b/Util/dns.go
@@ -0,0 +1,101 @@
+package Util
+
+import (
+	"net"
+	"net/http"
+	"net/url"
+	"strconv"
+	"encoding/json"
+	"strings"
+	"errors"
+)
+
+type rr int
+
+func (rr rr) String() string {
+	return strconv.Itoa(int(rr))
+}
+
+var (
+	a    rr = 1
+	aaaa rr = 28
+	any  rr = 255
+	srv  rr = 33
+)
+
+type response struct {
+	Answer []struct {
+		Type rr     `json:"type"`
+		Data string `json:"data"`
+	} `json:"Answer"`
+}
+
+func LookupIP(name string) (ips [][]byte, err error) {
+	ips = make([][]byte, 0)
+
+	ipv4, err := lookup(a, name)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, ip := range ipv4.Answer {
+		ips = append(ips, net.ParseIP(ip.Data))
+	}
+
+	ipv6, err := lookup(aaaa, name)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, ip := range ipv6.Answer {
+		ips = append(ips, net.ParseIP(ip.Data))
+	}
+
+	return ips, nil
+}
+
+func LookupSRV(service, proto, name string) (cname string, addrs []*net.SRV, err error) {
+	raw, err := lookup(srv, "_"+service+"._"+proto+"."+name)
+
+	for _, answer := range raw.Answer {
+		sa := strings.Split(answer.Data, " ")
+		if len(sa) != 4 {
+			return cname, addrs, errors.New("invalid response")
+		}
+
+		addrs = append(addrs, &net.SRV{
+			Target:   sa[3],
+			Port:     mustInt16(sa[2]),
+			Priority: mustInt16(sa[1]),
+			Weight:   mustInt16(sa[0]),
+		})
+	}
+
+	return cname, addrs, err
+}
+
+func lookup(rr rr, host string) (*response, error) {
+	raw, err := http.Get("https://1.1.1.1/dns-query?" + url.Values{
+		"name": []string{host},
+		"type": []string{rr.String()},
+		"ct":   []string{"application/dns-json"},
+	}.Encode())
+
+	if err != nil {
+		return nil, err
+	}
+
+	defer raw.Body.Close()
+
+	resp := new(response)
+	if err := json.NewDecoder(raw.Body).Decode(resp); err != nil {
+		return nil, err
+	}
+
+	return resp, nil
+}
+
+func mustInt16(s string) uint16 {
+	i, _ := strconv.Atoi(s)
+	return uint16(i)
+}
\ No newline at end of file
diff --git a/Util/file.go b/Util/file.go
index b615bff..0a61384 100644
--- a/Util/file.go
+++ b/Util/file.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package Util
 
 import "io/ioutil"