diff --git a/app/build.gradle b/app/build.gradle
index 5a1ceca9..6021b2bd 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -48,5 +48,7 @@ dependencies {
     compile 'com.github.florent37:singledateandtimepicker:1.0.8'
     compile 'com.jakewharton.timber:timber:4.5.1'
     compile 'com.google.android.gms:play-services:+'
+    compile 'com.scottyab:secure-preferences-lib:0.1.4'
+    compile 'com.github.gliechtenstein:PasscodeView:master'
     compile 'com.android.support:multidex:1.0.1'
 }
diff --git a/app/src/debug/AndroidManifest.xml b/app/src/debug/AndroidManifest.xml
index 59153641..7d3aab00 100644
--- a/app/src/debug/AndroidManifest.xml
+++ b/app/src/debug/AndroidManifest.xml
@@ -41,6 +41,7 @@
             android:name="com.commonsware.cwac.cam2.CameraActivity"
             android:process=":cwac_cam2"
             android:theme="@style/CameraTheme"/>
+        <activity android:name=".Lib.PasscodeActivity"/>
 
         <!-- Uncomment below to support push notification -->
         <!--
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 0683a882..0188031f 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -39,6 +39,7 @@
             android:name="com.commonsware.cwac.cam2.CameraActivity"
             android:process=":cwac_cam2"
             android:theme="@style/CameraTheme"/>
+        <activity android:name=".Lib.PasscodeActivity"/>
 
         <!-- Uncomment below line and add your Google Maps API key -->
         <!--
