diff --git a/README.md b/README.md
index 29ba34c..c94bc1f 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,8 @@
 [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fmailchain%2Fmailchain-web.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fmailchain%2Fmailchain-web?ref=badge_shield)
 [![Build Status](https://travis-ci.com/mailchain/mailchain-web.svg?branch=master)](https://travis-ci.com/mailchain/mailchain-web)
 [![Coverage Status](https://coveralls.io/repos/github/mailchain/mailchain-web/badge.svg?branch=master)](https://coveralls.io/github/mailchain/mailchain-web?branch=master)
+ [![Join the chat at https://gitter.im/Mailchain/mailchain-web](https://badges.gitter.im/Mailchain/mailchain.svg)](https://gitter.im/Mailchain/mailchain-web?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
 
 <!-- @import "[TOC]" {cmd="toc" depthFrom=1 depthTo=6 orderedList=false} -->
 
diff --git a/src/app/inbox/inbox-messages/inbox-messages.component.ts b/src/app/inbox/inbox-messages/inbox-messages.component.ts
index 3871cde..93f2734 100644
--- a/src/app/inbox/inbox-messages/inbox-messages.component.ts
+++ b/src/app/inbox/inbox-messages/inbox-messages.component.ts
@@ -158,7 +158,7 @@ export class InboxMessagesComponent implements OnInit, OnChanges {
    * Get the inbox messages, filtered by 'currently selected account' > 'searchtext'.
    * Dedupe message array - workaround for dupe messages @TODO: waiting on dupe bugfix in mailchain
    */
-  getCurrentAccountInboxMessages(){
+  getCurrentAccountInboxMessages(){    
     var inboxMessagesFilteredByAddress = this.addressPipe.transform(
       this.inboxMessages,
       this.currentAccount
diff --git a/src/app/inbox/inbox.component.html b/src/app/inbox/inbox.component.html
index 21e399d..231827b 100644
--- a/src/app/inbox/inbox.component.html
+++ b/src/app/inbox/inbox.component.html
@@ -37,18 +37,18 @@ <h1 class="page-title">Mailchain</h1>
       <ul class="list-group list-group-flush">
         <li *ngFor="let address of fromAddressesKeys"
           [class]="addressIsActive(address) ? 'list-group-item account-item active' : 'list-group-item account-item'"
-          [id]="address+'-folder-inbox'">
+        >
           <div class="row">
             <div class="col-2 p-0 my-auto">
-              <a class="nav-link" (click)="changeAccount(address); changeActiveItem(address+'-folder-inbox');">
+              <a class="nav-link" (click)="changeAccount(address)">
                 <img class="rounded-circle addressFolderIcon" src="{{accountIdenticons[address]}}" alt="">
               </a>
             </div>
             <div class="col-9 p-0 my-auto">
-              <a class="nav-link" (click)="changeAccount(address); changeActiveItem(address+'-folder-inbox');">{{address}}</a>
+              <a class="nav-link" (click)="changeAccount(address)">{{address}}</a>
             </div>
             <div class="col-1 p-0 my-auto">
-              <a class="nav-link" (click)="changeAccount(address); changeActiveItem(address+'-folder-inbox');">
+              <a class="nav-link" (click)="changeAccount(address)">
                 <span *ngIf="messagesLoaded"
                   [class]="fromAddresses[address]['messageCount']['inbox'] > 0 ? 'badge badge-pill badge-secondary float-right' : 'badge badge-pill badge-light float-right text-muted'">
                   {{fromAddresses[address]['messageCount']['inbox']}}
@@ -143,7 +143,7 @@ <h5>Current Port: <span>{{currentPort}}</span></h5>
           <h5></h5>
         </div>
       </div>
-      <form #serverSettingsForm="ngForm" id="serverSettingsForm" (ngSubmit)="serverSettingsFormSubmit(serverSettingsForm);modalWindowSettings.hide()" autocomplete="off">
+      <form #serverSettingsForm="ngForm" id="serverSettingsForm" (ngSubmit)="serverSettingsFormSubmit();modalWindowSettings.hide()" autocomplete="off">
         
         <div class="modal-body">
           <div class="form-group">
diff --git a/src/app/inbox/inbox.component.spec.ts b/src/app/inbox/inbox.component.spec.ts
index cb3a4ac..313606b 100644
--- a/src/app/inbox/inbox.component.spec.ts
+++ b/src/app/inbox/inbox.component.spec.ts
@@ -1,11 +1,13 @@
 import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import {BehaviorSubject} from 'rxjs';
+import {convertToParamMap, ParamMap} from '@angular/router';
 
 import { InboxComponent } from './inbox.component';
 import { InboxMessagesComponent } from './inbox-messages/inbox-messages.component';
 import { InboxMessageComponent } from './inbox-message/inbox-message.component';
 import { InboxComposeComponent } from './inbox-compose/inbox-compose.component';
 import { ModalModule } from 'ngx-bootstrap/modal';
-import { FormsModule } from '@angular/forms';
+import { FormsModule, NgForm } from '@angular/forms';
 import { HttpClientModule } from '@angular/common/http';
 import { HttpHelpersService } from '../services/helpers/http-helpers/http-helpers.service';
 import { RouterTestingModule } from '@angular/router/testing';
@@ -16,16 +18,24 @@ import { of } from 'rxjs';
 import { MailchainTestService } from '../test/test-helpers/mailchain-test.service';
 import { AddressesService } from '../services/mailchain/addresses/addresses.service';
 import { ProtocolsService } from '../services/mailchain/protocols/protocols.service';
-
+import { MailchainService } from '../services/mailchain/mailchain.service';
+import { ActivatedRoute } from '@angular/router';
+import { container } from '@angular/core/src/render3';
+import { InboundMail } from '../models/inbound-mail';
 
 describe('InboxComponent', () => {
   let component: InboxComponent;
   let fixture: ComponentFixture<InboxComponent>;
   let mailchainTestService: MailchainTestService
   let protocolsService: ProtocolsService
+  let localStorageAccountService: LocalStorageAccountService
+  let localStorageServerService: LocalStorageServerService
+  let mailchainService: MailchainService
+  let activatedRoute: any
   let networkList: any
   let currentWebProtocolsList: any
-
+  let inboundMessage: any
+  
   const currentAccount = '0x0123456789012345678901234567890123456789';
   const currentAccount2 = '0x0123456789abcdef0123456789abcdef01234567';
   const currentNetwork = 'testnet';
@@ -34,27 +44,54 @@ describe('InboxComponent', () => {
   const currentPort = '8080';
   const addresses = [currentAccount, currentAccount2];
   
+  let localStorageCurrentWebProtocol: string
+  let localStorageCurrentPort: string
+  let localStorageCurrentHost: string
+  let localStorageCurrentAccount: string
+  let localStorageCurrentNetwork: string
+
   class LocalStorageAccountServiceStub {
     getCurrentAccount(){
-      return currentAccount
+      return localStorageCurrentAccount
+    }
+    setCurrentAccount(address){
+      localStorageCurrentAccount = address
+    }
+    removeCurrentAccount(){
+      localStorageCurrentAccount = undefined
     }
   }
+
   class LocalStorageServerServiceStub {
     getCurrentWebProtocol(){
-      return currentWebProtocol
+      return localStorageCurrentWebProtocol
+    }
+    setCurrentWebProtocol(protocol){
+      localStorageCurrentWebProtocol = protocol
     }
     getCurrentHost(){
-      return currentHost
+      return localStorageCurrentHost
+    }
+    setCurrentHost(host){
+      localStorageCurrentHost = host
     }
     getCurrentPort(){
-      return currentPort
+      return localStorageCurrentPort
+    }
+    setCurrentPort(port){
+      localStorageCurrentPort = port
     }
     getCurrentNetwork(){
-      return currentNetwork
+      return localStorageCurrentNetwork
+    }
+    setCurrentNetwork(network){
+      localStorageCurrentNetwork = network
     }
     getCurrentServerDetails(){
       return `${currentWebProtocol}://${currentHost}:${currentPort}`
-
+    }
+    removeCurrentNetwork(){
+      localStorageCurrentNetwork = undefined
     }
   }
   class AddressesServiceStub {
@@ -74,6 +111,43 @@ describe('InboxComponent', () => {
     }
   }
 
+  class ActivatedRouteStub {
+    //Observable that contains a map of the parameters
+    private subjectParamMap = new BehaviorSubject(convertToParamMap(this.testParamMap));
+    paramMap = this.subjectParamMap.asObservable();
+
+    private _testParamMap: ParamMap;
+    get testParamMap() {
+        return this._testParamMap;
+    }
+    set testParamMap(params: {}) {
+        this._testParamMap = convertToParamMap(params);
+        this.subjectParamMap.next(this._testParamMap);
+    }
+
+    //Observable that contains a map of the query parameters
+    private subjectQueryParamMap = new BehaviorSubject(convertToParamMap(this.testParamMap));
+    queryParamMap = this.subjectQueryParamMap.asObservable();
+
+    private _testQueryParamMap: ParamMap;
+    get testQueryParamMap() {
+        return this._testQueryParamMap;
+    }
+    set testQueryParamMap(params: {}) {
+        this._testQueryParamMap = convertToParamMap(params);
+        this.subjectQueryParamMap.next(this._testQueryParamMap);
+    }
+
+    get snapshot() {
+        return {
+            paramMap: this.testParamMap,
+            queryParamMap: this.testQueryParamMap
+        }
+    }
+  }
+
+
+
 
   beforeEach(async(() => {
 
@@ -90,7 +164,8 @@ describe('InboxComponent', () => {
         { provide: LocalStorageServerService, useClass: LocalStorageServerServiceStub },
         { provide: AddressesService, useClass: AddressesServiceStub },
         { provide: ProtocolsService, useClass: ProtocolsServiceStub },
-        { provide: MessagesService, useClass: MessagesServiceStub }
+        { provide: MessagesService, useClass: MessagesServiceStub },
+        { provide: ActivatedRoute, useClass: ActivatedRouteStub }
 
       ],
       imports: [
@@ -104,35 +179,755 @@ describe('InboxComponent', () => {
     .compileComponents();
     mailchainTestService = TestBed.get(MailchainTestService);
     protocolsService = TestBed.get(ProtocolsService);
-    networkList = mailchainTestService.networkList();
-    currentWebProtocolsList = mailchainTestService.currentWebProtocolsList()
+    localStorageAccountService = TestBed.get(LocalStorageAccountService);
+    localStorageServerService = TestBed.get(LocalStorageServerService);
+    mailchainService = TestBed.get(MailchainService);
+    
   }));
   
   beforeEach(() => {
+    /* Set Values */
+    localStorageCurrentWebProtocol = currentWebProtocol
+    localStorageCurrentPort = currentPort
+    localStorageCurrentHost = currentHost
+    localStorageCurrentAccount = currentAccount
+    localStorageCurrentNetwork = currentNetwork
     
+    /* End Set Values */
+
+
     fixture = TestBed.createComponent(InboxComponent);
     component = fixture.componentInstance;
     fixture.detectChanges();
-
+  
   });
 
   afterEach(() => {
     fixture.destroy();
+
+    
   })
   
-  it('should create', () => {
+  it('should create the component', () => {
     expect(component).toBeTruthy();
   });
   
-  it('should setNetworkList', () => {
-    expect(fixture.componentInstance.networks).toEqual([]);
-    fixture.componentInstance.setNetworkList()
-    expect(fixture.componentInstance.networks).toEqual(networkList)
+
+  describe('composeMessage', () => {
+    
+    it('should change the view to "compose"', () => {
+      component.composeMessage()
+      expect(component.inboxPartial).toEqual('compose')
+    });
+    it('should handle being passed a message', () => {
+      let message = mailchainTestService.inboundMessage();
+
+      component.composeMessage(message)
+      expect(component.currentMessage).toEqual(message)
+    });
+    it('should handle NOT being passed a message', () => {
+      component.composeMessage()
+      expect(component.currentMessage).toEqual(undefined)
+    });
+  });
+
+  describe('changeView', () => {
+    it('should change the view when given a valid partial', () => {
+      let partials = [ "messages", "message", "compose"]
+      partials.forEach(partial => {
+        component.changeView(partial)
+        expect(component.inboxPartial).toEqual(partial)
+      })
+    });
+
+    it('should throw an error when passed an invalid patial', () => {
+      spyOn(console, 'error');
+      component.changeView("invalidPartial")
+      expect(console.error).toHaveBeenCalledWith('Error: Invalid partial');
+    });
+
+    it('should not change the partial when passed an invalid patial', () => {
+      let inboxPartial = component.inboxPartial
+      component.changeView("invalidPartial")
+      expect(component.inboxPartial).toEqual(inboxPartial)
+    });
   });
   
-  it('should setCurrentWebProtocolsList', () => {
-    expect(fixture.componentInstance.currentWebProtocols).toEqual([]);
-    fixture.componentInstance.setCurrentWebProtocolsList()
-    expect(fixture.componentInstance.currentWebProtocols).toEqual(currentWebProtocolsList)
+  describe('onInboxCounter', () => {
+    beforeEach(()=>{
+      component.fromAddresses = {
+        [currentAccount]: {
+          "messageCount": { "inbox": 5 }
+        },
+        [currentAccount2]: {
+          "messageCount": { "inbox": 2 }
+        }
+      }
+    });
+
+    it('should change the message count for an address', () => {
+      component.onInboxCounter([currentAccount2, 6])
+      expect(component.fromAddresses[currentAccount2]["messageCount"]["inbox"]).toEqual(6)
+    });
+
+    it('should NOT change another message count for an address', () => {
+      component.onInboxCounter([currentAccount2, 6])
+      expect(component.fromAddresses[currentAccount]["messageCount"]["inbox"]).toEqual(5)
+    });
+  });
+
+  describe('onOpenMessage', () => {
+    beforeEach(() => {
+      inboundMessage = mailchainTestService.inboundMessage
+    });
+
+    it('should change the view to "message"', () => {
+      component.onOpenMessage(inboundMessage)
+      expect(component.inboxPartial).toEqual("message")
+    });
+    it('should set the currentMessage to the passed in mail value', () => {
+      expect(component.currentMessage).not.toEqual(inboundMessage)
+
+      component.onOpenMessage(inboundMessage)
+      
+      expect(component.currentMessage).toEqual(inboundMessage)
+    });
+  });
+
+  describe('changeAccount', () => {
+    it('should change inboxPartial to "messages" if not already "messages"', () => {
+      component.inboxPartial = "compose"
+      component.changeAccount(currentAccount2)
+      expect(component.inboxPartial).toEqual("messages")
+    });
+
+    it('should set currentAccount to address value', () => {
+      expect(component.currentAccount).not.toEqual(currentAccount2)
+
+      component.changeAccount(currentAccount2)
+      expect(component.currentAccount).toEqual(currentAccount2)
+    });
+
+    it('should set the localStorage value for currentAccount to address value', async() => {
+      expect(await localStorageAccountService.getCurrentAccount()).not.toEqual(currentAccount2)
+
+      component.changeAccount(currentAccount2)
+      expect(await localStorageAccountService.getCurrentAccount()).toEqual(currentAccount2)
+      
+    });
+  });
+
+  describe('changeNetwork', () => {
+    it('should change inboxPartial to "messages" if not already "messages"', () => {
+      component.inboxPartial = "compose"
+      component.changeNetwork()
+      expect(component.inboxPartial).toEqual("messages")
+    });
+
+    it('should trigger the "getMails" function', async() => {
+      spyOn(component, 'getMails');
+      
+      component.changeNetwork();
+      expect(component.getMails).toHaveBeenCalled();
+    });
+
+    it('should set the localStorage value for currentNetwork to network value', async() => {
+      expect(await localStorageServerService.getCurrentNetwork()).not.toEqual('myTestNet')
+
+      component.currentNetwork = 'myTestNet';
+      component.changeNetwork();
+
+      expect(await localStorageServerService.getCurrentNetwork()).toEqual('myTestNet')
+    });
+  });
+  
+  describe('removeCurrentAccount', () => {
+    it('should call the localStorageAccountService.removeCurrentAccount function', () => {
+      spyOn(localStorageAccountService, 'removeCurrentAccount');
+      
+      component.removeCurrentAccount();
+      expect(localStorageAccountService.removeCurrentAccount).toHaveBeenCalled();
+    });
+  });
+  
+  describe('removeCurrentNetwork', () => {
+    it('should call the localStorageServerService.removeCurrentNetwork function', () => {
+      spyOn(localStorageServerService, 'removeCurrentNetwork');
+      
+      component.removeCurrentNetwork();
+      expect(localStorageServerService.removeCurrentNetwork).toHaveBeenCalled();
+    });
+  });
+
+  describe('serverSettingsFormSubmit', () => {
+    xit('should set the webProtocol value from the form', () => {
+    });
+    xit('should set the host value from the form', () => {
+    });
+    xit('should set the port value from the form', () => {
+    });
+    xit('should NOT set the values that are not defined in the form', () => {
+    });
+    xit('should call updateServerSettings with the settingsHash', () => {
+    });
+
+  });
+  describe('updateServerSettings', () => {
+    beforeEach(() => {
+      spyOn(component, 'windowReload').and.callFake(function(){});
+    });
+    
+    it('should set the webProtocol value from the settingsHash',  async() => {
+      let settingsHash = {
+        "web-protocol": "customproto"
+      }
+      component.updateServerSettings(settingsHash)
+      
+      expect(await localStorageServerService.getCurrentWebProtocol()).toEqual('customproto')
+
+      expect(component.windowReload).toHaveBeenCalled();
+    });
+    it('should set the host value from the settingsHash', async() => {
+      let settingsHash = {
+        "host": "example.com"
+      }
+      component.updateServerSettings(settingsHash)
+      fixture.detectChanges();
+      
+      expect(await localStorageServerService.getCurrentHost()).toEqual('example.com')
+
+      expect(component.windowReload).toHaveBeenCalled();
+    });
+    it('should set the port value from the settingsHash', async() => {
+      let settingsHash = {
+        "port": "8888"
+      }
+      component.updateServerSettings(settingsHash)
+      fixture.detectChanges();
+
+      expect(await localStorageServerService.getCurrentPort()).toEqual('8888')
+
+      expect(component.windowReload).toHaveBeenCalled();
+    });
+    
+    it('should reload the current path if serverSettings are changed"', () => {
+      let settingsHash = {
+        "web-protocol": "customproto"
+      }
+      component.updateServerSettings(settingsHash)
+      fixture.detectChanges();
+
+      expect(component.windowReload).toHaveBeenCalled();
+    });
+    it('should NOT reload the current path if serverSettings are NOT changed"', () => {
+      let settingsHash = {}
+      component.updateServerSettings(settingsHash)
+      fixture.detectChanges();
+
+      expect(component.windowReload).not.toHaveBeenCalled();
+    });
+    it('should remove the currentAccount if serverSettings are changed"', async() => {
+      let settingsHash = {
+        "web-protocol": "customproto"
+      }
+      localStorageAccountService.setCurrentAccount("accountVal")
+      expect(await localStorageAccountService.getCurrentAccount()).toEqual("accountVal")
+
+      component.updateServerSettings(settingsHash)
+      fixture.detectChanges();
+      
+      expect(await localStorageAccountService.getCurrentAccount()).toBeUndefined()
+    });
+    it('should NOT remove the currentAccount if serverSettings are NOT NOT changed"', async() => {
+      let settingsHash = {}
+      localStorageAccountService.setCurrentAccount("accountVal")
+      expect(await localStorageAccountService.getCurrentAccount()).toEqual("accountVal")
+
+      component.updateServerSettings(settingsHash)
+      fixture.detectChanges();
+      
+      expect(await localStorageAccountService.getCurrentAccount()).toEqual("accountVal");
+    });
+    
+    it('should remove the currentNetwork if serverSettings are changed"', async() => {
+      let settingsHash = {
+        "web-protocol": "customproto"
+      }
+      localStorageServerService.setCurrentNetwork("networkVal")
+      expect(await localStorageServerService.getCurrentNetwork()).toEqual("networkVal")
+
+      component.updateServerSettings(settingsHash)
+      fixture.detectChanges();
+      
+      expect(await localStorageServerService.getCurrentNetwork()).toBeUndefined()
+    });
+    it('should NOT remove the currentNetwork if serverSettings are NOT changed"', async() => {
+      let settingsHash = {}
+      localStorageServerService.setCurrentNetwork("networkVal")
+      expect(await localStorageServerService.getCurrentNetwork()).toEqual("networkVal")
+
+      component.updateServerSettings(settingsHash)
+      fixture.detectChanges();
+      
+      expect(await localStorageServerService.getCurrentNetwork()).toEqual("networkVal");
+    });
+
   });
+
+
+  describe('windowReload', () => {
+    xit('should reload the component with the same path', () => {
+      // TODO
+    });
+    
+    xit('should remove any params in the url', () => {
+      // TODO
+    });
+  });
+
+  describe('getServerSettings', () => {
+    it('should set the currentWebProtocol to the value foundin localStorage"', () => {
+      let val = 'webProtocolVal'
+      
+      localStorageServerService.setCurrentWebProtocol(val)
+      expect(component.currentWebProtocol).not.toEqual(val)
+
+      component.getServerSettings()
+      expect(component.currentWebProtocol).toEqual(val)
+      
+    });
+    it('should set the currentHost to the value foundin localStorage"', () => {
+      let val = 'hostVal'
+      
+      localStorageServerService.setCurrentWebProtocol(val)
+      expect(component.currentWebProtocol).not.toEqual(val)
+
+      component.getServerSettings()
+      expect(component.currentWebProtocol).toEqual(val)
+    });
+    it('should set the currentPort to the value foundin localStorage"', () => {
+      let val = 'portVal'
+      
+      localStorageServerService.setCurrentWebProtocol(val)
+      expect(component.currentWebProtocol).not.toEqual(val)
+
+      component.getServerSettings()
+      expect(component.currentWebProtocol).toEqual(val)
+    });
+  });
+
+  describe('addressIsActive', () => {
+    it('should return true if the address is equal to the currentAccount', () => {
+      component.currentAccount = currentAccount
+      expect(component.addressIsActive(currentAccount)).toEqual(true)
+    });
+    it('should return false if the address is NOT equal to the currentAccount', () => {
+      component.currentAccount = currentAccount2
+      expect(component.addressIsActive(currentAccount)).not.toEqual(true)
+    });
+  });
+
+  describe('setFromAddressList', () => {
+    beforeEach(() => {
+      component.fromAddresses = {}
+    });
+    it('should populate the fromAddresses', async() => {
+      await component.setFromAddressList()
+      
+      expect(Object.keys(component.fromAddresses)).toEqual(addresses)
+    });
+    it('should add a new address then this has been added ', async() => {
+      addresses.push("0x0000000000abcdef0123456789abcdef00000000")
+      await component.setFromAddressList()
+      
+      expect(Object.keys(component.fromAddresses)).toEqual(addresses)
+      addresses.pop()
+
+    });
+    it('should set the label to the address value', async() => {
+      await component.setFromAddressList()      
+      let keys = Object.keys(component.fromAddresses)
+      
+      keys.forEach(key => {
+        expect(component.fromAddresses[key]["label"]).toEqual(key)
+      })
+    });
+    it('should set the value to the address value', async() => {
+      await component.setFromAddressList()      
+      let keys = Object.keys(component.fromAddresses)
+  
+      keys.forEach(key => {
+        expect(component.fromAddresses[key]["value"]).toEqual(key)
+      })
+    });
+    it('should initialize the messageCount to 0 for inbox', async() => {
+      await component.setFromAddressList()      
+      let keys = Object.keys(component.fromAddresses)
+  
+      keys.forEach(key => {
+        expect(component.fromAddresses[key]["messageCount"]["inbox"]).toEqual(0)
+      })
+    });
+  });
+
+  describe('setNetworkList', () => {
+    beforeEach(() => {
+      networkList = mailchainTestService.networkList();
+    });
+
+    it('should populate the network list', () => {
+      expect(component.networks).toEqual([]);
+      component.setNetworkList()
+      expect(component.networks).toEqual(networkList)
+    });
+  });
+  
+  describe('setCurrentWebProtocolsList', () => {
+    beforeEach(() => {
+      currentWebProtocolsList = mailchainTestService.currentWebProtocolsList()
+    });
+
+    it('should populate the web protocols', () => {
+      expect(component.currentWebProtocols).toEqual([]);
+      component.setCurrentWebProtocolsList()
+      expect(component.currentWebProtocols).toEqual(currentWebProtocolsList)
+    });
+
+  });
+
+  describe('setAccountIdenticons', () => {
+    it('should generate identicons for each fromAddress', () => {
+      component.fromAddressesKeys = [currentAccount,currentAccount2]
+      component.setAccountIdenticons()
+      
+      expect(component.accountIdenticons[currentAccount]).toEqual(mailchainService.generateIdenticon(currentAccount))
+
+      expect(component.accountIdenticons[currentAccount2]).toEqual(mailchainService.generateIdenticon(currentAccount2))
+      component.fromAddresses
+    });
+  });
+  
+  describe('setupServerSettingsForm', () => {
+    it('should initialize values for the form', () => {
+      let obj = {
+        webProtocol: currentWebProtocol,
+        host: currentHost,
+        port: currentPort
+      }
+      
+      expect(component.serverSettings).toEqual({})
+      
+      component.currentWebProtocol = currentWebProtocol
+      component.currentHost = currentHost
+      component.currentPort = currentPort
+      component.setupServerSettingsForm()
+      
+      expect(component.serverSettings).toEqual(obj)
+    });
+  });
+  describe('checkServerSettingsInQueryParams', () => {
+    let wpVal = 'zttps'
+    let hostVal = 'someexample.com'
+    let portVal = '2019'
+
+    beforeEach(()=>{
+      activatedRoute = fixture.debugElement.injector.get(ActivatedRoute) as any;
+      
+      
+      spyOn(component, 'windowReload').and.callFake(function(){});
+      // activatedRoute.testParamMap = {category: 'api-02'};
+      // activatedRoute.testQueryParamMap = {period:'2018',size:'14'};
+    })
+
+    it('should update serverSettings if params are present', () => { 
+      activatedRoute.testQueryParamMap = {
+        "web-protocol":wpVal,
+        "host":hostVal,
+        "port":portVal
+      };
+      
+      component.checkServerSettingsInQueryParams()
+      expect(localStorageServerService.getCurrentWebProtocol()).toEqual(wpVal)
+      expect(localStorageServerService.getCurrentHost()).toEqual(hostVal)
+      expect(localStorageServerService.getCurrentPort()).toEqual(portVal)
+    });
+
+    it('should NOT update webProtocol serverSettings if webProtocol param is NOT present', () => {
+      let originalVal = localStorageServerService.getCurrentWebProtocol()
+      
+      activatedRoute.testQueryParamMap = {
+        // "web-protocol":wpVal,
+        "host":hostVal,
+        "port":portVal
+      };
+
+      component.checkServerSettingsInQueryParams()
+      expect(localStorageServerService.getCurrentWebProtocol()).not.toEqual(wpVal)
+      expect(localStorageServerService.getCurrentWebProtocol()).toEqual(originalVal)
+    });
+    it('should NOT update host serverSettings if host param is NOT present', () => {
+      let originalVal = localStorageServerService.getCurrentHost()
+
+      activatedRoute.testQueryParamMap = {
+        "web-protocol":wpVal,
+        // "host":hostVal,
+        "port":portVal
+      };
+
+      component.checkServerSettingsInQueryParams()
+      expect(localStorageServerService.getCurrentHost()).not.toEqual(hostVal)
+      expect(localStorageServerService.getCurrentHost()).toEqual(originalVal)
+    });
+    it('should NOT update port serverSettings if port param is NOT present', () => {
+      let originalVal = localStorageServerService.getCurrentPort()
+
+      activatedRoute.testQueryParamMap = {
+        "web-protocol":wpVal,
+        "host":hostVal,
+        // "port":portVal
+      };
+
+      component.checkServerSettingsInQueryParams()
+      expect(localStorageServerService.getCurrentPort()).not.toEqual(portVal)
+      expect(localStorageServerService.getCurrentPort()).toEqual(originalVal)
+    });
+
+  });
+
+  describe('getMails', () => {
+    xit('should fetch mails from the server', () => {
+    });
+    xit('should fetch mails in the background by default (quietly)', () => {
+    });
+    xit('should refetch mails as a clean fetch (NOT quietly)', () => {
+    });
+    xit('should set the fetchCount', () => {
+    });
+
+
+    xit('should fetch mails for each fromAddress', () => {
+    });
+    xit('should handle unread mails', () => {
+    });
+    xit('should ignore messages with message status NOT "ok"', () => {
+    });
+    xit('should add messages with message status "ok" to inbox', () => {
+      component.getMails.prototype.fil
+    });
+    xit('should handle unread mails', () => {
+    });
+    xit('should increment inbox counters for addresses', () => {
+    });
+
+
+    xit('should set messagesLoaded to TRUE when all addresses have been retrieved', () => {
+    });
+    xit('should set fetchMessagesDisabled to FALSE when all addresses have been retrieved', () => {
+    });
+  });
+  
+  describe('processUnreadMessagesInboxCounter', () => {
+    it('should call onInboxCounter with the correct params', () => {
+      spyOn(component, 'onInboxCounter')
+      const messages = [
+        {
+          "headers": {
+            "message-id": "00"
+          },
+          "read": true,
+          "status": "ok",
+        },
+        {
+          "headers": {
+            "message-id": "01"
+          },
+          "read": true,
+          "status": "error",
+        },
+        {
+          "headers": {
+            "message-id": "02"
+          },
+          "read": false,
+          "status": "ok",
+        },
+        {
+          "headers": {
+            "message-id": "03"
+          },
+          "read": false,
+          "status": "error",
+        }
+      ]
+      component.processUnreadMessagesInboxCounter(currentAccount, messages)
+      expect(component.onInboxCounter).toHaveBeenCalledWith([currentAccount,1])
+    });
+  });
+  
+  describe('processInboxMessages', () => {
+    const messages = [
+      {
+        "headers": {
+          "message-id": "00",
+          "from": "<0x0000000000000000000000000000000000000000@ropsten.ethereum>",
+
+        },
+        "read": true,
+        "status": "ok",
+      },
+      {
+        "headers": {
+          "message-id": "01",
+          "from": "<0x0000000000000000000000000000000000000000@ropsten.ethereum>",
+
+        },
+        "read": true,
+        "status": "error",
+      },
+      {
+        "headers": {
+          "message-id": "02",
+          "from": "<0x0000000000000000000000000000000000000000@ropsten.ethereum>",
+
+        },
+        "read": false,
+        "status": "ok",
+      },
+      {
+        "headers": {
+          "message-id": "03",
+          "from": "<0x0000000000000000000000000000000000000000@ropsten.ethereum>",
+
+        },
+        "read": false,
+        "status": "error",
+      }
+    ]
+    
+    it('should add valid messages to inboxMessages', () => {
+      expect(component.inboxMessages).toEqual([])
+      component.processInboxMessages(messages)
+      expect(component.inboxMessages.map(msg => msg["headers"]["message-id"])).toEqual(["00","02"]);
+    });
+  });
+  
+  describe('setFetchingMessagesState', () => {
+    describe('fetchMessagesText', () => {
+      it('should set fetchMessagesText to "Check Messages" when state is false', () => {
+        component.setFetchingMessagesState(false)
+        expect(component.fetchMessagesText).toEqual("Check Messages")
+      });
+      it('should set fetchMessagesText to "Loading..." when state is true', () => {
+        component.setFetchingMessagesState(true)
+        expect(component.fetchMessagesText).toEqual("Loading...")
+      });
+    });
+    
+    describe('fetchMessagesDisabled', () => {
+      it('should set fetchMessagesDisabled to true when state is true', () => {
+        component.fetchMessagesDisabled = false
+        component.setFetchingMessagesState(true)
+        expect(component.fetchMessagesDisabled).toBe(true)
+      });
+      it('should set fetchMessagesDisabled to false when state is true', () => {
+        component.fetchMessagesDisabled = true
+        component.setFetchingMessagesState(false)
+        expect(component.fetchMessagesDisabled).toBe(false)
+      });
+    });
+    
+    describe('messagesLoaded', () => {
+      it('should set messagesLoaded to false when NOT in quietMode', () => {
+        component.setFetchingMessagesState(true, false)
+        expect(component.messagesLoaded).toBe(false)
+      });
+      it('should NOT set messagesLoaded to false when in quietMode', () => {
+        component.messagesLoaded = true
+        component.setFetchingMessagesState(true, true)
+        expect(component.messagesLoaded).toBe(true)
+
+        component.messagesLoaded = false
+        component.setFetchingMessagesState(true, true)
+        expect(component.messagesLoaded).toBe(false)
+      });
+      it('should set messagesLoaded to false when quietMode is NOT defined', () => {
+        component.messagesLoaded = true
+        component.setFetchingMessagesState(true)
+        expect(component.messagesLoaded).toBe(false)
+      });
+    });
+  });
+
+  describe('addMailToInboxMessages', () => {
+    const message = {
+      "headers": {
+        "date": "2019-06-07T14:53:36Z",
+        "from": "\u003c0x0123456789012345678901234567890123456789@testnet.ethereum\u003e",
+        "to": "\u003c0x0123456789abcdef0123456789abcdef01234567@testnet.ethereum\u003e",
+        "message-id": "0020c"
+      },
+      "body": "",
+      "subject": "Re: Mailchain Test!",
+      "status": "ok",
+      "status-code": "",
+      "read": true
+    }
+
+    it('should add a message to inboxMessages', () => {      
+      expect(component.inboxMessages).toEqual([])
+      
+      component.addMailToInboxMessages(message)
+      let obj = component.inboxMessages[0]
+
+      expect(component.inboxMessages.length).toEqual(1)
+
+    })
+    
+    it('should set the `headers` field', () => {
+      component.addMailToInboxMessages(message)
+      let obj = component.inboxMessages[0]
+
+      expect(obj["headers"]["message-id"]).toEqual(message["headers"]["message-id"])
+      expect(obj["headers"]).toEqual(message["headers"])
+    });
+
+    it('should set the `subject` field', () => {
+      component.addMailToInboxMessages(message)
+      let obj = component.inboxMessages[0]
+      
+      expect(obj["subject"]).toEqual(message["subject"])
+    });
+
+    it('should set the `body` field', () => {
+      component.addMailToInboxMessages(message)
+      let obj = component.inboxMessages[0]
+
+      expect(obj["body"]).toEqual(message["body"])
+    });
+
+    it('should set the `read` field', () => {
+      component.addMailToInboxMessages(message)
+      let obj = component.inboxMessages[0]
+
+      expect(obj["read"]).toEqual(message["read"])
+    });
+
+    it('should set the `selected` field', () => {
+      component.addMailToInboxMessages(message)
+      let obj = component.inboxMessages[0]
+
+      expect(obj["selected"]).toEqual(false)
+    });
+
+    it('should set the `senderIdenticon` field', () => {
+      component.addMailToInboxMessages(message)
+      let identicon = mailchainService.generateIdenticon(message.headers.from)
+      let obj = component.inboxMessages[0]
+
+      expect(obj["senderIdenticon"]).toEqual(identicon)
+    });
+
+  });
+
+
 });
diff --git a/src/app/inbox/inbox.component.ts b/src/app/inbox/inbox.component.ts
index 2cc8d6a..1105575 100644
--- a/src/app/inbox/inbox.component.ts
+++ b/src/app/inbox/inbox.component.ts
@@ -8,6 +8,7 @@ import { LocalStorageServerService } from '../services/helpers/local-storage-ser
 import { ActivatedRoute } from '@angular/router';
 import { AddressesService } from '../services/mailchain/addresses/addresses.service';
 import { ProtocolsService } from '../services/mailchain/protocols/protocols.service';
+import { throwError } from 'rxjs';
 
 @Component({
   selector: 'app-inbox',
@@ -22,7 +23,7 @@ export class InboxComponent implements OnInit {
   public inboxMessages: Array<any> = [];
   public messagesLoaded: boolean = false;
   public fetchMessagesDisabled: boolean = false;
-  public fetchMessagesText: String = "Check Messages";
+  public fetchMessagesText: String
   
   public inboxPartial: string = 'messages'
 
@@ -49,7 +50,10 @@ export class InboxComponent implements OnInit {
     private activatedRoute: ActivatedRoute,
   ) {}
 
-
+  /**
+   * Changes the view to 'compose' a message.
+   * @param message (optional) message to reply to (>> 'currentMessage')
+   */
   composeMessage(message?): void {
     this.currentMessage = void 0;
     if (message != undefined) {
@@ -59,7 +63,8 @@ export class InboxComponent implements OnInit {
   }
 
   /**
-   * [address: string,count: number]
+   * Changes the messageCount for each inbox
+   * @param array [address: string,count: number]
    */
   onInboxCounter(array) {
     var address: string = array[0] 
@@ -67,27 +72,30 @@ export class InboxComponent implements OnInit {
     this.fromAddresses[address.toLowerCase()]["messageCount"]["inbox"] = count
   }
 
+  /**
+   * Changes the view to message and shows the mail
+   * @param mail the message to show
+   */
   onOpenMessage(mail: any): void {
     this.currentMessage = mail;
     this.changeView('message');
   }
 
-  changeView(inboxPartial: string): void {
-    this.inboxPartial = inboxPartial
-  }
-
   /**
-   * Changes active folder in list
+   * Changes the inboxPartial component in view. If an invalid inboxPartial is passed, it will throw a warning on the console and not change the partial.
+   * @param inboxPartial String required: `messages` | `message` | `compose`
    */
-  changeActiveItem(elementId): void {
-    document.querySelectorAll('.nav-item').forEach(element => {
-      element.classList.remove("active")
-    })
-    document.getElementById(elementId).classList.add("active");
+  changeView(inboxPartial: string): void {
+    if ( [ "messages", "message", "compose"].includes(inboxPartial) ) {
+      this.inboxPartial = inboxPartial
+    } else {
+      console.error('Error: Invalid partial')
+    }
   }
 
   /**
-   * Changes the local current Account and fetches mails for that account.
+   * Changes the local currentAccount.
+   * @param address is the account/address to set 
    */
   changeAccount(address){    
     if (this.inboxPartial != 'messages') {
@@ -101,21 +109,22 @@ export class InboxComponent implements OnInit {
    * Changes the network and fetches mails for that network.
    */
   changeNetwork(){    
-    this.changeView('messages')
+    if (this.inboxPartial != 'messages') {
+      this.changeView('messages');
+    }
     this.localStorageServerService.setCurrentNetwork(this.currentNetwork)
     this.getMails()
   }
 
   /**
-   * Removes the session storage account setting
+   * Removes the session storage currentAccount setting
    */
   removeCurrentAccount(){
     this.localStorageAccountService.removeCurrentAccount()
-    
   }
 
   /**
-   * Removes the session storage network setting
+   * Removes the session storage currentNetwork setting
    */
   removeCurrentNetwork(){
     this.localStorageServerService.removeCurrentNetwork()
@@ -125,10 +134,11 @@ export class InboxComponent implements OnInit {
    * Changes the server settings in the client from form data.
    * @param form is the settings form submitted from the view
    */
-  serverSettingsFormSubmit(form: NgForm){    
-    var webProtocol = form["form"]["value"]["serverSettingsWebProtocol"]
-    var host = form["form"]["value"]["serverSettingsHost"]
-    var port = form["form"]["value"]["serverSettingsPort"]
+  serverSettingsFormSubmit(){ 
+       
+    var webProtocol = this.serverSettings["webProtocol"]
+    var host = this.serverSettings["host"]
+    var port = this.serverSettings["port"]
     var settingsHash = {}
     
     if ( webProtocol != undefined && webProtocol != this.currentWebProtocol ) {      
@@ -148,9 +158,7 @@ export class InboxComponent implements OnInit {
    * @param settingsHash the server settings hash
    * `{ "web-protocol": "http"|"https", "host": "127.0.0.1", "port": "8080" }`
    */
-  async updateServerSettings(
-    settingsHash: any
-  ){
+  async updateServerSettings(settingsHash: any){
     let serverSettingsChanged: boolean = false
     
     if (
@@ -179,12 +187,20 @@ export class InboxComponent implements OnInit {
       this.removeCurrentAccount();
       this.removeCurrentNetwork();
 
-      let path = window.location.pathname
-      window.location.replace(path)
+      this.windowReload()
     }
 
   }
 
+  /**
+   * Reload the window with the original path.
+   * Used to remove url params and reload a clean component
+   */
+  public windowReload() {
+    let path = window.location.pathname
+    window.location.replace(path)
+  }
+
   /**
    * Retrieve the current server settings for the inbox
    */
@@ -202,7 +218,13 @@ export class InboxComponent implements OnInit {
     return address == this.currentAccount
   }
 
-
+  /**
+   * Creates a list of 'from' addresses (i.e. sender addresses) formatted as a hash with the following fields:
+   * label: the address
+   * value: the address
+   * messageCount: a hash containing folder values of message count:
+   *   inbox: default 0
+   */
   async setFromAddressList(){
     this.fromAddressesKeys = await this.addressesService.getAddresses();
     
@@ -260,7 +282,7 @@ export class InboxComponent implements OnInit {
   }
   
   /**
-   * Initiates the server settings form with default values
+   * Initiates the server settings form with default values. Default values are retrieved from local storage
    */
   setupServerSettingsForm() {
     this.serverSettings = {
@@ -294,6 +316,8 @@ export class InboxComponent implements OnInit {
   }
 
   async ngOnInit(): Promise<void> {
+    this.setFetchingMessagesState(true)
+
     try {
       this.currentAccount = await this.localStorageAccountService.getCurrentAccount()
       this.currentNetwork = this.localStorageServerService.getCurrentNetwork()
@@ -319,37 +343,25 @@ export class InboxComponent implements OnInit {
 
   /**
    * Fetch mails from the server
+   * @param 
    */
-  public getMails(quiet?: boolean){
-    if (!quiet) {
-      this.inboxMessages = []
-      this.messagesLoaded = false;
-    }
-    this.fetchMessagesText = "Loading...";
-    this.fetchMessagesDisabled = true;
-    
+  public getMails(quietMode: boolean = false){
+
+    this.setFetchingMessagesState(true, quietMode)
+
     let fetchCount = this.fromAddressesKeys.length // we count this down for each req
-    
+
     this.fromAddressesKeys.forEach(address => {
       var self = this
       this.messagesService.getMessages(address, this.currentNetwork).subscribe(function(res){
+
+        self.processUnreadMessagesInboxCounter(address, res["messages"])
+        self.processInboxMessages(res["messages"])
         
-        let unreadMsgs = res["messages"].filter(msg => msg.status === "ok" && !msg.read);
-        let uniqUnreadMsgs = self.mailchainService.dedupeMessagesByIds(unreadMsgs)
-
-        self.onInboxCounter([address, uniqUnreadMsgs.length])
-        res["messages"].forEach(decryptedData => {
-          // only parse valid messages
-          if (decryptedData.status == "ok") {
-            self.addMailToInboxMessages(decryptedData);
-          }
-        });
-        --fetchCount
+        --fetchCount // decrement fetchCount
         
-        if (fetchCount == 0 ) { // all get reqs should be complete
-          self.messagesLoaded = true;
-          self.fetchMessagesText = "Check Messages";
-          self.fetchMessagesDisabled = false;  
+        if (fetchCount == 0 ) { // all get requests should be complete
+           self.setFetchingMessagesState(false)
         }
       })
       
@@ -357,8 +369,76 @@ export class InboxComponent implements OnInit {
     
   };
 
-    /**
-   * 
+  /**
+   * processUnreadMessagesInboxCounter: counts the number of unread messages for an address and sets the inbox counter.
+   * @param address: (string) the address of the messages
+   * @param messages: array of messages
+   */
+  public processUnreadMessagesInboxCounter(address, messages) {
+    let unreadMsgs = this.mailchainService.filterMessages(
+      messages,
+      {status: "ok", readState: false}
+    )
+    let uniqUnreadMsgs = this.mailchainService.dedupeMessagesByIds(unreadMsgs)
+
+    this.onInboxCounter([address, uniqUnreadMsgs.length])
+    
+  }
+  
+  /**
+   * processInboxMessages: adds messages with status: "ok" to the InboxMessages as an InboundMail object
+   * @param messages 
+   */
+  public processInboxMessages(messages: Array<any>) {
+    let validMessages = this.mailchainService.filterMessages(
+      messages,
+      {status: "ok"}
+    )
+    validMessages.forEach(msg => this.addMailToInboxMessages(msg));
+  }
+  
+
+  /**
+   * setFetchingMessagesState
+   * @param state: boolean;
+   *  true when fetching messages
+   *  false when NOT fetching message
+   * @param quietMode: (optional) when true, messages are quietly loaded
+   */
+  public setFetchingMessagesState(state: boolean, quietMode?: boolean) {
+    this.fetchMessagesDisabled = state;
+    if (state) {
+      this.setFetchMessagesText(1)
+      if (!quietMode) {
+        this.inboxMessages = []
+        this.messagesLoaded = false;
+      }
+    } else {
+      this.setFetchMessagesText(0)
+      this.messagesLoaded = true;
+    }
+  }
+
+  /**
+   * Set the fetchMessagesText variable
+   * @param statusCode:
+   *    0 = Default state ('Check Messages')
+   *    1 = Loading ('Loading...')
+   */
+  private setFetchMessagesText(statusCode: number){
+    switch (statusCode) {
+      case 0:
+        this.fetchMessagesText = "Check Messages"
+        break
+      case 1:
+        this.fetchMessagesText = "Loading..."
+        break
+    }
+    
+  }
+
+  /**
+   * Adds a message to inboxMessages as an InboundMessage object
    * @param decryptedMsg 
    */
   addMailToInboxMessages(decryptedMsg){  
diff --git a/src/app/pipes/address-pipe/address-pipe.pipe.spec.ts b/src/app/pipes/address-pipe/address-pipe.pipe.spec.ts
index 95d9ec1..2245b46 100644
--- a/src/app/pipes/address-pipe/address-pipe.pipe.spec.ts
+++ b/src/app/pipes/address-pipe/address-pipe.pipe.spec.ts
@@ -1,10 +1,80 @@
+import { TestBed } from '@angular/core/testing';
 import { AddressPipe } from './address-pipe.pipe';
 
+let pipe: AddressPipe
+
+const addr1 = '0x0000000000000000000000000000000000000000'
+const addr2 = '0x0123456789abcdef0123456789abcdef01234567'
+const addr3 = '0x1111111111111111111111111111111111111111'
+
+const messages = [
+  {
+    "headers": {
+      "from": "\u003c" + addr1 + '@testnet.ethereum\u003e',
+      "to": "\u003c" + addr2 + '@testnet.ethereum\u003e',
+      "message-id": "001"
+    },
+    "body": "",
+    "subject": "Msg 1: 1 sends to 2"
+  },
+  {
+    "headers": {
+      "from": "\u003c" + addr2 + '@testnet.ethereum\u003e',
+      "to": "\u003c" + addr1 + '@testnet.ethereum\u003e',
+      "message-id": "002"
+    },
+    "body": "",
+    "subject": "Msg 2: 2 sends to 1"
+  },
+  {
+    "headers": {
+      "from": "\u003c" + addr1 + '@testnet.ethereum\u003e',
+      "to": "\u003c" + addr2 + '@testnet.ethereum\u003e',
+      "message-id": "003"
+    },
+    "body": "",
+    "subject": "Msg 1: 1 sends to 2 again"
+  },
+]
+
 describe('AddressPipe', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        AddressPipe
+      ],
+      imports: []
+    });
+    
+    pipe = TestBed.get(AddressPipe);
+  });
+
+  it('should create an instance', () => {
+    expect(pipe).toBeTruthy();
+  });
+
+  it('should return filtered messages when 1 message has been sent to an address', () => {
+    let result = [
+      messages[1],
+    ]
 
-  it('create an instance', () => {
-    // todo
-    // const pipe = new AddressPipe();
-    // expect(pipe).toBeTruthy();
+    expect(pipe.transform(messages, addr1).length).toEqual(1);
+    expect(pipe.transform(messages, addr1)).toEqual(result);
+  });
+  
+  it('should return filtered messages when >1 message has been sent to an address', () => {
+    let result = [
+      messages[0],
+      messages[2],
+    ]
+    expect(pipe.transform(messages, addr2).length).toEqual(2);
+    expect(pipe.transform(messages, addr2)).toEqual(result);
   });
+  
+  it('should return empty array when no messages exist for address', () => {
+    let result = []
+    expect(pipe.transform(messages, addr3).length).toEqual(0);
+    expect(pipe.transform(messages, addr3)).toEqual(result);
+  });
+
 });
diff --git a/src/app/pipes/address-pipe/address-pipe.pipe.ts b/src/app/pipes/address-pipe/address-pipe.pipe.ts
index cce1923..c79ccab 100644
--- a/src/app/pipes/address-pipe/address-pipe.pipe.ts
+++ b/src/app/pipes/address-pipe/address-pipe.pipe.ts
@@ -11,7 +11,13 @@ export class AddressPipe implements PipeTransform {
   constructor(
     private mailchainService: MailchainService,
   ){}
-  transform(value: any, args?: any): any {
+
+  /**
+   * Filters and returns messages sent to a particular address using the 'to' field
+   * @param value array of messages
+   * @param args the address to filter by
+   */
+  transform(value: any, args: any): any {
     var address = args;
     
     if (value) {
diff --git a/src/app/pipes/search-pipe/search-pipe.pipe.spec.ts b/src/app/pipes/search-pipe/search-pipe.pipe.spec.ts
index 42e1de2..c441e38 100644
--- a/src/app/pipes/search-pipe/search-pipe.pipe.spec.ts
+++ b/src/app/pipes/search-pipe/search-pipe.pipe.spec.ts
@@ -1,8 +1,94 @@
 import { SearchPipe } from './search-pipe.pipe';
+import { TestBed } from '@angular/core/testing';
+
+let pipe: SearchPipe
+
+const addr1 = '0x7777777777777777777777777777777777777777'
+const addr2 = '0x4444444444444444444444444444444444444444'
+
+const messages = [
+  {
+    "headers": {
+      "date": "2019-06-07T14:53:36Z",
+      "from": "\u003c" + addr1 + '@testnet.ethereum\u003e',
+      "to": "\u003c" + addr2 + '@testnet.ethereum\u003e',
+      "message-id": "001"
+    },
+    "body": "This is a body to be found",
+    "subject": "This is a subject NOT to be found"
+  },
+  {
+    "headers": {
+      "date": "2019-06-07T14:53:36Z",
+      "from": "\u003c" + addr2 + '@testnet.ethereum\u003e',
+      "to": "\u003c" + addr1 + '@testnet.ethereum\u003e',
+      "message-id": "002"
+    },
+    "body": "This is a body NOT to be found",
+    "subject": "This is a subject to be found"
+  }
+]
 
 describe('SearchPipe', () => {
-  it('create an instance', () => {
-    const pipe = new SearchPipe();
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        SearchPipe
+      ],
+      imports: []
+    });
+    
+    pipe = TestBed.get(SearchPipe);
+  });
+
+  it('should create an instance', () => {
     expect(pipe).toBeTruthy();
   });
+
+  it('should search the "sender" field', () => {
+    let result = [
+      messages[0],
+    ]
+    
+    expect(pipe.transform(messages, addr1).length).toEqual(1);
+    expect(pipe.transform(messages, addr1)).toEqual(result);
+  })
+  
+  it('should search the "subject" field', () => {
+    let result = [
+      messages[1],
+    ]
+    let str = "This is a subject to be found"
+    expect(pipe.transform(messages, str).length).toEqual(1);
+    expect(pipe.transform(messages, str)).toEqual(result);
+  })
+  
+  it('should search the "body" field', () => {
+    let result = [
+      messages[0],
+    ]
+    let str = "This is a body to be found"
+    expect(pipe.transform(messages, str).length).toEqual(1);
+    expect(pipe.transform(messages, str)).toEqual(result);
+  })
+  
+  it('should NOT search the "to" field', () => {
+    let result = [
+      messages[1]
+    ]
+    
+    expect(pipe.transform(messages, addr1).length).not.toEqual(2);
+    expect(pipe.transform(messages, addr1)).not.toEqual(result);
+  })
+  
+  it('should NOT search the "date" field', () => {
+    let result = [
+      messages[1],
+    ]
+    let str = messages[1]["headers"]["date"]
+
+    expect(pipe.transform(messages, str).length).toEqual(0);
+    expect(pipe.transform(messages, str)).toEqual([]);
+  
+  })
 });
diff --git a/src/app/pipes/search-pipe/search-pipe.pipe.ts b/src/app/pipes/search-pipe/search-pipe.pipe.ts
index 21caccc..b11f6ab 100644
--- a/src/app/pipes/search-pipe/search-pipe.pipe.ts
+++ b/src/app/pipes/search-pipe/search-pipe.pipe.ts
@@ -5,15 +5,19 @@ import { Pipe, PipeTransform } from '@angular/core';
   pure: false,
 })
 export class SearchPipe implements PipeTransform {
-
-  transform(value: any, args?: any): any {
+  /**
+   * Filters and returns messages with the search term in 'sender', 'subject' or 'body' fields
+   * @param value the object to search
+   * @param args the serch term
+   */
+  transform(value: any, args: any): any {
     const searchText = new RegExp(args, 'ig');
     if (value) {
       return value.filter(mail => {
         var result = false;
 
         [
-          mail["sender"],
+          mail["headers"]["from"],
           mail["subject"],
           mail["body"],
         ].forEach(el => {
diff --git a/src/app/services/mailchain/mailchain.service.spec.ts b/src/app/services/mailchain/mailchain.service.spec.ts
index ab94d0c..fab2d40 100644
--- a/src/app/services/mailchain/mailchain.service.spec.ts
+++ b/src/app/services/mailchain/mailchain.service.spec.ts
@@ -169,6 +169,46 @@ describe('MailchainService', () => {
       expect(response).toEqual(outboundMailObject)
     })
   })
+
+  describe('filterMessages', () => {
+    // id 00: read & status ok
+    // id 01: read & status error
+    // id 02: unread & status ok
+    // id 03: unread & status error
+    const messages = [
+      {
+        "read": true,
+        "status": "ok",
+      },
+      {
+        "read": true,
+        "status": "error",
+      },
+      {
+        "read": false,
+        "status": "ok",
+      },
+      {
+        "read": false,
+        "status": "error",
+      }
+    ]
+
+    it('should return messages with a matching status to the options["status"] value', () => {
+      expect(mailchainService.filterMessages(messages, {status: "ok"})).toEqual([ messages[0],messages[2] ])
+      expect(mailchainService.filterMessages(messages, {status: "error"})).toEqual([ messages[1],messages[3] ])
+    })
+    it('should return messages with a readState to the options["readState"] value', () => {
+      expect(mailchainService.filterMessages(messages, {readState: true})).toEqual([ messages[0],messages[1] ])
+      expect(mailchainService.filterMessages(messages, {readState: false})).toEqual([ messages[2],messages[3] ])
+    })
+    it('should return messages with a readState to the options["readState"] value', () => {
+      expect(mailchainService.filterMessages(messages, {status: "ok", readState: true})).toEqual([ messages[0] ])
+      expect(mailchainService.filterMessages(messages, {status: "ok", readState: false})).toEqual([ messages[2] ])
+      expect(mailchainService.filterMessages(messages, {status: "error", readState: true})).toEqual([ messages[1] ])
+      expect(mailchainService.filterMessages(messages, {status: "error", readState: false})).toEqual([ messages[3] ])
+    })
+  })
   
 
 });
diff --git a/src/app/services/mailchain/mailchain.service.ts b/src/app/services/mailchain/mailchain.service.ts
index e4d2623..5525cf5 100644
--- a/src/app/services/mailchain/mailchain.service.ts
+++ b/src/app/services/mailchain/mailchain.service.ts
@@ -83,4 +83,24 @@ export class MailchainService {
     return output
   }
 
+  /**
+   * Filter message array
+   * @param msgsArray the array of messages
+   * @param options: hash with the following options:
+   *    status: "ok" 
+   *    readState: boolean where false returns unread messages
+   */
+  public filterMessages(msgsArray, options){
+    let status = options.status 
+    let readState = options.readState
+    let output = msgsArray
+    if (status != undefined ) {
+      output = output.filter(msg => msg.status === status)
+    }
+    if (readState != undefined) {
+      output = output.filter(msg => msg.read === readState)
+    }
+    return output
+  }
+
 } 
diff --git a/src/app/test/test-helpers/mailchain-test.service.ts b/src/app/test/test-helpers/mailchain-test.service.ts
index f44cb40..438439c 100644
--- a/src/app/test/test-helpers/mailchain-test.service.ts
+++ b/src/app/test/test-helpers/mailchain-test.service.ts
@@ -57,6 +57,19 @@ export class MailchainTestService {
           "status-code": "",
           "read": true
         },
+        {
+          "headers": {
+            "date": "2019-05-06T11:23:13Z",
+            "from": "\u003c0x0123456789abcdef0123456789abcdef01234567@testnet.ethereum\u003e",
+            "to": "\u003c0x0000000000000000000000000000000000000000@testnet.ethereum\u003e",
+            "message-id": "0020f"
+          },
+          "body": "",
+          "subject": "Sender to Recipient",
+          "status": "ok",
+          "status-code": "",
+          "read": true
+        },
         {
           "status": "could not decrypt location: invalid mac",
           "status-code": "",