From c952e0ac80cc44f819f860021724f69195dafa43 Mon Sep 17 00:00:00 2001
From: gliechtenstein <ethan.gliechtenstein@gmail.com>
Date: Sun, 26 Nov 2017 20:52:59 -0800
Subject: [PATCH 01/10] Initial commit

---
 app/build.gradle                              |   1 +
 .../jasonette/seed/Action/JasonKeyAction.java | 427 ++++++++++++++++++
 2 files changed, 428 insertions(+)
 create mode 100644 app/src/main/java/com/jasonette/seed/Action/JasonKeyAction.java

diff --git a/app/build.gradle b/app/build.gradle
index 56b68ec5..38817ac9 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -47,4 +47,5 @@ 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'
 }
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..42e40aa8
--- /dev/null
+++ b/app/src/main/java/com/jasonette/seed/Action/JasonKeyAction.java
@@ -0,0 +1,427 @@
+package com.jasonette.seed.Action;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.util.Log;
+
+import com.jasonette.seed.Core.JasonViewActivity;
+import com.jasonette.seed.Helper.JasonHelper;
+import com.securepreferences.SecurePreferences;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+public class JasonKeyAction {
+    SharedPreferences keys;
+
+    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 void _fetch(JSONObject action, JSONObject event, JSONObject parsed, Context context) {
+
+        keys = new SecurePreferences(context);
+
+        try {
+            String serialized = keys.getString(parsed.getString("url"), "{}");
+            JSONObject deserialized = new JSONObject(serialized);
+            /*
+
+                deserialized := {
+                    "items": [{
+                        ...
+                    }, {
+                        ...
+                    }, {
+                        ...
+                    }]
+                }
+
+             */
+
+            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
+                    JSONArray filtered_items = new JSONArray();
+                    for (int i = 0; i < items.length(); i++) {
+                        JSONObject item = items.getJSONObject(i);
+                        JSONArray components = item.getJSONArray("components");
+                        JSONArray filtered_components = new JSONArray();
+                        for (int j = 0; j < components.length(); j++) {
+                            JSONObject component = components.getJSONObject(j);
+                            if (component.has("read")) {
+                                if (component.getString("read").equalsIgnoreCase("public")) {
+                                    // "read": "public" component
+                                    // Add to filtered_components
+                                    filtered_components.put(component);
+                                }
+                            }
+                        }
+
+                        JSONObject filtered_item = new JSONObject();
+                        filtered_item.put("components", filtered_components);
+
+                        filtered_items.put(filtered_item);
+                    }
+
+                    items = filtered_items;
+
+
+                } else {
+                    // Return the full object
+                    // so don't do anything
+                }
+            }
+
+            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"
+         }
+     }
+
+     **/
+    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
+                // fetch full key items
+                _fetch(action, event, parsed, context);
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+
+    }
+
+    /*******************
+     {
+         "type": "$key.add",
+         "options": {
+             "components": [{
+                 "key": "type",
+                 "val": "ETH"
+             }, {
+                 "key": "publickey",
+                 "val": "0xjdnfenfkdewfhk384b4"
+             }, {
+                 "key": "name",
+                 "val": "Ethereum"
+             }, {
+                 "key": "privatekey",
+                 "val": "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 (!action.getJSONObject("options").has("components")) {
+                JSONObject error = new JSONObject();
+                error.put("message", "A key item must have at least one component");
+                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
+                keys = new SecurePreferences(context);
+
+                try {
+                    // Get {"items": [...]} from preferences
+                    JSONArray items = _deserialize(url);
+
+                    // Add options object to the "items" array
+                    JSONObject options = action.getJSONObject("options");
+                    items.put(options);
+
+                    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 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
+                keys = new SecurePreferences(context);
+
+                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());
+                }
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+
+    }
+
+
+
+
+
+    /*********************************
+
+         {
+             "type": "$key.set",
+             "options": {
+                 "index": "{{$jason.index}}",
+                 "components": [{
+                     "key": "name",
+                     "val": "{{$jason.new_value}}"
+                 }]
+             },
+             "success": {
+                 "type": "$render"
+             }
+         }
+
+     *********************************/
+    public void set(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 set keys remotely");
+                JasonHelper.next("error", action, error, event, context);
+            } else {
+                // local
+                keys = new SecurePreferences(context);
+                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) {
+                        if (action.getJSONObject("options").has("components")) {
+                            JSONArray components_to_update = action.getJSONObject("options").getJSONArray("components");
+
+                            JSONObject old_item = items.getJSONObject(index);
+                            JSONArray old_components = old_item.getJSONArray("components");
+
+                            for(int i=0; i<components_to_update.length(); i++) {
+                                JSONObject component_to_update = components_to_update.getJSONObject(i);
+                                for(int j=0; j<old_components.length(); j++) {
+                                    JSONObject old_component = old_components.getJSONObject(j);
+                                    if (old_component.getString("key").equalsIgnoreCase(component_to_update.getString("key"))) {
+                                        // Match found!
+                                        // 1. Update the temp component's val
+                                        old_component.put("val", component_to_update.get("val"));
+                                        old_components.put(j, old_component);
+                                        break;
+                                    }
+                                }
+                            }
+
+                            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);
+                }
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+
+    }
+    public void reset(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 reset keys remotely");
+                JasonHelper.next("error", action, error, event, context);
+            } else {
+                // local
+                keys = new SecurePreferences(context);
+                JSONArray items = new JSONArray();
+                JSONObject res = _serialize(url, items);
+                JasonHelper.next("success", action, res, event, context);
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+    }
+}