diff --git a/app/src/main/java/com/jasonette/seed/Action/JasonKeyAction.java b/app/src/main/java/com/jasonette/seed/Action/JasonKeyAction.java
new file mode 100644
index 00000000..00c0e76c
--- /dev/null
+++ b/app/src/main/java/com/jasonette/seed/Action/JasonKeyAction.java
@@ -0,0 +1,73 @@
+package com.jasonette.seed.Action;
+import android.content.Context;
+import android.content.Intent;
+
+import com.jasonette.seed.Helper.JasonHelper;
+import com.jasonette.seed.Launcher.Launcher;
+import com.jasonette.seed.Service.key.JasonKeyService;
+
+import org.json.JSONObject;
+
+public class JasonKeyAction {
+
+    public void request(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+        _forward("request", action, data, event, context);
+    }
+    public void add(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+        _forward("add", action, data, event, context);
+    }
+    public void remove(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+        _forward("remove", action, data, event, context);
+    }
+    public void update(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+        _forward("update", action, data, event, context);
+    }
+    public void clear(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+        _forward("clear", action, data, event, context);
+    }
+    public void password(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+        _forward("password", action, data, event, context);
+    }
+
+
+    // Called from dispatchIntent
+    // Called right after the user has successfully updated the password
+    public void on_register(Intent intent, final JSONObject options) {
+        try {
+            JSONObject action = options.getJSONObject("action");
+            JSONObject event = options.getJSONObject("event");
+            Context context = (Context) options.get("context");
+
+            // Password update was successful, therefore it's safe to go onto the next action
+            JasonHelper.next("success", action, new JSONObject(), event, context);
+        } catch (Exception e) {
+
+        }
+    }
+
+    // Called from dispatchIntent
+    // Called right after the user has successfully authenticated
+    public void on_authenticate(Intent intent, final JSONObject options) {
+        try {
+            JSONObject action = options.getJSONObject("action");
+            JSONObject data = options.getJSONObject("data");
+            JSONObject event = options.getJSONObject("event");
+            Context context = (Context) options.get("context");
+            String type = action.getString("type");
+            String name = type.split("\\.")[1];
+
+            // Call the JasonKeyService method one more time.
+            // The first time 'authenticated' was false and was redirected to _auth.
+            // but this time 'authenticated' will be true, therefore will execute the actual intended action
+            JasonKeyService keyService = (JasonKeyService)((Launcher)context.getApplicationContext()).services.get("JasonKeyService");
+            keyService.forward(name, action, data, event);
+
+        } catch (Exception e) {
+
+        }
+    }
+
+    private void _forward(String name, final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+        ((Launcher)context.getApplicationContext()).forward("JasonKeyService", name, action, data, event, context);
+    }
+}
diff --git a/app/src/main/java/com/jasonette/seed/Action/JasonUtilAction.java b/app/src/main/java/com/jasonette/seed/Action/JasonUtilAction.java
index 69683818..7a14c65c 100644
--- a/app/src/main/java/com/jasonette/seed/Action/JasonUtilAction.java
+++ b/app/src/main/java/com/jasonette/seed/Action/JasonUtilAction.java
@@ -93,8 +93,13 @@ public void run() {
                     final ArrayList<EditText> textFields = new ArrayList<EditText>();
                     if (action.has("options")) {
                         options = action.getJSONObject("options");
-                        String title = options.getString("title");
-                        String description = options.getString("description");
+
+                        String title = "";
+                        if (options.has("title")) title = options.getString("title");
+
+                        String description = "";
+                        if (options.has("description")) description = options.getString("description");
+
                         builder.setTitle(title);
                         builder.setMessage(description);
 
diff --git a/app/src/main/java/com/jasonette/seed/Core/JasonViewActivity.java b/app/src/main/java/com/jasonette/seed/Core/JasonViewActivity.java
index ce8c8942..6f97e97d 100644
--- a/app/src/main/java/com/jasonette/seed/Core/JasonViewActivity.java
+++ b/app/src/main/java/com/jasonette/seed/Core/JasonViewActivity.java
@@ -275,9 +275,8 @@ protected void onCreate(Bundle savedInstanceState) {
         }
 
     }
-    private void setup_agents() {
+    private void setup_agents(JSONObject head) {
         try {
-            JSONObject head = model.jason.getJSONObject("$jason").getJSONObject("head");
             if (head.has("agents")) {
                 final JSONObject agents = head.getJSONObject("agents");
                 Iterator<String> iterator = agents.keys();
@@ -383,7 +382,8 @@ private void onSwitchTab(String newUrl, String newParams, Intent intent) {
             } else {
                 // build
                 model = m;
-                setup_agents();
+                JSONObject head = model.jason.getJSONObject("$jason").getJSONObject("head");
+                setup_agents(head);
                 setup_body(m.rendered);
             }
         } catch (Exception e) {
@@ -470,6 +470,12 @@ protected void onResume() {
         }
 
         if (!firstResume) {
+            try {
+                JSONObject head = model.jason.getJSONObject("$jason").getJSONObject("head");
+                setup_agents(head);
+            } catch (Exception e) {
+
+            }
             onShow();
         }
         firstResume = false;
@@ -1434,7 +1440,7 @@ public void href(final JSONObject action, JSONObject data, JSONObject event, Con
                     // 1. call dispatchIntent
                     // 2. the intent will return with JasonCallback.href
                     JSONObject callback = new JSONObject();
-                    callback.put("class", "JasonCallback");
+                    callback.put("class", "com.jasonette.seed.Core.JasonCallback");
                     callback.put("method", "href");
                     JasonHelper.dispatchIntent(action, data, event, context, intent, callback);
                 }
@@ -1573,25 +1579,7 @@ public void build(JSONObject jason){
                 if (jason.getJSONObject("$jason").has("head")) {
                     final JSONObject head = jason.getJSONObject("$jason").getJSONObject("head");
 
-                    if (head.has("agents")) {
-                        final JSONObject agents = head.getJSONObject("agents");
-                        Iterator<String> iterator = agents.keys();
-                        while (iterator.hasNext()) {
-                            final String key = iterator.next();
-                            runOnUiThread(new Runnable() {
-                                @Override
-                                public void run() {
-                                    try {
-                                        JasonAgentService agentService = (JasonAgentService)((Launcher)getApplicationContext()).services.get("JasonAgentService");
-                                        WebView agent = agentService.setup(JasonViewActivity.this, agents.getJSONObject(key), key);
-                                        rootLayout.addView(agent);
-                                    } catch (JSONException e) {
-                                    }
-                                }
-                            });
-                        }
-
-                    }
+                    setup_agents(head);
 
                     if (head.has("data")) {
                         if (head.has("templates")) {
diff --git a/app/src/main/java/com/jasonette/seed/Launcher/Launcher.java b/app/src/main/java/com/jasonette/seed/Launcher/Launcher.java
index b336e63f..905fb47b 100644
--- a/app/src/main/java/com/jasonette/seed/Launcher/Launcher.java
+++ b/app/src/main/java/com/jasonette/seed/Launcher/Launcher.java
@@ -30,6 +30,7 @@
 
 import okhttp3.OkHttpClient;
 import com.jasonette.seed.BuildConfig;
+import com.jasonette.seed.Service.key.JasonKeyService;
 import com.jasonette.seed.Service.agent.JasonAgentService;
 import com.jasonette.seed.Service.websocket.JasonWebsocketService;
 
@@ -42,6 +43,7 @@ public class Launcher extends Application {
     public JSONObject services;
     private static Context currentContext;
 
+
     public void call(String serviceName, String methodName, JSONObject action, Context context) {
         try {
             Object service = services.get(serviceName);
@@ -51,6 +53,15 @@ public void call(String serviceName, String methodName, JSONObject action, Conte
             Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
         }
     }
+    public void forward(String serviceName, String methodName, final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+        try {
+            Object service = services.get(serviceName);
+            Method method = service.getClass().getMethod(methodName, action.getClass(), data.getClass(), event.getClass(), Context.class);
+            method.invoke(service, action, data, event, context);
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+    }
 
     // get current context from anywhere
     public static Context getCurrentContext() {
@@ -147,9 +158,12 @@ public void onCreate() {
             JasonWebsocketService websocketService = new JasonWebsocketService(this);
             JasonAgentService agentService = new JasonAgentService();
             services.put("JasonWebsocketService", websocketService);
+            JasonKeyService keyService = new JasonKeyService(this);
+            services.put("JasonKeyService", keyService);
             services.put("JasonAgentService", agentService);
 
 
+
             // handler init
             handlers = new JSONObject();
 
@@ -256,7 +270,11 @@ public void trigger(JSONObject intent_to_resolve, JasonViewActivity context) {
                 }
 
                 String classname = handler.getString("class");
-                classname = "com.jasonette.seed.Action." + classname;
+                if (classname.startsWith("com.jasonette")) {
+                   // absolute path. don't touch
+                } else {
+                    classname = "com.jasonette.seed.Action." + classname;
+                }
                 String methodname = handler.getString("method");
 
                 Object module;
diff --git a/app/src/main/java/com/jasonette/seed/Lib/PasscodeActivity.java b/app/src/main/java/com/jasonette/seed/Lib/PasscodeActivity.java
new file mode 100644
index 00000000..fa099cb3
--- /dev/null
+++ b/app/src/main/java/com/jasonette/seed/Lib/PasscodeActivity.java
@@ -0,0 +1,117 @@
+package com.jasonette.seed.Lib;
+
+import android.content.Context;
+import android.content.Intent;
+import android.support.v7.app.AppCompatActivity;
+import android.graphics.Color;
+import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.LinearLayout;
+import android.widget.RelativeLayout;
+import android.widget.Toast;
+
+import com.hanks.passcodeview.PasscodeView;
+import com.jasonette.seed.Launcher.Launcher;
+import com.jasonette.seed.Service.key.JasonKeyService;
+
+import org.json.JSONObject;
+
+
+public class PasscodeActivity extends AppCompatActivity {
+    String mode;
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        class PView extends PasscodeView {
+            public PView(Context context) {
+                super(context);
+            }
+            @Override protected Boolean equals(String psd) {
+                try {
+                    if (mode.equalsIgnoreCase("authenticate")) {
+                        JasonKeyService keyService = (JasonKeyService)((Launcher)PasscodeActivity.this.getApplicationContext()).services.get("JasonKeyService");
+                        return keyService.is_authenticated(psd);
+                    } else if (mode.equalsIgnoreCase("register")) {
+                        return getLocalPasscode().equals(psd);
+                    }
+                } catch (Exception e) {
+                }
+                return false;
+            }
+        }
+        /*
+            1. Does this view already have a password set?
+            => YES: Ask for password
+            => NO: Call password() to ask for password
+        */
+
+        PView passcodeView = new PView(PasscodeActivity.this);
+
+        Intent intent = getIntent();
+        if (intent.hasExtra("mode")) {
+            mode = intent.getStringExtra("mode");
+            if (mode.equalsIgnoreCase("authenticate")) {
+                // Doesn't matter what it's set to because we'll use a custom "equals()" logic from above (PView)
+                passcodeView.setPasscodeLength(4).setLocalPasscode("0000");
+            } else if (mode.equalsIgnoreCase("register")) {
+
+            }
+        }
+
+        // 1. Get password for the current url
+        passcodeView.setBackgroundColor(Color.parseColor("#468af6"));
+        FrameLayout.LayoutParams layout = new FrameLayout.LayoutParams(
+                FrameLayout.LayoutParams.MATCH_PARENT,
+                FrameLayout.LayoutParams.MATCH_PARENT);
+        passcodeView.setLayoutParams(layout);
+        setContentView(passcodeView);
+
+        /**
+            Customize the view to get rid of unnecessary graphics that come with the library
+         **/
+        for(int i = 0; i < passcodeView.getChildCount(); i++) {
+            View child = passcodeView.getChildAt(i);
+            if (child.getClass().equals(LinearLayout.class)) {
+                int index = 0;
+                for (int j=0; j<((LinearLayout)child).getChildCount(); j++) {
+                    View grandchild = ((LinearLayout)child).getChildAt(j);
+                    if (grandchild.getClass().equals(RelativeLayout.class)) {
+                        index++;
+                        if (index == 2) {
+                            grandchild.setBackgroundColor(Color.WHITE);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+
+        passcodeView.setListener(new PasscodeView.PasscodeViewListener() {
+            @Override
+            public void onFail() {
+
+            }
+
+            @Override
+            public void onSuccess(String number) {
+                // Set return intent with extras
+                try {
+                    JasonKeyService keyService = (JasonKeyService)((Launcher)PasscodeActivity.this.getApplicationContext()).services.get("JasonKeyService");
+                    if (mode.equalsIgnoreCase("register")) {
+                        keyService.register(number);
+                    }
+                    Toast.makeText(getApplication(),"Success",Toast.LENGTH_SHORT).show();
+                } catch (Exception e) {
+
+                }
+                Intent intent = new Intent();
+                setResult(RESULT_OK, intent);
+                finish();
+            }
+        });
+    }
+}
diff --git a/app/src/main/java/com/jasonette/seed/Service/agent/JasonAgentService.java b/app/src/main/java/com/jasonette/seed/Service/agent/JasonAgentService.java
index a7d455f5..2f081627 100644
--- a/app/src/main/java/com/jasonette/seed/Service/agent/JasonAgentService.java
+++ b/app/src/main/java/com/jasonette/seed/Service/agent/JasonAgentService.java
@@ -457,7 +457,7 @@ public void onFinished(JSONObject reduced_action) {
                                         return false;
                                     } else {
                                         Intent intent = new Intent("call");
-                                        intent.putExtra("action", options.get("action").toString());
+                                        intent.putExtra("action", parsed.toString());
                                         intent.putExtra("data", "{\"url\": \"" + url + "\"}");
                                         LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
                                         return true;
diff --git a/app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java b/app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java
new file mode 100644
index 00000000..8f64372b
--- /dev/null
+++ b/app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java
@@ -0,0 +1,888 @@
+package com.jasonette.seed.Service.key;
+
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.util.Log;
+
+import com.jasonette.seed.Core.JasonViewActivity;
+import com.jasonette.seed.Helper.JasonHelper;
+import com.jasonette.seed.Launcher.Launcher;
+import com.securepreferences.SecurePreferences;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+public class JasonKeyService {
+    SharedPreferences keys;
+    private Launcher launcher;
+    private Boolean authenticated = false;
+    private String caller;
+    private Context context;
+    public JasonKeyService (Launcher launcherParam) {
+        launcher = launcherParam;
+        keys = new SecurePreferences(launcher);
+    }
+
+    public void forward(String _caller, JSONObject action, JSONObject data, JSONObject event) {
+        authenticated = true;
+        if (caller.equalsIgnoreCase("request")) {
+            request(action, data, event, context);
+        } else if (caller.equalsIgnoreCase("add")) {
+            add(action, data, event, context);
+        } else if (caller.equalsIgnoreCase("remove")) {
+            remove(action, data, event, context);
+        } else if (caller.equalsIgnoreCase("update")) {
+            update(action, data, event, context);
+        } else if (caller.equalsIgnoreCase("clear")) {
+            clear(action, data, event, context);
+        } else if (caller.equalsIgnoreCase("password")) {
+            password(action, data, event, context);
+       }
+    }
+
+    private void _updatePassword(String _caller, JSONObject action, JSONObject data, JSONObject event, Context _context) {
+        caller = _caller;
+        context = _context;
+        String encrypted_passcode = keys.getString("passcode", "");
+        Intent intent = new Intent(context, com.jasonette.seed.Lib.PasscodeActivity.class);
+        // Authenticated and requestion password,
+        // Which means at this time we're trying to update the password.
+        intent.putExtra("mode", "register");
+        intent.putExtra("action", action.toString());
+        intent.putExtra("data", data.toString());
+        intent.putExtra("event", event.toString());
+        intent.putExtra("caller", _caller);
+        try {
+            JSONObject callback = new JSONObject();
+            callback.put("class", "JasonKeyAction");
+            callback.put("method", "on_register");
+
+            // Use dispatchIntent to open the activity so that it can process the callback after closing
+            JasonHelper.dispatchIntent(action, data, event, context, intent, callback);
+        } catch (Exception e) {
+
+        }
+    }
+    private void _auth(String _caller, JSONObject action, JSONObject data, JSONObject event, Context _context) {
+        caller = _caller;
+        context = _context;
+        String encrypted_passcode = keys.getString("passcode", "");
+        Intent intent = new Intent(context, com.jasonette.seed.Lib.PasscodeActivity.class);
+        if (_caller.equalsIgnoreCase("password")) {
+            // Not authenticated yet
+            // Need to authenticate user first before allowing password update
+            intent.putExtra("mode", "authenticate");
+        } else if (encrypted_passcode.length() > 0) {
+            // authenticate
+            intent.putExtra("mode", "authenticate");
+        } else {
+            // no password set yet. enter new password
+            intent.putExtra("mode", "register");
+        }
+
+        try {
+            JSONObject callback = new JSONObject();
+            callback.put("class", "JasonKeyAction");
+            callback.put("method", "on_authenticate");
+
+            // Use dispatchIntent to open the activity so that it can process the callback after closing
+            JasonHelper.dispatchIntent(action, data, event, context, intent, callback);
+        } catch (Exception e) {
+
+        }
+    }
+    public void register(String raw) {
+
+        String encrypted = SecurePreferences.hashPrefKey(raw);
+        SharedPreferences.Editor editor = keys.edit();
+        editor.putString("passcode", encrypted);
+        editor.commit();
+    }
+    public Boolean is_authenticated(String raw) {
+        String encrypted_passcode = keys.getString("passcode", "");
+        if (encrypted_passcode.length() > 0) {
+            String after = SecurePreferences.hashPrefKey(raw);
+            return after.equals(encrypted_passcode);
+        } else {
+            return false;
+        }
+    }
+
+    public JSONObject _parse(final JSONObject action, Context context) {
+        JSONObject res = new JSONObject();
+        try {
+            if (action.has("options")) {
+                JSONObject options = action.getJSONObject("options");
+                if (options.has("url")) {
+                    res.put("url", options.getString("url"));
+                    res.put("remote", true);
+                } else {
+                    res.put("url", ((JasonViewActivity)context).url);
+                    res.put("remote", false);
+                }
+            } else {
+                res.put("url", ((JasonViewActivity)context).url);
+                res.put("remote", false);
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+        return res;
+    }
+
+
+    private JSONArray _filter_public(JSONArray items) {
+        JSONArray filtered_items = new JSONArray();
+        try {
+            for (int i = 0; i < items.length(); i++) {
+                JSONObject item = items.getJSONObject(i);
+                JSONObject filtered_item = new JSONObject();
+                JSONArray keys = item.names();
+                for (int j = 0; j < keys.length(); j++) {
+                    String key = keys.getString(j);
+                    JSONObject component = item.getJSONObject(key);
+                    if (component.has("read") && component.getString("read").equalsIgnoreCase("public")) {
+                        // "read": "public" component
+                        // Add to filtered_components
+                        filtered_item.put(key, component);
+                    }
+                }
+                filtered_items.put(filtered_item);
+            }
+        } catch (Exception e) {
+        }
+        return filtered_items;
+    }
+
+
+    private JSONArray _filter_query(JSONArray items, JSONArray filter) {
+        // items Key/Val Filtering
+        try {
+            /**
+
+             filter := [{
+                 "type": {
+                     "value": "BTC"
+                 },
+                 "name": {
+                     "value": "Bitcoin"
+                 }
+             }, {
+                 "type": {
+                     "value": "ETH"
+                 }
+             }]
+
+
+             items := [{
+                 "type": {
+                     "value": "BTC",
+                     "read": "public"
+                 },
+                 "name": {
+                     "value": "Bitcoin",
+                     "read": "public"
+                 },
+                 "publickey": {
+                     "value": "0xm4ng83ng8wengn3kngdn3ngknal32ng".
+                     "read": "public"
+                 },
+                 "privatekey": {
+                     "value": "0xngn4bgbebgbgbejbgjbjbjbebsdjbdskb328fg3bgjewh2112hfdhg"
+                 }
+             }, {
+                 ...
+             }, {
+                 ...
+             }]
+
+
+             Need to filter 'items' with 'filter'.
+
+             Each item in the filter array is a query. All items that match at least one of the filter item gets selected
+             for the final result.
+
+             */
+
+            JSONArray filtered_items = new JSONArray();
+            // Go through each item and decide whether to include in the final item
+            for (int item_index = 0; item_index < items.length(); item_index++) {
+
+                // Testing nth item to decide whether to include
+                JSONObject item = items.getJSONObject(item_index);
+
+                // Loop for each filter item
+                // and merge all the results
+                for (int filter_index = 0; filter_index < filter.length(); filter_index++) {
+                    JSONObject filter_item = filter.getJSONObject(filter_index);
+
+                    /*
+
+                        filter_item := {
+                            "type": {
+                                "value": "BTC"
+                            },
+                            "name": {
+                                "value": "Bitcoin"
+                            }
+                        }
+
+                        Must match ALL attributes for the filter_item
+                    */
+
+                    // filter_keys := ["type", "name"]
+                    JSONArray filter_keys = filter_item.names();
+
+                    // innocent by default and loop until proven guilty
+                    boolean its_a_match = true;
+
+                    for (int key_index = 0; key_index < filter_keys.length(); key_index++) {
+                        String filter_key = filter_keys.getString(key_index);
+                        JSONObject filter_value = filter_item.getJSONObject(filter_key);
+
+                        /*
+
+                            filter_key := "type"
+                            filter_value := {
+                                "value": "BTC"
+                            }
+                            item := {
+                                 "type": {
+                                     "value": "BTC",
+                                     "read": "public"
+                                 },
+                                 "name": {
+                                     "value": "Bitcoin",
+                                     "read": "public"
+                                 },
+                                 "publickey": {
+                                     "value": "0xm4ng83ng8wengn3kngdn3ngknal32ng".
+                                     "read": "public"
+                                 },
+                                 "privatekey": {
+                                     "value": "0xngn4bgbebgbgbejbgjbjbjbebsdjbdskb328fg3bgjewh2112hfdhg"
+                                 }
+                             }
+
+                             check:
+                             1. item[filter_key] exists
+                             2. item[filter_key]["value"] == filter_value["value"]
+
+                        */
+
+                        if (item.has(filter_key)
+                            && item.getJSONObject(filter_key).has("value")
+                            && filter_value.has("value")
+                            && item.getJSONObject(filter_key).get("value").equals(filter_value.get("value"))){
+                            // this condition must match, every time.
+                            // Otherwise it needs to fail out.
+                        } else {
+                            its_a_match = false;
+                            break;
+                        }
+                    }
+
+                    if (its_a_match) {
+                        // If this item is a match, no need to look further.
+                        filtered_items.put(item);
+                        // Go on to checking the next item by breaking
+                        break;
+                    }
+                }
+            }
+            return filtered_items;
+        } catch (Exception e) {
+            return new JSONArray();
+        }
+    }
+
+    private void _fetch(JSONObject action, JSONObject event, JSONObject parsed, Context context) {
+
+        try {
+            String serialized = keys.getString(parsed.getString("url"), "{}");
+            JSONObject deserialized = new JSONObject(serialized);
+            /*
+
+                deserialized := {
+                    "items": [{
+                        "type": {
+                            "value": "BTC",
+                            "read": "public"
+                        },
+                        "name": {
+                            "value": "Bitcoin",
+                            "read": "public"
+                        },
+                        "publickey": {
+                            "value": "0xm4ng83ng8wengn3kngdn3ngknal32ng".
+                            "read": "public"
+                        },
+                        "privatekey": {
+                            "value": "0xngn4bgbebgbgbejbgjbjbjbebsdjbdskb328fg3bgjewh2112hfdhg"
+                        }
+                    }, {
+                        ...
+                    }, {
+                        ...
+                    }]
+                }
+
+             */
+
+            Boolean isRemote = parsed.getBoolean("remote");
+            JSONArray items;
+            if (!deserialized.has("items")) {
+                items = new JSONArray();
+            } else {
+                items = deserialized.getJSONArray("items");
+                if (isRemote) {
+                    // Need to filter only the public attributes
+                    items = _filter_public(items);
+                } else {
+                    // Return the full object
+                    // so don't do anything
+                }
+
+                // items Key/Val Filtering
+                if (action.has("options")) {
+                    JSONObject options = action.getJSONObject("options");
+                    if (options.has("items")) {
+                        JSONArray filter = options.getJSONArray("items");
+                        items = _filter_query(items, filter);
+                    }
+                }
+
+            }
+
+            JSONObject res = new JSONObject();
+            res.put("items", items);
+
+            JasonHelper.next("success", action, res, event, context);
+
+            // Filter only the "read
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+
+    }
+
+
+    /**
+
+     1. Local Request
+
+     {
+         "type": "$key.request"
+     }
+
+     2. Remote Request
+
+     {
+         "type": "$key.request",
+         "options": {
+             "url": "file://wallet.json"
+         }
+     }
+
+     3. Request with query
+
+     {
+         "type": "$key.request",
+         "options": {
+             "url": "file://wallet.json",
+             "items": [{
+                "type": "BTC"
+             }, {
+                "type": "BCH"
+             }]
+         }
+     }
+
+     **/
+    public void request(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+        JSONObject parsed = _parse(action, context);
+        try {
+            Boolean isRemote = parsed.getBoolean("remote");
+            if (isRemote) {
+                // remote.
+                // fetch only the public attributes.
+                _fetch(action, event, parsed, context);
+            } else {
+                // local
+                if (authenticated) {
+                    // IF authenticated, fetch full key items
+                    _fetch(action, event, parsed, context);
+                    authenticated = false;
+                } else {
+                    // If not yet authenticated, open passcode
+                    _auth("request", action, data, event, context);
+                }
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+
+    }
+
+    /*******************
+
+     1. Appending to end
+
+     {
+         "type": "$key.add",
+         "options": {
+            "item": {
+                "type": {
+                    "value": "ETH"
+                },
+                "publickey": {
+                    "value": "0xjdnfenfkdewfhk384b4"
+                },
+                "name": {
+                    "value": "Ethereum"
+                },
+                "privatekey": {
+                    "value": "0x8dbgjenb8fngjwev742gfh47gh8ds87fh3bv"
+                }
+             }
+         }
+     }
+
+     2. Adding into index
+
+     {
+         "type": "$key.add",
+         "options": {
+            "index": 1,
+            "item": {
+                "type": {
+                    "value": "ETH"
+                },
+                "publickey": {
+                    "value": "0xjdnfenfkdewfhk384b4"
+                },
+                "name": {
+                    "value": "Ethereum"
+                },
+                "privatekey": {
+                    "value": "0x8dbgjenb8fngjwev742gfh47gh8ds87fh3bv"
+                }
+            }
+        }
+    }
+     *******************/
+    public void add(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+        JSONObject parsed = _parse(action, context);
+        try {
+            Boolean isRemote = parsed.getBoolean("remote");
+            String url = parsed.getString("url");
+
+            if (!action.has("options")) {
+                JSONObject error = new JSONObject();
+                error.put("message", "Must specify an item to add");
+                JasonHelper.next("error", action, error, event, context);
+                return;
+            }
+
+            if (isRemote) {
+                // remote.
+                // cannot add from remote
+                // 1. Construct error
+                JSONObject error = new JSONObject();
+                error.put("message", "You are not allowed to add keys remotely");
+                // 2. Trigger error callback
+                JasonHelper.next("error", action, error, event, context);
+            } else {
+                // local
+                try {
+                    // Get {"items": [...]} from preferences
+                    JSONArray items = _deserialize(url);
+
+                    // Add options object to the "items" array
+                    JSONObject options = action.getJSONObject("options");
+                    JSONObject item = options.getJSONObject("item");
+
+                    boolean isvalid = _validate(item);
+                    if (!isvalid) {
+                        JSONObject error = new JSONObject();
+                        error.put("message", "Invalid key format. Please follow the $key item schema");
+                        JasonHelper.next("error", action, error, event, context);
+                        return;
+                    }
+
+                    if (options.has("index")) {
+                        JSONArray new_items = new JSONArray();
+                        int index = options.getInt("index");
+                        if (index == items.length()) {
+                            new_items.put(item);
+                        } else {
+                            for (int i=0; i<items.length(); i++) {
+                                if (i==options.getInt("index")) {
+                                    new_items.put(item);
+                                }
+                                new_items.put(items.getJSONObject(i));
+                            }
+                        }
+                        items = new_items;
+                    } else {
+                        items.put(item);
+                    }
+
+                    JSONObject res = _serialize(url, items);
+
+                    // Return the updated {"items": [...]} as a return value
+                    JasonHelper.next("success", action, res, event, context);
+
+                } catch (Exception e) {
+                    Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+                }
+
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+
+    }
+
+
+    private boolean _validate(JSONObject item) {
+        /**
+
+         item needs to be in the following format
+
+         for each key,
+            it has an attribute called 'value' or 'read'. Nothing else.
+
+        {
+            "type": {
+                "value": [VAL]
+            },
+            "publickey": {
+                "value": "0xjdnfenfkdewfhk384b4"
+            },
+            "name": {
+                "value": "Ethereum"
+            },
+            "privatekey": {
+                "value": "0x8dbgjenb8fngjwev742gfh47gh8ds87fh3bv"
+            }
+        }
+
+         **/
+
+        try {
+            JSONObject allowed = new JSONObject();
+            allowed.put("value", true);
+            allowed.put("read", true);
+            /**
+
+             allowed := {
+                "value": true,
+                "read": true
+             }
+
+             */
+
+            JSONArray keys = item.names();
+            for(int i=0; i<keys.length(); i++) {
+                JSONObject attrs = item.getJSONObject(keys.getString(i));
+                JSONArray attr_keys = attrs.names();
+                for(int j=0; j<attr_keys.length(); j++) {
+                    if (!allowed.has(attr_keys.getString(j))) {
+                        // if any of the attribute keys are not "value" or "read", it's invalid
+                        return false;
+                    }
+                }
+
+            }
+        } catch (Exception e) {
+            return false;
+        }
+        return true;
+    }
+
+
+
+    private JSONObject _serialize(String url, JSONArray items) {
+        try {
+            // update the {"items": [...]} with the new "items" array
+            JSONObject res = new JSONObject();
+            res.put("items", items);
+
+            // Update preference with the items
+            SharedPreferences.Editor editor = keys.edit();
+            editor.putString(url, res.toString());
+            editor.commit();
+            return res;
+
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+            return new JSONObject();
+        }
+    }
+    private JSONArray _deserialize(String url) {
+        try {
+            String serialized = keys.getString(url, "{}");
+            JSONObject deserialized = new JSONObject(serialized);
+            if (deserialized.has("items")) {
+                JSONArray items = deserialized.getJSONArray("items");
+                return items;
+            } else {
+                return new JSONArray();
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+            return new JSONArray();
+        }
+    }
+
+    /*******************
+     {
+         "type": "$key.remove",
+         "options": {
+             "index": 1
+         }
+     }
+     *******************/
+    public void remove(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+        JSONObject parsed = _parse(action, context);
+        try {
+
+            Boolean isRemote = parsed.getBoolean("remote");
+            String url = parsed.getString("url");
+            if (isRemote) {
+                // remote
+                // cannot remove from remote
+                JSONObject error = new JSONObject();
+                error.put("message", "You are not allowed to remove keys remotely");
+                JasonHelper.next("error", action, error, event, context);
+            } else {
+                // local
+                if (authenticated) {
+                    try {
+                        // Get {"items": [...]} from preferences
+                        JSONArray items = _deserialize(url);
+
+                        // Remove item at index
+                        if (action.has("options") && action.getJSONObject("options").has("index")) {
+                            int index = action.getJSONObject("options").getInt("index");
+                            JSONArray new_items = new JSONArray();
+                            if (items.length() > index) {
+                                for(int i=0; i<items.length(); i++) {
+                                    if (i != index) {
+                                        new_items.put(items.get(i));
+                                    }
+                                }
+                                JSONObject res = _serialize(url, new_items);
+                                // Return the updated {"items": [...]} as a return value
+                                JasonHelper.next("success", action, res, event, context);
+                            } else {
+                                JSONObject error = new JSONObject();
+                                error.put("message", "Invalid index");
+                                JasonHelper.next("error", action, error, event, context);
+                            }
+
+                        } else {
+                            JSONObject error = new JSONObject();
+                            error.put("message", "Need to specify an index to remove from");
+                            JasonHelper.next("error", action, error, event, context);
+                        }
+                    } catch (Exception e) {
+                        Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+                    }
+
+                    authenticated = false;
+                } else {
+                    _auth("remove", action, data, event, context);
+                }
+
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+
+    }
+
+
+
+
+
+    /*********************************
+
+        {
+            "type": "$key.update",
+            "options": {
+                "index": "{{$jason.index}}",
+                "item": {
+                    "name": {
+                        "value": "{{$jason.new_value}}"
+                    },
+                    "type": {
+                        "value": "BTC"
+                    }
+                }
+            },
+            "success": {
+                "type": "$render"
+            }
+        }
+
+     *********************************/
+    public void update(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+        JSONObject parsed = _parse(action, context);
+        try {
+            Boolean isRemote = parsed.getBoolean("remote");
+            String url = parsed.getString("url");
+            if (isRemote) {
+                JSONObject error = new JSONObject();
+                error.put("message", "You are not allowed to update keys remotely");
+                JasonHelper.next("error", action, error, event, context);
+            } else {
+                // local
+                if (authenticated) {
+
+                    JSONArray items = _deserialize(url);
+
+                    if (action.has("options") && action.getJSONObject("options").has("index")) {
+                        int index = action.getJSONObject("options").getInt("index");
+                        JSONArray new_items = new JSONArray();
+                        if (items.length() > index) {
+
+                            JSONObject selected_item = items.getJSONObject(index);
+
+                            if (action.getJSONObject("options").has("item")) {
+                                // Iterate through all keys and update the value
+                                JSONObject subtree_to_update = action.getJSONObject("options").getJSONObject("item");
+                                JSONArray keys_to_update = subtree_to_update.names();
+
+                                /**
+
+                                 subtree_to_update := {
+                                     "name": {
+                                         "value": "{{$jason.new_value}}",
+                                         "read": "public"
+                                     },
+                                     "type": {
+                                         "value": "BTC"
+                                     }
+                                 }
+
+                                 keys_to_update := ["name", "type"]
+
+                                 **/
+
+
+                                for(int i=0; i<keys_to_update.length(); i++) {
+                                    String key = keys_to_update.getString(i);
+                                    JSONObject attrs = subtree_to_update.getJSONObject(key);
+                                    /**
+
+                                        key := "name"
+
+                                        attrs := {
+                                            "value": "{{$jason.new_value}}",
+                                            "read": "public"
+                                        }
+
+                                     */
+                                    JSONArray attr_keys = attrs.names();
+                                    for (int j=0; j<attr_keys.length(); j++) {
+                                        String attr_key = attr_keys.getString(j);
+                                        selected_item.getJSONObject(key).put(attr_key, attrs.get(attr_key));
+                                    }
+                                }
+                                JSONObject res = _serialize(url, items);
+                                // Return the updated {"items": [...]} as a return value
+                                JasonHelper.next("success", action, res, event, context);
+
+                            } else {
+                                JSONObject error = new JSONObject();
+                                error.put("message", "Please specify at least one component to update");
+                                JasonHelper.next("error", action, error, event, context);
+                            }
+                        } else {
+                            JSONObject error = new JSONObject();
+                            error.put("message", "Invalid index");
+                            JasonHelper.next("error", action, error, event, context);
+                        }
+
+                    } else {
+                        JSONObject error = new JSONObject();
+                        error.put("message", "Need to specify an index to update");
+                        JasonHelper.next("error", action, error, event, context);
+                    }
+
+                    authenticated = false;
+
+                } else {
+                    _auth("update", action, data, event, context);
+                }
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+
+    }
+
+
+
+    /*********************************
+
+     {
+         "type": "$key.clear",
+     }
+
+     *********************************/
+
+    public void clear(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+        JSONObject parsed = _parse(action, context);
+        try {
+            Boolean isRemote = parsed.getBoolean("remote");
+            String url = parsed.getString("url");
+            if (isRemote) {
+                JSONObject error = new JSONObject();
+                error.put("message", "You are not allowed to clear keys remotely");
+                JasonHelper.next("error", action, error, event, context);
+            } else {
+                if (authenticated) {
+                    JSONArray items = new JSONArray();
+                    JSONObject res = _serialize(url, items);
+                    JasonHelper.next("success", action, res, event, context);
+                    authenticated = false;
+                } else {
+                    _auth("clear", action, data, event, context);
+                }
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+    }
+
+
+    /*********************************
+
+     {
+         "type": "$key.password",
+     }
+
+     *********************************/
+
+    public void password(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+        JSONObject parsed = _parse(action, context);
+        try {
+            // Password can be reset from anywhere
+            if (authenticated) {
+                // Called AFTER the user has authenticated
+                // Now finally able to update the password
+                _updatePassword("password", action, data, event, context);
+            } else {
+                // Called BEFORE the user authenticated therefore need to _auth() first.
+                _auth("password", action, data, event, context);
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+    }
+}