From c4e2f35a79d9580b55f28167667578f042616eaa Mon Sep 17 00:00:00 2001
From: gliechtenstein <ethan.gliechtenstein@gmail.com>
Date: Sun, 26 Nov 2017 21:08:26 -0800
Subject: [PATCH 02/10] Use service for faster key query/manipulation

---
 .../jasonette/seed/Action/JasonKeyAction.java | 421 +----------------
 .../com/jasonette/seed/Launcher/Launcher.java |  13 +
 .../seed/Service/key/JasonKeyService.java     | 439 ++++++++++++++++++
 3 files changed, 463 insertions(+), 410 deletions(-)
 create mode 100644 app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java

diff --git a/app/src/main/java/com/jasonette/seed/Action/JasonKeyAction.java b/app/src/main/java/com/jasonette/seed/Action/JasonKeyAction.java
index 42e40aa8..57ace26f 100644
--- a/app/src/main/java/com/jasonette/seed/Action/JasonKeyAction.java
+++ b/app/src/main/java/com/jasonette/seed/Action/JasonKeyAction.java
@@ -1,427 +1,28 @@
 package com.jasonette.seed.Action;
-
 import android.content.Context;
-import android.content.SharedPreferences;
-import android.util.Log;
-
-import com.jasonette.seed.Core.JasonViewActivity;
-import com.jasonette.seed.Helper.JasonHelper;
-import com.securepreferences.SecurePreferences;
-
-import org.json.JSONArray;
+import com.jasonette.seed.Launcher.Launcher;
 import org.json.JSONObject;
 
 public class JasonKeyAction {
-    SharedPreferences keys;
-
-    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 void _fetch(JSONObject action, JSONObject event, JSONObject parsed, Context context) {
-
-        keys = new SecurePreferences(context);
-
-        try {
-            String serialized = keys.getString(parsed.getString("url"), "{}");
-            JSONObject deserialized = new JSONObject(serialized);
-            /*
-
-                deserialized := {
-                    "items": [{
-                        ...
-                    }, {
-                        ...
-                    }, {
-                        ...
-                    }]
-                }
-
-             */
-
-            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
-                    JSONArray filtered_items = new JSONArray();
-                    for (int i = 0; i < items.length(); i++) {
-                        JSONObject item = items.getJSONObject(i);
-                        JSONArray components = item.getJSONArray("components");
-                        JSONArray filtered_components = new JSONArray();
-                        for (int j = 0; j < components.length(); j++) {
-                            JSONObject component = components.getJSONObject(j);
-                            if (component.has("read")) {
-                                if (component.getString("read").equalsIgnoreCase("public")) {
-                                    // "read": "public" component
-                                    // Add to filtered_components
-                                    filtered_components.put(component);
-                                }
-                            }
-                        }
-
-                        JSONObject filtered_item = new JSONObject();
-                        filtered_item.put("components", filtered_components);
-
-                        filtered_items.put(filtered_item);
-                    }
-
-                    items = filtered_items;
-
-
-                } else {
-                    // Return the full object
-                    // so don't do anything
-                }
-            }
-
-            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"
-         }
-     }
-
-     **/
     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
-                // fetch full key items
-                _fetch(action, event, parsed, context);
-            }
-        } catch (Exception e) {
-            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
-        }
-
+        _forward("request", action, data, event, context);
     }
-
-    /*******************
-     {
-         "type": "$key.add",
-         "options": {
-             "components": [{
-                 "key": "type",
-                 "val": "ETH"
-             }, {
-                 "key": "publickey",
-                 "val": "0xjdnfenfkdewfhk384b4"
-             }, {
-                 "key": "name",
-                 "val": "Ethereum"
-             }, {
-                 "key": "privatekey",
-                 "val": "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 (!action.getJSONObject("options").has("components")) {
-                JSONObject error = new JSONObject();
-                error.put("message", "A key item must have at least one component");
-                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
-                keys = new SecurePreferences(context);
-
-                try {
-                    // Get {"items": [...]} from preferences
-                    JSONArray items = _deserialize(url);
-
-                    // Add options object to the "items" array
-                    JSONObject options = action.getJSONObject("options");
-                    items.put(options);
-
-                    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 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();
-        }
+        _forward("add", action, data, event, context);
     }
-
-    /*******************
-     {
-         "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
-                keys = new SecurePreferences(context);
-
-                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());
-                }
-            }
-        } catch (Exception e) {
-            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
-        }
-
+        _forward("remove", action, data, event, context);
     }
-
-
-
-
-
-    /*********************************
-
-         {
-             "type": "$key.set",
-             "options": {
-                 "index": "{{$jason.index}}",
-                 "components": [{
-                     "key": "name",
-                     "val": "{{$jason.new_value}}"
-                 }]
-             },
-             "success": {
-                 "type": "$render"
-             }
-         }
-
-     *********************************/
     public void set(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 set keys remotely");
-                JasonHelper.next("error", action, error, event, context);
-            } else {
-                // local
-                keys = new SecurePreferences(context);
-                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) {
-                        if (action.getJSONObject("options").has("components")) {
-                            JSONArray components_to_update = action.getJSONObject("options").getJSONArray("components");
-
-                            JSONObject old_item = items.getJSONObject(index);
-                            JSONArray old_components = old_item.getJSONArray("components");
-
-                            for(int i=0; i<components_to_update.length(); i++) {
-                                JSONObject component_to_update = components_to_update.getJSONObject(i);
-                                for(int j=0; j<old_components.length(); j++) {
-                                    JSONObject old_component = old_components.getJSONObject(j);
-                                    if (old_component.getString("key").equalsIgnoreCase(component_to_update.getString("key"))) {
-                                        // Match found!
-                                        // 1. Update the temp component's val
-                                        old_component.put("val", component_to_update.get("val"));
-                                        old_components.put(j, old_component);
-                                        break;
-                                    }
-                                }
-                            }
-
-                            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);
-                }
-            }
-        } catch (Exception e) {
-            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
-        }
-
+        _forward("set", action, data, event, context);
     }
     public void reset(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 reset keys remotely");
-                JasonHelper.next("error", action, error, event, context);
-            } else {
-                // local
-                keys = new SecurePreferences(context);
-                JSONArray items = new JSONArray();
-                JSONObject res = _serialize(url, items);
-                JasonHelper.next("success", action, res, event, context);
-            }
-        } catch (Exception e) {
-            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
-        }
+        _forward("reset", action, data, event, context);
+    }
+
+
+    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/Launcher/Launcher.java b/app/src/main/java/com/jasonette/seed/Launcher/Launcher.java
index b6d130be..14c4ee12 100644
--- a/app/src/main/java/com/jasonette/seed/Launcher/Launcher.java
+++ b/app/src/main/java/com/jasonette/seed/Launcher/Launcher.java
@@ -29,6 +29,7 @@
 
 import okhttp3.OkHttpClient;
 import com.jasonette.seed.BuildConfig;
+import com.jasonette.seed.Service.key.JasonKeyService;
 import com.jasonette.seed.Service.websocket.JasonWebsocketService;
 
 
@@ -48,6 +49,15 @@ public void call(String serviceName, String methodName, JSONObject action) {
             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() {
@@ -124,6 +134,9 @@ public void onCreate() {
             services = new JSONObject();
             JasonWebsocketService websocketService = new JasonWebsocketService(this);
             services.put("JasonWebsocketService", websocketService);
+            JasonKeyService keyService = new JasonKeyService(this);
+            services.put("JasonKeyService", keyService);
+
 
 
             // handler init
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..c6673511
--- /dev/null
+++ b/app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java
@@ -0,0 +1,439 @@
+package com.jasonette.seed.Service.key;
+
+
+import android.content.Context;
+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;
+    public JasonKeyService (Launcher launcherParam) {
+        launcher = launcherParam;
+        keys = new SecurePreferences(launcher);
+    }
+
+    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 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": [{
+                        ...
+                    }, {
+                        ...
+                    }, {
+                        ...
+                    }]
+                }
+
+             */
+
+            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
+                    JSONArray filtered_items = new JSONArray();
+                    for (int i = 0; i < items.length(); i++) {
+                        JSONObject item = items.getJSONObject(i);
+                        JSONArray components = item.getJSONArray("components");
+                        JSONArray filtered_components = new JSONArray();
+                        for (int j = 0; j < components.length(); j++) {
+                            JSONObject component = components.getJSONObject(j);
+                            if (component.has("read")) {
+                                if (component.getString("read").equalsIgnoreCase("public")) {
+                                    // "read": "public" component
+                                    // Add to filtered_components
+                                    filtered_components.put(component);
+                                }
+                            }
+                        }
+
+                        JSONObject filtered_item = new JSONObject();
+                        filtered_item.put("components", filtered_components);
+
+                        filtered_items.put(filtered_item);
+                    }
+
+                    items = filtered_items;
+
+
+                } else {
+                    // Return the full object
+                    // so don't do anything
+                }
+            }
+
+            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"
+         }
+     }
+
+     **/
+    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
+                // fetch full key items
+                _fetch(action, event, parsed, context);
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+
+    }
+
+    /*******************
+     {
+         "type": "$key.add",
+         "options": {
+             "components": [{
+                 "key": "type",
+                 "val": "ETH"
+             }, {
+                 "key": "publickey",
+                 "val": "0xjdnfenfkdewfhk384b4"
+             }, {
+                 "key": "name",
+                 "val": "Ethereum"
+             }, {
+                 "key": "privatekey",
+                 "val": "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 (!action.getJSONObject("options").has("components")) {
+                JSONObject error = new JSONObject();
+                error.put("message", "A key item must have at least one component");
+                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");
+                    items.put(options);
+
+                    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 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
+
+                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());
+                }
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+
+    }
+
+
+
+
+
+    /*********************************
+
+     {
+         "type": "$key.set",
+         "options": {
+             "index": "{{$jason.index}}",
+             "components": [{
+                 "key": "name",
+                 "val": "{{$jason.new_value}}"
+             }]
+         },
+         "success": {
+             "type": "$render"
+         }
+     }
+
+     *********************************/
+    public void set(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 set keys remotely");
+                JasonHelper.next("error", action, error, event, context);
+            } else {
+                // local
+                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) {
+                        if (action.getJSONObject("options").has("components")) {
+                            JSONArray components_to_update = action.getJSONObject("options").getJSONArray("components");
+
+                            JSONObject old_item = items.getJSONObject(index);
+                            JSONArray old_components = old_item.getJSONArray("components");
+
+                            for(int i=0; i<components_to_update.length(); i++) {
+                                JSONObject component_to_update = components_to_update.getJSONObject(i);
+                                for(int j=0; j<old_components.length(); j++) {
+                                    JSONObject old_component = old_components.getJSONObject(j);
+                                    if (old_component.getString("key").equalsIgnoreCase(component_to_update.getString("key"))) {
+                                        // Match found!
+                                        // 1. Update the temp component's val
+                                        old_component.put("val", component_to_update.get("val"));
+                                        old_components.put(j, old_component);
+                                        break;
+                                    }
+                                }
+                            }
+
+                            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);
+                }
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+
+    }
+
+
+
+    /*********************************
+
+     {
+         "type": "$key.reset",
+     }
+
+     *********************************/
+
+    public void reset(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 reset keys remotely");
+                JasonHelper.next("error", action, error, event, context);
+            } else {
+                // local
+                JSONArray items = new JSONArray();
+                JSONObject res = _serialize(url, items);
+                JasonHelper.next("success", action, res, event, context);
+            }
+        } catch (Exception e) {
+            Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
+        }
+    }
+}

From a9543acab83f0c2a98c43fe23e8e8510e0a473d4 Mon Sep 17 00:00:00 2001
From: gliechtenstein <ethan.gliechtenstein@gmail.com>
Date: Mon, 27 Nov 2017 19:47:15 -0800
Subject: [PATCH 03/10] Added password protection for $keys

---
 app/build.gradle                              |   1 +
 app/src/debug/AndroidManifest.xml             |   1 +
 app/src/main/AndroidManifest.xml              |   1 +
 .../jasonette/seed/Action/JasonKeyAction.java |  45 +++
 .../com/jasonette/seed/Launcher/Launcher.java |   2 +-
 .../jasonette/seed/Lib/PasscodeActivity.java  | 117 ++++++++
 .../seed/Service/key/JasonKeyService.java     | 267 +++++++++++++-----
 7 files changed, 367 insertions(+), 67 deletions(-)
 create mode 100644 app/src/main/java/com/jasonette/seed/Lib/PasscodeActivity.java

diff --git a/app/build.gradle b/app/build.gradle
index 38817ac9..e184e615 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -48,4 +48,5 @@ dependencies {
     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'
 }
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
index 57ace26f..d39338b4 100644
--- a/app/src/main/java/com/jasonette/seed/Action/JasonKeyAction.java
+++ b/app/src/main/java/com/jasonette/seed/Action/JasonKeyAction.java
@@ -1,6 +1,11 @@
 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 {
@@ -20,7 +25,47 @@ public void set(final JSONObject action, final JSONObject data, final JSONObject
     public void reset(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
         _forward("reset", 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/Launcher/Launcher.java b/app/src/main/java/com/jasonette/seed/Launcher/Launcher.java
index 14c4ee12..1b5acf15 100644
--- a/app/src/main/java/com/jasonette/seed/Launcher/Launcher.java
+++ b/app/src/main/java/com/jasonette/seed/Launcher/Launcher.java
@@ -37,7 +37,7 @@ public class Launcher extends Application {
     private JSONObject handlers;
     private JSONObject global;
     private JSONObject env;
-    private JSONObject services;
+    public JSONObject services;
     private static Context currentContext;
 
     public void call(String serviceName, String methodName, JSONObject action) {
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/key/JasonKeyService.java b/app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java
index c6673511..96a78966 100644
--- a/app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java
+++ b/app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java
@@ -2,6 +2,7 @@
 
 
 import android.content.Context;
+import android.content.Intent;
 import android.content.SharedPreferences;
 import android.util.Log;
 
@@ -16,11 +17,99 @@
 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("set")) {
+            set(action, data, event, context);
+        } else if (caller.equalsIgnoreCase("reset")) {
+            reset(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 {
@@ -141,8 +230,14 @@ public void request(final JSONObject action, final JSONObject data, final JSONOb
                 _fetch(action, event, parsed, context);
             } else {
                 // local
-                // fetch full key items
-                _fetch(action, event, parsed, context);
+                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());
@@ -200,7 +295,6 @@ public void add(final JSONObject action, final JSONObject data, final JSONObject
                 JasonHelper.next("error", action, error, event, context);
             } else {
                 // local
-
                 try {
                     // Get {"items": [...]} from preferences
                     JSONArray items = _deserialize(url);
@@ -217,6 +311,7 @@ public void add(final JSONObject action, final JSONObject data, final JSONObject
                 } catch (Exception e) {
                     Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
                 }
+
             }
         } catch (Exception e) {
             Log.d("Warning", e.getStackTrace()[0].getMethodName() + " : " + e.toString());
@@ -280,38 +375,44 @@ public void remove(final JSONObject action, final JSONObject data, final JSONObj
                 JasonHelper.next("error", action, error, event, context);
             } else {
                 // local
-
-                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));
+                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);
                             }
-                            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");
+                            error.put("message", "Need to specify an index to remove from");
                             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());
                     }
-                } 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());
@@ -346,57 +447,63 @@ public void set(final JSONObject action, final JSONObject data, final JSONObject
             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 set keys remotely");
                 JasonHelper.next("error", action, error, event, context);
             } else {
                 // local
-                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) {
-                        if (action.getJSONObject("options").has("components")) {
-                            JSONArray components_to_update = action.getJSONObject("options").getJSONArray("components");
-
-                            JSONObject old_item = items.getJSONObject(index);
-                            JSONArray old_components = old_item.getJSONArray("components");
-
-                            for(int i=0; i<components_to_update.length(); i++) {
-                                JSONObject component_to_update = components_to_update.getJSONObject(i);
-                                for(int j=0; j<old_components.length(); j++) {
-                                    JSONObject old_component = old_components.getJSONObject(j);
-                                    if (old_component.getString("key").equalsIgnoreCase(component_to_update.getString("key"))) {
-                                        // Match found!
-                                        // 1. Update the temp component's val
-                                        old_component.put("val", component_to_update.get("val"));
-                                        old_components.put(j, old_component);
-                                        break;
+                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) {
+                            if (action.getJSONObject("options").has("components")) {
+                                JSONArray components_to_update = action.getJSONObject("options").getJSONArray("components");
+
+                                JSONObject old_item = items.getJSONObject(index);
+                                JSONArray old_components = old_item.getJSONArray("components");
+
+                                for(int i=0; i<components_to_update.length(); i++) {
+                                    JSONObject component_to_update = components_to_update.getJSONObject(i);
+                                    for(int j=0; j<old_components.length(); j++) {
+                                        JSONObject old_component = old_components.getJSONObject(j);
+                                        if (old_component.getString("key").equalsIgnoreCase(component_to_update.getString("key"))) {
+                                            // Match found!
+                                            // 1. Update the temp component's val
+                                            old_component.put("val", component_to_update.get("val"));
+                                            old_components.put(j, old_component);
+                                            break;
+                                        }
                                     }
                                 }
-                            }
 
-                            JSONObject res = _serialize(url, items);
-                            // Return the updated {"items": [...]} as a return value
-                            JasonHelper.next("success", action, res, event, context);
+                                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", "Please specify at least one component to update");
+                            error.put("message", "Invalid index");
                             JasonHelper.next("error", action, error, event, context);
                         }
+
                     } else {
                         JSONObject error = new JSONObject();
-                        error.put("message", "Invalid index");
+                        error.put("message", "Need to specify an index to update");
                         JasonHelper.next("error", action, error, event, context);
                     }
 
+                    authenticated = false;
+
                 } else {
-                    JSONObject error = new JSONObject();
-                    error.put("message", "Need to specify an index to update");
-                    JasonHelper.next("error", action, error, event, context);
+                    _auth("set", action, data, event, context);
                 }
             }
         } catch (Exception e) {
@@ -421,16 +528,44 @@ public void reset(final JSONObject action, final JSONObject data, final JSONObje
             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 reset keys remotely");
                 JasonHelper.next("error", action, error, event, context);
             } else {
-                // local
-                JSONArray items = new JSONArray();
-                JSONObject res = _serialize(url, items);
-                JasonHelper.next("success", action, res, event, context);
+                if (authenticated) {
+                    JSONArray items = new JSONArray();
+                    JSONObject res = _serialize(url, items);
+                    JasonHelper.next("success", action, res, event, context);
+                    authenticated = false;
+                } else {
+                    _auth("reset", 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());

From 821f1f2c7ccb3012d56d300605d81e6f2fb3c2fd Mon Sep 17 00:00:00 2001
From: gliechtenstein <ethan.gliechtenstein@gmail.com>
Date: Mon, 27 Nov 2017 20:51:15 -0800
Subject: [PATCH 04/10] lint

---
 .../jasonette/seed/Service/key/JasonKeyService.java    | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

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
index 96a78966..f5e7055d 100644
--- a/app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java
+++ b/app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java
@@ -165,12 +165,10 @@ private void _fetch(JSONObject action, JSONObject event, JSONObject parsed, Cont
                         JSONArray filtered_components = new JSONArray();
                         for (int j = 0; j < components.length(); j++) {
                             JSONObject component = components.getJSONObject(j);
-                            if (component.has("read")) {
-                                if (component.getString("read").equalsIgnoreCase("public")) {
-                                    // "read": "public" component
-                                    // Add to filtered_components
-                                    filtered_components.put(component);
-                                }
+                            if (component.has("read") && component.getString("read").equalsIgnoreCase("public")) {
+                                // "read": "public" component
+                                // Add to filtered_components
+                                filtered_components.put(component);
                             }
                         }
 

From edca55fcc565dfecce93e9c3f2ca76a939d3457c Mon Sep 17 00:00:00 2001
From: gliechtenstein <ethan.gliechtenstein@gmail.com>
Date: Fri, 1 Dec 2017 12:50:22 -0800
Subject: [PATCH 05/10] update api: $key.set => $key.update; $key.reset =>
 $key.clear

---
 .../jasonette/seed/Action/JasonKeyAction.java |  8 +++----
 .../seed/Service/key/JasonKeyService.java     | 24 +++++++++----------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/app/src/main/java/com/jasonette/seed/Action/JasonKeyAction.java b/app/src/main/java/com/jasonette/seed/Action/JasonKeyAction.java
index d39338b4..00c0e76c 100644
--- a/app/src/main/java/com/jasonette/seed/Action/JasonKeyAction.java
+++ b/app/src/main/java/com/jasonette/seed/Action/JasonKeyAction.java
@@ -19,11 +19,11 @@ public void add(final JSONObject action, final JSONObject data, final JSONObject
     public void remove(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
         _forward("remove", action, data, event, context);
     }
-    public void set(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
-        _forward("set", 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 reset(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
-        _forward("reset", 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);
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
index f5e7055d..9a79c459 100644
--- a/app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java
+++ b/app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java
@@ -33,10 +33,10 @@ public void forward(String _caller, JSONObject action, JSONObject data, JSONObje
             add(action, data, event, context);
         } else if (caller.equalsIgnoreCase("remove")) {
             remove(action, data, event, context);
-        } else if (caller.equalsIgnoreCase("set")) {
-            set(action, data, event, context);
-        } else if (caller.equalsIgnoreCase("reset")) {
-            reset(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);
        }
@@ -425,7 +425,7 @@ public void remove(final JSONObject action, final JSONObject data, final JSONObj
     /*********************************
 
      {
-         "type": "$key.set",
+         "type": "$key.update",
          "options": {
              "index": "{{$jason.index}}",
              "components": [{
@@ -439,14 +439,14 @@ public void remove(final JSONObject action, final JSONObject data, final JSONObj
      }
 
      *********************************/
-    public void set(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+    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 set keys remotely");
+                error.put("message", "You are not allowed to update keys remotely");
                 JasonHelper.next("error", action, error, event, context);
             } else {
                 // local
@@ -501,7 +501,7 @@ public void set(final JSONObject action, final JSONObject data, final JSONObject
                     authenticated = false;
 
                 } else {
-                    _auth("set", action, data, event, context);
+                    _auth("update", action, data, event, context);
                 }
             }
         } catch (Exception e) {
@@ -515,19 +515,19 @@ public void set(final JSONObject action, final JSONObject data, final JSONObject
     /*********************************
 
      {
-         "type": "$key.reset",
+         "type": "$key.clear",
      }
 
      *********************************/
 
-    public void reset(final JSONObject action, final JSONObject data, final JSONObject event, final Context context) {
+    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 reset keys remotely");
+                error.put("message", "You are not allowed to clear keys remotely");
                 JasonHelper.next("error", action, error, event, context);
             } else {
                 if (authenticated) {
@@ -536,7 +536,7 @@ public void reset(final JSONObject action, final JSONObject data, final JSONObje
                     JasonHelper.next("success", action, res, event, context);
                     authenticated = false;
                 } else {
-                    _auth("reset", action, data, event, context);
+                    _auth("clear", action, data, event, context);
                 }
             }
         } catch (Exception e) {

From 4afe017c2473ceeae70c0df2d19c5b3a2d1b9a52 Mon Sep 17 00:00:00 2001
From: gliechtenstein <ethan.gliechtenstein@gmail.com>
Date: Sat, 2 Dec 2017 01:17:42 -0800
Subject: [PATCH 06/10] $util.alert should allow empty title or empty
 description

---
 .../java/com/jasonette/seed/Action/JasonUtilAction.java  | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

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);
 

From 77e056bf93efe214c04e93e651ab8443975d233d Mon Sep 17 00:00:00 2001
From: gliechtenstein <ethan.gliechtenstein@gmail.com>
Date: Sat, 2 Dec 2017 01:19:46 -0800
Subject: [PATCH 07/10] re-setup agent whenever the parent view resumes

---
 .../seed/Core/JasonViewActivity.java          | 34 ++++++-------------
 .../com/jasonette/seed/Launcher/Launcher.java |  7 +++-
 2 files changed, 17 insertions(+), 24 deletions(-)

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 a58f9683..fcc13211 100644
--- a/app/src/main/java/com/jasonette/seed/Core/JasonViewActivity.java
+++ b/app/src/main/java/com/jasonette/seed/Core/JasonViewActivity.java
@@ -279,9 +279,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();
@@ -387,7 +386,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) {
@@ -474,6 +474,12 @@ protected void onResume() {
         }
 
         if (!firstResume) {
+            try {
+                JSONObject head = model.jason.getJSONObject("$jason").getJSONObject("head");
+                setup_agents(head);
+            } catch (Exception e) {
+
+            }
             onShow();
         }
         firstResume = false;
@@ -1438,7 +1444,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);
                 }
@@ -1577,25 +1583,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 1748224e..905fb47b 100644
--- a/app/src/main/java/com/jasonette/seed/Launcher/Launcher.java
+++ b/app/src/main/java/com/jasonette/seed/Launcher/Launcher.java
@@ -43,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);
@@ -269,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;

From 17346387513eb12b2b19213e36d83941c382266a Mon Sep 17 00:00:00 2001
From: gliechtenstein <ethan.gliechtenstein@gmail.com>
Date: Mon, 4 Dec 2017 13:46:54 -0800
Subject: [PATCH 08/10] Added SELECT & WHERE

---
 .../seed/Service/key/JasonKeyService.java     | 72 ++++++++++++++++++-
 1 file changed, 69 insertions(+), 3 deletions(-)

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
index 9a79c459..12400b2e 100644
--- a/app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java
+++ b/app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java
@@ -177,14 +177,80 @@ private void _fetch(JSONObject action, JSONObject event, JSONObject parsed, Cont
 
                         filtered_items.put(filtered_item);
                     }
-
                     items = filtered_items;
-
-
                 } else {
                     // Return the full object
                     // so don't do anything
                 }
+
+
+                // WHERE Key/Val Filtering
+                JSONObject options = action.getJSONObject("options");
+                if (options.has("where")) {
+                    JSONObject where = options.getJSONObject("where");
+                    if (where.has("key") && where.has("val")) {
+                        JSONArray filtered_items = new JSONArray();
+                        String filter_key = where.getString("key");
+                        String filter_val = where.getString("val");
+                        // 1. Go through each item
+                        for (int index=0; index<items.length(); index++) {
+                            JSONObject item = items.getJSONObject(index);
+                            if (item.has("components")) {
+                                JSONArray components = item.getJSONArray("components");
+                                for (int component_index=0; component_index<components.length(); component_index++) {
+                                    JSONObject component = components.getJSONObject(component_index);
+                                    String actual_key = component.getString("key");
+                                    String actual_val = component.getString("val");
+                                    if (actual_key.equalsIgnoreCase(filter_key) && actual_val.equalsIgnoreCase(filter_val)) {
+                                        // We have a winner!
+                                        filtered_items.put(item);
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        // 2. See if any of its components match they key/val pair
+                        items = filtered_items;
+                    }
+                }
+
+                // SELECT key filtering
+                if (options.has("select") && options.getJSONObject("select").has("components")) {
+                    JSONArray select_query = options.getJSONObject("select").getJSONArray("components");
+                    JSONArray select_items = new JSONArray();
+                    for (int index=0; index<items.length(); index++) {
+                        JSONObject item = items.getJSONObject(index);
+                        if (item.has("components")) {
+                            JSONObject select_item = new JSONObject();
+                            JSONArray components = item.getJSONArray("components");
+                            JSONArray select_components = new JSONArray();
+                            for (int component_index=0; component_index<components.length(); component_index++) {
+                                // For each component, must run through query filter to find the match
+                                JSONObject component = components.getJSONObject(component_index);
+                                String actual_key = component.getString("key");
+                                String actual_val = component.getString("val");
+                                for (int select_query_index=0; select_query_index<select_query.length(); select_query_index++) {
+                                    // Go through each query object and see if the current component matches any of the query key/val pair.
+                                    // It's an AND operation => Must match key AND val simultaneously
+                                    JSONObject query_object = select_query.getJSONObject(select_query_index);
+                                    String query_key = query_object.getString("key");
+                                    String query_val = query_object.getString("val");
+                                    if (actual_key.equalsIgnoreCase(query_key) && actual_val.equalsIgnoreCase(query_val)) {
+                                        // It's a match!
+                                        // Add the component to selected components array and break;
+                                       select_components.put(component);
+                                       break;
+                                    }
+                                }
+                            }
+                            select_item.put("components", select_components);
+                            select_items.put(select_item);
+                        }
+                    }
+                    items = select_items;
+                }
+
+
             }
 
             JSONObject res = new JSONObject();

From 1cd5bb781f43a8bac4dceb5d8446f2a555dcf1ec Mon Sep 17 00:00:00 2001
From: gliechtenstein <ethan.gliechtenstein@gmail.com>
Date: Tue, 5 Dec 2017 02:49:12 -0800
Subject: [PATCH 09/10] updated API

---
 .../seed/Service/key/JasonKeyService.java     | 524 +++++++++++++-----
 1 file changed, 387 insertions(+), 137 deletions(-)

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
index 12400b2e..8f64372b 100644
--- a/app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java
+++ b/app/src/main/java/com/jasonette/seed/Service/key/JasonKeyService.java
@@ -131,6 +131,173 @@ public JSONObject _parse(final JSONObject action, Context context) {
         }
         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 {
@@ -140,7 +307,21 @@ private void _fetch(JSONObject action, JSONObject event, JSONObject parsed, Cont
 
                 deserialized := {
                     "items": [{
-                        ...
+                        "type": {
+                            "value": "BTC",
+                            "read": "public"
+                        },
+                        "name": {
+                            "value": "Bitcoin",
+                            "read": "public"
+                        },
+                        "publickey": {
+                            "value": "0xm4ng83ng8wengn3kngdn3ngknal32ng".
+                            "read": "public"
+                        },
+                        "privatekey": {
+                            "value": "0xngn4bgbebgbgbejbgjbjbjbebsdjbdskb328fg3bgjewh2112hfdhg"
+                        }
                     }, {
                         ...
                     }, {
@@ -158,99 +339,21 @@ private void _fetch(JSONObject action, JSONObject event, JSONObject parsed, Cont
                 items = deserialized.getJSONArray("items");
                 if (isRemote) {
                     // Need to filter only the public attributes
-                    JSONArray filtered_items = new JSONArray();
-                    for (int i = 0; i < items.length(); i++) {
-                        JSONObject item = items.getJSONObject(i);
-                        JSONArray components = item.getJSONArray("components");
-                        JSONArray filtered_components = new JSONArray();
-                        for (int j = 0; j < components.length(); j++) {
-                            JSONObject component = components.getJSONObject(j);
-                            if (component.has("read") && component.getString("read").equalsIgnoreCase("public")) {
-                                // "read": "public" component
-                                // Add to filtered_components
-                                filtered_components.put(component);
-                            }
-                        }
-
-                        JSONObject filtered_item = new JSONObject();
-                        filtered_item.put("components", filtered_components);
-
-                        filtered_items.put(filtered_item);
-                    }
-                    items = filtered_items;
+                    items = _filter_public(items);
                 } else {
                     // Return the full object
                     // so don't do anything
                 }
 
-
-                // WHERE Key/Val Filtering
-                JSONObject options = action.getJSONObject("options");
-                if (options.has("where")) {
-                    JSONObject where = options.getJSONObject("where");
-                    if (where.has("key") && where.has("val")) {
-                        JSONArray filtered_items = new JSONArray();
-                        String filter_key = where.getString("key");
-                        String filter_val = where.getString("val");
-                        // 1. Go through each item
-                        for (int index=0; index<items.length(); index++) {
-                            JSONObject item = items.getJSONObject(index);
-                            if (item.has("components")) {
-                                JSONArray components = item.getJSONArray("components");
-                                for (int component_index=0; component_index<components.length(); component_index++) {
-                                    JSONObject component = components.getJSONObject(component_index);
-                                    String actual_key = component.getString("key");
-                                    String actual_val = component.getString("val");
-                                    if (actual_key.equalsIgnoreCase(filter_key) && actual_val.equalsIgnoreCase(filter_val)) {
-                                        // We have a winner!
-                                        filtered_items.put(item);
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-                        // 2. See if any of its components match they key/val pair
-                        items = filtered_items;
-                    }
-                }
-
-                // SELECT key filtering
-                if (options.has("select") && options.getJSONObject("select").has("components")) {
-                    JSONArray select_query = options.getJSONObject("select").getJSONArray("components");
-                    JSONArray select_items = new JSONArray();
-                    for (int index=0; index<items.length(); index++) {
-                        JSONObject item = items.getJSONObject(index);
-                        if (item.has("components")) {
-                            JSONObject select_item = new JSONObject();
-                            JSONArray components = item.getJSONArray("components");
-                            JSONArray select_components = new JSONArray();
-                            for (int component_index=0; component_index<components.length(); component_index++) {
-                                // For each component, must run through query filter to find the match
-                                JSONObject component = components.getJSONObject(component_index);
-                                String actual_key = component.getString("key");
-                                String actual_val = component.getString("val");
-                                for (int select_query_index=0; select_query_index<select_query.length(); select_query_index++) {
-                                    // Go through each query object and see if the current component matches any of the query key/val pair.
-                                    // It's an AND operation => Must match key AND val simultaneously
-                                    JSONObject query_object = select_query.getJSONObject(select_query_index);
-                                    String query_key = query_object.getString("key");
-                                    String query_val = query_object.getString("val");
-                                    if (actual_key.equalsIgnoreCase(query_key) && actual_val.equalsIgnoreCase(query_val)) {
-                                        // It's a match!
-                                        // Add the component to selected components array and break;
-                                       select_components.put(component);
-                                       break;
-                                    }
-                                }
-                            }
-                            select_item.put("components", select_components);
-                            select_items.put(select_item);
-                        }
+                // 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);
                     }
-                    items = select_items;
                 }
 
-
             }
 
             JSONObject res = new JSONObject();
@@ -283,6 +386,20 @@ private void _fetch(JSONObject action, JSONObject event, JSONObject parsed, Cont
          }
      }
 
+     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);
@@ -310,24 +427,51 @@ public void request(final JSONObject action, final JSONObject data, final JSONOb
     }
 
     /*******************
+
+     1. Appending to end
+
      {
          "type": "$key.add",
          "options": {
-             "components": [{
-                 "key": "type",
-                 "val": "ETH"
-             }, {
-                 "key": "publickey",
-                 "val": "0xjdnfenfkdewfhk384b4"
-             }, {
-                 "key": "name",
-                 "val": "Ethereum"
-             }, {
-                 "key": "privatekey",
-                 "val": "0x8dbgjenb8fngjwev742gfh47gh8ds87fh3bv"
-             }]
+            "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);
@@ -342,13 +486,6 @@ public void add(final JSONObject action, final JSONObject data, final JSONObject
                 return;
             }
 
-            if (!action.getJSONObject("options").has("components")) {
-                JSONObject error = new JSONObject();
-                error.put("message", "A key item must have at least one component");
-                JasonHelper.next("error", action, error, event, context);
-                return;
-            }
-
             if (isRemote) {
                 // remote.
                 // cannot add from remote
@@ -365,7 +502,33 @@ public void add(final JSONObject action, final JSONObject data, final JSONObject
 
                     // Add options object to the "items" array
                     JSONObject options = action.getJSONObject("options");
-                    items.put(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);
 
@@ -384,6 +547,64 @@ public void add(final JSONObject action, final JSONObject data, final JSONObject
     }
 
 
+    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
@@ -490,19 +711,23 @@ public void remove(final JSONObject action, final JSONObject data, final JSONObj
 
     /*********************************
 
-     {
-         "type": "$key.update",
-         "options": {
-             "index": "{{$jason.index}}",
-             "components": [{
-                 "key": "name",
-                 "val": "{{$jason.new_value}}"
-             }]
-         },
-         "success": {
-             "type": "$render"
-         }
-     }
+        {
+            "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) {
@@ -524,29 +749,54 @@ public void update(final JSONObject action, final JSONObject data, final JSONObj
                         int index = action.getJSONObject("options").getInt("index");
                         JSONArray new_items = new JSONArray();
                         if (items.length() > index) {
-                            if (action.getJSONObject("options").has("components")) {
-                                JSONArray components_to_update = action.getJSONObject("options").getJSONArray("components");
-
-                                JSONObject old_item = items.getJSONObject(index);
-                                JSONArray old_components = old_item.getJSONArray("components");
-
-                                for(int i=0; i<components_to_update.length(); i++) {
-                                    JSONObject component_to_update = components_to_update.getJSONObject(i);
-                                    for(int j=0; j<old_components.length(); j++) {
-                                        JSONObject old_component = old_components.getJSONObject(j);
-                                        if (old_component.getString("key").equalsIgnoreCase(component_to_update.getString("key"))) {
-                                            // Match found!
-                                            // 1. Update the temp component's val
-                                            old_component.put("val", component_to_update.get("val"));
-                                            old_components.put(j, old_component);
-                                            break;
+
+                            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");

From 64b1e0ff06fce0c9bf6fc8a44470d1310b0fc60f Mon Sep 17 00:00:00 2001
From: gliechtenstein <ethan.gliechtenstein@gmail.com>
Date: Tue, 5 Dec 2017 12:08:29 -0800
Subject: [PATCH 10/10] use the parsed action instead of performing duplicate
 parse later

---
 .../com/jasonette/seed/Service/agent/JasonAgentService.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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;