├── .coveralls.yml
├── src
    ├── assets
    │   ├── .gitkeep
    │   ├── logo.png
    │   ├── message-logo.png
    │   ├── protocols
    │   │   ├── ethereum.png
    │   │   ├── polkadot.png
    │   │   ├── ethereum_orig.png
    │   │   └── polkadot_orig.png
    │   ├── mailchain_logo_text.png
    │   └── question-circle-regular.svg
    ├── scss
    │   ├── _libs-override.scss
    │   ├── _bootstrap-override.scss
    │   ├── _font.scss
    │   ├── helpers.scss
    │   ├── application.scss
    │   ├── _base.scss
    │   ├── _general.scss
    │   └── _variables.scss
    ├── favicon.ico
    ├── app
    │   ├── settings
    │   │   └── settings
    │   │   │   ├── settings.component.scss
    │   │   │   └── settings.component.html
    │   ├── modals
    │   │   └── modal-connectivity-error
    │   │   │   ├── modal-connectivity-error.component.scss
    │   │   │   ├── modal-connectivity-error.component.ts
    │   │   │   ├── modal-connectivity-error.component.html
    │   │   │   └── modal-connectivity-error.component.spec.ts
    │   ├── models
    │   │   ├── mail.spec.ts
    │   │   ├── inbound-mail.spec.ts
    │   │   ├── outbound-mail.spec.ts
    │   │   ├── inbound-mail.ts
    │   │   ├── mail.ts
    │   │   └── outbound-mail.ts
    │   ├── inbox
    │   │   ├── inbox-messages
    │   │   │   ├── inbox-messages.component.scss
    │   │   │   ├── inbox-messages.component.html
    │   │   │   └── inbox-messages.component.ts
    │   │   ├── inbox.component.scss
    │   │   ├── inbox-compose
    │   │   │   ├── inbox-compose.component.scss
    │   │   │   └── inbox-compose.component.html
    │   │   ├── inbox-message
    │   │   │   ├── inbox-message.component.scss
    │   │   │   ├── inbox-message.component.html
    │   │   │   └── inbox-message.component.ts
    │   │   └── inbox.component.html
    │   ├── app.component.scss
    │   ├── services
    │   │   ├── helpers
    │   │   │   ├── local-storage-protocol
    │   │   │   │   ├── local-storage-protocol.service.stub.ts
    │   │   │   │   ├── local-storage-protocol.service.ts
    │   │   │   │   └── local-storage-protocol.service.spec.ts
    │   │   │   ├── local-storage-account
    │   │   │   │   ├── local-storage-account.service.stub.ts
    │   │   │   │   ├── local-storage-account.service.ts
    │   │   │   │   └── local-storage-account.service.spec.ts
    │   │   │   ├── http-helpers
    │   │   │   │   ├── http-helpers.service.ts
    │   │   │   │   └── http-helpers.service.spec.ts
    │   │   │   ├── error-messages
    │   │   │   │   └── error-messages.ts
    │   │   │   ├── local-storage-server
    │   │   │   │   ├── local-storage-server.service.stub.ts
    │   │   │   │   ├── local-storage-server.service.ts
    │   │   │   │   └── local-storage-server.service.spec.ts
    │   │   │   └── local-storage-nameservice
    │   │   │   │   ├── local-storage-nameservice.service.ts
    │   │   │   │   └── local-storage-nameservice.service.spec.ts
    │   │   └── mailchain
    │   │   │   ├── messages
    │   │   │       ├── send.service.stub.ts
    │   │   │       ├── read.service.stub.ts
    │   │   │       ├── messages.service.stub.ts
    │   │   │       ├── messages.service.ts
    │   │   │       ├── send.service.ts
    │   │   │       ├── read.service.ts
    │   │   │       ├── messages.service.spec.ts
    │   │   │       ├── read.service.spec.ts
    │   │   │       └── send.service.spec.ts
    │   │   │   ├── public-key
    │   │   │       ├── public-key.service.stub.ts
    │   │   │       ├── public-key.service.ts
    │   │   │       └── public-key.service.spec.ts
    │   │   │   ├── envelope
    │   │   │       ├── envelope.service.stub.ts
    │   │   │       ├── envelope.service.ts
    │   │   │       └── envelope.service.spec.ts
    │   │   │   ├── version
    │   │   │       ├── version.service.ts
    │   │   │       └── version.service.spec.ts
    │   │   │   ├── nameservice
    │   │   │       ├── nameservice.service.stub.ts
    │   │   │       ├── nameservice.service.ts
    │   │   │       └── nameservice.service.spec.ts
    │   │   │   ├── protocols
    │   │   │       ├── protocols.service.stub.ts
    │   │   │       ├── protocols.service.ts
    │   │   │       └── protocols.service.spec.ts
    │   │   │   ├── addresses
    │   │   │       ├── addresses.service.stub.ts
    │   │   │       ├── addresses.service.ts
    │   │   │       └── addresses.service.spec.ts
    │   │   │   └── connectivity
    │   │   │       └── connectivity.service.ts
    │   ├── pipes
    │   │   ├── search-pipe
    │   │   │   ├── search-pipe.pipe.ts
    │   │   │   └── search-pipe.pipe.spec.ts
    │   │   └── address-pipe
    │   │   │   ├── address-pipe.pipe.ts
    │   │   │   └── address-pipe.pipe.spec.ts
    │   ├── app.component.html
    │   ├── app.module.ts
    │   ├── app-routing.module.ts
    │   └── app.component.ts
    ├── tsconfig.app.json
    ├── index.html
    ├── tsconfig.spec.json
    ├── tslint.json
    ├── main.ts
    ├── test.ts
    ├── environments
    │   ├── environment.prod.ts
    │   └── environment.ts
    ├── test
    │   └── invoice.txt
    ├── karma.conf.js
    └── polyfills.ts
├── e2e
    ├── tsconfig.e2e.json
    ├── src
    │   ├── app.po.ts
    │   └── app.e2e-spec.ts
    └── protractor.conf.js
├── .travis.yml
├── .browserslistrc
├── tsconfig.json
├── .github
    ├── ISSUE_TEMPLATE
    │   ├── feature_request.md
    │   └── bug_report.md
    └── FUNDING.yml
├── .gitignore
├── package.json
├── 3RD-PARTY-LICENSES.md
├── tslint.json
├── angular.json
└── README.md


/.coveralls.yml:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/src/assets/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/src/scss/_libs-override.scss:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/src/scss/_bootstrap-override.scss:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/src/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mailchain/mailchain-web/master/src/favicon.ico


--------------------------------------------------------------------------------
/src/app/settings/settings/settings.component.scss:
--------------------------------------------------------------------------------
1 | .header-logo {
2 |   max-width: 180px;
3 | }
4 | 


--------------------------------------------------------------------------------
/src/assets/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mailchain/mailchain-web/master/src/assets/logo.png


--------------------------------------------------------------------------------
/src/assets/message-logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mailchain/mailchain-web/master/src/assets/message-logo.png


--------------------------------------------------------------------------------
/src/app/modals/modal-connectivity-error/modal-connectivity-error.component.scss:
--------------------------------------------------------------------------------
1 | .icon-large {
2 |   font-size: 30px;
3 | }


--------------------------------------------------------------------------------
/src/scss/_font.scss:
--------------------------------------------------------------------------------
1 | @import url('https://fonts.googleapis.com/css?family=Montserrat:300,400,500,500i,600,700');
2 | 
3 | 


--------------------------------------------------------------------------------
/src/assets/protocols/ethereum.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mailchain/mailchain-web/master/src/assets/protocols/ethereum.png


--------------------------------------------------------------------------------
/src/assets/protocols/polkadot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mailchain/mailchain-web/master/src/assets/protocols/polkadot.png


--------------------------------------------------------------------------------
/src/assets/mailchain_logo_text.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mailchain/mailchain-web/master/src/assets/mailchain_logo_text.png


--------------------------------------------------------------------------------
/src/assets/protocols/ethereum_orig.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mailchain/mailchain-web/master/src/assets/protocols/ethereum_orig.png


--------------------------------------------------------------------------------
/src/assets/protocols/polkadot_orig.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mailchain/mailchain-web/master/src/assets/protocols/polkadot_orig.png


--------------------------------------------------------------------------------
/src/app/models/mail.spec.ts:
--------------------------------------------------------------------------------
1 | import { Mail } from './mail';
2 | 
3 | describe('Mail', () => {
4 |   it('should create an instance', () => {
5 |     expect(new Mail()).toBeTruthy();
6 |   });
7 | });
8 | 


--------------------------------------------------------------------------------
/src/scss/helpers.scss:
--------------------------------------------------------------------------------
1 | @import "./variables";
2 | 
3 | @import "../../node_modules/bootstrap/scss/functions";
4 | @import "../../node_modules/bootstrap/scss/variables";
5 | @import "../../node_modules/bootstrap/scss/mixins";
6 | 


--------------------------------------------------------------------------------
/src/app/models/inbound-mail.spec.ts:
--------------------------------------------------------------------------------
1 | import { InboundMail } from './inbound-mail';
2 | 
3 | describe('InboundMail', () => {
4 |   it('should create an instance', () => {
5 |     expect(new InboundMail()).toBeTruthy();
6 |   });
7 | });
8 | 


--------------------------------------------------------------------------------
/src/app/models/outbound-mail.spec.ts:
--------------------------------------------------------------------------------
1 | import { OutboundMail } from './outbound-mail';
2 | 
3 | describe('OutboundMail', () => {
4 |   it('should create an instance', () => {
5 |     expect(new OutboundMail()).toBeTruthy();
6 |   });
7 | });
8 | 


--------------------------------------------------------------------------------
/e2e/tsconfig.e2e.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "extends": "../tsconfig.json",
 3 |   "compilerOptions": {
 4 |     "outDir": "../out-tsc/app",
 5 |     "module": "commonjs",
 6 |     "target": "es5",
 7 |     "types": [
 8 |       "jasmine",
 9 |       "jasminewd2",
10 |       "node"
11 |     ]
12 |   }
13 | }


--------------------------------------------------------------------------------
/src/app/inbox/inbox-messages/inbox-messages.component.scss:
--------------------------------------------------------------------------------
 1 | .unread {
 2 |   font-weight: 600;
 3 | }
 4 | .widget-body {
 5 |   padding-top: 15px;
 6 |   border-radius: 5px;
 7 | }
 8 | 
 9 | 
10 | .resolved-address {
11 |   font-style: italic;
12 | }
13 | .unresolved-address {
14 |   font-style: normal;
15 | }


--------------------------------------------------------------------------------
/src/app/app.component.scss:
--------------------------------------------------------------------------------
 1 | @import "../scss/variables";
 2 | 
 3 | .footer {
 4 |   position: fixed;
 5 |   bottom: 0;
 6 |   width: 100%;
 7 |   height: $footer-height;
 8 |   line-height: $footer-height;
 9 |   background-color: #f5f5f5;
10 | }
11 | 
12 | #main-content {
13 |   padding-bottom: 10px;
14 | }
15 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | dist: trusty
 2 | 
 3 | language: node_js
 4 | node_js:
 5 |   - "13"
 6 | 
 7 | addons:
 8 |   chrome: stable
 9 | 
10 | cache:
11 |   directories:
12 |     - ./node_modules
13 | 
14 | install:
15 |   - npm install
16 | 
17 | script:
18 |   - npm run test -- --watch=false --browsers=ChromeHeadlessNoSandbox
19 | 


--------------------------------------------------------------------------------
/e2e/src/app.po.ts:
--------------------------------------------------------------------------------
 1 | import { browser, by, element } from 'protractor';
 2 | 
 3 | export class AppPage {
 4 |   navigateTo() {
 5 |     return browser.get(browser.baseUrl) as Promise<any>;
 6 |   }
 7 | 
 8 |   getTitleText() {
 9 |     return element(by.css('app-root h1')).getText() as Promise<string>;
10 |   }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/tsconfig.app.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "extends": "../tsconfig.json",
 3 |   "compilerOptions": {
 4 |     "outDir": "../out-tsc/app",
 5 |     "types": [],
 6 |     "resolveJsonModule": true
 7 |   },
 8 |   "files": [
 9 |     "main.ts",
10 |     "polyfills.ts"
11 |   ],
12 |   "include": [
13 |     "src/**/*.d.ts"
14 |   ]
15 | }


--------------------------------------------------------------------------------
/src/index.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | 
 4 | <head>
 5 |   <meta charset="utf-8">
 6 |   <title>Mailchain Inbox</title>
 7 | 
 8 |   <meta name="viewport" content="width=device-width, initial-scale=1">
 9 |   <link rel="icon" type="image/x-icon" href="favicon.ico">
10 | </head>
11 | 
12 | <body>
13 |   <app-root></app-root>
14 | </body>
15 | 
16 | </html>


--------------------------------------------------------------------------------
/src/app/models/inbound-mail.ts:
--------------------------------------------------------------------------------
 1 | export class InboundMail {
 2 |   public headers: any = {};
 3 |   public subject: string = "No Subject";
 4 |   public body: string = "";
 5 |   public read: boolean = false;
 6 |   public selected: boolean = false;
 7 |   public senderIdenticon: string = "";
 8 |   public status: string = "";
 9 |   public 'status-code': string = "";
10 | }
11 | 


--------------------------------------------------------------------------------
/src/app/models/mail.ts:
--------------------------------------------------------------------------------
 1 | export class Mail {
 2 |   public to: string = "";
 3 |   public from: string = "";
 4 |   public replyTo: string = "";
 5 |   public subject: string = "";
 6 |   public body: string = "";
 7 |   public publicKey: string = "";
 8 |   public publicKeyEncoding: string = "";
 9 |   public publicKeyKind: string = "";
10 |   public supportedEncryptionTypes: Array<any> = [];
11 | }


--------------------------------------------------------------------------------
/src/tsconfig.spec.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "extends": "../tsconfig.json",
 3 |   "compilerOptions": {
 4 |     "outDir": "../out-tsc/spec",
 5 |     "types": [
 6 |       "jasmine",
 7 |       "node"
 8 |     ],
 9 |     "resolveJsonModule": true
10 |   },
11 |   "files": [
12 |     "test.ts",
13 |     "polyfills.ts"
14 |   ],
15 |   "include": [
16 |     "**/*.spec.ts",
17 |     "**/*.d.ts"
18 |   ]
19 | }


--------------------------------------------------------------------------------
/src/tslint.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "extends": "../tslint.json",
 3 |     "rules": {
 4 |         "directive-selector": [
 5 |             true,
 6 |             "attribute",
 7 |             "app",
 8 |             "camelCase"
 9 |         ],
10 |         "component-selector": [
11 |             true,
12 |             "element",
13 |             "app",
14 |             "kebab-case"
15 |         ]
16 |     }
17 | }


--------------------------------------------------------------------------------
/src/scss/application.scss:
--------------------------------------------------------------------------------
 1 | @import "variables";
 2 | 
 3 | // Bootstrap
 4 | @import "../../node_modules/bootstrap/scss/bootstrap";
 5 | 
 6 | // Fonts
 7 | @import "../../node_modules/font-awesome/scss/font-awesome";
 8 | 
 9 | // Overides
10 | @import "bootstrap-override";
11 | @import "libs-override";
12 | 
13 | // Custom Styling
14 | @import "font";
15 | @import "general";
16 | @import "base";
17 | 
18 | 
19 | 


--------------------------------------------------------------------------------
/src/app/services/helpers/local-storage-protocol/local-storage-protocol.service.stub.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | 
 3 | @Injectable({
 4 |   providedIn: 'root'
 5 | })
 6 | export class LocalStorageProtocolServiceStub {
 7 | 
 8 |   constructor(
 9 |   ) { }
10 | 
11 |   async getCurrentProtocol() {
12 |     return 'myProtocol'
13 |   }
14 | 
15 |   setCurrentProtocol(protocol) {
16 | 
17 |   }
18 | 
19 | }
20 | 


--------------------------------------------------------------------------------
/src/app/inbox/inbox.component.scss:
--------------------------------------------------------------------------------
 1 | .account-item {
 2 |   padding-bottom: 0;
 3 |   padding-top: 0;
 4 |   &.active {
 5 |     color: inherit;
 6 |     background-color: #f2f2f2;
 7 |     border-color: #f2f2f2;
 8 |   }
 9 | }
10 | 
11 | .addressFolderIcon{
12 |   width: 100%;
13 | }
14 | 
15 | .accountNameRecord {
16 |   display: block;
17 |   padding: 0 1rem 0.5rem 1rem;
18 | }
19 | 
20 | .header-logo {
21 |   max-width: 180px;
22 | }


--------------------------------------------------------------------------------
/src/main.ts:
--------------------------------------------------------------------------------
 1 | import { enableProdMode } from '@angular/core';
 2 | import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
 3 | 
 4 | import { AppModule } from './app/app.module';
 5 | import { environment } from './environments/environment';
 6 | 
 7 | if (environment.production) {
 8 |   enableProdMode();
 9 | }
10 | 
11 | platformBrowserDynamic().bootstrapModule(AppModule)
12 |   .catch(err => console.error(err));
13 | 


--------------------------------------------------------------------------------
/.browserslistrc:
--------------------------------------------------------------------------------
 1 | # This file is currently used by autoprefixer to adjust CSS to support the below specified browsers
 2 | # For additional information regarding the format and rule options, please see:
 3 | # https://github.com/browserslist/browserslist#queries
 4 | #
 5 | # For IE 9-11 support, please remove 'not' from the last line of the file and adjust as needed
 6 | 
 7 | > 0.5%
 8 | last 2 versions
 9 | Firefox ESR
10 | not dead
11 | not IE 9-11


--------------------------------------------------------------------------------
/src/app/services/mailchain/messages/send.service.stub.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { OutboundMail } from 'src/app/models/outbound-mail';
 3 | import { of } from 'rxjs';
 4 | 
 5 | @Injectable({
 6 |   providedIn: 'root'
 7 | })
 8 | export class SendServiceStub {
 9 | 
10 |   constructor(
11 |   ) {
12 |   }
13 | 
14 |   sendMail(outboundMail: OutboundMail, protocol: string, network: string) {
15 |     return of([])
16 |   }
17 | 
18 | }
19 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/messages/read.service.stub.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { of } from 'rxjs';
 3 | 
 4 | @Injectable({
 5 |   providedIn: 'root'
 6 | })
 7 | export class ReadServiceStub {
 8 | 
 9 |   constructor(
10 |   ) {
11 |   }
12 | 
13 |   markRead(message_id) {
14 |     return of(["ok"])
15 |   }
16 | 
17 |   markUnread(message_id) {
18 |     return of(["ok"])
19 |   }
20 | 
21 |   initUrl() {
22 |   }
23 | 
24 |   urlHelper(message_id) {
25 |   }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/scss/_base.scss:
--------------------------------------------------------------------------------
 1 | // custom styles
 2 | 
 3 | pre {
 4 |   white-space: pre-wrap;       /* Since CSS 2.1 */
 5 |   white-space: -moz-pre-wrap;  /* Mozilla, since 1999 */
 6 |   white-space: -pre-wrap;      /* Opera 4-6 */
 7 |   white-space: -o-pre-wrap;    /* Opera 7 */
 8 |   word-wrap: break-word;       /* Internet Explorer 5.5+ */
 9 | }
10 | 
11 | main {
12 |   margin-bottom: $footer-margin-offset;
13 | }
14 | 
15 | .widget-body {
16 |   padding-top: 15px;
17 |   border-radius: 5px;
18 | }
19 | 
20 | 


--------------------------------------------------------------------------------
/src/app/models/outbound-mail.ts:
--------------------------------------------------------------------------------
 1 | export class OutboundMail {
 2 |   public message: any = {
 3 |     "body": "",
 4 |     "headers": {
 5 |       "from": "",
 6 |       "reply-to": "",
 7 |       "to": ""
 8 |     },
 9 |     "public-key": "",
10 |     "public-key-encoding": "",
11 |     "public-key-kind": "",
12 |     "subject": ""
13 |   };
14 |   public "envelope": string = "";
15 |   public "encryption-method-name": string = "aes256cbc";
16 |   public "content-type": string = "text/plain; charset=\"UTF-8\"";
17 | }
18 | 
19 | 


--------------------------------------------------------------------------------
/src/scss/_general.scss:
--------------------------------------------------------------------------------
 1 | @-ms-viewport{
 2 |   width: auto;
 3 | }
 4 | 
 5 | html, body{
 6 |   height: 100%;
 7 | }
 8 | 
 9 | html {
10 |   font-size: 14px;
11 | }
12 | 
13 | body{
14 |   font-weight: 300;
15 |   overflow-x: hidden;
16 | }
17 | 
18 | th{
19 |   font-weight: 600;
20 | }
21 | 
22 | a {
23 |   cursor: pointer;
24 | }
25 | 
26 | svg {
27 |   width: 100%;
28 | }
29 | 
30 | strong, b {
31 |   font-weight: bold;
32 | }
33 | 
34 | abbr[title] {
35 |   text-decoration: none;
36 |   border-bottom: 1px dotted #999;
37 | }
38 | 
39 | button {
40 |   cursor: pointer;
41 | }
42 | 


--------------------------------------------------------------------------------
/src/app/modals/modal-connectivity-error/modal-connectivity-error.component.ts:
--------------------------------------------------------------------------------
 1 | import { Component, Input } from '@angular/core';
 2 | import { BsModalRef } from 'ngx-bootstrap/modal';
 3 | 
 4 | @Component({
 5 |   selector: 'app-modal-connectivity-error',
 6 |   templateUrl: './modal-connectivity-error.component.html',
 7 |   styleUrls: ['./modal-connectivity-error.component.scss']
 8 | })
 9 | export class ModalConnectivityErrorComponent {
10 |   @Input() errorTitle: string;
11 |   @Input() errorMessage: string;
12 | 
13 |   constructor(public bsModalRef: BsModalRef) { }
14 | 
15 | }
16 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compileOnSave": false,
 3 |   "compilerOptions": {
 4 |     "baseUrl": "./",
 5 |     "downlevelIteration": true,
 6 |     "outDir": "./dist/out-tsc",
 7 |     "sourceMap": true,
 8 |     "declaration": false,
 9 |     "module": "es2020",
10 |     "moduleResolution": "node",
11 |     "resolveJsonModule": true,
12 |     "emitDecoratorMetadata": true,
13 |     "experimentalDecorators": true,
14 |     "importHelpers": true,
15 |     "target": "es2015",
16 |     "typeRoots": [
17 |       "node_modules/@types"
18 |     ],
19 |     "lib": [
20 |       "es2018",
21 |       "dom"
22 |     ]
23 |   }
24 | }


--------------------------------------------------------------------------------
/src/app/services/helpers/local-storage-account/local-storage-account.service.stub.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | 
 3 | @Injectable({
 4 |   providedIn: 'root'
 5 | })
 6 | export class LocalStorageAccountServiceStub {
 7 |   private localStorageCurrentAccount: string
 8 | 
 9 |   constructor(
10 |   ) { }
11 | 
12 |   async getCurrentAccount() {
13 |     return this.localStorageCurrentAccount
14 |   }
15 | 
16 | 
17 |   setCurrentAccount(address: string) {
18 |     this.localStorageCurrentAccount = address
19 |   }
20 | 
21 |   removeCurrentAccount() {
22 |     this.localStorageCurrentAccount = undefined
23 | 
24 |   }
25 | 
26 | 
27 | }
28 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/messages/messages.service.stub.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { Observable, of } from 'rxjs';
 3 | import { MailchainTestService } from 'src/app/test/test-helpers/mailchain-test.service';
 4 | 
 5 | @Injectable({
 6 |   providedIn: 'root'
 7 | })
 8 | export class MessagesServiceStub {
 9 | 
10 |   constructor(
11 |     private mailchainTestService: MailchainTestService
12 |   ) {
13 |   }
14 | 
15 |   getMessages(rcptAddress: string, protocol: string, network: string): Observable<any> {
16 |     let messages = this.mailchainTestService.messagesResponse
17 |     return of(messages)
18 |   };
19 | 
20 | }
21 | 


--------------------------------------------------------------------------------
/src/app/inbox/inbox-compose/inbox-compose.component.scss:
--------------------------------------------------------------------------------
 1 | .courier {
 2 |   font-family: 'Courier New', Courier, monospace
 3 | }
 4 | 
 5 | .addressIcon{
 6 |   width: 100%;
 7 |   max-width: 32px;
 8 | }
 9 | 
10 | .compose-form {
11 |   max-width: 950px;
12 | }
13 | 
14 | .address-box {
15 |   padding-top: 5px;
16 |   padding-bottom: 5px;
17 | }
18 | 
19 | .content-type-switch {
20 |   text-align: right;
21 |   width: 100%;
22 | }
23 | 
24 | :host ::ng-deep .ck-editor__editable_inline {
25 |   min-height: 500px;
26 | }
27 | 
28 | #messageBody {
29 |   width: 100%;
30 | }
31 | 
32 | :host ::ng-deep .ck-editor blockquote {
33 |   font-style: inherit;
34 | }
35 | 
36 | 


--------------------------------------------------------------------------------
/src/scss/_variables.scss:
--------------------------------------------------------------------------------
 1 | $fa-font-path: "~font-awesome/fonts";
 2 | 
 3 | 
 4 | $footer-height: 60px;
 5 | $footer-margin-offset: 45px;
 6 | 
 7 | // Color variables
 8 | $custom:                #13ce67;
 9 | $white:                 #ffffff;
10 | 
11 | $primary:               #58638a;
12 | $success:               #519965;
13 | $info:                  #1f1420;
14 | $warning:               #ce892d;
15 | $danger:                #f44336;
16 | $dark:                  #0f1f3e;
17 | $light:                 #f8f9fa;
18 | 
19 | $link-color:            #3857c3;
20 | // $background:            #B2B6CC;
21 | // #A84258 // burgundy red
22 | // #7983A3 // light purple
23 | // #F5F7F5 // light grey


--------------------------------------------------------------------------------
/src/app/services/mailchain/public-key/public-key.service.stub.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { of } from 'rxjs';
 3 | import { MailchainTestService } from 'src/app/test/test-helpers/mailchain-test.service';
 4 | 
 5 | @Injectable({
 6 |   providedIn: 'root'
 7 | })
 8 | export class PublicKeyServiceStub {
 9 | 
10 |   constructor(
11 |     private mailchainTestService: MailchainTestService
12 |   ) {
13 |   }
14 | 
15 | 
16 |   /**
17 |    * Get the public key of a public address
18 |    */
19 |   getPublicKeyFromAddress(public_address: any, network: any) {
20 |     return of(
21 |       this.mailchainTestService.publicKeyHexZeroXResponse()
22 |     )
23 |   }
24 | 
25 | }


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature_request.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Feature request
 3 | about: Suggest an idea for this project
 4 | title: ''
 5 | labels: ''
 6 | assignees: ''
 7 | 
 8 | ---
 9 | 
10 | **Is your feature request related to a problem? Please describe.**
11 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
12 | 
13 | **Describe the solution you'd like**
14 | A clear and concise description of what you want to happen.
15 | 
16 | **Describe alternatives you've considered**
17 | A clear and concise description of any alternative solutions or features you've considered.
18 | 
19 | **Additional context**
20 | Add any other context or screenshots about the feature request here.
21 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/envelope/envelope.service.stub.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | 
 3 | @Injectable({
 4 |   providedIn: 'root'
 5 | })
 6 | export class EnvelopeServiceStub {
 7 |   private envelopes: Array<any>
 8 | 
 9 |   constructor(
10 |   ) {
11 |   }
12 | 
13 |   async getEnvelope() {
14 |     if (this.envelopes) {
15 |       return this.envelopes
16 |     } else {
17 |       return [{ "type": "0x01", "description": "Private Message Stored with MLI" }]
18 |     }
19 |   }
20 | 
21 |   // Only for stub
22 |   /**
23 |    * Sets the envelopes for the stub
24 |    * @param envelopes Array of envelopes
25 |    */
26 |   public setEnvelopes(envelopes) {
27 |     this.envelopes = envelopes
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/e2e/src/app.e2e-spec.ts:
--------------------------------------------------------------------------------
 1 | import { AppPage } from './app.po';
 2 | import { browser, logging } from 'protractor';
 3 | 
 4 | describe('workspace-project App', () => {
 5 |   let page: AppPage;
 6 | 
 7 |   beforeEach(() => {
 8 |     page = new AppPage();
 9 |   });
10 | 
11 |   it('should display welcome message', () => {
12 |     page.navigateTo();
13 |     expect(page.getTitleText()).toEqual('Welcome to mailchain-web!');
14 |   });
15 | 
16 |   afterEach(async () => {
17 |     // Assert that there are no errors emitted from the browser
18 |     const logs = await browser.manage().logs().get(logging.Type.BROWSER);
19 |     expect(logs).not.toContain(jasmine.objectContaining({
20 |       level: logging.Level.SEVERE,
21 |     }));
22 |   });
23 | });
24 | 


--------------------------------------------------------------------------------
/src/test.ts:
--------------------------------------------------------------------------------
 1 | // This file is required by karma.conf.js and loads recursively all the .spec and framework files
 2 | 
 3 | import 'zone.js/dist/zone-testing';
 4 | import { getTestBed } from '@angular/core/testing';
 5 | import {
 6 |   BrowserDynamicTestingModule,
 7 |   platformBrowserDynamicTesting
 8 | } from '@angular/platform-browser-dynamic/testing';
 9 | 
10 | declare const require: any;
11 | 
12 | // First, initialize the Angular testing environment.
13 | getTestBed().initTestEnvironment(
14 |   BrowserDynamicTestingModule,
15 |   platformBrowserDynamicTesting()
16 | );
17 | // Then we find all the tests.
18 | const context = require.context('./', true, /\.spec\.ts$/);
19 | // And load the modules.
20 | context.keys().map(context);
21 | 
22 | beforeEach(function() {
23 |   sessionStorage.clear();
24 | });


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # See http://help.github.com/ignore-files/ for more about ignoring files.
 2 | 
 3 | # compiled output
 4 | /dist
 5 | /tmp
 6 | /out-tsc
 7 | 
 8 | # dependencies
 9 | /node_modules
10 | 
11 | # profiling files
12 | chrome-profiler-events.json
13 | speed-measure-plugin.json
14 | 
15 | # IDEs and editors
16 | /.idea
17 | .project
18 | .classpath
19 | .c9/
20 | *.launch
21 | .settings/
22 | *.sublime-workspace
23 | 
24 | # IDE - VSCode
25 | .vscode/*
26 | !.vscode/settings.json
27 | !.vscode/tasks.json
28 | !.vscode/launch.json
29 | !.vscode/extensions.json
30 | .history/*
31 | 
32 | # misc
33 | /.sass-cache
34 | /connect.lock
35 | /coverage
36 | /libpeerconnection.log
37 | npm-debug.log
38 | yarn-error.log
39 | testem.log
40 | /typings
41 | 
42 | # System Files
43 | .DS_Store
44 | Thumbs.db
45 | deploy.sh
46 | deploy-staging.sh
47 | 


--------------------------------------------------------------------------------
/src/environments/environment.prod.ts:
--------------------------------------------------------------------------------
 1 | import { version } from '../../package.json';
 2 | 
 3 | export const environment = {
 4 |   production: true,
 5 |   version: version,
 6 |   repositoryVersionLatestEndpoint: "https://api.github.com/repos/mailchain/mailchain/releases/latest",
 7 | };
 8 | 
 9 | const mailchainNodeBaseWebProtocol = "http"
10 | const mailchainNodeBaseHost = "127.0.0.1"
11 | const mailchainNodeBasePort = "8080"
12 | 
13 | export const applicationApiConfig = {
14 |   "webProtocols": ["http", "https"],
15 |   "networks": [
16 |     "mainnet",
17 |     "ropsten",
18 |     "rinkeby",
19 |     "kovan",
20 |     "goerli"
21 |   ],
22 |   "protocols": ["ethereum"],
23 | 
24 |   "mailchainNodeBaseWebProtocol": mailchainNodeBaseWebProtocol,
25 |   "mailchainNodeBaseHost": mailchainNodeBaseHost,
26 |   "mailchainNodeBasePort": mailchainNodeBasePort,
27 | }
28 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
 1 | # These are supported funding model platforms
 2 | 
 3 | github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 4 | patreon: # Replace with a single Patreon username
 5 | open_collective: # Replace with a single Open Collective username
 6 | ko_fi: # Replace with a single Ko-fi username
 7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 9 | liberapay: # Replace with a single Liberapay username
10 | issuehunt: # Replace with a single IssueHunt username
11 | otechie: # Replace with a single Otechie username
12 | custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
13 | custom: ['https://gitcoin.co/grants/153/mailchain-email-like-messaging-and-attachment-capa/fund']
14 | 


--------------------------------------------------------------------------------
/e2e/protractor.conf.js:
--------------------------------------------------------------------------------
 1 | // Protractor configuration file, see link for more information
 2 | // https://github.com/angular/protractor/blob/master/lib/config.ts
 3 | 
 4 | const { SpecReporter } = require('jasmine-spec-reporter');
 5 | 
 6 | exports.config = {
 7 |   allScriptsTimeout: 11000,
 8 |   specs: [
 9 |     './src/**/*.e2e-spec.ts'
10 |   ],
11 |   capabilities: {
12 |     'browserName': 'chrome'
13 |   },
14 |   directConnect: true,
15 |   baseUrl: 'http://localhost:4200/',
16 |   framework: 'jasmine',
17 |   jasmineNodeOpts: {
18 |     showColors: true,
19 |     defaultTimeoutInterval: 30000,
20 |     print: function () { }
21 |   },
22 |   onPrepare() {
23 |     require('ts-node').register({
24 |       project: require('path').join(__dirname, './tsconfig.e2e.json')
25 |     });
26 |     jasmine.getEnv().addReporter(new SpecReporter({ spec: { displayStacktrace: true } }));
27 |   }
28 | };


--------------------------------------------------------------------------------
/src/environments/environment.ts:
--------------------------------------------------------------------------------
 1 | import { version } from '../../package.json';
 2 | 
 3 | export const environment = {
 4 |   production: false,
 5 |   version: version,
 6 |   repositoryVersionLatestEndpoint: "https://api.github.com/repos/mailchain/mailchain/releases/latest",
 7 | };
 8 | 
 9 | const mailchainNodeBaseWebProtocol = "http"
10 | const mailchainNodeBaseHost = "127.0.0.1"
11 | const mailchainNodeBasePort = "8080"
12 | 
13 | export const applicationApiConfig = {
14 |   "webProtocols": ["http", "https"],
15 |   "networks": [
16 |     "mainnet",
17 |     "ropsten",
18 |     "rinkeby",
19 |     "kovan",
20 |     "goerli"
21 |   ],
22 |   "protocols": ["ethereum"],
23 | 
24 |   "mailchainNodeBaseWebProtocol": mailchainNodeBaseWebProtocol,
25 |   "mailchainNodeBaseHost": mailchainNodeBaseHost,
26 |   "mailchainNodeBasePort": mailchainNodeBasePort,
27 | }
28 | 
29 | // import 'zone.js/dist/zone-error';  // Included with Angular CLI.
30 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/version/version.service.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { HttpClient } from '@angular/common/http';
 3 | import { LocalStorageServerService } from '../../helpers/local-storage-server/local-storage-server.service';
 4 | 
 5 | @Injectable({
 6 |   providedIn: 'root'
 7 | })
 8 | export class VersionService {
 9 | 
10 |   private url: string
11 | 
12 |   constructor(
13 |     private http: HttpClient,
14 |     private localStorageServerService: LocalStorageServerService,
15 |   ) {
16 |     this.initUrl()
17 |   }
18 | 
19 |   /**
20 |    * Initialize URL from local storage
21 |    */
22 |   initUrl() {
23 |     this.url = `${this.localStorageServerService.getCurrentServerDetails()}/api`
24 |   }
25 | 
26 |   /**
27 |    * Get and return the protocols configured on the api application
28 |    */
29 |   getVersion() {
30 |     return this.http.get(this.url + `/version`);
31 |   }
32 | 
33 | }
34 | 


--------------------------------------------------------------------------------
/src/app/modals/modal-connectivity-error/modal-connectivity-error.component.html:
--------------------------------------------------------------------------------
 1 | <!-- modalConnectivityError -->
 2 |   <div class="modal-header flex-column">
 3 |     <button (click)="bsModalRef.hide()" aria-label="Close" class="close ml-auto" type="button">
 4 |       <span aria-hidden="true">×</span>
 5 |     </button>
 6 |     <div class="col-12 text-center">
 7 |       <h3 class="modal-title" id="connectivityModal">{{errorTitle}}</h3>
 8 |     </div>
 9 |   </div>
10 |   <div class="modal-body">
11 |     <p class="text-center text-danger icon-large"><i class="fa fa-exclamation-triangle"></i></p>
12 |     <p [innerHTML]="errorMessage"></p>
13 |   </div>
14 |   <div class="modal-footer">
15 |     <button type="button" class="btn btn-outline-success" onClick="window.location.reload()">Reload</button>
16 |     <button type="button" class="btn btn-outline-secondary" (click)="bsModalRef.hide()">Close</button>
17 |   </div>
18 | <!-- end modalConnectivityError -->
19 | 


--------------------------------------------------------------------------------
/src/app/pipes/search-pipe/search-pipe.pipe.ts:
--------------------------------------------------------------------------------
 1 | import { Pipe, PipeTransform } from '@angular/core';
 2 | 
 3 | @Pipe({
 4 |   name: 'searchPipe',
 5 |   pure: false,
 6 | })
 7 | export class SearchPipe implements PipeTransform {
 8 |   /**
 9 |    * Filters and returns messages with the search term in 'sender', 'subject' or 'body' fields
10 |    * @param value the object to search
11 |    * @param args the serch term
12 |    */
13 |   transform(value: any, args: any): any {
14 |     const searchText = new RegExp(args, 'ig');
15 |     if (value) {
16 |       return value.filter(mail => {
17 |         var result = false;
18 | 
19 |         [
20 |           mail["headers"]["from"],
21 |           mail["subject"],
22 |           mail["body"],
23 |         ].forEach(el => {
24 |           if (
25 |             el != undefined &&
26 |             el.search(searchText) !== -1
27 |           ) {
28 |             result = true
29 |           }
30 |         });
31 |         return result
32 |       });
33 |     }
34 |   }
35 | }
36 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a report to help us improve
 4 | title: ''
 5 | labels: ''
 6 | assignees: ''
 7 | 
 8 | ---
 9 | 
10 | **Describe the bug**
11 | A clear and concise description of what the bug is.
12 | 
13 | **To Reproduce**
14 | Steps to reproduce the behavior:
15 | 1. Go to '...'
16 | 2. Click on '....'
17 | 3. Scroll down to '....'
18 | 4. See error
19 | 
20 | **Expected behavior**
21 | A clear and concise description of what you expected to happen.
22 | 
23 | **Screenshots**
24 | If applicable, add screenshots to help explain your problem.
25 | 
26 | **Desktop (please complete the following information):**
27 |  - OS: [e.g. iOS]
28 |  - Browser [e.g. chrome, safari]
29 |  - Version [e.g. 22]
30 | 
31 | **Smartphone (please complete the following information):**
32 |  - Device: [e.g. iPhone6]
33 |  - OS: [e.g. iOS8.1]
34 |  - Browser [e.g. stock browser, safari]
35 |  - Version [e.g. 22]
36 | 
37 | **Additional context**
38 | Add any other context about the problem here.
39 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/envelope/envelope.service.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { HttpClient } from '@angular/common/http';
 3 | import { LocalStorageServerService } from '../../helpers/local-storage-server/local-storage-server.service';
 4 | 
 5 | @Injectable({
 6 |   providedIn: 'root'
 7 | })
 8 | export class EnvelopeService {
 9 | 
10 |   private url: string
11 | 
12 |   constructor(
13 |     private http: HttpClient,
14 |     private localStorageServerService: LocalStorageServerService,
15 |   ) {
16 |     this.initUrl()
17 |   }
18 | 
19 |   /**
20 |    * Initialize URL from local storage
21 |    */
22 |   initUrl() {
23 |     this.url = `${this.localStorageServerService.getCurrentServerDetails()}/api`
24 |   }
25 | 
26 |   /**
27 |    * Get and return the available envelope(s)
28 |    */
29 |   async getEnvelope() {
30 | 
31 |     let envelopes = await this.http.get<any[]>(
32 |       this.url + `/envelope`
33 |       // TODO handle failure
34 |     ).toPromise();
35 |     return envelopes
36 |   }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/app/app.component.html:
--------------------------------------------------------------------------------
 1 | <div class="container-fluid" id="main-content">
 2 |   <main id="content" class="content" role="main">
 3 |     <div class="router-component" #routerComponent>
 4 |       <router-outlet></router-outlet>
 5 |     </div>
 6 | 
 7 |   </main>
 8 | </div>
 9 | <footer class="footer">
10 |   <div class="container">
11 | 
12 |     <div class="row">
13 |       <div class="col">
14 |         <span class="text-muted">
15 |           Made by <a href="https://mailchain.xyz" target="_blank">Mailchain</a>
16 |         </span>
17 |       </div>
18 |       <div class="col">
19 |         <span *ngIf="currentProtocol" class="text-muted">
20 |           <i class="fa fa-bolt"></i>&nbsp;Connected to {{currentNetwork | titlecase}} on {{currentProtocol | titlecase}}
21 |         </span>
22 |       </div>
23 |       <div class="col">
24 |         <span class="text-muted pull-right"><i class="fa fa-envelope"></i>&nbsp;Inbox Version: {{version}} (API Version:
25 |           {{apiVersion}})</span>
26 |       </div>
27 |     </div>
28 | 
29 |   </div>
30 | </footer>


--------------------------------------------------------------------------------
/src/app/inbox/inbox-message/inbox-message.component.scss:
--------------------------------------------------------------------------------
 1 | .pre-inherit {
 2 |   font-family: inherit;
 3 |   font-size: inherit;
 4 |   font-weight: inherit;
 5 | }
 6 | 
 7 | .message-body {
 8 |   font-family: 'Courier New', Courier, monospace;
 9 | }
10 | 
11 | .message-body-container {
12 |   display: contents;
13 | }
14 | 
15 | .message-body-html {
16 |    flex-grow: 1; border: none; margin: 0; padding: 0;
17 | }
18 | 
19 | .message-identicon {
20 |   width: 35px;
21 |   height: 35px;
22 |   float: left;
23 |   margin-right: 10px;
24 | }
25 | 
26 | .message-actions {
27 |   position: absolute;
28 |   right: 0;
29 |   top: 0;
30 |   text-align: right;
31 |   z-index: 1;
32 | }
33 | 
34 | .message-action {
35 |   padding-left: 5px;
36 |   padding-right: 5px;
37 |   display: inline;
38 | }
39 | 
40 | .message-to {
41 |   display: block;
42 | }
43 | 
44 | .message-to{
45 |   padding-top: 5px; 
46 | }
47 | 
48 | blockquote {
49 |   overflow: hidden;
50 |   padding-right: 1.5em;
51 |   padding-left: 1.5em;
52 |   margin-left: 0;
53 |   margin-right: 0;
54 |   border-left: 5px solid #ccc;
55 | }


--------------------------------------------------------------------------------
/src/app/modals/modal-connectivity-error/modal-connectivity-error.component.spec.ts:
--------------------------------------------------------------------------------
 1 | import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
 2 | 
 3 | import { ModalConnectivityErrorComponent } from './modal-connectivity-error.component';
 4 | import { ModalModule, BsModalRef } from 'ngx-bootstrap/modal';
 5 | 
 6 | describe('ModalConnectivityErrorComponent', () => {
 7 |   let component: ModalConnectivityErrorComponent;
 8 |   let fixture: ComponentFixture<ModalConnectivityErrorComponent>;
 9 | 
10 |   beforeEach(waitForAsync(() => {
11 |     TestBed.configureTestingModule({
12 |       declarations: [
13 |         ModalConnectivityErrorComponent
14 |       ],
15 |       providers: [
16 |         BsModalRef
17 |       ],
18 |       imports: [
19 |         ModalModule.forRoot(),
20 |       ]
21 |     })
22 |       .compileComponents();
23 |   }));
24 | 
25 |   beforeEach(() => {
26 |     fixture = TestBed.createComponent(ModalConnectivityErrorComponent);
27 |     component = fixture.componentInstance;
28 |     fixture.detectChanges();
29 |   });
30 | 
31 |   it('should create', () => {
32 |     expect(component).toBeTruthy();
33 |   });
34 | });
35 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/nameservice/nameservice.service.stub.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { of } from 'rxjs';
 3 | 
 4 | @Injectable({
 5 |   providedIn: 'root'
 6 | })
 7 | export class NameserviceServiceStub {
 8 |   private addr = '0x0123456789012345678901234567890123456789';
 9 |   private addr2 = '0x0123456789abcdef0123456789abcdef01234567';
10 |   private addrNameLookup = 'myaddress.eth';
11 |   private addr2NameLookup = 'someaddress.myaddress.eth';
12 |   constructor(
13 |   ) {
14 |   }
15 | 
16 |   public resolveName(protocol, network, name) {
17 |     return of(
18 |       { body: { address: this.addr } }
19 |     )
20 |   };
21 | 
22 |   public resolveAddress(protocol, network, address) {
23 | 
24 |     let returnVals = {}
25 |     let addresses = [this.addr, this.addr2]
26 | 
27 |     returnVals[this.addr] = this.addrNameLookup
28 |     returnVals[this.addr2] = this.addr2NameLookup
29 |     if (addresses.includes(address)) {
30 | 
31 |       return of(
32 |         {
33 |           "body": { name: returnVals[address] },
34 |           "ok": true
35 |         }
36 |       )
37 |     } else {
38 |       return of({ "status": 404 })
39 |     }
40 |   }
41 | 
42 | }
43 | 
44 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/protocols/protocols.service.stub.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { of } from 'rxjs';
 3 | import { MailchainTestService } from 'src/app/test/test-helpers/mailchain-test.service';
 4 | 
 5 | @Injectable({
 6 |   providedIn: 'root'
 7 | })
 8 | export class ProtocolsServiceStub {
 9 | 
10 |   constructor(
11 |     private mailchainTestService: MailchainTestService
12 |   ) {
13 |   }
14 | 
15 |   /**
16 |    * Get and return the protocols configured on the api application
17 |    */
18 |   getProtocols() {
19 |     return of(this.mailchainTestService.protocolsServerResponse())
20 |   }
21 | 
22 |   getProtocolsByName() {
23 |     return ["ethereum", "substrate"]
24 |   }
25 | 
26 |   async getProtocolNetworkAttributes(protocol: string, network: string) {
27 |     let res = this.mailchainTestService.protocolsServerResponse()
28 |     let attributes = {}
29 |     let p = res["protocols"].find(el => el["name"] == protocol)
30 |     attributes = p["networks"].find(nw => nw["name"] == network)
31 |     return attributes
32 |   }
33 | 
34 |   public getProtocolsResponse() {
35 |     return of(this.mailchainTestService.protocolsObserveResponse())
36 |   }
37 | 
38 | }
39 | 


--------------------------------------------------------------------------------
/src/app/services/helpers/local-storage-protocol/local-storage-protocol.service.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { ProtocolsService } from '../../mailchain/protocols/protocols.service';
 3 | 
 4 | @Injectable({
 5 |   providedIn: 'root'
 6 | })
 7 | export class LocalStorageProtocolService {
 8 | 
 9 |   constructor(
10 |     private protocolsService: ProtocolsService,
11 |   ) { }
12 | 
13 |   /**
14 |    * Retrieves the current protocol for the application.
15 |    */
16 |   async getCurrentProtocol() {
17 | 
18 |     if (sessionStorage['currentProtocol'] && sessionStorage['currentProtocol'] != "undefined") {
19 |       return sessionStorage.getItem('currentProtocol')
20 |     } else {
21 |       var protocols = await this.protocolsService.getProtocolsByName()
22 | 
23 |       var protocol = ""
24 |       if (protocols.length) {
25 |         protocol = protocols.includes('ethereum') ? 'ethereum' : protocols[0]
26 |       }
27 | 
28 |       this.setCurrentProtocol(protocol)
29 |       return protocol
30 |     }
31 |   }
32 | 
33 |   /**
34 |    * Sets the current protocol for the user
35 |    * @param protocol is the protocol e.g. ethereum
36 |    */
37 |   setCurrentProtocol(protocol) {
38 |     sessionStorage.setItem('currentProtocol', protocol);
39 |   }
40 | 
41 | }
42 | 


--------------------------------------------------------------------------------
/src/test/invoice.txt:
--------------------------------------------------------------------------------
 1 | ------------------------------------------------------------------------------
 2 | Mailchain Demo Team                                              DRAFT INVOICE
 3 | team@mailchain.xyz
 4 | 
 5 |                                                                   Invoice #109
 6 |                                                            Date:  13 May, 2019
 7 | To:
 8 |     0x1234...4321
 9 | 
10 | ------------------------------------------------------------------------------
11 | | Quantity |         Description        | Unit Price |    Tax     |  Total   |
12 | ------------------------------------------------------------------------------
13 | | 1        | Awesome Demo               | 1.2    ETH | 0.24 ETH   | 1.44 ETH |
14 | | 2        | Cool Demo Services         | 0.3    ETH | 0.06 ETH   | 0.72 ETH |
15 | ------------------------------------------------------------------------------
16 |                                                             TOTAL | 2.16 ETH |
17 |                                                             ------------------
18 | 
19 | 
20 | Payment Instructions:
21 | 
22 |   Send payment within 30 days to:
23 |    mailchain.eth (0x4ad2b251246aafc2f3bdf3b690de3bf906622c51)
24 | 
25 | ------------------------------------------------------------------------------


--------------------------------------------------------------------------------
/src/app/pipes/address-pipe/address-pipe.pipe.ts:
--------------------------------------------------------------------------------
 1 | import { Pipe, PipeTransform } from '@angular/core';
 2 | 
 3 | import { MailchainService } from 'src/app/services/mailchain/mailchain.service';
 4 | import { AddressesService } from 'src/app/services/mailchain/addresses/addresses.service';
 5 | 
 6 | @Pipe({
 7 |   name: 'addressPipe',
 8 |   pure: false,
 9 | })
10 | 
11 | export class AddressPipe implements PipeTransform {
12 |   constructor(
13 |     private mailchainService: MailchainService,
14 |     private addressesService: AddressesService,
15 |   ) { }
16 | 
17 |   /**
18 |    * Filters and returns messages sent to a particular address using the 'to' field
19 |    * @param value array of messages
20 |    * @param args a hash: {
21 |       protocol: protocol_value,
22 |       address: address_value
23 |     }
24 |    */
25 |   transform(value: any, args: any): any {
26 | 
27 |     let protocol = args['protocol']
28 |     let fromAddress = this.addressesService.handleAddressFormattingByProtocol(args['address'], protocol);
29 | 
30 |     if (value) {
31 |       return value.filter(conversation => {
32 |         let toAddress = this.mailchainService.parseAddressFromMailchain(protocol, conversation["headers"]["to"])
33 |         
34 |         return fromAddress == this.addressesService.handleAddressFormattingByProtocol(toAddress, protocol);
35 |       });
36 |     }
37 |   }
38 | }
39 | 
40 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/messages/messages.service.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { HttpClient } from '@angular/common/http';
 3 | import { Observable } from 'rxjs';
 4 | import { LocalStorageServerService } from '../../helpers/local-storage-server/local-storage-server.service';
 5 | import { HttpHelpersService } from '../../helpers/http-helpers/http-helpers.service';
 6 | 
 7 | @Injectable({
 8 |   providedIn: 'root'
 9 | })
10 | export class MessagesService {
11 |   private url: string
12 | 
13 |   constructor(
14 |     private http: HttpClient,
15 |     private httpHelpersService: HttpHelpersService,
16 |     private localStorageServerService: LocalStorageServerService,
17 |   ) {
18 |     this.initServerDetails()
19 |   }
20 | 
21 |   /**
22 |    * Initialize URL from local storage
23 |    */
24 |   async initServerDetails() {
25 |     this.url = `${this.localStorageServerService.getCurrentServerDetails()}/api`
26 |   }
27 | 
28 |   /**
29 |  * Gets decrypted messages from api
30 |  */
31 |   getMessages(rcptAddress: string, protocol: string, network: string, fetch: boolean = true): Observable<any> {
32 |     var httpOptions = this.httpHelpersService.getHttpOptions([
33 |       ['protocol', protocol],
34 |       ['network', network],
35 |       ['address', rcptAddress],
36 |       ['fetch', fetch],
37 |     ])
38 | 
39 |     return this.http.get(
40 |       `${this.url}/messages`,
41 |       httpOptions
42 |     );
43 |   };
44 | 
45 | }
46 | 


--------------------------------------------------------------------------------
/src/app/services/helpers/http-helpers/http-helpers.service.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | 
 3 | import { HttpHeaders, HttpParams } from '@angular/common/http';
 4 | 
 5 | @Injectable()
 6 | export class HttpHelpersService {
 7 | 
 8 |   constructor() { }
 9 | 
10 |   /**
11 |    * Get the httpOptions for a request
12 |    * @param queryParams (optional) as array of arrays containing [['key', 'value']]
13 |    */
14 |   public getHttpOptions(queryParams?) {
15 |     let httpOptions = {
16 |       headers: new HttpHeaders({
17 |         'Content-Type': 'application/json',
18 |       }),
19 |       observe: "response",
20 |       params: new HttpParams()
21 |     };
22 |     // If we have params, set them and return the httpOptions:
23 |     return this.setParams(httpOptions, queryParams)
24 |   }
25 | 
26 |   /**
27 |    * Return the HttpParams object
28 |    * @param httpOptions httpOptions
29 |    * @param queryParams as array of arrays containing [['key', 'value']]
30 |    * e.g. [['status', 'open']] >> ?status=open
31 |    */
32 |   setParams(httpOptions, queryParams?) {
33 |     httpOptions.params = new HttpParams()
34 |     if (queryParams != undefined) {
35 |       queryParams.forEach(param => {
36 |         httpOptions.params = httpOptions.params.append(param[0], param[1]);
37 |       });
38 |     } else {
39 |       httpOptions.params = new HttpParams() // need to make sure params are not cached as strange things can happen
40 |     }
41 |     return httpOptions;
42 |   };
43 | 
44 | }
45 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/messages/send.service.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { HttpClient } from '@angular/common/http';
 3 | import { HttpHelpersService } from '../../helpers/http-helpers/http-helpers.service';
 4 | import { OutboundMail } from 'src/app/models/outbound-mail';
 5 | import { LocalStorageServerService } from '../../helpers/local-storage-server/local-storage-server.service';
 6 | 
 7 | @Injectable({
 8 |   providedIn: 'root'
 9 | })
10 | export class SendService {
11 |   private url: string
12 | 
13 |   constructor(
14 |     private http: HttpClient,
15 |     private httpHelpersService: HttpHelpersService,
16 |     private localStorageServerService: LocalStorageServerService,
17 |   ) {
18 |     this.initUrl()
19 |   }
20 | 
21 |   /**
22 |    * Initialize URL from local storage
23 |    */
24 |   async initUrl() {
25 |     this.url = `${this.localStorageServerService.getCurrentServerDetails()}/api`
26 |   }
27 | 
28 |   /**
29 |  * Sends a mail via the api
30 |  * @param outboundMail an outbound mail object
31 |  * @param network the network to send to (e.g. ropsten, mainnet etc.)
32 |  */
33 |   sendMail(outboundMail: OutboundMail, protocol: string, network: string) {
34 | 
35 |     var url = `${this.url}/messages`
36 |     var body = outboundMail
37 |     var httpOptions = this.httpHelpersService.getHttpOptions([
38 |       ['protocol', protocol],
39 |       ['network', network]
40 |     ])
41 | 
42 |     return this.http.post(url, body, httpOptions);
43 |   }
44 | 
45 | }
46 | 


--------------------------------------------------------------------------------
/src/app/services/helpers/error-messages/error-messages.ts:
--------------------------------------------------------------------------------
 1 | export const errorMessages = {
 2 |   // protocol configuration error
 3 |   "protocolConfigurationErrorTitle": "Mailchain Configuration Error",
 4 |   "protocolConfigurationErrorMessage": "<p>There are no protocols configured in the Mailchain client.</p><p>Run 'mailchain protocol help' in the console for further details or visit 'https://docs.mailchain.xyz/getting-started'",
 5 | 
 6 |   // account configuration error
 7 |   "accountConfigurationErrorTitle": "Mailchain Configuration Error",
 8 |   "accountConfigurationErrorMessage": "<p>There are no addresses configured in the Mailchain client.</p><p>Run 'mailchain account help' in the console for further details or visit 'https://docs.mailchain.xyz/getting-started'",
 9 | 
10 |   // client not running
11 |   "clientNotRunningErrorMessage": "<p>The Mailchain client does not seem to be running.</p><p>Please visit <a href=\"https://docs.mailchain.xyz/troubleshooting/common-inbox-errors\" target=\"_blank\">Docs: common inbox errors</a> to see how to fix this.</p>",
12 |   "clientNotRunningErrorTitle": "Error connecting to Mailchain client",
13 | 
14 |   // connection error
15 |   "connectionErrorTitle": "Connection Error",
16 | 
17 |   // unknown error
18 |   "unknownErrorMessage": "<p>An unknown error occurred.</p><p>Please raise an issue on <a href=\"https://github.com/mailchain/mailchain-web/issues\" target=\"_blank\">Github</a> to get some help.</p>",
19 |   "unknownErrorTitle": "Unknown Error",
20 | 
21 |   // update available
22 |   "updateAvailableTitle": "Update Available",
23 | 
24 | }


--------------------------------------------------------------------------------
/src/app/app.module.ts:
--------------------------------------------------------------------------------
 1 | import { BrowserModule } from '@angular/platform-browser';
 2 | import { NgModule } from '@angular/core';
 3 | 
 4 | import { AppRoutingModule } from './app-routing.module';
 5 | import { AppComponent } from './app.component';
 6 | 
 7 | import { BsDropdownModule } from 'ngx-bootstrap/dropdown';
 8 | import { ModalModule } from 'ngx-bootstrap/modal';
 9 | 
10 | import { HttpClientModule } from '@angular/common/http';
11 | import { HttpHelpersService } from './services/helpers/http-helpers/http-helpers.service';
12 | import { SearchPipe } from './pipes/search-pipe/search-pipe.pipe';
13 | import { AddressPipe } from './pipes/address-pipe/address-pipe.pipe';
14 | import { LocationStrategy, HashLocationStrategy, APP_BASE_HREF } from '@angular/common';
15 | import { ModalConnectivityErrorComponent } from './modals/modal-connectivity-error/modal-connectivity-error.component';
16 | import { SettingsComponent } from './settings/settings/settings.component';
17 | 
18 | @NgModule({
19 |   declarations: [
20 |     AppComponent,
21 |     SearchPipe,
22 |     AddressPipe,
23 |     ModalConnectivityErrorComponent,
24 |   ],
25 |   imports: [
26 |     AppRoutingModule,
27 |     BrowserModule,
28 |     BsDropdownModule.forRoot(),
29 |     ModalModule.forRoot(),
30 |     HttpClientModule,
31 |   ],
32 |   providers: [
33 |     HttpHelpersService,
34 |     { provide: APP_BASE_HREF, useValue: '/' },
35 |     { provide: LocationStrategy, useClass: HashLocationStrategy }
36 |   ],
37 |   entryComponents: [
38 |     ModalConnectivityErrorComponent
39 |   ],
40 |   bootstrap: [AppComponent]
41 | })
42 | export class AppModule { }
43 | 
44 | 
45 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/public-key/public-key.service.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { HttpClient } from '@angular/common/http';
 3 | import { LocalStorageServerService } from '../../helpers/local-storage-server/local-storage-server.service';
 4 | import { LocalStorageProtocolService } from '../../helpers/local-storage-protocol/local-storage-protocol.service';
 5 | import { HttpHelpersService } from '../../helpers/http-helpers/http-helpers.service';
 6 | 
 7 | @Injectable({
 8 |   providedIn: 'root'
 9 | })
10 | export class PublicKeyService {
11 |   private url: string
12 |   private protocol: string
13 | 
14 |   constructor(
15 |     private http: HttpClient,
16 |     private httpHelpersService: HttpHelpersService,
17 |     private localStorageServerService: LocalStorageServerService,
18 |     private localStorageProtocolService: LocalStorageProtocolService,
19 | 
20 |   ) {
21 |     this.initUrl()
22 |   }
23 | 
24 |   /**
25 |    * Initialize URL from local storage
26 |    */
27 |   async initUrl() {
28 |     this.url = `${this.localStorageServerService.getCurrentServerDetails()}/api`
29 |     this.protocol = await this.localStorageProtocolService.getCurrentProtocol()
30 | 
31 |   }
32 | 
33 |   /**
34 |    * Get the public key of a public address
35 |    */
36 |   getPublicKeyFromAddress(public_address, network) {
37 |     var httpOptions = this.httpHelpersService.getHttpOptions([
38 |       ['protocol', this.protocol],
39 |       ['network', network],
40 |       ['address', public_address],
41 |     ])
42 | 
43 |     return this.http.get(
44 |       `${this.url}/public-key`,
45 |       httpOptions
46 |       // TODO: handle failure
47 |     );
48 |   }
49 | 
50 | }


--------------------------------------------------------------------------------
/src/app/services/mailchain/messages/read.service.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { HttpClient } from '@angular/common/http';
 3 | import { HttpHelpersService } from '../../helpers/http-helpers/http-helpers.service';
 4 | import { LocalStorageServerService } from '../../helpers/local-storage-server/local-storage-server.service';
 5 | 
 6 | @Injectable({
 7 |   providedIn: 'root'
 8 | })
 9 | export class ReadService {
10 |   private url: string
11 | 
12 |   constructor(
13 |     private http: HttpClient,
14 |     private httpHelpersService: HttpHelpersService,
15 |     private localStorageServerService: LocalStorageServerService,
16 |   ) {
17 |     this.initUrl()
18 |   }
19 | 
20 |   /**
21 |    * Marks a message as read. This is stored locally in the client
22 |    * @param message_id The message Id to mark as read
23 |    */
24 |   markRead(message_id) {
25 |     var url = this.urlHelper(message_id)
26 |     var httpOptions = this.httpHelpersService.getHttpOptions()
27 |     return this.http.put(url, {}, httpOptions);
28 |   }
29 | 
30 |   /**
31 |    * Removes the read status for a message.
32 |    * @param message_id The message Id to mark as unread
33 |    */
34 |   markUnread(message_id) {
35 |     var url = this.urlHelper(message_id)
36 |     var httpOptions = this.httpHelpersService.getHttpOptions()
37 | 
38 |     return this.http.delete(url, httpOptions);
39 |   }
40 | 
41 |   /**
42 |  * Initialize URL from local storage
43 |  */
44 |   initUrl() {
45 |     this.url = `${this.localStorageServerService.getCurrentServerDetails()}/api`
46 |   }
47 | 
48 |   /**
49 |    * Inserts the message id into the api url endpoint
50 |    * @param message_id the message id to insert into url
51 |    */
52 |   urlHelper(message_id) {
53 |     return `${this.url}/messages/${message_id}/read`
54 |   }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/messages/messages.service.spec.ts:
--------------------------------------------------------------------------------
 1 | import { TestBed } from '@angular/core/testing';
 2 | 
 3 | import { MessagesService } from './messages.service';
 4 | import { HttpHelpersService } from '../../helpers/http-helpers/http-helpers.service';
 5 | import { HttpClientTestingModule } from '@angular/common/http/testing';
 6 | import { MailchainTestService } from 'src/app/test/test-helpers/mailchain-test.service';
 7 | import { LocalStorageServerService } from '../../helpers/local-storage-server/local-storage-server.service';
 8 | import { LocalStorageServerServiceStub } from '../../helpers/local-storage-server/local-storage-server.service.stub';
 9 | 
10 | describe('MessagesService', () => {
11 |   let messagesService: MessagesService;
12 |   let mailchainTestService: MailchainTestService;
13 | 
14 |   beforeEach(() => {
15 |     TestBed.configureTestingModule({
16 |       providers: [
17 |         MessagesService,
18 |         HttpHelpersService,
19 |         { provide: LocalStorageServerService, useClass: LocalStorageServerServiceStub },
20 |       ],
21 |       imports: [HttpClientTestingModule]
22 |     });
23 | 
24 |     messagesService = TestBed.inject(MessagesService);
25 |     mailchainTestService = TestBed.inject(MailchainTestService);
26 | 
27 |   });
28 | 
29 |   it('should be created', () => {
30 |     expect(messagesService).toBeTruthy();
31 |   });
32 | 
33 |   describe('initServerDetails', () => {
34 |     it('should initialize the url', () => {
35 |       let messagesService: MessagesService = TestBed.inject(MessagesService)
36 |       expect(messagesService['url']).toEqual('http://127.0.0.1:8080/api')
37 |     });
38 |   });
39 | 
40 |   describe('getMessages', () => {
41 |     xit('should initialize the protocol', () => {
42 |       //TODO: return messages stub
43 |     });
44 | 
45 | 
46 |   });
47 | });
48 | 


--------------------------------------------------------------------------------
/src/app/app-routing.module.ts:
--------------------------------------------------------------------------------
 1 | import { NgModule } from '@angular/core';
 2 | import { Routes, RouterModule, ExtraOptions } from '@angular/router';
 3 | import { InboxComponent } from './inbox/inbox.component';
 4 | import { FormsModule } from '@angular/forms';
 5 | import { CommonModule } from '@angular/common';
 6 | import { HttpHelpersService } from './services/helpers/http-helpers/http-helpers.service';
 7 | import { ModalModule } from 'ngx-bootstrap/modal';
 8 | import { CollapseModule } from 'ngx-bootstrap/collapse';
 9 | import { AccordionModule } from 'ngx-bootstrap/accordion';
10 | import { InboxComposeComponent } from './inbox/inbox-compose/inbox-compose.component';
11 | import { InboxMessageComponent } from './inbox/inbox-message/inbox-message.component';
12 | import { InboxMessagesComponent } from './inbox/inbox-messages/inbox-messages.component';
13 | import { CKEditorModule } from '@ckeditor/ckeditor5-angular';
14 | import { SettingsComponent } from './settings/settings/settings.component';
15 | 
16 | 
17 | const routes: Routes = [
18 |   { path: '', component: InboxComponent },
19 |   { path: 'settings', component: SettingsComponent }
20 | 
21 | ];
22 | 
23 | const routerOptions: ExtraOptions = {
24 |     anchorScrolling: 'enabled',
25 |     relativeLinkResolution: 'legacy'
26 | };
27 | 
28 | @NgModule({
29 |   declarations: [
30 |     InboxComponent,
31 |     InboxMessagesComponent,
32 |     InboxMessageComponent,
33 |     InboxComposeComponent,
34 |     SettingsComponent,
35 |   ],
36 |   imports: [
37 |     FormsModule,
38 |     AccordionModule.forRoot(),
39 |     CollapseModule.forRoot(),
40 |     ModalModule.forRoot(),
41 |     CommonModule,
42 |     CKEditorModule,
43 |     RouterModule.forRoot(routes, routerOptions)
44 |   ],
45 |   providers: [HttpHelpersService],
46 |   exports: [RouterModule]
47 | })
48 | export class AppRoutingModule { }
49 | 


--------------------------------------------------------------------------------
/src/app/services/helpers/local-storage-account/local-storage-account.service.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { AddressesService } from '../../mailchain/addresses/addresses.service';
 3 | import { LocalStorageProtocolService } from '../local-storage-protocol/local-storage-protocol.service';
 4 | import { LocalStorageServerService } from '../local-storage-server/local-storage-server.service';
 5 | 
 6 | @Injectable({
 7 |   providedIn: 'root'
 8 | })
 9 | export class LocalStorageAccountService {
10 | 
11 |   constructor(
12 |     private addressesService: AddressesService,
13 |     private localStorageProtocolService: LocalStorageProtocolService,
14 |     private localStorageServerService: LocalStorageServerService,
15 |   ) { }
16 | 
17 |   /**
18 |    * Retrieves the current account for the user. If no value is stored, it will try to fetch the first account listed
19 |    */
20 |   async getCurrentAccount() {
21 |     if (sessionStorage['currentAccount'] && sessionStorage['currentAccount'] != "undefined") {
22 |       return sessionStorage.getItem('currentAccount')
23 |     } else {
24 |       let protocol = await this.localStorageProtocolService.getCurrentProtocol()
25 |       let network = await this.localStorageServerService.getCurrentNetwork()
26 | 
27 |       var addresses = await this.addressesService.getAddresses(protocol, network);
28 | 
29 |       var address = addresses.length ? addresses[0] : ""
30 |       this.setCurrentAccount(address)
31 |       return address
32 |     }
33 |   }
34 | 
35 |   /**
36 |    * Sets the current account for the user
37 |    * @param address is the public address
38 |    */
39 |   setCurrentAccount(address) {
40 |     sessionStorage.setItem('currentAccount', address);
41 |   }
42 | 
43 |   /**
44 |    * Removes current account
45 |    */
46 |   removeCurrentAccount() {
47 |     sessionStorage.removeItem('currentAccount')
48 |   }
49 | 
50 | 
51 | }
52 | 


--------------------------------------------------------------------------------
/src/assets/question-circle-regular.svg:
--------------------------------------------------------------------------------
 1 | <svg width="35" height="35" xmlns="http://www.w3.org/2000/svg">
 2 |  <!-- Created with Method Draw - http://github.com/duopixel/Method-Draw/ -->
 3 | 
 4 |  <g>
 5 |   <title>background</title>
 6 |   <rect fill="none" id="canvas_background" height="37" width="37" y="-1" x="-1"/>
 7 |   <g display="none" overflow="visible" y="0" x="0" height="100%" width="100%" id="canvasGrid">
 8 |    <rect fill="url(#gridpattern)" stroke-width="0" y="1" x="1" height="400" width="580"/>
 9 |   </g>
10 |  </g>
11 |  <g>
12 |   <title>Layer 1</title>
13 |   <g fill="currentColor" id="svg_5">
14 |    <path id="svg_4" d="m17.500785,0.681949c-9.28799,0 -16.818575,7.533297 -16.818575,16.818575c0,9.290703 7.530585,16.818575 16.818575,16.818575s16.818575,-7.527872 16.818575,-16.818575c0,-9.285278 -7.530585,-16.818575 -16.818575,-16.818575zm0,30.381942c-7.49593,0 -13.563367,-6.064927 -13.563367,-13.563367c0,-7.493421 6.067708,-13.563367 13.563367,-13.563367c7.49315,0 13.563367,6.06764 13.563367,13.563367c0,7.495795 -6.064927,13.563367 -13.563367,13.563367zm7.272949,-17.306856c0,4.547254 -4.911363,4.617241 -4.911363,6.297675l0,0.429755c0,0.449422 -0.36438,0.813802 -0.813802,0.813802l-3.095635,0c-0.449422,0 -0.813802,-0.36438 -0.813802,-0.813802l0,-0.587226c0,-2.424113 1.837836,-3.393148 3.226657,-4.17182c1.190931,-0.667657 1.920844,-1.121758 1.920844,-2.005954c0,-1.169569 -1.491903,-1.945868 -2.698025,-1.945868c-1.572605,0 -2.298584,0.744425 -3.319092,2.032403c-0.275133,0.347222 -0.777181,0.411716 -1.130235,0.144043l-1.886936,-1.4308c-0.346341,-0.262587 -0.423923,-0.750461 -0.179308,-1.109687c1.602308,-2.352837 3.643188,-3.674655 6.820678,-3.674655c3.32784,0 6.880018,2.597656 6.880018,6.022135zm-4.424642,11.338975c0,1.57057 -1.277737,2.848307 -2.848307,2.848307s-2.848307,-1.277737 -2.848307,-2.848307s1.277737,-2.848307 2.848307,-2.848307s2.848307,1.277737 2.848307,2.848307z" fill="#cccccc"/>
15 |   </g>
16 |  </g>
17 | </svg>


--------------------------------------------------------------------------------
/src/app/services/helpers/local-storage-server/local-storage-server.service.stub.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { applicationApiConfig } from 'src/environments/environment';
 3 | 
 4 | @Injectable({
 5 |   providedIn: 'root'
 6 | })
 7 | export class LocalStorageServerServiceStub {
 8 |   public localStorageCurrentNetwork: string
 9 |   public localStorageCurrentWebProtocol: string
10 |   public localStorageCurrentHost: string
11 |   public localStorageCurrentPort: string
12 | 
13 |   public currentWebProtocol = 'http';
14 |   public currentHost = '127.0.0.1';
15 |   public currentPort = '8080';
16 | 
17 |   constructor(
18 |   ) { }
19 | 
20 |   getCurrentNetwork() {
21 |     if (sessionStorage['currentNetwork'] && sessionStorage['currentNetwork'] != "undefined") {
22 |       return sessionStorage.getItem('currentNetwork')
23 |     } else {
24 |       var networks = applicationApiConfig.networks
25 |       var network = networks.length ? networks[0] : ""
26 |       this.setCurrentNetwork(network)
27 |       return network
28 |     }
29 |   }
30 | 
31 |   setCurrentNetwork(network: string) {
32 |     this.localStorageCurrentNetwork = network
33 |   }
34 | 
35 |   removeCurrentNetwork() {
36 |     this.localStorageCurrentNetwork = undefined
37 |   }
38 | 
39 |   getCurrentWebProtocol() {
40 |     return this.localStorageCurrentWebProtocol
41 |   }
42 | 
43 |   setCurrentWebProtocol(webProtocol: string) {
44 |     this.localStorageCurrentWebProtocol = webProtocol
45 |   }
46 | 
47 |   getCurrentHost() {
48 |     return this.localStorageCurrentHost
49 |   }
50 | 
51 |   setCurrentHost(host: string) {
52 |     this.localStorageCurrentHost = host
53 |   }
54 | 
55 |   getCurrentPort() {
56 |     return this.localStorageCurrentPort
57 |   }
58 | 
59 |   setCurrentPort(port: string) {
60 |     this.localStorageCurrentPort = port
61 |   }
62 | 
63 |   getCurrentServerDetails() {
64 |     return `${this.currentWebProtocol}://${this.currentHost}:${this.currentPort}`
65 |   }
66 | 
67 | }
68 | 


--------------------------------------------------------------------------------
/src/karma.conf.js:
--------------------------------------------------------------------------------
 1 | // Karma configuration file, see link for more information
 2 | // https://karma-runner.github.io/1.0/config/configuration-file.html
 3 | 
 4 | module.exports = function (config) {
 5 |   config.set({
 6 |     basePath: '',
 7 |     frameworks: ['jasmine', '@angular-devkit/build-angular'],
 8 |     plugins: [
 9 |       require('karma-jasmine'),
10 |       require('karma-chrome-launcher'),
11 |       require('karma-jasmine-html-reporter'),
12 |       require('karma-coverage'),
13 |       require('karma-spec-reporter'),
14 |       require('@angular-devkit/build-angular/plugins/karma'),
15 |       require('karma-coveralls')
16 |     ],
17 |     client: {
18 |       clearContext: false // leave Jasmine Spec Runner output visible in browser
19 |     },
20 |     coverageReporter: {
21 |       dir: require('path').join(__dirname, '../coverage/mailchain-web'),
22 |       reporters: [
23 |         { type: 'html', subdir: 'report-html' },
24 |         { type: 'lcov', subdir: 'report-lcov' },
25 |         { type: 'text-summary' }
26 |       ],
27 |       fixWebpackSourcePaths: true
28 |     },
29 |     reporters: ['progress', 'kjhtml', 'coverage', 'coveralls'],
30 |     port: 9876,
31 |     colors: true,
32 |     logLevel: config.LOG_INFO,
33 |     autoWatch: true,
34 |     browsers: ['Chrome'],
35 |     singleRun: false,
36 |     customLaunchers: {
37 |       ChromeHeadlessNoSandbox: {
38 |         base: 'ChromeHeadless',
39 |         flags: ['--no-sandbox']
40 |       }
41 |     },
42 |     specReporter: {
43 |       // maxLogLines: 5,         // limit number of lines logged per test
44 |       // suppressErrorSummary: false,  // do not print error summary
45 |       // suppressPassed: true,  // do not print information about passed tests
46 |       // suppressFailed: false,  // do not print information about failed tests
47 |       // suppressSkipped: true,  // do not print information about skipped tests
48 |       // showSpecTiming: false // print the time elapsed for each spec
49 |     }
50 |   });
51 | };
52 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/addresses/addresses.service.stub.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { MailchainTestService } from 'src/app/test/test-helpers/mailchain-test.service';
 3 | import { LocalStorageServerService } from '../../helpers/local-storage-server/local-storage-server.service';
 4 | 
 5 | @Injectable({
 6 |   providedIn: 'root'
 7 | })
 8 | export class AddressesServiceStub {
 9 |   private url
10 | 
11 |   constructor(
12 |     private mailchainTestService: MailchainTestService,
13 |     private localStorageServerService: LocalStorageServerService
14 |   ) {
15 | 
16 |     this.initUrl()
17 |   }
18 | 
19 |   /**
20 |    * Initialize URL from local storage
21 |    */
22 |   async initUrl() {
23 |     this.url = `${this.localStorageServerService.getCurrentServerDetails()}/api`
24 |   }
25 | 
26 | 
27 |   async getAddresses(protocol, network) {
28 |     let addresses = []
29 |     let res: any
30 | 
31 |     switch (protocol) {
32 |       case 'ethereum':
33 |         res = this.mailchainTestService.senderAddressesEthereumObserveResponse()
34 |         break;
35 |       case 'substrate':
36 |         res = this.mailchainTestService.senderAddressesSubstrateObserveResponse()
37 |         break;
38 |       default:
39 |         break;
40 |     }
41 |     res["body"]["addresses"].forEach(address => {
42 |       addresses.push(
43 |         this.handleAddressFormatting(
44 |           address["value"],
45 |           address["encoding"]
46 |         )
47 |       )
48 |     });
49 |     return addresses
50 |   }
51 | 
52 |   handleAddressFormatting(address, encoding) {
53 |     switch (encoding) {
54 |       case 'hex/0x-prefix':
55 |         return address.toLowerCase()
56 |       case 'base58/plain':
57 |       default:
58 |         return address
59 |     }
60 |   }
61 | 
62 |   handleAddressFormattingByProtocol(address, protocol) {
63 |     switch (protocol) {
64 |       case 'ethereum':
65 |         return address.toLowerCase()
66 |       case 'substrate':
67 |       default:
68 |         return address
69 |     }
70 |   }
71 | 
72 | }
73 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/version/version.service.spec.ts:
--------------------------------------------------------------------------------
 1 | import { TestBed } from '@angular/core/testing';
 2 | import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
 3 | 
 4 | import { MailchainTestService } from 'src/app/test/test-helpers/mailchain-test.service';
 5 | 
 6 | import { VersionService } from './version.service';
 7 | 
 8 | describe('VersionService', () => {
 9 |   let versionService: VersionService;
10 |   let httpTestingController: HttpTestingController;
11 |   let mailchainTestService: MailchainTestService;
12 |   let serverResponse
13 | 
14 |   const desiredUrl = `http://127.0.0.1:8080/api/version`
15 | 
16 |   beforeEach(() => {
17 |     TestBed.configureTestingModule({
18 |       providers: [
19 |         VersionService,
20 |       ],
21 |       imports: [HttpClientTestingModule]
22 |     });
23 |     mailchainTestService = TestBed.inject(MailchainTestService);
24 | 
25 |     versionService = TestBed.inject(VersionService);
26 |     mailchainTestService = TestBed.inject(MailchainTestService);
27 |     httpTestingController = TestBed.inject(HttpTestingController);
28 | 
29 |     serverResponse = mailchainTestService.versionServerResponse()
30 |   });
31 | 
32 |   afterEach(() => {
33 |     httpTestingController.verify();
34 |   });
35 | 
36 |   it('should be created', () => {
37 |     const service: VersionService = TestBed.inject(VersionService);
38 |     expect(service).toBeTruthy();
39 |   });
40 | 
41 |   describe('initUrl', () => {
42 |     it('should initialize the url', () => {
43 |       let versionService: VersionService = TestBed.inject(VersionService)
44 |       expect(versionService['url']).toEqual('http://127.0.0.1:8080/api')
45 |     });
46 |   });
47 | 
48 |   it('should return version info', () => {
49 |     versionService.getVersion().subscribe(res => {
50 |       expect(res).toEqual(serverResponse)
51 |     });
52 | 
53 |     // handle open connections
54 |     const req = httpTestingController.expectOne(desiredUrl);
55 |     expect(req.request.method).toBe("GET");
56 |     req.flush(serverResponse);
57 |   });
58 | 
59 | });
60 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/protocols/protocols.service.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { HttpClient } from '@angular/common/http';
 3 | import { LocalStorageServerService } from '../../helpers/local-storage-server/local-storage-server.service';
 4 | import { HttpHelpersService } from '../../helpers/http-helpers/http-helpers.service';
 5 | 
 6 | @Injectable({
 7 |   providedIn: 'root'
 8 | })
 9 | export class ProtocolsService {
10 | 
11 |   private url: string
12 | 
13 |   constructor(
14 |     private http: HttpClient,
15 |     private httpHelpersService: HttpHelpersService,
16 |     private localStorageServerService: LocalStorageServerService,
17 |   ) {
18 |     this.initUrl()
19 |   }
20 | 
21 |   /**
22 |    * Initialize URL from local storage
23 |    */
24 |   initUrl() {
25 |     this.url = `${this.localStorageServerService.getCurrentServerDetails()}/api/protocols`
26 |   }
27 | 
28 |   /**
29 |    * Get and return the protocols configured on the api application
30 |    */
31 |   getProtocols() {
32 |     return this.http.get(this.url);
33 |   }
34 | 
35 |   /**
36 |    * Helper function to get and return the protocols by name
37 |    */
38 |   async getProtocolsByName() {
39 |     let protocols: Array<any>
40 |     await this.getProtocols().toPromise().then(res => {
41 |       protocols = res["protocols"].map(el => el["name"])
42 |     })
43 |     return protocols
44 |   }
45 | 
46 |   /**
47 |    * Helper function to get and return the protocol & network attributes
48 |    */
49 |   async getProtocolNetworkAttributes(protocol: string, network: string) {
50 |     let attributes = {}
51 |     await this.getProtocols().toPromise().then(res => {
52 |       let p = res["protocols"].find(el => el["name"] == protocol)
53 |       attributes = p["networks"].find(nw => nw["name"] == network)
54 |     })
55 |     return attributes
56 |   }
57 | 
58 |   /**
59 |    * Returns the protocols response with status codes
60 |    */
61 |   public getProtocolsResponse() {
62 |     var httpOptions = this.httpHelpersService.getHttpOptions()
63 | 
64 |     return this.http.get(
65 |       this.url,
66 |       httpOptions
67 |     )
68 |   }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/envelope/envelope.service.spec.ts:
--------------------------------------------------------------------------------
 1 | import { TestBed } from '@angular/core/testing';
 2 | import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
 3 | 
 4 | import { EnvelopeService } from './envelope.service';
 5 | 
 6 | import { MailchainTestService } from 'src/app/test/test-helpers/mailchain-test.service';
 7 | import { HttpHelpersService } from '../../helpers/http-helpers/http-helpers.service';
 8 | 
 9 | 
10 | describe('EnvelopeService', () => {
11 | 
12 |   let envelopeService: EnvelopeService;
13 |   let httpTestingController: HttpTestingController;
14 |   let mailchainTestService: MailchainTestService
15 |   let serverResponse
16 |   let expectedAddresses
17 | 
18 |   const desiredUrl = `http://127.0.0.1:8080/api/envelope`
19 | 
20 |   beforeEach(() => {
21 |     TestBed.configureTestingModule({
22 |       providers: [
23 |         EnvelopeService,
24 |         HttpHelpersService,
25 |       ],
26 |       imports: [HttpClientTestingModule]
27 |     });
28 | 
29 |     envelopeService = TestBed.inject(EnvelopeService);
30 |     mailchainTestService = TestBed.inject(MailchainTestService);
31 |     httpTestingController = TestBed.inject(HttpTestingController);
32 | 
33 |     serverResponse = mailchainTestService.envelopeTypesMultiple()
34 |   });
35 | 
36 |   afterEach(() => {
37 |     httpTestingController.verify();
38 |   });
39 | 
40 |   it('should be created', () => {
41 |     const service: EnvelopeService = TestBed.inject(EnvelopeService);
42 |     expect(service).toBeTruthy();
43 |   });
44 | 
45 | 
46 |   describe('initUrl', () => {
47 |     it('should initialize the url', () => {
48 |       expect(envelopeService['url']).toEqual('http://127.0.0.1:8080/api')
49 |     });
50 |   })
51 | 
52 |   it('should get an array of envelope types with their description', () => {
53 |     envelopeService.getEnvelope().then(res => {
54 |       expect(res).toEqual(serverResponse)
55 |     });
56 | 
57 |     // handle open connections
58 |     const req = httpTestingController.expectOne(desiredUrl);
59 |     expect(req.request.method).toBe("GET");
60 |     req.flush(serverResponse);
61 |   });
62 | 
63 | });
64 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "mailchain-web",
 3 |   "version": "0.0.16",
 4 |   "scripts": {
 5 |     "ng": "ng",
 6 |     "start": "ng serve",
 7 |     "build": "ng build --prod",
 8 |     "test": "ng test",
 9 |     "lint": "ng lint",
10 |     "e2e": "ng e2e"
11 |   },
12 |   "private": true,
13 |   "dependencies": {
14 |     "@angular/animations": "~11.2.0",
15 |     "@angular/common": "~11.2.0",
16 |     "@angular/compiler": "~11.2.0",
17 |     "@angular/core": "~11.2.0",
18 |     "@angular/forms": "~11.2.0",
19 |     "@angular/platform-browser": "~11.2.0",
20 |     "@angular/platform-browser-dynamic": "~11.2.0",
21 |     "@angular/router": "~11.2.0",
22 |     "@ckeditor/ckeditor5-angular": "^1.2.3",
23 |     "@ckeditor/ckeditor5-build-classic": "github:mailchain/ckeditor5-build-classic#mailchain_stable",
24 |     "core-js": "^2.6.12",
25 |     "bootstrap": "^4.6.0",
26 |     "ethereum-blockies-base64": "^1.0.2",
27 |     "font-awesome": "^4.7.0",
28 |     "glyphicons-halflings": "^1.9.1",
29 |     "jquery": "^3.5.1",
30 |     "ngx-bootstrap": "^3.2.0",
31 |     "popper.js": "^1.16.1",
32 |     "rxjs": "~6.6.3",
33 |     "semver": "^6.3.0",
34 |     "tslib": "^2.0.0",
35 |     "webpack": "^4.46.0",
36 |     "zone.js": "~0.10.2"
37 |   },
38 |   "devDependencies": {
39 |     "@angular-devkit/build-angular": "~0.1102.0",
40 |     "@angular/cli": "^11.2.0",
41 |     "@angular/compiler-cli": "~11.2.0",
42 |     "@angular/language-service": "~11.2.0",
43 |     "@babel/compat-data": "~7.8.0",
44 |     "@types/jasmine": "~3.6.0",
45 |     "@types/jasminewd2": "~2.0.3",
46 |     "@types/node": "^12.11.1",
47 |     "codelyzer": "^6.0.0",
48 |     "elliptic": "^6.5.3",
49 |     "jasmine-core": "~3.6.0",
50 |     "jasmine-spec-reporter": "~5.0.0",
51 |     "karma": "^6.1.1",
52 |     "karma-chrome-launcher": "~3.1.0",
53 |     "karma-coverage": "^2.0.3",
54 |     "karma-coveralls": "^2.1.0",
55 |     "karma-jasmine": "~4.0.0",
56 |     "karma-jasmine-html-reporter": "^1.5.0",
57 |     "karma-spec-reporter": "0.0.32",
58 |     "protractor": "~7.0.0",
59 |     "sass-loader": "^7.1.0",
60 |     "ts-node": "~7.0.0",
61 |     "tslint": "~6.1.0",
62 |     "typescript": "~4.0.7"
63 |   }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/app/services/helpers/local-storage-protocol/local-storage-protocol.service.spec.ts:
--------------------------------------------------------------------------------
 1 | import { TestBed } from '@angular/core/testing';
 2 | 
 3 | import { LocalStorageProtocolService } from './local-storage-protocol.service';
 4 | import { HttpClientModule } from '@angular/common/http';
 5 | import { MailchainTestService } from 'src/app/test/test-helpers/mailchain-test.service';
 6 | import { of } from 'rxjs';
 7 | import { ProtocolsService } from '../../mailchain/protocols/protocols.service';
 8 | import { ProtocolsServiceStub } from '../../mailchain/protocols/protocols.service.stub';
 9 | 
10 | describe('LocalStorageProtocolService', () => {
11 |   let localStorageProtocolService: LocalStorageProtocolService;
12 |   let mailchainTestService: MailchainTestService;
13 | 
14 |   beforeEach(() => {
15 |     TestBed.configureTestingModule({
16 |       providers: [
17 |         LocalStorageProtocolService,
18 |         { provide: ProtocolsService, useClass: ProtocolsServiceStub },
19 |       ],
20 |       imports: [HttpClientModule]
21 |     });
22 | 
23 |     localStorageProtocolService = TestBed.inject(LocalStorageProtocolService);
24 |     mailchainTestService = TestBed.inject(MailchainTestService);
25 | 
26 |   });
27 | 
28 |   afterEach(() => {
29 |     sessionStorage.clear();
30 |   })
31 | 
32 |   it('should be created', () => {
33 |     expect(localStorageProtocolService).toBeTruthy();
34 |   });
35 | 
36 |   describe('getCurrentProtocol', () => {
37 |     it('should retrieve the currentProtocol when NO value is stored', async () => {
38 |       expect(await localStorageProtocolService.getCurrentProtocol()).toEqual(mailchainTestService.protocolsServerResponse()["protocols"][1]["name"])
39 |     });
40 | 
41 |     it('should retrieve the currentProtocol when a value is stored', async () => {
42 |       sessionStorage.setItem('currentProtocol', 'newChain');
43 |       expect(await localStorageProtocolService.getCurrentProtocol()).toEqual('newChain')
44 |     });
45 |   });
46 | 
47 |   describe('setCurrentProtocol', () => {
48 |     it('should set the current protocol', async () => {
49 |       expect(await localStorageProtocolService.getCurrentProtocol()).not.toEqual('newerChain')
50 |       localStorageProtocolService.setCurrentProtocol('newerChain')
51 |       expect(await localStorageProtocolService.getCurrentProtocol()).toEqual('newerChain')
52 |     });
53 |   });
54 | });
55 | 


--------------------------------------------------------------------------------
/src/app/services/helpers/http-helpers/http-helpers.service.spec.ts:
--------------------------------------------------------------------------------
 1 | import { TestBed } from '@angular/core/testing';
 2 | import { HttpHelpersService } from './http-helpers.service';
 3 | import { HttpHeaders, HttpParams } from '@angular/common/http';
 4 | 
 5 | let queryParams = [['myKey', 'myValue'], ['anotherKey', 'anotherValue']]
 6 | 
 7 | describe('HttpHelpersService', () => {
 8 |   let httpHelpersService: HttpHelpersService;
 9 | 
10 |   beforeEach(() => {
11 |     TestBed.configureTestingModule({
12 |       providers: [HttpHelpersService]
13 |     });
14 | 
15 |     httpHelpersService = TestBed.inject(HttpHelpersService);
16 |   });
17 | 
18 | 
19 |   it('should be created', () => {
20 |     expect(httpHelpersService).toBeTruthy();
21 |   });
22 | 
23 |   describe('getHttpOptions', () => {
24 |     it('should have a header: Content-Type equal to application/json', () => {
25 |       expect(httpHelpersService.getHttpOptions().headers.get('Content-Type')).toEqual('application/json')
26 |     })
27 | 
28 |     it('should get the httpOptions without query params', () => {
29 |       expect(httpHelpersService.getHttpOptions().params.keys()).toEqual([])
30 |     });
31 | 
32 | 
33 |     it('should get the httpOptions with query params', () => {
34 |       expect(httpHelpersService.getHttpOptions(queryParams).params.keys()).toEqual(['myKey', 'anotherKey'])
35 |       expect(httpHelpersService.getHttpOptions(queryParams).params.toString()).toEqual('myKey=myValue&anotherKey=anotherValue')
36 |       expect(httpHelpersService.getHttpOptions(queryParams).params.get('myKey')).toEqual('myValue')
37 |     })
38 |   });
39 | 
40 |   describe('setParams', () => {
41 |     it('should return httpOptions from setParams without query params', () => {
42 |       let httpOptions = {};
43 |       let expectedObj = new HttpParams
44 | 
45 |       expect(httpHelpersService.setParams(httpOptions).params).toEqual(expectedObj)
46 |     })
47 |     it('should return httpOptions from setParams with query params', () => {
48 |       let httpOptions = {};
49 | 
50 |       expect(httpHelpersService.setParams(httpOptions, queryParams).params.keys()).toEqual(['myKey', 'anotherKey'])
51 | 
52 |       expect(httpHelpersService.setParams(httpOptions, queryParams).params.toString()).toEqual('myKey=myValue&anotherKey=anotherValue')
53 | 
54 |       expect(httpHelpersService.setParams(httpOptions, queryParams).params.get('myKey')).toEqual('myValue')
55 | 
56 |     })
57 |   });
58 | 
59 | });
60 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/nameservice/nameservice.service.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { HttpClient } from '@angular/common/http';
 3 | import { HttpHelpersService } from '../../helpers/http-helpers/http-helpers.service';
 4 | 
 5 | import { LocalStorageServerService } from '../../helpers/local-storage-server/local-storage-server.service';
 6 | import { LocalStorageNameserviceService } from '../../helpers/local-storage-nameservice/local-storage-nameservice.service';
 7 | import { observable, Observable } from 'rxjs';
 8 | 
 9 | @Injectable({
10 |   providedIn: 'root'
11 | })
12 | export class NameserviceService {
13 |   private url: string
14 |   private protocol: string
15 | 
16 |   constructor(
17 |     private http: HttpClient,
18 |     private httpHelpersService: HttpHelpersService,
19 |     private localStorageServerService: LocalStorageServerService,
20 |     private localStorageNameserviceService: LocalStorageNameserviceService,
21 |   ) {
22 |     this.initUrl()
23 |   }
24 | 
25 |   /**
26 |    * Initialize URL from local storage
27 |    */
28 |   initUrl() {
29 |     this.url = `${this.localStorageServerService.getCurrentServerDetails()}/api`
30 |   }
31 | 
32 |   /**
33 |    * Get address (e.g. 0x...) from name (e.g. alice.eth).
34 |   * @param name the name to lookup
35 |    */
36 |   public async resolveName(protocol, network, name) {
37 |     if (await this.localStorageNameserviceService.getCurrentNameserviceDomainEnabled() == "true") {
38 |       var httpOptions = this.httpHelpersService.getHttpOptions([
39 |         ['protocol', protocol],
40 |         ['network', network],
41 |       ])
42 |   
43 |       return this.http.get(
44 |         this.url + `/nameservice/name/${name}/resolve`,
45 |         httpOptions
46 |         // TODO: handle failure
47 |       );
48 |     } else {
49 |       console.warn("resolveName", protocol, network, name);
50 |       return new Observable
51 |     };
52 |   };
53 | 
54 |   /**
55 |    * Get name (e.g. alice.eth) from address (e.g. 0x...).
56 |    * @param address the public address
57 |    */
58 |   public async resolveAddress(protocol, network, address) {
59 |     if (await this.localStorageNameserviceService.getCurrentNameserviceAddressEnabled() == "true") {
60 |       var httpOptions = this.httpHelpersService.getHttpOptions([
61 |         ['protocol', protocol],
62 |         ['network', network],
63 |       ])
64 | 
65 |       return this.http.get(
66 |         this.url + `/nameservice/address/${address}/resolve`,
67 |         httpOptions
68 |         // TODO: handle failure
69 |       );
70 |     } else {
71 |       console.warn("resolveAddress", protocol, network, address);
72 |       return new Observable
73 |     };
74 |   }
75 | 
76 | }
77 | 
78 | 


--------------------------------------------------------------------------------
/src/app/pipes/search-pipe/search-pipe.pipe.spec.ts:
--------------------------------------------------------------------------------
 1 | import { SearchPipe } from './search-pipe.pipe';
 2 | import { TestBed } from '@angular/core/testing';
 3 | 
 4 | let pipe: SearchPipe
 5 | 
 6 | const addr1 = '0x7777777777777777777777777777777777777777'
 7 | const addr2 = '0x4444444444444444444444444444444444444444'
 8 | 
 9 | const messages = [
10 |   {
11 |     "headers": {
12 |       "date": "2019-06-07T14:53:36Z",
13 |       "from": "\u003c" + addr1 + '@testnet.ethereum\u003e',
14 |       "to": "\u003c" + addr2 + '@testnet.ethereum\u003e',
15 |       "message-id": "001"
16 |     },
17 |     "body": "This is a body to be found",
18 |     "subject": "This is a subject NOT to be found"
19 |   },
20 |   {
21 |     "headers": {
22 |       "date": "2019-06-07T14:53:36Z",
23 |       "from": "\u003c" + addr2 + '@testnet.ethereum\u003e',
24 |       "to": "\u003c" + addr1 + '@testnet.ethereum\u003e',
25 |       "message-id": "002"
26 |     },
27 |     "body": "This is a body NOT to be found",
28 |     "subject": "This is a subject to be found"
29 |   }
30 | ]
31 | 
32 | describe('SearchPipe', () => {
33 |   beforeEach(() => {
34 |     TestBed.configureTestingModule({
35 |       providers: [
36 |         SearchPipe
37 |       ],
38 |       imports: []
39 |     });
40 | 
41 |     pipe = TestBed.inject(SearchPipe);
42 |   });
43 | 
44 |   it('should create an instance', () => {
45 |     expect(pipe).toBeTruthy();
46 |   });
47 | 
48 |   it('should search the "sender" field', () => {
49 |     let result = [
50 |       messages[0],
51 |     ]
52 | 
53 |     expect(pipe.transform(messages, addr1).length).toEqual(1);
54 |     expect(pipe.transform(messages, addr1)).toEqual(result);
55 |   })
56 | 
57 |   it('should search the "subject" field', () => {
58 |     let result = [
59 |       messages[1],
60 |     ]
61 |     let str = "This is a subject to be found"
62 |     expect(pipe.transform(messages, str).length).toEqual(1);
63 |     expect(pipe.transform(messages, str)).toEqual(result);
64 |   })
65 | 
66 |   it('should search the "body" field', () => {
67 |     let result = [
68 |       messages[0],
69 |     ]
70 |     let str = "This is a body to be found"
71 |     expect(pipe.transform(messages, str).length).toEqual(1);
72 |     expect(pipe.transform(messages, str)).toEqual(result);
73 |   })
74 | 
75 |   it('should NOT search the "to" field', () => {
76 |     let result = [
77 |       messages[1]
78 |     ]
79 | 
80 |     expect(pipe.transform(messages, addr1).length).not.toEqual(2);
81 |     expect(pipe.transform(messages, addr1)).not.toEqual(result);
82 |   })
83 | 
84 |   it('should NOT search the "date" field', () => {
85 |     let result = [
86 |       messages[1],
87 |     ]
88 |     let str = messages[1]["headers"]["date"]
89 | 
90 |     expect(pipe.transform(messages, str).length).toEqual(0);
91 |     expect(pipe.transform(messages, str)).toEqual([]);
92 | 
93 |   })
94 | });
95 | 


--------------------------------------------------------------------------------
/src/app/services/helpers/local-storage-account/local-storage-account.service.spec.ts:
--------------------------------------------------------------------------------
 1 | import { TestBed, waitForAsync } from '@angular/core/testing';
 2 | 
 3 | import { LocalStorageAccountService } from './local-storage-account.service';
 4 | import { HttpClientModule } from '@angular/common/http';
 5 | import { AddressesService } from '../../mailchain/addresses/addresses.service';
 6 | import { AddressesServiceStub } from '../../mailchain/addresses/addresses.service.stub';
 7 | import { ProtocolsService } from '../../mailchain/protocols/protocols.service';
 8 | import { ProtocolsServiceStub } from '../../mailchain/protocols/protocols.service.stub';
 9 | 
10 | describe('LocalStorageAccountService', () => {
11 | 
12 |   let localStorageAccountService: LocalStorageAccountService;
13 |   const currentAccount = '0x92d8f10248c6a3953cc3692a894655ad05d61efb';
14 | 
15 |   const newAddr = '0x12345678901234567890123456789012'
16 | 
17 |   beforeEach(() => {
18 |     TestBed.configureTestingModule({
19 |       providers: [
20 |         LocalStorageAccountService,
21 |         { provide: AddressesService, useClass: AddressesServiceStub },
22 |         { provide: ProtocolsService, useClass: ProtocolsServiceStub },
23 |       ],
24 |       imports: [HttpClientModule]
25 |     });
26 | 
27 |     localStorageAccountService = TestBed.inject(LocalStorageAccountService);
28 |   });
29 | 
30 |   afterEach(() => {
31 |     sessionStorage.clear();
32 |   })
33 | 
34 |   it('should be created', () => {
35 |     expect(localStorageAccountService).toBeTruthy();
36 |   });
37 | 
38 |   describe('getCurrentAccount', () => {
39 |     it('should retrieve the currentAccount when NO value is stored', async () => {
40 |       expect(await localStorageAccountService.getCurrentAccount()).toEqual(currentAccount);
41 |     });
42 | 
43 |     it('should retrieve the currentAccount when a value is stored', async () => {
44 |       sessionStorage.setItem('currentAccount', newAddr);
45 |       expect(await localStorageAccountService.getCurrentAccount()).toEqual(newAddr);
46 |     });
47 |   });
48 | 
49 |   describe('setCurrentAccount', () => {
50 |     it('should set the current network', async () => {
51 |       expect(await localStorageAccountService.getCurrentAccount()).not.toEqual(newAddr)
52 |       localStorageAccountService.setCurrentAccount(newAddr)
53 |       expect(await localStorageAccountService.getCurrentAccount()).toEqual(newAddr)
54 |     });
55 |   });
56 | 
57 |   describe('removeCurrentAccount', () => {
58 |     it('should remove the current network', async () => {
59 |       localStorageAccountService.setCurrentAccount(newAddr)
60 |       expect(await localStorageAccountService.getCurrentAccount()).toEqual(newAddr)
61 |       localStorageAccountService.removeCurrentAccount()
62 |       expect(await localStorageAccountService.getCurrentAccount()).toEqual(currentAccount);
63 |     });
64 |   });
65 | });


--------------------------------------------------------------------------------
/src/app/pipes/address-pipe/address-pipe.pipe.spec.ts:
--------------------------------------------------------------------------------
 1 | import { TestBed } from '@angular/core/testing';
 2 | import { AddressPipe } from './address-pipe.pipe';
 3 | import { HttpClientTestingModule } from '@angular/common/http/testing';
 4 | import { HttpHelpersService } from 'src/app/services/helpers/http-helpers/http-helpers.service';
 5 | 
 6 | let pipe: AddressPipe
 7 | 
 8 | const addr1 = '0x0000000000000000000000000000000000000000'
 9 | const addr2 = '0x0123456789abcdef0123456789abcdef01234567'
10 | const addr3 = '0x1111111111111111111111111111111111111111'
11 | 
12 | const messages = [
13 |   {
14 |     "headers": {
15 |       "from": "\u003c" + addr1 + '@testnet.ethereum\u003e',
16 |       "to": "\u003c" + addr2 + '@testnet.ethereum\u003e',
17 |       "message-id": "001"
18 |     },
19 |     "body": "",
20 |     "subject": "Msg 1: 1 sends to 2"
21 |   },
22 |   {
23 |     "headers": {
24 |       "from": "\u003c" + addr2 + '@testnet.ethereum\u003e',
25 |       "to": "\u003c" + addr1 + '@testnet.ethereum\u003e',
26 |       "message-id": "002"
27 |     },
28 |     "body": "",
29 |     "subject": "Msg 2: 2 sends to 1"
30 |   },
31 |   {
32 |     "headers": {
33 |       "from": "\u003c" + addr1 + '@testnet.ethereum\u003e',
34 |       "to": "\u003c" + addr2 + '@testnet.ethereum\u003e',
35 |       "message-id": "003"
36 |     },
37 |     "body": "",
38 |     "subject": "Msg 1: 1 sends to 2 again"
39 |   },
40 | ]
41 | 
42 | describe('AddressPipe', () => {
43 |   beforeEach(() => {
44 |     TestBed.configureTestingModule({
45 |       providers: [
46 |         AddressPipe,
47 |         HttpHelpersService,
48 |       ],
49 |       imports: [
50 |         HttpClientTestingModule,
51 |       ]
52 |     });
53 | 
54 |     pipe = TestBed.inject(AddressPipe);
55 |   });
56 | 
57 |   it('should create an instance', () => {
58 |     expect(pipe).toBeTruthy();
59 |   });
60 | 
61 |   it('should return filtered messages when 1 message has been sent to an address', () => {
62 |     let args = { 'protocol': 'ethereum', 'address': addr1 }
63 |     let result = [
64 |       messages[1],
65 |     ]
66 |     expect(pipe.transform(messages, args).length).toEqual(1);
67 |     expect(pipe.transform(messages, args)).toEqual(result);
68 |   });
69 | 
70 |   it('should return filtered messages when >1 message has been sent to an address', () => {
71 |     let args = { 'protocol': 'ethereum', 'address': addr2 }
72 |     let result = [
73 |       messages[0],
74 |       messages[2],
75 |     ]
76 | 
77 |     expect(pipe.transform(messages, args).length).toEqual(2);
78 |     expect(pipe.transform(messages, args)).toEqual(result);
79 |   });
80 | 
81 |   it('should return empty array when no messages exist for address', () => {
82 |     let args = { 'protocol': 'ethereum', 'address': addr3 }
83 |     let result = []
84 |     expect(pipe.transform(messages, args).length).toEqual(0);
85 |     expect(pipe.transform(messages, args)).toEqual(result);
86 |   });
87 | 
88 | });
89 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/addresses/addresses.service.ts:
--------------------------------------------------------------------------------
  1 | import { Injectable } from '@angular/core';
  2 | import { HttpClient } from '@angular/common/http';
  3 | import { LocalStorageServerService } from '../../helpers/local-storage-server/local-storage-server.service';
  4 | import { HttpHelpersService } from '../../helpers/http-helpers/http-helpers.service';
  5 | 
  6 | @Injectable({
  7 |   providedIn: 'root'
  8 | })
  9 | export class AddressesService {
 10 | 
 11 |   private url: string
 12 | 
 13 |   constructor(
 14 |     private http: HttpClient,
 15 |     private httpHelpersService: HttpHelpersService,
 16 |     private localStorageServerService: LocalStorageServerService,
 17 |   ) {
 18 |     this.initUrl()
 19 |   }
 20 | 
 21 |   /**
 22 |    * Initialize URL from local storage
 23 |    */
 24 |   async initUrl() {
 25 |     this.url = `${this.localStorageServerService.getCurrentServerDetails()}/api`
 26 |   }
 27 | 
 28 |   /**
 29 |    * Get and return the public addresses from my wallet to send from
 30 |    */
 31 |   async getAddresses(protocol, network) {
 32 |     var httpOptions = this.httpHelpersService.getHttpOptions([
 33 |       ['protocol', protocol],
 34 |       ['network', network]
 35 |     ])
 36 | 
 37 |     var addresses = []
 38 |     let res = await this.http.get(
 39 |       this.url + `/addresses`,
 40 |       httpOptions
 41 |       // TODO handle failure
 42 |     ).toPromise();
 43 | 
 44 |     res["body"]["addresses"].forEach(address => {
 45 |       addresses.push(
 46 |         this.handleAddressFormatting(
 47 |           address["value"],
 48 |           address["encoding"]
 49 |         )
 50 |       )
 51 |     });
 52 |     return addresses
 53 |   }
 54 | 
 55 |   /**
 56 |    * handleAddressFormatting
 57 |    * @param address 
 58 |    * @param encoding "hex/0x-prefix" | "base58/plain"
 59 |    */
 60 |   handleAddressFormatting(address, encoding) {
 61 |     switch (encoding) {
 62 |       case 'hex/0x-prefix':
 63 |         return address.toLowerCase()
 64 |       case 'base58/plain':
 65 |         return address
 66 |       default:
 67 |         return address
 68 |     }
 69 |   }
 70 | 
 71 |   /**
 72 |    * handleAddressFormattingByProtocol
 73 |    * @param address 
 74 |    * @param protocol "ethereum" | "substrate""
 75 |    */
 76 |   handleAddressFormattingByProtocol(address, protocol) {
 77 | 
 78 |     switch (protocol) {
 79 |       case 'ethereum':
 80 |         return address.toLowerCase()
 81 |       case 'substrate':
 82 |         return address
 83 |       default:
 84 |         return address
 85 |     }
 86 |   }
 87 | 
 88 |   /**
 89 |    * Returns the addresses response with status codes
 90 |    */
 91 |   public getAddressesResponse(protocol, network) {
 92 |     var httpOptions = this.httpHelpersService.getHttpOptions([
 93 |       ['protocol', protocol],
 94 |       ['network', network]
 95 |     ])
 96 | 
 97 |     return this.http.get(
 98 |       this.url + `/addresses`,
 99 |       httpOptions
100 |     )
101 |   }
102 | 
103 | }
104 | 


--------------------------------------------------------------------------------
/src/polyfills.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * This file includes polyfills needed by Angular and is loaded before the app.
 3 |  * You can add your own extra polyfills to this file.
 4 |  *
 5 |  * This file is divided into 2 sections:
 6 |  *   1. Browser polyfills. These are applied before loading ZoneJS and are sorted by browsers.
 7 |  *   2. Application imports. Files imported after ZoneJS that should be loaded before your main
 8 |  *      file.
 9 |  *
10 |  * The current setup is for so-called "evergreen" browsers; the last versions of browsers that
11 |  * automatically update themselves. This includes Safari >= 10, Chrome >= 55 (including Opera),
12 |  * Edge >= 13 on the desktop, and iOS 10 and Chrome on mobile.
13 |  *
14 |  * Learn more in https://angular.io/guide/browser-support
15 |  */
16 | 
17 | /***************************************************************************************************
18 |  * BROWSER POLYFILLS
19 |  */
20 | 
21 | /** IE10 and IE11 requires the following for NgClass support on SVG elements */
22 | // import 'classlist.js';  // Run `npm install --save classlist.js`.
23 | 
24 | /**
25 |  * Web Animations `@angular/platform-browser/animations`
26 |  * Only required if AnimationBuilder is used within the application and using IE/Edge or Safari.
27 |  * Standard animation support in Angular DOES NOT require any polyfills (as of Angular 6.0).
28 |  */
29 | // import 'web-animations-js';  // Run `npm install --save web-animations-js`.
30 | 
31 | /**
32 |  * By default, zone.js will patch all possible macroTask and DomEvents
33 |  * user can disable parts of macroTask/DomEvents patch by setting following flags
34 |  * because those flags need to be set before `zone.js` being loaded, and webpack
35 |  * will put import in the top of bundle, so user need to create a separate file
36 |  * in this directory (for example: zone-flags.ts), and put the following flags
37 |  * into that file, and then add the following code before importing zone.js.
38 |  * import './zone-flags.ts';
39 |  *
40 |  * The flags allowed in zone-flags.ts are listed here.
41 |  *
42 |  * The following flags will work for all browsers.
43 |  *
44 |  * (window as any).__Zone_disable_requestAnimationFrame = true; // disable patch requestAnimationFrame
45 |  * (window as any).__Zone_disable_on_property = true; // disable patch onProperty such as onclick
46 |  * (window as any).__zone_symbol__UNPATCHED_EVENTS = ['scroll', 'mousemove']; // disable patch specified eventNames
47 |  *
48 |  *  in IE/Edge developer tools, the addEventListener will also be wrapped by zone.js
49 |  *  with the following flag, it will bypass `zone.js` patch for IE/Edge
50 |  *
51 |  *  (window as any).__Zone_enable_cross_context_check = true;
52 |  *
53 |  */
54 | 
55 | /***************************************************************************************************
56 |  * Zone JS is required by default for Angular itself.
57 |  */
58 | import 'zone.js/dist/zone';  // Included with Angular CLI.
59 | 
60 | 
61 | /***************************************************************************************************
62 |  * APPLICATION IMPORTS
63 |  */
64 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/messages/read.service.spec.ts:
--------------------------------------------------------------------------------
 1 | import { TestBed } from '@angular/core/testing';
 2 | import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
 3 | import { HttpHelpersService } from '../../helpers/http-helpers/http-helpers.service';
 4 | 
 5 | import { ReadService } from './read.service';
 6 | 
 7 | describe('ReadService', () => {
 8 |   let readService: ReadService;
 9 |   let httpTestingController: HttpTestingController;
10 | 
11 |   const message_id = "32eb5d3bdb59a0a3f30e29d4b4073c960b47"
12 |   const desiredUrl = `http://127.0.0.1:8080/api/messages/${message_id}/read`
13 | 
14 | 
15 |   beforeEach(() => {
16 |     TestBed.configureTestingModule({
17 |       providers: [
18 |         ReadService,
19 |         HttpHelpersService,
20 |       ],
21 |       imports: [HttpClientTestingModule]
22 |     });
23 | 
24 |     readService = TestBed.inject(ReadService);
25 |     httpTestingController = TestBed.inject(HttpTestingController);
26 | 
27 |   });
28 | 
29 |   afterEach(() => {
30 |     httpTestingController.verify();
31 |   });
32 | 
33 |   it('should be created', () => {
34 |     expect(readService).toBeTruthy();
35 |   });
36 | 
37 |   describe('markRead', () => {
38 | 
39 |     it('should return 200 code when PUT is used to mark unread message as read', () => {
40 |       let response = readService.markRead(message_id)
41 | 
42 |       response.subscribe(res => {
43 |         expect(res["url"]).toEqual(desiredUrl)
44 |         expect(res["status"]).toEqual(200)
45 |       })
46 | 
47 |       // handle open connections
48 |       const req = httpTestingController.expectOne(desiredUrl);
49 |       expect(req.request.method).toBe("PUT");
50 |       req.flush(response);
51 | 
52 |     });
53 |   });
54 | 
55 |   describe('markUnread', () => {
56 |     it('should return 200 code when DELETE is used to mark a read message as unread', () => {
57 |       let response = readService.markUnread(message_id)
58 | 
59 |       response.subscribe(res => {
60 |         expect(res["url"]).toEqual(desiredUrl)
61 |         expect(res["status"]).toEqual(200)
62 |       })
63 | 
64 |       // handle open connections
65 |       const req = httpTestingController.expectOne(desiredUrl);
66 |       expect(req.request.method).toBe("DELETE");
67 |       req.flush(response);
68 |     });
69 |   });
70 | 
71 |   describe('urlHelper', () => {
72 |     it('should return the correct url given a message id', () => {
73 | 
74 |       let response = readService.urlHelper(message_id)
75 | 
76 |       expect(response).toEqual(desiredUrl);
77 |     });
78 |   });
79 | 
80 |   describe('initUrl', () => {
81 |     it('should initialize the url', () => {
82 |       let readService: ReadService = TestBed.inject(ReadService)
83 |       expect(readService['url']).toEqual('http://127.0.0.1:8080/api')
84 |     });
85 |   })
86 | 
87 |   describe('urlHelper', () => {
88 |     it('should return the url containing the message id', () => {
89 |       let readService: ReadService = TestBed.inject(ReadService)
90 |       expect(readService.urlHelper("12345")).toEqual('http://127.0.0.1:8080/api/messages/12345/read')
91 |     });
92 |   })
93 | 
94 | 
95 | 
96 | 
97 | });
98 | 


--------------------------------------------------------------------------------
/src/app/inbox/inbox-messages/inbox-messages.component.html:
--------------------------------------------------------------------------------
 1 | <div class="row">
 2 |   <div class="col-sm-6">
 3 |     <div class="btn-group">
 4 |       <a class="btn btn-outline-secondary btn-sm dropdown-toggle" href="#" data-toggle="dropdown">
 5 |         Select
 6 |       </a>
 7 |       <ul class="dropdown-menu">
 8 |         <li><a class="dropdown-item" (click)="selectAll()">All</a></li>
 9 |         <li><a class="dropdown-item" (click)="selectNone()">None</a></li>
10 |         <li class="dropdown-divider"></li>
11 |         <li><a class="dropdown-item" (click)="selectRead()">Read</a></li>
12 |         <li><a class="dropdown-item" (click)="selectUnread()">Unread</a></li>
13 |       </ul>
14 |     </div>
15 |     <div class="btn-group">
16 |       <a class="btn btn-sm btn-outline-secondary dropdown-toggle" href="#" data-toggle="dropdown">
17 |         Actions
18 |       </a>
19 |       <ul class="dropdown-menu">
20 |         <li><a class="dropdown-item" (click)="markSelectedAsRead()">Mark As Read</a></li>
21 |         <li><a class="dropdown-item" (click)="markSelectedAsUnread()">Mark As Unread</a></li>
22 |       </ul>
23 |     </div>
24 |   </div>
25 |   <div class="col-sm-6">
26 |     <input class="form-control form-control-sm float-right" [(ngModel)]="searchText"
27 |       (ngModelChange)="getCurrentAccountInboxMessages()" type="text" placeholder="Search Messages">
28 |   </div>
29 | </div>
30 | 
31 | <div class="widget-body" id="mailbox-content">
32 |   <table class="table table-striped table-hover" id="messages-table" #messagesTable
33 |     attr.data-value="{{currentAccountInboxMessages}}">
34 |     <tbody>
35 |       <tr *ngFor="let mail of currentAccountInboxMessages" [ngClass]="{'unread': !mail.read}">
36 |         <td>
37 |           <div class="form-check">
38 |             <input class="form-check-input" type="checkbox" id="checkbox{{mail.headers['message-id']}}"
39 |               [checked]="mail.selected" (click)="selectMail(mail)">
40 |             <label class="form-check-label" attr.for="checkbox{{mail.headers['message-id']}}"></label>
41 |           </div>
42 |         </td>
43 |         <td class="d-none d-md-block" (click)="openMail(mail,messagesTable.attributes['data-value'].value)">
44 | 
45 |           <!-- Name defined -->
46 |           <span *ngIf="messagesNameRecords[parseAddressFromMailchain(mail.headers.from)] != undefined">
47 | 
48 |             <span class="resolved-name">{{messagesNameRecords[parseAddressFromMailchain(mail.headers.from)]}}</span>
49 | 
50 |             <br>
51 | 
52 |             <span class="resolved-address text-muted">{{mail.headers.from}}</span>
53 | 
54 |           </span>
55 |           <!-- ./ Name defined -->
56 | 
57 |           <!-- Name not defined -->
58 |           <span class="unresolved-address"
59 |             *ngIf="messagesNameRecords[parseAddressFromMailchain(mail.headers.from)] == undefined">
60 |             <br>
61 |             {{mail.headers.from}}
62 |           </span>
63 |           <!-- ./ Name not defined -->
64 | 
65 |         </td>
66 |         <td class="subject" (click)="openMail(mail)">{{mail.subject}}</td>
67 |         <td class="">{{mail.headers.date}}</td>
68 |       </tr>
69 |       <tr *ngIf="messagesLoaded && (currentAccountInboxMessages).length == 0">
70 |         <td colspan="12">
71 |           Nothing here yet
72 |         </td>
73 |       </tr>
74 |       <tr *ngIf="!messagesLoaded">
75 |         <td colspan="12">
76 |           Loading...
77 |         </td>
78 |       </tr>
79 |     </tbody>
80 |   </table>
81 | </div>


--------------------------------------------------------------------------------
/src/app/services/mailchain/public-key/public-key.service.spec.ts:
--------------------------------------------------------------------------------
 1 | import { TestBed } from '@angular/core/testing';
 2 | 
 3 | import { PublicKeyService } from './public-key.service';
 4 | import { HttpHelpersService } from '../../helpers/http-helpers/http-helpers.service';
 5 | import { LocalStorageProtocolService } from '../../helpers/local-storage-protocol/local-storage-protocol.service';
 6 | import { ProtocolsService } from '../protocols/protocols.service';
 7 | import { ProtocolsServiceStub } from '../protocols/protocols.service.stub';
 8 | import { HttpClientTestingModule } from '@angular/common/http/testing';
 9 | import { PublicKeyServiceStub } from './public-key.service.stub';
10 | import { of } from 'rxjs';
11 | import { MailchainTestService } from 'src/app/test/test-helpers/mailchain-test.service';
12 | 
13 | describe('PublicKeyService', () => {
14 |   let publicKeyService: PublicKeyService;
15 |   let mailchainTestService: MailchainTestService
16 | 
17 |   beforeEach(() => {
18 |     TestBed.configureTestingModule({
19 |       providers: [
20 |         LocalStorageProtocolService,
21 |         HttpHelpersService,
22 |         PublicKeyService,
23 |         { provide: ProtocolsService, useClass: ProtocolsServiceStub },
24 |       ],
25 |       imports: [HttpClientTestingModule]
26 |     });
27 | 
28 |     publicKeyService = TestBed.inject(PublicKeyService);
29 |     mailchainTestService = TestBed.inject(MailchainTestService);
30 |   });
31 | 
32 |   it('should be created', () => {
33 |     expect(publicKeyService).toBeTruthy();
34 |   });
35 | 
36 |   describe('getPublicKeyFromAddress', () => {
37 |     beforeEach(() => {
38 |       spyOn(publicKeyService, 'getPublicKeyFromAddress').and.returnValue(
39 |         of(mailchainTestService.publicKeyHexZeroXResponse())
40 |       )
41 |     });
42 |     it('should return `public-key`', async () => {
43 |       let result
44 |       await publicKeyService.getPublicKeyFromAddress("0x0123456789abcdef0123456789abcdef01234567", "ropsten").subscribe(res => {
45 |         result = res["body"]
46 |       })
47 |       expect(result["public-key"]).toBe("0x1234567890")
48 |       expect(publicKeyService.getPublicKeyFromAddress).toHaveBeenCalled()
49 |     });
50 |     it('should return `public-key-encoding`', async () => {
51 |       let result
52 |       await publicKeyService.getPublicKeyFromAddress("0x0123456789abcdef0123456789abcdef01234567", "ropsten").subscribe(res => {
53 |         result = res["body"]
54 |       })
55 |       expect(result["public-key-encoding"]).toBe("hex/0x-prefix")
56 |       expect(publicKeyService.getPublicKeyFromAddress).toHaveBeenCalled()
57 |     });
58 |     it('should return `public-key-kind`', async () => {
59 |       let result
60 |       await publicKeyService.getPublicKeyFromAddress("0x0123456789abcdef0123456789abcdef01234567", "ropsten").subscribe(res => {
61 |         result = res["body"]
62 |       })
63 |       expect(result["public-key-kind"]).toBe("secp256k1")
64 |       expect(publicKeyService.getPublicKeyFromAddress).toHaveBeenCalled()
65 |     });
66 |     it('should return `supported-encryption-types`', async () => {
67 |       let result
68 |       await publicKeyService.getPublicKeyFromAddress("0x0123456789abcdef0123456789abcdef01234567", "ropsten").subscribe(res => {
69 |         result = res["body"]
70 |       })
71 |       expect(result["supported-encryption-types"]).toEqual(["aes256cbc", "noop"])
72 |       expect(publicKeyService.getPublicKeyFromAddress).toHaveBeenCalled()
73 |     });
74 | 
75 |   });
76 | });
77 | 


--------------------------------------------------------------------------------
/3RD-PARTY-LICENSES.md:
--------------------------------------------------------------------------------
 1 | # License overview of included 3rd party libraries
 2 | 
 3 | The Mailchain Web project is licensed under the terms of the [Apache 2.0](./LICENSE).
 4 | 
 5 | However, Mailchain Web includes several third-party Open-Source libraries, which are licensed under their own respective Open-Source licenses.
 6 | 
 7 | Click here to see [![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)
 8 | 
 9 | ## Other License Information For Packages Included In Mailchain Web
10 | 
11 | ### CKEditor 5
12 | 
13 | License: LGPL / GPLv2 / MPL
14 | http://ckeditor.com/license
15 | 
16 | Notes:
17 | CKEDITOR extends its license under a 'FREE FOR OPEN SOURCE LICENSE AGREEMENT' under the following conditions:
18 | 
19 | #### 1 License
20 | 
21 | CKSource hereby grants to the Customer a non-exclusive, revocable, royalty free, worldwide license (the “License”) to embed the Software as part of the Project, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense such Combined Software product to the Customer’s customers and sublicensees (the “Sublicensees”) and to permit the Sublicensees herein, subject to the conditions specified in the Section 2 License Conditions.
22 | 
23 | All rights of any kind to the Software which are not expressly granted under this Agreement, are entirely and exclusively reserved by CKSource.
24 | 
25 | For the avoidance of doubt, the Agreement does not grant to the Customer any rights to the Premium Features (Comments plug-in for CKEditor 5; Track Changes plug-in for CKEditor 5; Letters; CKEditor Cloud Services; CKEditor Cloud Services On-Premises), however both parties may enter into relevant agreement regulating granting such rights.
26 | 
27 | #### 2 License Conditions
28 | 
29 | (i) the Customer must provide its Sublicensees with the following legal notice:
30 | THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL CKSOURCE OR ITS LICENSORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
31 | 
32 | (ii) the Customer shall not develop any software nor provide services which may constitute a competitive product and/or services to the Software and to the Premium Features. The restriction indicated in the preceding sentence do not apply to the Sublicensees.
33 | 
34 | #### 3 No Warranties and Support
35 | 
36 | CKSource makes no representations or warranties, express or implied, regarding the Software. CKSource does not provide any support for the Software.
37 | 
38 | UNDER THIS AGREEMENT, THE SOFTWARE IS PROVIDED “AS-IS” WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OR WARRANTIES THAT IT IS FREE OF DEFECTS OR VIRUSES. IN NO EVENT SHALL CKSOURCE OR ITS RESPECTIVE LICENSORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
39 | 
40 | The entire risk relating to the quality and performance of the Software licensed under this Agreement is borne by the Customer. The Customer has no right to claim any indemnification based on the Customer’s or Sublicensees use of the Software licensed under this Agreement.
41 | 


--------------------------------------------------------------------------------
/tslint.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "extends": "tslint:recommended",
  3 |   "rulesDirectory": [
  4 |     "codelyzer"
  5 |   ],
  6 |   "rules": {
  7 |     "align": {
  8 |       "options": [
  9 |         "parameters",
 10 |         "statements"
 11 |       ]
 12 |     },
 13 |     "array-type": false,
 14 |     "arrow-parens": false,
 15 |     "arrow-return-shorthand": true,
 16 |     "deprecation": {
 17 |       "severity": "warn"
 18 |     },
 19 |     "curly": true,
 20 |     "import-blacklist": [
 21 |       true,
 22 |       "rxjs/Rx"
 23 |     ],
 24 |     "interface-name": false,
 25 |     "eofline": true,
 26 |     "max-classes-per-file": false,
 27 |     "import-spacing": true,
 28 |     "indent": {
 29 |       "options": [
 30 |         "spaces"
 31 |       ]
 32 |     },
 33 |     "max-line-length": [
 34 |       true,
 35 |       140
 36 |     ],
 37 |     "member-access": false,
 38 |     "member-ordering": [
 39 |       true,
 40 |       {
 41 |         "order": [
 42 |           "static-field",
 43 |           "instance-field",
 44 |           "static-method",
 45 |           "instance-method"
 46 |         ]
 47 |       }
 48 |     ],
 49 |     "no-consecutive-blank-lines": false,
 50 |     "no-console": [
 51 |       true,
 52 |       "debug",
 53 |       "info",
 54 |       "time",
 55 |       "timeEnd",
 56 |       "trace"
 57 |     ],
 58 |     "no-empty": false,
 59 |     "no-inferrable-types": [
 60 |       true,
 61 |       "ignore-params"
 62 |     ],
 63 |     "no-non-null-assertion": true,
 64 |     "no-redundant-jsdoc": true,
 65 |     "no-switch-case-fall-through": true,
 66 |     "no-var-requires": false,
 67 |     "object-literal-key-quotes": [
 68 |       true,
 69 |       "as-needed"
 70 |     ],
 71 |     "object-literal-sort-keys": false,
 72 |     "ordered-imports": false,
 73 |     "quotemark": [
 74 |       true,
 75 |       "single"
 76 |     ],
 77 |     "trailing-comma": false,
 78 |     "no-output-on-prefix": true,
 79 |     "no-inputs-metadata-property": true,
 80 |     "no-outputs-metadata-property": true,
 81 |     "no-host-metadata-property": true,
 82 |     "no-input-rename": true,
 83 |     "no-output-rename": true,
 84 |     "use-lifecycle-interface": true,
 85 |     "semicolon": {
 86 |       "options": [
 87 |         "always"
 88 |       ]
 89 |     },
 90 |     "space-before-function-paren": {
 91 |       "options": {
 92 |         "anonymous": "never",
 93 |         "asyncArrow": "always",
 94 |         "constructor": "never",
 95 |         "method": "never",
 96 |         "named": "never"
 97 |       }
 98 |     },
 99 |     "use-pipe-transform-interface": true,
100 |     "typedef-whitespace": {
101 |       "options": [
102 |         {
103 |           "call-signature": "nospace",
104 |           "index-signature": "nospace",
105 |           "parameter": "nospace",
106 |           "property-declaration": "nospace",
107 |           "variable-declaration": "nospace"
108 |         },
109 |         {
110 |           "call-signature": "onespace",
111 |           "index-signature": "onespace",
112 |           "parameter": "onespace",
113 |           "property-declaration": "onespace",
114 |           "variable-declaration": "onespace"
115 |         }
116 |       ]
117 |     },
118 |     "component-class-suffix": true,
119 |     "directive-class-suffix": true,
120 |     "variable-name": {
121 |       "options": [
122 |         "ban-keywords",
123 |         "check-format",
124 |         "allow-pascal-case"
125 |       ]
126 |     },
127 |     "whitespace": {
128 |       "options": [
129 |         "check-branch",
130 |         "check-decl",
131 |         "check-operator",
132 |         "check-separator",
133 |         "check-type",
134 |         "check-typecast"
135 |       ]
136 |     }
137 |   }
138 | }


--------------------------------------------------------------------------------
/src/app/inbox/inbox-message/inbox-message.component.html:
--------------------------------------------------------------------------------
 1 | <div class="clearfix mb-xs">
 2 |   <a class="btn btn-outline-secondary btn-sm float-left" id="back-btn" (click)="returnToInboxMessages()">
 3 |     <i class="fa fa-angle-left fa-lg"></i> Back To Messages
 4 |   </a>
 5 | </div>
 6 | <hr>
 7 | <div>
 8 |   <h4>{{currentMessage.subject}}</h4>
 9 |   <div class="message-actions float-right">
10 |     <div class="message-action">
11 |       <button class="btn btn-sm btn-outline-secondary" type="button" (click)="modalWindowMailInfo.show()">
12 |         <i class="fa fa-info-circle"></i>
13 |       </button>
14 |     </div>
15 | 
16 |     <div class="message-action">
17 |       <div class="btn-group">
18 |         <button id="reply" class="btn btn-sm btn-outline-secondary" (click)="replyToMsg()">
19 |           <i class="fa fa-reply"></i> Reply
20 |         </button>
21 |       </div>
22 |     </div>
23 |   </div>
24 | </div>
25 | <div id="message" class="clearfix">
26 |   <div id="message-header">
27 |     <span class="float-left">
28 |       <img class="rounded-circle message-identicon" src="{{currentMessage.senderIdenticon}}" alt="">
29 |     </span>
30 |     <div class="float-left">
31 |       <!-- From name defined -->
32 |       <span *ngIf="messageNameRecords[parseAddressFromMailchain(currentMessage.headers.from)] != undefined">
33 |         <span>
34 |           From:&nbsp;{{messageNameRecords[parseAddressFromMailchain(currentMessage.headers.from)]}}
35 |         </span>
36 |         <br>
37 |         <span>{{currentMessage.headers.from}}</span>
38 |       </span>
39 |       <!-- ./ From name defined -->
40 |       <!-- From name not defined -->
41 |       <span *ngIf="messageNameRecords[parseAddressFromMailchain(currentMessage.headers.from)] == undefined">
42 |         <span>From:&nbsp;{{currentMessage.headers.from}}</span>
43 |       </span>
44 |       <!-- ./ From name not defined -->
45 |       <br>
46 |       <!-- To name defined -->
47 |       <span class="message-to"
48 |         *ngIf="messageNameRecords[parseAddressFromMailchain(currentMessage.headers.to)] != undefined">
49 |         <span>
50 |           To:&nbsp;{{messageNameRecords[parseAddressFromMailchain(currentMessage.headers.to)]}}
51 |         </span>
52 |         <br>
53 |         <span>{{currentMessage.headers.to}}</span>
54 |       </span>
55 |       <!-- ./ To name defined -->
56 |       <!-- To name not defined -->
57 |       <span class="message-to"
58 |         *ngIf="messageNameRecords[parseAddressFromMailchain(currentMessage.headers.to)] == undefined">
59 |         <span>To:&nbsp;{{currentMessage.headers.to}}</span>
60 |       </span>
61 |       <!-- ./ To name not defined -->
62 |     </div>
63 |     <div class="float-right">
64 |       {{currentMessage.headers.date}}
65 |     </div>
66 |   </div>
67 | </div>
68 | <hr>
69 | 
70 | <div id="message-frame" class="message-body-container"></div>
71 | 
72 | 
73 | <!-- modalWindowMailInfo -->
74 | <div bsModal #modalWindowMailInfo="bs-modal" class="modal fade" tabindex="-1" role="dialog" aria-hidden="true">
75 |   <div class="modal-dialog modal-lg">
76 |     <div class="modal-content">
77 |       <div class="modal-header flex-column">
78 |         <button (click)="modalWindowMailInfo.hide()" aria-label="Close" class="close ml-auto" type="button">
79 |           <span aria-hidden="true">×</span>
80 |         </button>
81 |         <div class="col-12 text-center">
82 |           <h3 class="modal-title" id="mailModal">Raw Message Details</h3>
83 |         </div>
84 |       </div>
85 |       <div class="modal-body">
86 |         <pre>{{currentMessage | json}}</pre>
87 |       </div>
88 |       <div class="modal-footer">
89 |         <button type="button" class="btn btn-outline-secondary" (click)="modalWindowMailInfo.hide()">Close</button>
90 |       </div>
91 |     </div>
92 |   </div>
93 | </div>
94 | <!-- end modalWindowMailInfo -->


--------------------------------------------------------------------------------
/src/app/inbox/inbox.component.html:
--------------------------------------------------------------------------------
 1 | <div class="row">
 2 |   <div class="col-md-6">
 3 |     <h1 class="page-title text-primary">
 4 |       <img src="../../assets/mailchain_logo_text.png" alt="Mailchain" class="header-logo">
 5 |     </h1>
 6 |   </div>
 7 |   <div class="col-md-6">
 8 |     <div class="row">
 9 |       <div class="col">
10 |         <div class="mb-s mt-2 pull-right">
11 |           <a class="btn btn-outline-primary btn-sm float-left ml-2" id="settings-btn" routerLink="settings">
12 |             <i class="fa fa-cog"></i>&nbsp;
13 |             Settings
14 |           </a>
15 |         </div>
16 |       </div>
17 |     </div>
18 |   </div>
19 | </div>
20 | <div class="row">
21 |   <div class="col-lg-4 col-xl-3 col-12">
22 |     <div id="actionButtons" class="mb-4">
23 |       <button class="btn btn-secondary btn-block" type="button" id="fetch-messages-btn" (click)="getMails(false)"
24 |         [disabled]="fetchMessagesDisabled">{{fetchMessagesText}}</button>
25 |       <button class="btn btn-primary btn-block" type="button" id="compose" (click)="composeMessage()">Compose</button>
26 |     </div>
27 | 
28 |     <div class="card">
29 |       <div class="card-header">
30 |         Addresses
31 |       </div>
32 |       <ul class="list-group list-group-flush">
33 |         <li *ngFor="let address of fromAddressesKeys"
34 |           [class]="addressIsActive(address) ? 'list-group-item account-item active' : 'list-group-item account-item'">
35 |           <div class="row">
36 |             <div class="col-2 p-0 my-auto">
37 |               <a class="nav-link" (click)="changeAccount(address)">
38 |                 <img class="rounded-circle addressFolderIcon" src="{{accountIdenticons[address]}}" alt="">
39 |               </a>
40 |             </div>
41 |             <div class="col-9 p-0 my-auto">
42 |               <a class="nav-link" (click)="changeAccount(address)">{{address}}</a>
43 |               <span class="nav-link accountNameRecord"
44 |                 *ngIf="accountNameRecord[address]">({{accountNameRecord[address]}})</span>
45 |             </div>
46 |             <div class="col-1 p-0 my-auto">
47 |               <a class="nav-link" (click)="changeAccount(address)">
48 |                 <span *ngIf="messagesLoaded"
49 |                   [class]="fromAddresses[address]['messageCount']['inbox'] > 0 ? 'badge badge-pill badge-secondary float-right' : 'badge badge-pill badge-light float-right text-muted'">
50 |                   {{fromAddresses[address]['messageCount']['inbox']}}
51 |                 </span>
52 |                 <span *ngIf="!messagesLoaded" class="badge badge-pill badge-light float-right text-muted">
53 |                   ...
54 |                 </span>
55 |               </a>
56 |             </div>
57 |           </div>
58 |         </li>
59 |       </ul>
60 |     </div>
61 |   </div>
62 | 
63 | 
64 |   <div *ngIf="inboxPartial == 'messages'" inbox-messages class="col-lg-8 col-xl-9 col-12"
65 |     [messagesLoaded]="messagesLoaded" [currentAccount]="currentAccount" [inboxMessages]="inboxMessages"
66 |     [currentProtocol]="currentProtocol" [currentNetwork]="currentNetwork" (openMessage)="onOpenMessage($event)"
67 |     (inboxCounter)="onInboxCounter($event)"></div>
68 | 
69 |   <div *ngIf="inboxPartial == 'message'" inbox-message class="col-lg-8 col-xl-9 col-12"
70 |     [currentMessage]="currentMessage" [inboxMessages]="inboxMessages" [currentProtocol]="currentProtocol"
71 |     [currentNetwork]="currentNetwork" (replyToMessage)="composeMessage($event)"
72 |     (goToInboxMessages)="changeView('messages')"></div>
73 | 
74 |   <div *ngIf="inboxPartial == 'compose'" inbox-compose class="col-lg-8 col-xl-9 col-12"
75 |     [currentAccount]="currentAccount" [currentMessage]="currentMessage" [currentNetwork]="currentNetwork"
76 |     [currentProtocol]="currentProtocol" (openMessage)="onOpenMessage($event)"
77 |     (goToInboxMessages)="changeView('messages')"></div>
78 | 
79 | 
80 | </div>


--------------------------------------------------------------------------------
/src/app/services/helpers/local-storage-server/local-storage-server.service.ts:
--------------------------------------------------------------------------------
  1 | import { Injectable } from '@angular/core';
  2 | import { applicationApiConfig } from 'src/environments/environment';
  3 | 
  4 | @Injectable({
  5 |   providedIn: 'root'
  6 | })
  7 | export class LocalStorageServerService {
  8 | 
  9 |   constructor(
 10 |   ) { }
 11 | 
 12 |   /**
 13 |    * Retrieves the current network. If no value is stored, it will try to fetch the first network from the environment config
 14 |    */
 15 |   getCurrentNetwork() {
 16 | 
 17 |     if (sessionStorage['currentNetwork'] && sessionStorage['currentNetwork'] != "undefined") {
 18 |       return sessionStorage.getItem('currentNetwork')
 19 |     } else {
 20 |       var networks = applicationApiConfig.networks
 21 |       var network = networks.length ? networks[0] : ""
 22 |       this.setCurrentNetwork(network)
 23 |       return network
 24 |     }
 25 |   }
 26 | 
 27 |   /**
 28 |    * Sets the current network for the user
 29 |    * @param network is the public network
 30 |    */
 31 |   setCurrentNetwork(network: string) {
 32 |     sessionStorage.setItem('currentNetwork', network);
 33 |   }
 34 | 
 35 |   /**
 36 |    * Removes current network
 37 |    */
 38 |   removeCurrentNetwork() {
 39 |     sessionStorage.removeItem('currentNetwork')
 40 |   }
 41 | 
 42 |   /**
 43 |    * Retrieves the current web protocol for the mailchain application. If no value is stored, it will return the default web protocol set in environment.ts
 44 |    */
 45 |   getCurrentWebProtocol() {
 46 | 
 47 |     if (sessionStorage['currentWebProtocol'] && sessionStorage['currentWebProtocol'] != "undefined") {
 48 |       return sessionStorage.getItem('currentWebProtocol')
 49 |     } else {
 50 |       var webProtocol = applicationApiConfig.mailchainNodeBaseWebProtocol
 51 |       this.setCurrentWebProtocol(webProtocol)
 52 |       return webProtocol
 53 |     }
 54 |   }
 55 | 
 56 |   /**
 57 |    * Sets the current web protocol for the mailchain application
 58 |    * @param webProtocol is the server web protocol e.g. http or https
 59 |    */
 60 |   setCurrentWebProtocol(webProtocol: string) {
 61 |     sessionStorage.setItem('currentWebProtocol', webProtocol);
 62 |   }
 63 | 
 64 |   /**
 65 |    * Retrieves the current host for the mailchain application. If no value is stored, it will return the default host set in environment.ts
 66 |    */
 67 |   getCurrentHost() {
 68 |     if (sessionStorage['currentHost'] && sessionStorage['currentHost'] != "undefined") {
 69 |       return sessionStorage.getItem('currentHost')
 70 |     } else {
 71 |       var host = applicationApiConfig.mailchainNodeBaseHost
 72 |       this.setCurrentHost(host)
 73 |       return host
 74 |     }
 75 |   }
 76 | 
 77 |   /**
 78 |    * Sets the current host for the mailchain application
 79 |    * @param host is the server host e.g. 127.0.0.1
 80 |    */
 81 |   setCurrentHost(host: string) {
 82 |     sessionStorage.setItem('currentHost', host);
 83 |   }
 84 | 
 85 |   /**
 86 |    * Retrieves the current port for the mailchain application. If no value is stored, it will return the default port set in environment.ts
 87 |    */
 88 |   getCurrentPort() {
 89 | 
 90 |     if (sessionStorage['currentPort'] && sessionStorage['currentPort'] != "undefined") {
 91 |       return sessionStorage.getItem('currentPort')
 92 |     } else {
 93 |       var port = applicationApiConfig.mailchainNodeBasePort
 94 |       this.setCurrentPort(port)
 95 |       return port
 96 |     }
 97 |   }
 98 | 
 99 |   /**
100 |    * Sets the current port for the mailchain application
101 |    * @param port is the server port e.g. 8080
102 |    */
103 |   setCurrentPort(port: string) {
104 |     sessionStorage.setItem('currentPort', port);
105 |   }
106 | 
107 |   /**
108 |    * Gets the server `protocol`, `host` & `port`
109 |    */
110 |   getCurrentServerDetails() {
111 |     return `${this.getCurrentWebProtocol()}://${this.getCurrentHost()}:${this.getCurrentPort()}`
112 |   }
113 | 
114 | }
115 | 


--------------------------------------------------------------------------------
/src/app/services/helpers/local-storage-nameservice/local-storage-nameservice.service.ts:
--------------------------------------------------------------------------------
 1 | import { Injectable } from '@angular/core';
 2 | import { ProtocolsService } from '../../mailchain/protocols/protocols.service';
 3 | import { LocalStorageProtocolService } from '../local-storage-protocol/local-storage-protocol.service';
 4 | import { LocalStorageServerService } from '../local-storage-server/local-storage-server.service';
 5 | 
 6 | @Injectable({
 7 |   providedIn: 'root'
 8 | })
 9 | export class LocalStorageNameserviceService {
10 | 
11 |   constructor(
12 |     private protocolsService: ProtocolsService,
13 |     private localStorageProtocolService: LocalStorageProtocolService,
14 |     private localStorageServerService: LocalStorageServerService,
15 |   ) { }
16 | 
17 |   /**
18 |    * Gets the current nameservice address lookup enabled status.
19 |    * If no value exists, it attempts to look it up via the protocolsService.
20 |    */
21 |   async getCurrentNameserviceAddressEnabled(){
22 |     if (sessionStorage['currentNameserviceAddressEnabled'] && sessionStorage['currentNameserviceAddressEnabled'] != "undefined") {
23 |       return sessionStorage.getItem('currentNameserviceAddressEnabled')
24 |     } else {
25 |       let currentNetwork = this.localStorageServerService.getCurrentNetwork();
26 |       let currentProtocol = await this.localStorageProtocolService.getCurrentProtocol();
27 |       if (![currentProtocol,currentNetwork].includes(undefined)) {
28 |         let status = await this.protocolsService.getProtocolNetworkAttributes(currentProtocol,currentNetwork)
29 |         return this.setCurrentNameserviceAddressEnabled(status["nameservice-address-enabled"].toString())
30 |       } else {
31 |         return this.setCurrentNameserviceAddressEnabled("false")
32 |       }
33 |     }
34 |   }
35 | 
36 |   /**
37 |    * Sets the current nameservice address lookup enabled status.
38 |    * @param status string: `true` | `false`
39 |    */
40 |   setCurrentNameserviceAddressEnabled(status: string) {
41 |     let val = status.toString() == "true" ? "true" : "false"
42 |     sessionStorage.setItem('currentNameserviceAddressEnabled', val);
43 |     return val
44 |   }
45 | 
46 |   /**
47 |    * Removes the nameservice address lookup enabled value
48 |    */
49 |   removeCurrentNameserviceAddressEnabled(){
50 |     sessionStorage.removeItem('currentNameserviceAddressEnabled')
51 |   }
52 | 
53 | 
54 |   /**
55 |    * Gets the current nameservice domain lookup enabled status.
56 |    * If no value exists, it attempts to look it up via the protocolsService.
57 |    */
58 |   async getCurrentNameserviceDomainEnabled(){
59 |     if (sessionStorage['currentNameserviceDomainEnabled'] && sessionStorage['currentNameserviceDomainEnabled'] != "undefined") {
60 |       return sessionStorage.getItem('currentNameserviceDomainEnabled')
61 |     } else {
62 |       let currentNetwork = this.localStorageServerService.getCurrentNetwork();
63 |       let currentProtocol = await this.localStorageProtocolService.getCurrentProtocol();
64 | 
65 |       if (![currentProtocol,currentNetwork].includes(undefined)) {
66 |         let status = await this.protocolsService.getProtocolNetworkAttributes(currentProtocol,currentNetwork)
67 |         return this.setCurrentNameserviceDomainEnabled(status["nameservice-domain-enabled"].toString())
68 |       } else {
69 |         return this.setCurrentNameserviceDomainEnabled("false")
70 |       }      
71 |     }
72 |   }
73 | 
74 |   /**
75 |    * Sets the current nameservice domain lookup enabled status.
76 |    * @param status string: `true` | `false`
77 |    */
78 |   setCurrentNameserviceDomainEnabled(status: string) {
79 |     let val = status.toString() == "true" ? "true" : "false"
80 |     sessionStorage.setItem('currentNameserviceDomainEnabled', val);
81 |     return val
82 |   }
83 | 
84 |   /**
85 |    * Removes the nameservice domain lookup enabled value
86 |    */
87 |   removeCurrentNameserviceDomainEnabled(){
88 |     sessionStorage.removeItem('currentNameserviceDomainEnabled')
89 |   }
90 | 
91 | }
92 | 
93 | 
94 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/protocols/protocols.service.spec.ts:
--------------------------------------------------------------------------------
  1 | import { TestBed } from '@angular/core/testing';
  2 | import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
  3 | 
  4 | import { MailchainTestService } from 'src/app/test/test-helpers/mailchain-test.service';
  5 | 
  6 | import { ProtocolsService } from './protocols.service';
  7 | import { HttpHelpersService } from '../../helpers/http-helpers/http-helpers.service';
  8 | import { of } from 'rxjs';
  9 | 
 10 | describe('ProtocolsService', () => {
 11 | 
 12 |   let protocolsService: ProtocolsService;
 13 |   let httpTestingController: HttpTestingController;
 14 |   let mailchainTestService: MailchainTestService;
 15 |   let serverResponse
 16 | 
 17 |   const desiredUrl = `http://127.0.0.1:8080/api/protocols`
 18 | 
 19 |   beforeEach(() => {
 20 |     TestBed.configureTestingModule({
 21 |       providers: [
 22 |         ProtocolsService,
 23 |         HttpHelpersService,
 24 |       ],
 25 |       imports: [HttpClientTestingModule]
 26 |     });
 27 |     mailchainTestService = TestBed.inject(MailchainTestService);
 28 | 
 29 |     protocolsService = TestBed.inject(ProtocolsService);
 30 |     mailchainTestService = TestBed.inject(MailchainTestService);
 31 |     httpTestingController = TestBed.inject(HttpTestingController);
 32 | 
 33 |     serverResponse = mailchainTestService.protocolsServerResponse()
 34 |   });
 35 | 
 36 |   afterEach(() => {
 37 |     httpTestingController.verify();
 38 |   });
 39 | 
 40 |   it('should be created', () => {
 41 |     const protocolsService: ProtocolsService = TestBed.inject(ProtocolsService);
 42 |     expect(protocolsService).toBeTruthy();
 43 |   });
 44 | 
 45 |   describe('initUrl', () => {
 46 |     it('should initialize the url', () => {
 47 |       let protocolsService: ProtocolsService = TestBed.inject(ProtocolsService)
 48 |       expect(protocolsService['url']).toEqual('http://127.0.0.1:8080/api/protocols')
 49 |     });
 50 |   });
 51 | 
 52 |   
 53 |   describe('getProtocols', () => {
 54 |     it('should get an array of protocols and networks', () => {
 55 |       protocolsService.getProtocols().subscribe(res => {
 56 |         expect(res).toEqual(serverResponse)
 57 |       });
 58 |   
 59 |       // handle open connections
 60 |       const req = httpTestingController.expectOne(desiredUrl);
 61 |       expect(req.request.method).toBe("GET");
 62 |       req.flush(serverResponse);
 63 |     });
 64 |   });
 65 | 
 66 |   describe('getProtocolsByName', () => {
 67 |     it('should get the protocols by name', async () => {
 68 |       spyOn(protocolsService,'getProtocols').and.returnValue(of(mailchainTestService.protocolsServerResponse()))
 69 |       expect(await protocolsService.getProtocolsByName()).toEqual(['algorand', 'ethereum','substrate'])
 70 |     });
 71 |   });
 72 | 
 73 |   describe('getProtocolNetworkAttributes', () => {
 74 |     it('should return the attributes for a protocol network', async () => {
 75 |       spyOn(protocolsService,'getProtocols').and.returnValue(of(mailchainTestService.protocolsServerResponse()))
 76 |       expect(await protocolsService.getProtocolNetworkAttributes("algorand","mainnet")).toEqual(
 77 |         {
 78 |           "name": "mainnet",
 79 |           "id": "",
 80 |           "nameservice-domain-enabled": false,
 81 |           "nameservice-address-enabled": false
 82 |         }
 83 |       )
 84 |       expect(await protocolsService.getProtocolNetworkAttributes("ethereum","mainnet")).toEqual(
 85 |         {
 86 |           "name": "mainnet",
 87 |           "id": "",
 88 |           "nameservice-domain-enabled": true,
 89 |           "nameservice-address-enabled": true
 90 |         }
 91 |       )
 92 |       expect(await protocolsService.getProtocolNetworkAttributes("substrate","edgeware-mainnet")).toEqual(
 93 |         {
 94 |           "name": "edgeware-mainnet",
 95 |           "id": "7",
 96 |           "nameservice-domain-enabled": false,
 97 |           "nameservice-address-enabled": false
 98 |         }
 99 |       )
100 |     });
101 |   });
102 | 
103 | });
104 | 
105 | 


--------------------------------------------------------------------------------
/src/app/services/helpers/local-storage-server/local-storage-server.service.spec.ts:
--------------------------------------------------------------------------------
  1 | import { TestBed } from '@angular/core/testing';
  2 | 
  3 | import { LocalStorageServerService } from './local-storage-server.service';
  4 | import { HttpClientModule } from '@angular/common/http';
  5 | import { applicationApiConfig } from 'src/environments/environment';
  6 | 
  7 | describe('LocalStorageServerService', () => {
  8 |   let localStorageServerService: LocalStorageServerService;
  9 | 
 10 |   beforeEach(() => {
 11 |     TestBed.configureTestingModule({
 12 |       providers: [
 13 |         LocalStorageServerService,
 14 |       ],
 15 |       imports: [HttpClientModule]
 16 |     });
 17 | 
 18 |     localStorageServerService = TestBed.inject(LocalStorageServerService);
 19 |   });
 20 | 
 21 |   afterEach(() => {
 22 |     sessionStorage.clear();
 23 |   })
 24 | 
 25 |   it('should be created', () => {
 26 |     expect(localStorageServerService).toBeTruthy();
 27 |   });
 28 | 
 29 |   describe('getCurrentNetwork', () => {
 30 |     it('should retrieve the current network when NO value is stored', () => {
 31 |       expect(localStorageServerService.getCurrentNetwork()).toEqual(applicationApiConfig.networks[0]);
 32 |     });
 33 | 
 34 |     it('should retrieve the current network when a value is stored', () => {
 35 |       sessionStorage.setItem('currentNetwork', 'ropsten-1010');
 36 |       expect(localStorageServerService.getCurrentNetwork()).toEqual("ropsten-1010")
 37 |     });
 38 |   });
 39 | 
 40 |   describe('setCurrentNetwork', () => {
 41 |     it('should set the current network', () => {
 42 |       expect(localStorageServerService.getCurrentNetwork()).not.toEqual("ropsten-9090")
 43 |       localStorageServerService.setCurrentNetwork('ropsten-9090')
 44 |       expect(localStorageServerService.getCurrentNetwork()).toEqual("ropsten-9090")
 45 |     });
 46 |   });
 47 | 
 48 |   describe('removeCurrentNetwork', () => {
 49 |     it('should remove the current network', () => {
 50 |       localStorageServerService.setCurrentNetwork('ropsten-7742')
 51 |       expect(localStorageServerService.getCurrentNetwork()).toEqual("ropsten-7742")
 52 |       localStorageServerService.removeCurrentNetwork()
 53 |       expect(localStorageServerService.getCurrentNetwork()).toEqual(applicationApiConfig.networks[0]);
 54 |     });
 55 |   });
 56 | 
 57 |   describe('getCurrentWebProtocol', () => {
 58 |     it('should get the current web protocol', () => {
 59 |       expect(localStorageServerService.getCurrentWebProtocol()).toEqual(applicationApiConfig.mailchainNodeBaseWebProtocol);
 60 |     });
 61 |   });
 62 |   describe('setCurrentWebProtocol', () => {
 63 |     it('should set the current web protocol', () => {
 64 |       expect(localStorageServerService.getCurrentWebProtocol()).not.toEqual('https-test');
 65 |       localStorageServerService.setCurrentWebProtocol('https-test')
 66 |       expect(localStorageServerService.getCurrentWebProtocol()).toEqual('https-test');
 67 | 
 68 |     });
 69 |   });
 70 | 
 71 |   describe('getCurrentHost', () => {
 72 |     it('should get the current host', () => {
 73 |       expect(localStorageServerService.getCurrentHost()).toEqual(applicationApiConfig.mailchainNodeBaseHost);
 74 |     });
 75 |   });
 76 |   describe('setCurrentHost', () => {
 77 |     it('should set the current host', () => {
 78 |       expect(localStorageServerService.getCurrentHost()).not.toEqual("example.com");
 79 |       localStorageServerService.setCurrentHost("example.com")
 80 |       expect(localStorageServerService.getCurrentHost()).toEqual("example.com");
 81 |     });
 82 |   });
 83 | 
 84 |   describe('getCurrentPort', () => {
 85 |     it('should get the current port', () => {
 86 |       expect(localStorageServerService.getCurrentPort()).toEqual(applicationApiConfig.mailchainNodeBasePort);
 87 |     });
 88 |   });
 89 |   describe('setCurrentPort', () => {
 90 |     it('should set the current port', () => {
 91 |       expect(localStorageServerService.getCurrentPort()).not.toEqual("8084");
 92 |       localStorageServerService.setCurrentPort("8084")
 93 |       expect(localStorageServerService.getCurrentPort()).toEqual("8084");
 94 |     });
 95 |   });
 96 | 
 97 |   describe('getCurrentServerDetails', () => {
 98 |     it('should set the current server details', () => {
 99 |       let url = `${applicationApiConfig.mailchainNodeBaseWebProtocol}://${applicationApiConfig.mailchainNodeBaseHost}:${applicationApiConfig.mailchainNodeBasePort}`
100 | 
101 |       expect(localStorageServerService.getCurrentServerDetails()).toEqual(url);
102 | 
103 |     });
104 |   });
105 | 
106 | });
107 | 


--------------------------------------------------------------------------------
/src/app/inbox/inbox-message/inbox-message.component.ts:
--------------------------------------------------------------------------------
  1 | import { Component, Input, Output, EventEmitter, OnInit, ViewEncapsulation } from '@angular/core';
  2 | import { InboundMail } from 'src/app/models/inbound-mail';
  3 | import { NameserviceService } from 'src/app/services/mailchain/nameservice/nameservice.service';
  4 | import { MailchainService } from 'src/app/services/mailchain/mailchain.service';
  5 | import { LocalStorageNameserviceService } from 'src/app/services/helpers/local-storage-nameservice/local-storage-nameservice.service';
  6 | 
  7 | @Component({
  8 |   selector: '[inbox-message]',
  9 |   templateUrl: './inbox-message.component.html',
 10 |   styleUrls: ['./inbox-message.component.scss'],
 11 |   encapsulation: ViewEncapsulation.None,
 12 | })
 13 | export class InboxMessageComponent implements OnInit {
 14 |   @Input() currentMessage: InboundMail = new InboundMail;
 15 |   @Input() inboxMessages: Array<any> = [];
 16 |   @Input() currentProtocol: string;
 17 |   @Input() currentNetwork: string;
 18 |   @Output() goToInboxMessages = new EventEmitter();
 19 |   @Output() replyToMessage = new EventEmitter();
 20 | 
 21 |   public messageNameRecords = {}
 22 | 
 23 |   constructor(
 24 |     private nameserviceService: NameserviceService,
 25 |     private mailchainService: MailchainService,
 26 |     private localStorageNameserviceService: LocalStorageNameserviceService,
 27 |   ) { }
 28 |   /**
 29 |    * Go back to the inbox-messages view
 30 |    */
 31 |   public returnToInboxMessages(): void {
 32 |     this.goToInboxMessages.emit('');
 33 |   }
 34 | 
 35 |   async ngOnInit() {
 36 |     await this.resolveNamesFromMessage()
 37 |     this.getViewForContentType()
 38 |   }
 39 | 
 40 |   /**
 41 |    * replyToMsg message when reply action is taken so the compose message knows which message is being replied to.
 42 |    */
 43 |   replyToMsg(): void {
 44 |     this.replyToMessage.emit(this.currentMessage);
 45 |   }
 46 | 
 47 |   /**
 48 |    * resolveMessageNameRecords resolves name for a given address
 49 |    * Sets the name corresponding to messageNameRecords
 50 |    * @param addr address in format 0x1234...1234
 51 |    */
 52 |   private async resolveMessageNameRecords(addr) {
 53 |     let obs = await this.nameserviceService.resolveAddress(
 54 |       this.currentProtocol,
 55 |       this.currentNetwork,
 56 |       addr
 57 |     )
 58 |     obs.subscribe(res => {
 59 |       if (res['ok']) {
 60 |         this.messageNameRecords[addr] = res['body']['name']
 61 |       }
 62 |     })
 63 |   }
 64 | 
 65 |   /**
 66 |    * resolveNamesFromMessages looks up the 'to' and 'from' name
 67 |    * records according to the currentNetwork and currentProtocol
 68 |    */
 69 |   private async resolveNamesFromMessage() {
 70 |     if (await this.localStorageNameserviceService.getCurrentNameserviceAddressEnabled() == "true") {
 71 | 
 72 |       [
 73 |         this.currentMessage["headers"]["to"],
 74 |         this.currentMessage["headers"]["from"]
 75 |       ].forEach(async element => {
 76 |         let parsedAddr = this.parseAddressFromMailchain(element)
 77 |         await this.resolveMessageNameRecords(parsedAddr)
 78 |       });
 79 |     };
 80 |   }
 81 | 
 82 |   /**
 83 |    * Returns the extracted public address from mailchain formatted address
 84 |    * @param address formatted <0x...@network.protocol> address
 85 |    */
 86 |   public parseAddressFromMailchain(address) {
 87 |     return this.mailchainService.parseAddressFromMailchain(this.currentProtocol, address)
 88 |   }
 89 | 
 90 |   /**
 91 |    * getViewForContentType: Returns correct view for content-type
 92 |    */
 93 |   public getViewForContentType() {
 94 |     let ct = this.currentMessage.headers["content-type"]
 95 | 
 96 |     switch (ct) {
 97 |       case 'plaintext':
 98 |         this.addMessageText()
 99 |         break;
100 |       case 'text/html; charset="UTF-8"':
101 |         this.addMessageIframe()
102 |         break;
103 |       default:
104 |         this.addMessageText()
105 |         break;
106 |     }
107 |   }
108 | 
109 |   /** addMessageIframe: Creates iframe containing message and adds it to message-frame */
110 |   public addMessageIframe() {
111 |     var messageFrame = document.getElementById('message-frame')
112 | 
113 |     var ifrm = document.createElement("iframe");
114 |     ifrm.setAttribute("srcdoc", this.currentMessage.body);
115 |     ifrm.setAttribute("frameborder", "0");
116 |     ifrm.style.width = "100%";
117 |     ifrm.style.height = "100%";
118 |     ifrm.classList.add("message-body-html")
119 | 
120 |     messageFrame.appendChild(ifrm);
121 |   }
122 | 
123 |   /** Creates message div & pre containing message and adds it to message-frame */
124 |   public addMessageText() {
125 |     var messageFrame = document.getElementById('message-frame')
126 | 
127 |     var divMessage = document.createElement('div')
128 |     divMessage.classList.add("message-body")
129 | 
130 |     var preMessage = document.createElement('pre')
131 |     divMessage.classList.add("pre-inherit")
132 |     divMessage.innerText = this.currentMessage.body
133 | 
134 |     divMessage.appendChild(preMessage)
135 |     messageFrame.appendChild(divMessage)
136 |   }
137 | 
138 | }
139 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/nameservice/nameservice.service.spec.ts:
--------------------------------------------------------------------------------
  1 | import { TestBed } from '@angular/core/testing';
  2 | import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
  3 | 
  4 | import { NameserviceService } from './nameservice.service';
  5 | 
  6 | import { HttpHelpersService } from '../../helpers/http-helpers/http-helpers.service';
  7 | 
  8 | import { MailchainTestService } from '../../../test/test-helpers/mailchain-test.service';
  9 | import { ProtocolsService } from '../protocols/protocols.service';
 10 | import { ProtocolsServiceStub } from '../protocols/protocols.service.stub';
 11 | 
 12 | describe('NameserviceService', () => {
 13 | 
 14 |   let nameserviceService: NameserviceService;
 15 |   let httpTestingController: HttpTestingController;
 16 |   let mailchainTestService: MailchainTestService;
 17 |   let protocolsService: ProtocolsService;
 18 | 
 19 | 
 20 |   let address: String = "0x0000000000000000000000000000000000000022"
 21 |   let protocol: String = "ethereum"
 22 |   let network: String = "testnet"
 23 |   let name: String = "mailchain.eth"
 24 | 
 25 |   let expectedResolveNameUrlWithParams = `http://127.0.0.1:8080/api/nameservice/name/${name}/resolve?protocol=${protocol}&network=${network}`
 26 |   let expectedResolveAddressUrlWithParams = `http://127.0.0.1:8080/api/nameservice/address/${address}/resolve?protocol=${protocol}&network=${network}`
 27 | 
 28 |   beforeEach(() => {
 29 |     TestBed.configureTestingModule({
 30 |       providers: [
 31 |         NameserviceService,
 32 |         HttpHelpersService,
 33 |         MailchainTestService,
 34 |         { provide: ProtocolsService, useClass: ProtocolsServiceStub },
 35 |       ],
 36 |       imports: [HttpClientTestingModule]
 37 |     });
 38 | 
 39 |     nameserviceService = TestBed.inject(NameserviceService);
 40 |     httpTestingController = TestBed.inject(HttpTestingController);
 41 |     mailchainTestService = TestBed.inject(MailchainTestService);
 42 |     protocolsService = TestBed.inject(ProtocolsService);
 43 | 
 44 | 
 45 |   });
 46 | 
 47 |   afterEach(() => {
 48 |     httpTestingController.verify();
 49 |   });
 50 | 
 51 |   it('should be created', () => {
 52 |     expect(nameserviceService).toBeTruthy();
 53 |   });
 54 | 
 55 |   describe('initUrl', () => {
 56 |     it('should initialize the url', () => {
 57 |       expect(nameserviceService['url']).toEqual('http://127.0.0.1:8080/api')
 58 |     });
 59 |   });
 60 | 
 61 |   describe('resolveName', () => {
 62 |     it('should add the right params to the request', async () => {
 63 |       let resResponse = mailchainTestService.resolveNameResponse()
 64 |       let response = await nameserviceService.resolveName(protocol, network, name)
 65 |       
 66 |       response.subscribe()
 67 | 
 68 |       // handle open connections      
 69 |       const req = httpTestingController.expectOne(expectedResolveNameUrlWithParams);
 70 | 
 71 |       expect(req.request.method).toBe("GET");
 72 |       
 73 |       expect(req.request.params.get('protocol')).toEqual(protocol);
 74 |       expect(req.request.params.get('network')).toEqual(network);
 75 | 
 76 |       req.flush(resResponse);
 77 |     });
 78 | 
 79 |     it('should resolve a public address from a name', async () => {
 80 | 
 81 |       let resResponse = mailchainTestService.resolveNameResponse()
 82 |       let response = await nameserviceService.resolveName(protocol, network, name)
 83 | 
 84 |       response.subscribe(res => {
 85 |         expect(res['url']).toEqual(expectedResolveNameUrlWithParams)
 86 |         expect(res['body']['address']).toEqual(address)
 87 |       })
 88 | 
 89 |       // handle open connections      
 90 |       const req = httpTestingController.expectOne(expectedResolveNameUrlWithParams);
 91 |       expect(req.request.method).toBe("GET");
 92 | 
 93 |       req.flush(resResponse);
 94 |     });
 95 | 
 96 |   });
 97 | 
 98 |   describe('resolveAddress', () => {
 99 |     it('should add the right params to the request', async () => {
100 | 
101 |       let resResponse = mailchainTestService.resolveAddressResponse()
102 |       let response = await nameserviceService.resolveAddress(protocol, network, address)
103 | 
104 |       response.subscribe()
105 | 
106 |       // handle open connections      
107 |       const req = httpTestingController.expectOne(expectedResolveAddressUrlWithParams);
108 | 
109 |       expect(req.request.method).toBe("GET");
110 | 
111 |       expect(req.request.params.get('protocol')).toEqual(protocol);
112 |       expect(req.request.params.get('network')).toEqual(network);
113 | 
114 |       req.flush(resResponse);
115 |     });
116 | 
117 |     it('should resolve a name from a public address', async () => {
118 | 
119 |       let resResponse = mailchainTestService.resolveAddressResponse()
120 |       let response = await nameserviceService.resolveAddress(protocol, network, address)
121 | 
122 |       response.subscribe(res => {
123 |         expect(res['url']).toEqual(expectedResolveAddressUrlWithParams)
124 |         expect(res['body']['name']).toEqual(name)
125 |       })
126 | 
127 |       // handle open connections      
128 |       const req = httpTestingController.expectOne(expectedResolveAddressUrlWithParams);
129 |       // const req = httpTestingController.expectOne({method: "GET"});
130 |       expect(req.request.method).toBe("GET");
131 | 
132 |       req.flush(resResponse);
133 |     });
134 | 
135 |   });
136 | 
137 | });
138 | 


--------------------------------------------------------------------------------
/angular.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
  3 |   "version": 1,
  4 |   "newProjectRoot": "projects",
  5 |   "projects": {
  6 |     "mailchain-web": {
  7 |       "root": "",
  8 |       "sourceRoot": "src",
  9 |       "projectType": "application",
 10 |       "prefix": "app",
 11 |       "schematics": {
 12 |         "@schematics/angular:component": {
 13 |           "style": "scss"
 14 |         }
 15 |       },
 16 |       "architect": {
 17 |         "build": {
 18 |           "builder": "@angular-devkit/build-angular:browser",
 19 |           "options": {
 20 |             "aot": true,
 21 |             "outputPath": "dist/mailchain-web",
 22 |             "index": "src/index.html",
 23 |             "main": "src/main.ts",
 24 |             "polyfills": "src/polyfills.ts",
 25 |             "tsConfig": "src/tsconfig.app.json",
 26 |             "assets": [
 27 |               "src/favicon.ico",
 28 |               "src/assets"
 29 |             ],
 30 |             "styles": [
 31 |               "src/scss/application.scss"
 32 |             ],
 33 |             "scripts": [
 34 |               "node_modules/jquery/dist/jquery.js",
 35 |               "node_modules/popper.js/dist/umd/popper.js",
 36 |               "node_modules/bootstrap/dist/js/bootstrap.js"
 37 |             ]
 38 |           },
 39 |           "configurations": {
 40 |             "production": {
 41 |               "fileReplacements": [
 42 |                 {
 43 |                   "replace": "src/environments/environment.ts",
 44 |                   "with": "src/environments/environment.prod.ts"
 45 |                 }
 46 |               ],
 47 |               "optimization": true,
 48 |               "outputHashing": "all",
 49 |               "sourceMap": false,
 50 |               "namedChunks": false,
 51 |               "aot": true,
 52 |               "extractLicenses": true,
 53 |               "vendorChunk": false,
 54 |               "buildOptimizer": true,
 55 |               "budgets": [
 56 |                 {
 57 |                   "type": "initial",
 58 |                   "maximumWarning": "2mb",
 59 |                   "maximumError": "5mb"
 60 |                 },
 61 |                 {
 62 |                   "type": "anyComponentStyle",
 63 |                   "maximumWarning": "6kb"
 64 |                 }
 65 |               ]
 66 |             }
 67 |           }
 68 |         },
 69 |         "serve": {
 70 |           "builder": "@angular-devkit/build-angular:dev-server",
 71 |           "options": {
 72 |             "browserTarget": "mailchain-web:build"
 73 |           },
 74 |           "configurations": {
 75 |             "production": {
 76 |               "browserTarget": "mailchain-web:build:production"
 77 |             }
 78 |           }
 79 |         },
 80 |         "extract-i18n": {
 81 |           "builder": "@angular-devkit/build-angular:extract-i18n",
 82 |           "options": {
 83 |             "browserTarget": "mailchain-web:build"
 84 |           }
 85 |         },
 86 |         "test": {
 87 |           "builder": "@angular-devkit/build-angular:karma",
 88 |           "options": {
 89 |             "codeCoverage": true,
 90 |             "codeCoverageExclude": [
 91 |               "/**/*mock.ts",
 92 |               "/**/*stub.ts",
 93 |               "/**/test-helpers/**",
 94 |               "src/test/**"
 95 |             ],
 96 |             "main": "src/test.ts",
 97 |             "polyfills": "src/polyfills.ts",
 98 |             "tsConfig": "src/tsconfig.spec.json",
 99 |             "karmaConfig": "src/karma.conf.js",
100 |             "styles": [
101 |               "./node_modules/bootstrap/dist/css/bootstrap.min.css",
102 |               "src/scss/application.scss"
103 |             ],
104 |             "scripts": [
105 |               "node_modules/jquery/dist/jquery.js",
106 |               "node_modules/popper.js/dist/umd/popper.js",
107 |               "node_modules/bootstrap/dist/js/bootstrap.js"
108 |             ],
109 |             "assets": [
110 |               "src/favicon.ico",
111 |               "src/assets"
112 |             ]
113 |           }
114 |         },
115 |         "lint": {
116 |           "builder": "@angular-devkit/build-angular:tslint",
117 |           "options": {
118 |             "tsConfig": [
119 |               "src/tsconfig.app.json",
120 |               "src/tsconfig.spec.json"
121 |             ],
122 |             "exclude": [
123 |               "**/node_modules/**"
124 |             ]
125 |           }
126 |         }
127 |       }
128 |     },
129 |     "mailchain-web-e2e": {
130 |       "root": "e2e/",
131 |       "projectType": "application",
132 |       "prefix": "",
133 |       "architect": {
134 |         "e2e": {
135 |           "builder": "@angular-devkit/build-angular:protractor",
136 |           "options": {
137 |             "protractorConfig": "e2e/protractor.conf.js",
138 |             "devServerTarget": "mailchain-web:serve"
139 |           },
140 |           "configurations": {
141 |             "production": {
142 |               "devServerTarget": "mailchain-web:serve:production"
143 |             }
144 |           }
145 |         },
146 |         "lint": {
147 |           "builder": "@angular-devkit/build-angular:tslint",
148 |           "options": {
149 |             "tsConfig": "e2e/tsconfig.e2e.json",
150 |             "exclude": [
151 |               "**/node_modules/**"
152 |             ]
153 |           }
154 |         }
155 |       }
156 |     }
157 |   },
158 |   "defaultProject": "mailchain-web"
159 | }


--------------------------------------------------------------------------------
/src/app/settings/settings/settings.component.html:
--------------------------------------------------------------------------------
  1 | <div class="row">
  2 |   <div class="col-md-6">
  3 |     <h1 class="page-title text-primary inline">
  4 |       <img src="../../assets/mailchain_logo_text.png" alt="Mailchain" class="header-logo">
  5 |     </h1>
  6 |     <div class="clearfix mb-xs">
  7 |     </div>
  8 |   </div>
  9 |   <div class="col-md-4">
 10 |     <div class="row">
 11 |       <div class="col">
 12 |         <div class="mb-s mt-2 pull-right">
 13 |           <a class="btn btn-outline-danger btn-sm float-left" id="back-btn" (click)="returnToInboxMessages()">
 14 |             <i class="fa fa-chevron-left fa-lg"></i> Return To Messages
 15 |           </a>
 16 |           <a class="btn btn-outline-primary btn-sm float-left ml-2" id="save-btn" (click)="updateServerSettings()">
 17 |             <i class="fa fa-save fa-lg"></i> Save Settings
 18 |           </a>
 19 |         </div>
 20 |       </div>
 21 |     </div>
 22 |   </div>
 23 | </div>
 24 | 
 25 | <div class="row">
 26 |   <div class="col-lg-4 col-xl-3 col-12">
 27 |     <div class="card">
 28 |       <div class="card-header">
 29 |         Settings
 30 |       </div>
 31 |       <ul class="list-group list-group-flush">
 32 |         <li class="list-group-item">
 33 |           <div class="row">
 34 |             <div class="col-12 p-0 my-auto">
 35 |               <a class="nav-link" [routerLink]="['/settings/']" fragment='mailchain-api-settings'>
 36 |                 Mailchain API Settings
 37 |               </a>
 38 |             </div>
 39 |           </div>
 40 |         </li>
 41 |         <li class="list-group-item">
 42 |           <div class="row">
 43 |             <div class="col-12 p-0 my-auto">
 44 |               <a class="nav-link" [routerLink]="['/settings/']" fragment='blockchain-settings'>
 45 |                 Blockchain Settings
 46 |               </a>
 47 |             </div>
 48 |           </div>
 49 |         </li>
 50 |         <li class="list-group-item">
 51 |           <div class="row">
 52 |             <div class="col-12 p-0 my-auto">
 53 |               <a class="nav-link" [routerLink]="['/settings/']" fragment='reset-settings'>
 54 |                 Reset Settings
 55 |               </a>
 56 |             </div>
 57 |           </div>
 58 |         </li>
 59 |       </ul>
 60 |     </div>
 61 |   </div>
 62 |   <div class="col-lg-6 col-xl-7 col-12">
 63 | 
 64 |     <!--  -->
 65 |     <form class="my-3">
 66 |       <div id="mailchain-api-settings-div" class="my-4">
 67 |         <h3 id="mailchain-api-settings" class="mb-3">Mailchain API Settings</h3>
 68 | 
 69 |         <div class="form-group row">
 70 |           <label for="apiProtocol" class="col-sm-3 col-form-label">API Protocol</label>
 71 |           <div class="col-sm-3">
 72 |             <select class="form-control" id="apiProtocol" name="apiProtocol" [(ngModel)]="currentWebProtocol">
 73 |               <option value="http">HTTP</option>
 74 |               <option value="https">HTTPS</option>
 75 |             </select>
 76 |           </div>
 77 |         </div>
 78 |         <div class="form-group row">
 79 |           <label for="apiHost" class="col-sm-3 col-form-label">API Host URL</label>
 80 |           <div class="col-sm-6">
 81 |             <input type="text" class="form-control" id="apiHost" name="apiHost" [(ngModel)]="currentHost"
 82 |               placeholder="e.g. localhost, 127.0.0.1, example.com">
 83 |           </div>
 84 |         </div>
 85 |         <div class="form-group row">
 86 |           <label for="apiPort" class="col-sm-3 col-form-label">API Host Port</label>
 87 |           <div class="col-sm-3">
 88 |             <input type="text" class="form-control" id="apiPort" name="apiPort" [(ngModel)]="currentPort"
 89 |               placeholder="e.g. 8080">
 90 |           </div>
 91 |         </div>
 92 |       </div>
 93 |       <hr>
 94 | 
 95 |       <div id="blockchain-settings-div" class="my-4">
 96 |         <h3 id="blockchain-settings" class="mb-3">Blockchain Protocol Settings</h3>
 97 | 
 98 |         <div class="form-group row">
 99 |           <label for="blockchainProtocol" class="col-sm-3 col-form-label">Blockchain Protocol</label>
100 |           <div class="col-sm-3">
101 |             <select class="form-control" id="blockchainProtocol" name="blockchainProtocol" [(ngModel)]="currentProtocol"
102 |               (ngModelChange)="changeProtocol()">
103 |               <option *ngFor="let protocol of protocols; let i = index" [value]="protocol">
104 |                 {{protocol | titlecase}}
105 |               </option>
106 |             </select>
107 |           </div>
108 |         </div>
109 | 
110 |         <div class="form-group row">
111 |           <label for="blockchainNetwork" class="col-sm-3 col-form-label">Blockchain Network</label>
112 |           <div class="col-sm-3">
113 |             <select class="form-control" id="blockchainNetwork" name="blockchainNetwork" [(ngModel)]="currentNetwork">
114 |               <option *ngFor="let network of networks; let i = index" [value]="network.value">
115 |                 {{network.label | titlecase}}
116 |               </option>
117 |             </select>
118 |           </div>
119 |         </div>
120 | 
121 |       </div>
122 |       <hr>
123 |     </form>
124 |     <div id="reset-settings-div" class="my-4">
125 |       <h3 id="reset-settings" class="mb-3">Reset Settings</h3>
126 |       <div class="form-group row">
127 |         <label for="resetSettings" class="col-sm-5 col-form-label">Reset Settings To Default</label>
128 |         <div class="col-sm-6">
129 |           <button type="button" class="btn btn-outline-danger btn-sm">Reset All Settings To Default</button>
130 |         </div>
131 |       </div>
132 | 
133 |       <!-- Button with confirmation -->
134 | 
135 |     </div>
136 | 
137 |   </div>
138 | </div>


--------------------------------------------------------------------------------
/src/app/services/mailchain/addresses/addresses.service.spec.ts:
--------------------------------------------------------------------------------
  1 | import { TestBed } from '@angular/core/testing';
  2 | import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
  3 | 
  4 | import { AddressesService } from './addresses.service';
  5 | import { MailchainTestService } from 'src/app/test/test-helpers/mailchain-test.service';
  6 | import { HttpHelpersService } from '../../helpers/http-helpers/http-helpers.service';
  7 | import { ProtocolsServiceStub } from '../protocols/protocols.service.stub';
  8 | import { ProtocolsService } from '../protocols/protocols.service';
  9 | import { Observable, of } from 'rxjs';
 10 | 
 11 | 
 12 | describe('AddressesService', () => {
 13 | 
 14 |   let addressesService: AddressesService;
 15 |   let httpTestingController: HttpTestingController;
 16 |   let mailchainTestService: MailchainTestService
 17 |   let serverResponse
 18 | 
 19 |   const desiredUrl = `http://127.0.0.1:8080/api/addresses?protocol=ethereum&network=mainnet`
 20 | 
 21 |   beforeEach(() => {
 22 |     TestBed.configureTestingModule({
 23 |       providers: [
 24 |         HttpHelpersService,
 25 |         { provide: ProtocolsService, useClass: ProtocolsServiceStub },
 26 |         AddressesService,
 27 |       ],
 28 |       imports: [HttpClientTestingModule]
 29 |     });
 30 | 
 31 |     addressesService = TestBed.inject(AddressesService);
 32 |     mailchainTestService = TestBed.inject(MailchainTestService);
 33 |     httpTestingController = TestBed.inject(HttpTestingController);
 34 | 
 35 |     serverResponse = mailchainTestService.senderAddressesEthereumObserveResponse()
 36 |     // expectedAddresses = mailchainTestService.senderAddresses()
 37 |   });
 38 | 
 39 |   afterEach(() => {
 40 |     httpTestingController.verify();
 41 |   });
 42 | 
 43 | 
 44 |   describe('initUrl', () => {
 45 |     it('should initialize the url', () => {
 46 |       addressesService.initUrl()
 47 |       expect(addressesService['url']).toEqual('http://127.0.0.1:8080/api')
 48 |     });
 49 |   })
 50 | 
 51 |   it('should be created', () => {
 52 |     expect(addressesService).toBeTruthy();
 53 |   });
 54 | 
 55 |   describe('getAddresses', () => {
 56 |     beforeEach(() => {
 57 |       let obs: Observable<any> = of(mailchainTestService.senderAddressesEthereumObserveResponse())
 58 |       spyOn(addressesService, 'getAddresses').and.returnValue(
 59 |         obs.toPromise()
 60 |       )
 61 |     });
 62 |     it('should get an array of sender addresses', async () => {
 63 |       let result
 64 |       await addressesService.getAddresses('ethereum', 'mainnet').then(res => {
 65 |         result = res
 66 |       });
 67 |       expect(result).toEqual(mailchainTestService.senderAddressesEthereumObserveResponse())
 68 |       expect(addressesService.getAddresses).toHaveBeenCalled()
 69 |     });
 70 |   });
 71 |   describe('handleAddressFormatting', () => {
 72 |     it('should return address when "hex/0x-prefix" is specified', () => {
 73 |       let address: string = mailchainTestService.senderAddressesHex0xPrefix()[0]
 74 |       let result: string = addressesService.handleAddressFormatting(address, 'hex/0x-prefix')
 75 |       expect(result).toEqual(address)
 76 |     });
 77 |     it('should return converted "hex/0x-prefix" as lowercase', () => {
 78 |       let address: string = mailchainTestService.senderAddressesHex0xPrefix()[0].toUpperCase()
 79 |       let result: string = addressesService.handleAddressFormatting(address, 'hex/0x-prefix')
 80 |       expect(result).toEqual(address.toLowerCase())
 81 |     });
 82 |     it('should return address when "base58/plain" is specified', () => {
 83 |       let address: string = mailchainTestService.senderAddressesBase58Plain()[0]
 84 |       let result: string = addressesService.handleAddressFormatting(address, 'base58/plain')
 85 |       expect(result).toEqual(address)
 86 |     });
 87 |     it('should NOT return converted "base58/plain" as lowercase', () => {
 88 |       let address: string = mailchainTestService.senderAddressesBase58Plain()[0]
 89 |       let result: string = addressesService.handleAddressFormatting(address, 'base58/plain')
 90 |       expect(result).not.toEqual(address.toLowerCase())
 91 |     });
 92 |     it('should return address when an unknown format is specified', () => {
 93 |       let address: string = mailchainTestService.senderAddressesBase58Plain()[0]
 94 |       let result: string = addressesService.handleAddressFormatting(address, 'base12/unknown')
 95 |       expect(result).toEqual(address)
 96 |     });
 97 |     it('should NOT return converted unknown format as lowercase', () => {
 98 |       let address: string = mailchainTestService.senderAddressesBase58Plain()[0]
 99 |       let result: string = addressesService.handleAddressFormatting(address, 'base12/unknown')
100 |       expect(result).not.toEqual(address.toLowerCase())
101 |     });
102 |   });
103 |   describe('handleAddressFormattingByProtocol', () => {
104 |     it('should return address when "ethereum" is specified', () => {
105 |       let address: string = mailchainTestService.senderAddressesHex0xPrefix()[0]
106 |       let result: string = addressesService.handleAddressFormattingByProtocol(address, 'ethereum')
107 |       expect(result).toEqual(address)
108 |     });
109 |     it('should return converted "ethereum" as lowercase', () => {
110 |       let address: string = mailchainTestService.senderAddressesHex0xPrefix()[0].toUpperCase()
111 |       let result: string = addressesService.handleAddressFormattingByProtocol(address, 'ethereum')
112 |       expect(result).toEqual(address.toLowerCase())
113 |     });
114 |     it('should return address when "substrate" is specified', () => {
115 |       let address: string = mailchainTestService.senderAddressesBase58Plain()[0]
116 |       let result: string = addressesService.handleAddressFormattingByProtocol(address, 'substrate')
117 |       expect(result).toEqual(address)
118 |     });
119 |     it('should NOT return converted "substrate" as lowercase', () => {
120 |       let address: string = mailchainTestService.senderAddressesBase58Plain()[0]
121 |       let result: string = addressesService.handleAddressFormattingByProtocol(address, 'substrate')
122 |       expect(result).not.toEqual(address.toLowerCase())
123 |     });
124 |     it('should return address when an unknown protocol is specified', () => {
125 |       let address: string = mailchainTestService.senderAddressesBase58Plain()[0]
126 |       let result: string = addressesService.handleAddressFormattingByProtocol(address, 'unknown-protocol')
127 |       expect(result).toEqual(address)
128 |     });
129 |     it('should NOT return converted unknown protocol as lowercase', () => {
130 |       let address: string = mailchainTestService.senderAddressesBase58Plain()[0]
131 |       let result: string = addressesService.handleAddressFormattingByProtocol(address, 'unknown-protocol')
132 |       expect(result).not.toEqual(address.toLowerCase())
133 |     });
134 |   });
135 | });
136 | 


--------------------------------------------------------------------------------
/src/app/app.component.ts:
--------------------------------------------------------------------------------
  1 | import { Component, OnInit } from '@angular/core';
  2 | import { environment } from 'src/environments/environment';
  3 | import { ConnectivityService } from './services/mailchain/connectivity/connectivity.service';
  4 | import { BsModalService, BsModalRef } from 'ngx-bootstrap/modal';
  5 | import { ModalConnectivityErrorComponent } from './modals/modal-connectivity-error/modal-connectivity-error.component';
  6 | import { errorMessages } from './services/helpers/error-messages/error-messages'
  7 | import { LocalStorageProtocolService } from './services/helpers/local-storage-protocol/local-storage-protocol.service';
  8 | import { LocalStorageServerService } from './services/helpers/local-storage-server/local-storage-server.service';
  9 | 
 10 | @Component({
 11 |   selector: 'app-root',
 12 |   templateUrl: './app.component.html',
 13 |   styleUrls: ['./app.component.scss']
 14 | })
 15 | 
 16 | export class AppComponent implements OnInit {
 17 |   public version: string = environment.version;
 18 |   public title = 'Mailchain Inbox';
 19 |   public apiVersionInfo = {};
 20 |   public errorTitle: string = ""
 21 |   public errorMessage: string = ""
 22 |   public apiVersion = "";
 23 |   public modalConnectivityError: BsModalRef;
 24 | 
 25 |   public currentNetwork: String;
 26 |   public currentProtocol: String;
 27 | 
 28 |   constructor(
 29 |     private connectivityService: ConnectivityService,
 30 |     private modalService: BsModalService,
 31 |     private localStorageProtocolService: LocalStorageProtocolService,
 32 |     private localStorageServerService: LocalStorageServerService,
 33 |   ) {
 34 | 
 35 |   }
 36 | 
 37 |   public setApiVersion() {
 38 |     this.apiVersion = this.apiVersionInfo["client-version"]
 39 |   }
 40 | 
 41 |   public async ngOnInit() {
 42 |     this.currentNetwork = await this.localStorageServerService.getCurrentNetwork()
 43 |     this.currentProtocol = await this.localStorageProtocolService.getCurrentProtocol()
 44 | 
 45 |     await this.handleApiProtocolsAvailability()
 46 |     await this.handleApiAddressesAvailability()
 47 |     await this.handleWebConnectivity()
 48 |     this.setApiVersion()
 49 |   }
 50 | 
 51 |   /**
 52 |    * handleApiAddressesAvailability checks if the client is available.
 53 |    * Displays an error modal if not able to connect or hides the error modal if able to connect
 54 |    */
 55 |   public async handleApiProtocolsAvailability() {
 56 |     let apiConnectivityInfo = await this.connectivityService.getApiProtocolsAvailability();
 57 | 
 58 |     if (apiConnectivityInfo["status"] == "error") {
 59 |       this.handleApiConnectivityError(apiConnectivityInfo)
 60 |     } else if (apiConnectivityInfo["status"] == "ok") {
 61 |       if (apiConnectivityInfo["protocols"] == 0) {
 62 |         // No protocols are configured
 63 |         this.handleErrorOnPage(
 64 |           errorMessages.protocolConfigurationErrorTitle,
 65 |           errorMessages.protocolConfigurationErrorMessage
 66 |         )
 67 |       } else {
 68 |         if (this.modalConnectivityError) {
 69 |           this.modalConnectivityError.hide()
 70 |         }
 71 |       }
 72 |     }
 73 |   }
 74 | 
 75 |   /**
 76 |    * handleApiAddressesAvailability checks if the client is available.
 77 |    * Displays an error modal if not able to connect or hides the error modal if able to connect
 78 |    */
 79 |   public async handleApiAddressesAvailability() {
 80 |     let apiConnectivityInfo = await this.connectivityService.getApiAddressAvailability();
 81 | 
 82 |     if (apiConnectivityInfo["status"] == "error") {
 83 |       this.handleApiConnectivityError(apiConnectivityInfo)
 84 |     } else if (apiConnectivityInfo["status"] == "ok") {
 85 |       if (apiConnectivityInfo["addresses"] == 0) {
 86 |         // No addresses are configured
 87 |         this.handleErrorOnPage(
 88 |           errorMessages.accountConfigurationErrorTitle,
 89 |           errorMessages.accountConfigurationErrorMessage
 90 |         )
 91 |       } else {
 92 |         if (this.modalConnectivityError) {
 93 |           this.modalConnectivityError.hide()
 94 |         }
 95 |       }
 96 |     }
 97 |   }
 98 | 
 99 |   /**
100 |    * handleApiConnectivityError
101 |    */
102 |   handleApiConnectivityError(errorBlock) {
103 |     switch (errorBlock["code"]) {
104 |       case 0:
105 |         // Could not connect to Mailchain client
106 |         this.handleErrorOnPage(
107 |           errorMessages.clientNotRunningErrorTitle,
108 |           errorMessages.clientNotRunningErrorMessage
109 |         )
110 |         break;
111 | 
112 |       default:
113 |         // Something else happened
114 |         this.handleErrorOnPage(
115 |           errorMessages.unknownErrorTitle,
116 |           errorMessages.unknownErrorMessage
117 |         )
118 |         console.warn('please add a new error message for this code', errorBlock["code"]);
119 |         break;
120 |     }
121 |   }
122 | 
123 |   /**
124 |    * handleWebConnectivity
125 |    */
126 |   public async handleWebConnectivity() {
127 | 
128 |     try {
129 |       this.apiVersionInfo = await this.connectivityService.getVersionStatus();
130 |     } catch (error) {
131 |       this.handleErrorOnPage(
132 |         errorMessages.connectionErrorTitle,
133 |         error["message"]
134 |       )
135 |     }
136 |     if (this.apiVersionInfo["errors"] > 0) {
137 | 
138 |       let errorStatusFields = [
139 |         "client",
140 |         "release"
141 |       ]
142 | 
143 |       errorStatusFields.forEach(element => {
144 |         if (this.apiVersionInfo[`${element}-error-status`] != undefined) {
145 |           this.handleErrorOnPage(
146 |             errorMessages.connectionErrorTitle,
147 |             this.apiVersionInfo[`${element}-error-message`]
148 |           )
149 |         }
150 |       });
151 |     }
152 |     if (this.apiVersionInfo["status"] == "outdated") {
153 |       this.handleErrorOnPage(
154 |         errorMessages.updateAvailableTitle,
155 |         `<p>Your Mailchain client version is ${this.apiVersionInfo["client-version"]}. Please upgrade it to version ${this.apiVersionInfo["release-version"]} to ensure things work as expected.</p><p>Please visit <a href="https://docs.mailchain.xyz/troubleshooting/common-inbox-errors" target="_blank">Docs: common inbox errors</a> to see how to fix this.</p>`
156 |       )
157 |     }
158 |   }
159 | 
160 |   /**
161 |    * handleErrorOnPage
162 |    */
163 |   public handleErrorOnPage(errorTitle, errorMessage) {
164 | 
165 |     if (this.errorTitle.length == 0 && this.errorMessage.length == 0) {
166 |       this.errorTitle = errorTitle
167 |       this.errorMessage = errorMessage
168 | 
169 |       const initialState = {
170 |         errorTitle: errorTitle,
171 |         errorMessage: errorMessage,
172 |       };
173 | 
174 |       this.modalConnectivityError = this.modalService.show(ModalConnectivityErrorComponent, { initialState });
175 |       this.modalConnectivityError.content.closeBtnName = 'Close'
176 |     }
177 |   }
178 | 
179 | }
180 | 


--------------------------------------------------------------------------------
/src/app/inbox/inbox-compose/inbox-compose.component.html:
--------------------------------------------------------------------------------
  1 | <div class="clearfix mb-xs">
  2 |   <a class="btn btn-outline-secondary btn-sm float-left" id="back-btn" (click)="returnToMessage()">
  3 |     <i class="fa fa-angle-left fa-lg"></i> Back To Message
  4 |   </a>
  5 | </div>
  6 | <hr>
  7 | <div>
  8 |   <h4>Compose <span class="fw-semi-bold">New</span></h4>
  9 |   <div class="compose-form" id="compose-view">
 10 | 
 11 |     <form #mailForm="ngForm" id="message-compose" (ngSubmit)="onSubmit()" autocomplete="off">
 12 | 
 13 |       <!-- From Field -->
 14 |       <div class="form-group row">
 15 |         <label for="from" class="col-form-label col-sm-2 col-md-2 col-lg-2">From:</label>
 16 |         <div class="col-md-10 col-lg-9">
 17 |           <div class="input-group mb-2 row">
 18 |             <div class="input-group-prepend">
 19 |               <div class="input-group-text p-0">
 20 |                 <img class="rounded-circle addressIcon" src={{generateIdenticon(model.from)}} alt="">
 21 |               </div>
 22 |             </div>
 23 |             
 24 |             <select class="form-control" [(ngModel)]="model.from" name="from" [disabled]="isReply">
 25 |               <option *ngFor="let address of fromAddresses; let i = index" [value]="address">
 26 |                 {{address}}
 27 |               </option>
 28 |             </select>
 29 |           </div>
 30 |         </div>
 31 |       </div>
 32 | 
 33 |       <!-- ./From Field -->
 34 | 
 35 |       <!-- To Field -->
 36 |       <div class="form-group mb-0">
 37 |         <div class="row">
 38 |           <label for="to" class="col-form-label col-sm-2 col-md-2 col-lg-2">To:</label>
 39 |           <div class="col-md-10 col-lg-9">
 40 |             <div class="input-group row">
 41 |               <div class="input-group-prepend">
 42 |                 <div class="input-group-text p-0">
 43 |                   <img class="rounded-circle addressIcon" src={{generateIdenticon(model.to)}} alt="">
 44 |                 </div>
 45 |               </div>
 46 |               <input type="text" id="messageTo" placeholder="To" name="to" class="form-control "
 47 |               placeholder="e.g. 0x0000...0000 or mailchain.eth" [(ngModel)]="messageToField"
 48 |               [disabled]="isReply"
 49 |                 (keyup)="recipientResolve($event)">
 50 |             </div>
 51 |           </div>
 52 |         </div>
 53 | 
 54 |         <div class="row">
 55 |           <div class="col-md-10 col-lg-9 offset-md-2 offset-sm-0">
 56 |             <div class="row pl-2">
 57 |               <p>
 58 |                 <i class="{{recipientLoadingIcon}}"></i>&nbsp;
 59 |                 <span>{{recipientLoadingText | titlecase}}</span>&nbsp;
 60 |                 <span *ngIf="currentRecipientValue != model.to">{{model.to}}</span>
 61 |               </p>
 62 |             </div>
 63 |           </div>
 64 |         </div>
 65 | 
 66 |       </div>
 67 |       <!-- ./To Field -->
 68 | 
 69 | 
 70 | 
 71 | 
 72 |       <!-- Subject Field -->
 73 |       <div class="form-group row">
 74 | 
 75 |         <label for="subject" class="col-form-label col-sm-2 col-md-2 col-lg-2">Subject:</label>
 76 | 
 77 |         <div class="col-md-10 col-lg-9">
 78 |           <div class="input-group mb-2 row">
 79 |             <input type="text" id="messageSubject" placeholder="Subject" [(ngModel)]="model.subject" name="subject"
 80 |               class="form-control">
 81 |           </div>
 82 |         </div>
 83 | 
 84 |       </div>
 85 |       <!-- ./Subject Field -->
 86 | 
 87 | 
 88 |       <div class="form-group row">
 89 |         <label for="envelope" class="col-form-label col-sm-2 col-md-2 col-lg-2">Envelope Type:</label>
 90 |         <div class="col-md-10 col-lg-10">
 91 |           <div class="input-group mb-2 row">
 92 |             <!-- Envelope Field -->
 93 |             <div class="col-md-7 col-lg-7">
 94 |               <div class="input-group mb-2 row">
 95 |                 <!-- <1 Envelope -->
 96 |                 <input type="hidden" *ngIf="envelopeType && envelopes.length <= 1" [(ngModel)]="envelope"
 97 |                   name="envelope">
 98 |                 <input type="text" *ngIf="envelopeType && envelopes.length <= 1"
 99 |                   value="{{envelopeDescription}} ({{envelopeType}})" name="envelope" class="form-control" disabled>
100 |                 <!-- ./ <1 Envelope -->
101 |                 <!-- >1 Envelope -->
102 |                 <select class="form-control" [(ngModel)]="envelope" name="envelope" *ngIf="envelopes.length > 1">
103 |                   <option *ngFor="let envelope of envelopes; let i = index" [value]="envelope.type">
104 |                     {{envelope.description}} ({{envelope.type}})
105 |                   </option>
106 |                 </select>
107 |                 <!-- ./ >1 Envelope -->
108 |               </div>
109 |             </div>
110 |             <!-- ./Envelope Field -->
111 |             <!-- Plain/HTML toggle field -->
112 |             <div class="col-md-5 col-lg-4">
113 |               <div class="custom-control custom-switch content-type-switch">
114 |                 <input type="checkbox" class="custom-control-input" id="contentTypeSwitch"
115 |                   (click)="convertToPlainText()" [disabled]="inputContentType == 'plaintext'">
116 |                 <label class="custom-control-label" for="contentTypeSwitch">{{contentTypeSwitchLabel}}</label>
117 |               </div>
118 |             </div>
119 |             <!-- ./Plain/HTML toggle field -->
120 |           </div>
121 |         </div>
122 |       </div>
123 | 
124 |       <!-- Body Field -->
125 |       <!-- Plaintext Field -->
126 |       <div *ngIf="inputContentType == 'plaintext' " class="form-group row">
127 |         <div class="col-md-10 col-lg-9 offset-md-2 offset-sm-0">
128 |           <div class="input-group mb-2 row">
129 | 
130 |             <textarea class="form-control courier" id="messageBody" [(ngModel)]="model.body"
131 |               (keydown.enter)="supressEnterPropagation($event)" name="body" rows="18"></textarea>
132 | 
133 |           </div>
134 |         </div>
135 |       </div>
136 |       <!-- ./Plaintext Field -->
137 | 
138 |       <!-- CKeditor Field -->
139 |       <div *ngIf="inputContentType == 'html' " class="form-group row">
140 |         <div class="col-md-10 col-lg-9 offset-md-2 offset-sm-0">
141 |           <div class="input-group mb-2 row">
142 | 
143 |             <ckeditor #editor id="messageBody" name="body" [(ngModel)]="model.body"
144 |               (keydown.enter)="supressEnterPropagation($event)" [editor]="Editor"></ckeditor>
145 | 
146 |           </div>
147 |         </div>
148 |       </div>
149 |       <!-- ./CKeditor Field -->
150 |       <!-- ./Body Field -->
151 | 
152 |       <!-- <div class="clearfix"> -->
153 |       <div class="form-group row">
154 |         <div class="col-md-10 col-lg-9 offset-md-2 offset-sm-0">
155 | 
156 |           <div class="float-right mt-2 mr-3">
157 |             <div class="btn-group mr-2">
158 |               <button type="reset" class="btn btn-outline-secondary" (click)="returnToMessage()">Discard</button>
159 |             </div>
160 |             <div class="btn-group">
161 |               <button type="submit" class="btn btn-danger"
162 |                 [disabled]="sendMessagesDisabled">&nbsp;&nbsp;&nbsp;Send&nbsp;&nbsp;&nbsp;</button>
163 |             </div>
164 |           </div>
165 | 
166 |         </div>
167 |       </div>
168 |     </form>
169 |   </div>
170 | </div>


--------------------------------------------------------------------------------
/src/app/services/mailchain/connectivity/connectivity.service.ts:
--------------------------------------------------------------------------------
  1 | import { Injectable } from '@angular/core';
  2 | import { HttpClient } from '@angular/common/http';
  3 | import { environment } from 'src/environments/environment';
  4 | import { VersionService } from '../version/version.service';
  5 | import { AddressesService } from '../addresses/addresses.service';
  6 | import { lt as semverLt, coerce as semverCoerce } from 'semver'
  7 | import { LocalStorageProtocolService } from '../../helpers/local-storage-protocol/local-storage-protocol.service';
  8 | import { LocalStorageServerService } from '../../helpers/local-storage-server/local-storage-server.service';
  9 | import { ProtocolsService } from '../protocols/protocols.service';
 10 | 
 11 | @Injectable({
 12 |   providedIn: 'root'
 13 | })
 14 | export class ConnectivityService {
 15 |   // private semver = require('semver')
 16 | 
 17 |   constructor(
 18 |     private http: HttpClient,
 19 |     private versionService: VersionService,
 20 |     private addressesService: AddressesService,
 21 |     private protocolsService: ProtocolsService,
 22 |     private localStorageProtocolService: LocalStorageProtocolService,
 23 |     private localStorageServerService: LocalStorageServerService,
 24 | 
 25 |   ) { }
 26 | 
 27 |   /**
 28 |    * Checks the API version.
 29 |    * Returns hash with:
 30 |    * {
 31 |    *    "status": "ok", "outdated" or "unknown",
 32 |    *    "release-version": "0.0.34",
 33 |    *    "client-version": "0.0.32"
 34 |    * }
 35 |    */
 36 |   public async getVersionStatus() {
 37 |     let result: any = {
 38 |       "status": "unknown",
 39 |       "errors": 0,
 40 |     }
 41 | 
 42 |     let resRelease: any = await this.getResRelease();
 43 |     let clientRelease: any = await this.getClientRelease();
 44 | 
 45 |     result = {
 46 |       ...result,
 47 |       ...resRelease,
 48 |       ...clientRelease
 49 |     }
 50 | 
 51 |     result["errors"] = (
 52 |       result["errors"] +
 53 |       result["release-error"] +
 54 |       result["client-error"]
 55 |     )
 56 | 
 57 |     result["status"] = this.checkVersionStatus(
 58 |       result["release-version"],
 59 |       result["client-version"]
 60 |     )
 61 | 
 62 |     return result
 63 |   }
 64 | 
 65 |   /**
 66 |    * Get the latest release version from release api endpoint.
 67 |    * If something doesn't return semantic version, return soft error
 68 |    */
 69 |   public async getResRelease() {
 70 |     let result = {
 71 |       "release-version": "unknown",
 72 |       "release-error-message": "",
 73 |       "release-error-status": undefined,
 74 |       "release-error": 0
 75 |     }
 76 |     let resReleaseReq = this.http.get(environment.repositoryVersionLatestEndpoint).toPromise()
 77 | 
 78 |     try {
 79 |       let resRelease = await resReleaseReq
 80 | 
 81 |       if (resRelease && resRelease["tag_name"] && semverCoerce(resRelease["tag_name"]) != null) {
 82 |         result["release-version"] = semverCoerce(resRelease["tag_name"]).version
 83 |       }
 84 |     } catch (error) {
 85 |       result["release-error-status"] = error["status"]
 86 |       result["release-error-message"] = error["message"]
 87 |       result["release-error"] = 1
 88 | 
 89 |     }
 90 |     return result
 91 |   }
 92 | 
 93 |   /**
 94 |    * Get the client release version from local env.
 95 |    * If something doesn't return semantic version, return soft error
 96 |    */
 97 |   public async getClientRelease() {
 98 |     let result = {
 99 |       "client-version": "unknown",
100 |       "client-error-message": "",
101 |       "client-error-status": undefined,
102 |       "client-error": 0
103 |     }
104 |     let clientReleaseReq = this.versionService.getVersion().toPromise()
105 | 
106 |     try {
107 |       let clientRelease = await clientReleaseReq
108 | 
109 |       if (clientRelease && clientRelease["version"] && semverCoerce(clientRelease["version"]) != null) {
110 |         result["client-version"] = semverCoerce(clientRelease["version"]).version
111 |       }
112 | 
113 |     } catch (error) {
114 |       result["client-error-status"] = error["status"]
115 |       result["client-error-message"] = error["message"]
116 |       result["client-error"] = 1
117 |     }
118 |     return result
119 |   }
120 | 
121 |   /**
122 |    * Compare the versions, returning the `status`:
123 |    * "ok", "outdated", or "unknown"
124 |    * @param releaseVersion 
125 |    * @param clientVersion
126 |    */
127 |   private checkVersionStatus(releaseVersion, clientVersion) {
128 |     let status = "unknown"
129 | 
130 |     let versionsDefined = (
131 |       ![clientVersion, releaseVersion].includes(undefined) &&
132 |       ![clientVersion, releaseVersion].includes(null)
133 |     )
134 | 
135 |     if (versionsDefined && semverCoerce(releaseVersion) != null && semverCoerce(clientVersion) != null) {
136 |       let rel = semverCoerce(releaseVersion)["version"]
137 |       let client = semverCoerce(clientVersion)["version"]
138 | 
139 |       if (rel == client) {
140 |         status = "ok"
141 |       } else if (semverLt(client, rel)) {
142 |         status = "outdated"
143 |       }
144 |     }
145 | 
146 |     return status
147 |   }
148 | 
149 |   /**
150 |    * Get API status (address endpoint) and number of addresses configured.
151 |    * This helps a user understand/ troubleshoot connection details.
152 |    * Errors:
153 |    *    200 - OK
154 |    *    404 - Not found
155 |    *    0   - Nothing returns (offline?)
156 |    *
157 |    * Addresses: 0 by default
158 |    */
159 |   public async getApiAddressAvailability() {
160 |     let status = { "addresses": 0 }
161 |     let protocol = await this.localStorageProtocolService.getCurrentProtocol()
162 |     let network = await this.localStorageServerService.getCurrentNetwork()
163 | 
164 |     let res = await this.addressesService.getAddressesResponse(protocol, network).toPromise().catch(err => {
165 |       status["status"] = "error",
166 |         status["code"] = err.status,
167 |         status["message"] = err.message
168 |     });
169 | 
170 |     if (res && res["status"] == 200) {
171 |       status["status"] = "ok",
172 |         status["code"] = res["status"],
173 |         status["message"] = res["statusText"]
174 |       // Are any addresses configured?
175 |       status["addresses"] = (res["body"] && res["body"]["addresses"]) ? res["body"]["addresses"].length : 0
176 |     }
177 | 
178 |     return status
179 |   }
180 | 
181 |   /**
182 |    * Get API status (protocols endpoint) and number of protocols configured.
183 |    * This helps a user understand/ troubleshoot connection details.
184 |    * Errors:
185 |    *    200 - OK
186 |    *    404 - Not found
187 |    *    0   - Nothing returns (offline?)
188 |    *
189 |    * Protocols: 0 by default
190 |    */
191 |   public async getApiProtocolsAvailability() {
192 |     let status = { "protocols": 0 }
193 | 
194 |     let res = await this.protocolsService.getProtocolsResponse().toPromise().catch(err => {
195 |       status["status"] = "error",
196 |         status["code"] = err.status,
197 |         status["message"] = err.message
198 |     });
199 | 
200 |     if (res && res["status"] == 200) {
201 |       status["status"] = "ok",
202 |         status["code"] = res["status"],
203 |         status["message"] = res["statusText"]
204 |       // Are any protocols configured?
205 |       status["protocols"] = (res["body"] && res["body"]["protocols"]) ? res["body"]["protocols"].length : 0
206 |     }
207 | 
208 |     return status
209 |   }
210 | 
211 | 
212 | 
213 | }
214 | 


--------------------------------------------------------------------------------
/src/app/services/helpers/local-storage-nameservice/local-storage-nameservice.service.spec.ts:
--------------------------------------------------------------------------------
  1 | import { TestBed } from '@angular/core/testing';
  2 | import { MailchainTestService } from 'src/app/test/test-helpers/mailchain-test.service';
  3 | import { ProtocolsService } from '../../mailchain/protocols/protocols.service';
  4 | import { ProtocolsServiceStub } from '../../mailchain/protocols/protocols.service.stub';
  5 | 
  6 | import { LocalStorageNameserviceService } from './local-storage-nameservice.service';
  7 | 
  8 | describe('LocalStorageNameserviceService', () => {
  9 |   let localStorageNameserviceService: LocalStorageNameserviceService;
 10 |   let mailchainTestService: MailchainTestService;
 11 |   let protocolsService: ProtocolsService;
 12 | 
 13 | MailchainTestService
 14 |   beforeEach(() => {
 15 |     TestBed.configureTestingModule({
 16 |       providers: [
 17 |         LocalStorageNameserviceService,
 18 |         { provide: ProtocolsService, useClass: ProtocolsServiceStub },
 19 |       ]
 20 |     });
 21 | 
 22 |     mailchainTestService = TestBed.inject(MailchainTestService);
 23 |     localStorageNameserviceService = TestBed.inject(LocalStorageNameserviceService);
 24 |     protocolsService = TestBed.inject(ProtocolsService)
 25 | 
 26 |   });
 27 | 
 28 |   afterEach(() => {
 29 |     sessionStorage.clear();
 30 |   })
 31 |   it('should be created', () => {
 32 |     const service: LocalStorageNameserviceService = TestBed.inject(LocalStorageNameserviceService);
 33 |     expect(service).toBeTruthy();
 34 |   });
 35 | 
 36 |   describe('getCurrentNameserviceAddressEnabled', () => {
 37 |     it('should get the current nameservice address enabled status when "true"', async () => {
 38 |       sessionStorage.setItem('currentNameserviceAddressEnabled', "true");
 39 |       expect(await localStorageNameserviceService.getCurrentNameserviceAddressEnabled()).toEqual("true");
 40 |     });
 41 |     it('should get the current nameservice address enabled status when "false"', async () => {
 42 |       sessionStorage.setItem('currentNameserviceAddressEnabled', "false");
 43 |       expect(await localStorageNameserviceService.getCurrentNameserviceAddressEnabled()).toEqual("false");
 44 |     });
 45 |     it('should look up the current nameservice address enabled status from protocols endpoint if not defined, expecting `true` (ethereum)', async () => {
 46 |       sessionStorage.removeItem('currentNameserviceAddressEnabled');
 47 |       sessionStorage.setItem('currentProtocol', 'ethereum')
 48 |       sessionStorage.setItem('currentNetwork', 'mainnet')
 49 |       spyOn(protocolsService, 'getProtocols').and.returnValue(mailchainTestService.protocolsServerResponse())
 50 | 
 51 |       expect(await localStorageNameserviceService.getCurrentNameserviceAddressEnabled()).toEqual("true");
 52 |     });
 53 |     it('should look up the current nameservice address enabled status from protocols endpoint if not defined, expecting `false` (substrate)', async () => {
 54 |       sessionStorage.removeItem('currentNameserviceAddressEnabled');
 55 |       sessionStorage.setItem('currentProtocol', 'substrate')
 56 |       sessionStorage.setItem('currentNetwork', 'edgeware-mainnet')
 57 |       spyOn(protocolsService, 'getProtocols').and.returnValue(mailchainTestService.protocolsServerResponse())
 58 | 
 59 |       expect(await localStorageNameserviceService.getCurrentNameserviceAddressEnabled()).toEqual("false");
 60 |     });
 61 | 
 62 |   });
 63 |   describe('setCurrentNameserviceAddressEnabled', () => {
 64 |     it('should set the current nameservice address enabled status to "true" when `"true"`', async () => {
 65 |       localStorageNameserviceService.setCurrentNameserviceAddressEnabled("true")
 66 |       expect(await localStorageNameserviceService.getCurrentNameserviceAddressEnabled()).toEqual("true");
 67 |     });
 68 |     it('should set the current nameservice address enabled status to "false" if not "true"', async () => {
 69 |       localStorageNameserviceService.setCurrentNameserviceAddressEnabled("false")
 70 |       expect(await localStorageNameserviceService.getCurrentNameserviceAddressEnabled()).toEqual("false");
 71 |     });
 72 |   });
 73 |   describe('removeCurrentNameserviceAddressEnabled', () => {
 74 |     it('should remove the current nameservice address enabled status', async () => {
 75 |       sessionStorage.setItem('currentNameserviceAddressEnabled', "true")
 76 |       localStorageNameserviceService.removeCurrentNameserviceAddressEnabled()
 77 |       expect(sessionStorage.getItem('currentNameserviceAddressEnabled')).toEqual(null);
 78 |     });
 79 |   });
 80 | 
 81 |   describe('getCurrentNameserviceDomainEnabled', () => {
 82 |     it('should get the current nameservice domain enabled status when "true"', async () => {
 83 |       sessionStorage.setItem('currentNameserviceDomainEnabled', "true");
 84 |       expect(await localStorageNameserviceService.getCurrentNameserviceDomainEnabled()).toEqual("true");
 85 |     });
 86 |     it('should get the current nameservice domain enabled status when "false"', async () => {
 87 |       sessionStorage.setItem('currentNameserviceDomainEnabled', "false");
 88 |       expect(await localStorageNameserviceService.getCurrentNameserviceDomainEnabled()).toEqual("false");
 89 |     });
 90 |     it('should look up the current nameservice domain enabled status from protocols endpoint if not defined, expecting `true` (ethereum)', async () => {
 91 |       sessionStorage.removeItem('currentNameserviceDomainEnabled');
 92 |       sessionStorage.setItem('currentProtocol', 'ethereum')
 93 |       sessionStorage.setItem('currentNetwork', 'mainnet')
 94 |       spyOn(protocolsService, 'getProtocols').and.returnValue(mailchainTestService.protocolsServerResponse())
 95 | 
 96 |       expect(await localStorageNameserviceService.getCurrentNameserviceDomainEnabled()).toEqual("true");
 97 |     });
 98 |     it('should look up the current nameservice domain enabled status from protocols endpoint if not defined, expecting `false` (substrate)', async () => {
 99 |       sessionStorage.removeItem('currentNameserviceDomainEnabled');
100 |       sessionStorage.setItem('currentProtocol', 'substrate')
101 |       sessionStorage.setItem('currentNetwork', 'edgeware-mainnet')
102 |       spyOn(protocolsService, 'getProtocols').and.returnValue(mailchainTestService.protocolsServerResponse())
103 | 
104 |       expect(await localStorageNameserviceService.getCurrentNameserviceDomainEnabled()).toEqual("false");
105 |     });
106 |     it('should look up the current nameservice domain enabled status from protocols endpoint if not defined, expecting `false` (algorand)', async () => {
107 |       sessionStorage.removeItem('currentNameserviceDomainEnabled');
108 |       sessionStorage.setItem('currentProtocol', 'algorand')
109 |       sessionStorage.setItem('currentNetwork', 'mainnet')
110 |       spyOn(protocolsService, 'getProtocols').and.returnValue(mailchainTestService.protocolsServerResponse())
111 | 
112 |       expect(await localStorageNameserviceService.getCurrentNameserviceDomainEnabled()).toEqual("false");
113 |     });
114 | 
115 |   });
116 |   describe('setCurrentNameserviceDomainEnabled', () => {
117 |     it('should set the current nameservice domain enabled status to "true" when `"true"`', async () => {
118 |       localStorageNameserviceService.setCurrentNameserviceDomainEnabled("true")
119 |       expect(await localStorageNameserviceService.getCurrentNameserviceDomainEnabled()).toEqual("true");
120 |     });
121 |     it('should set the current nameservice domain enabled status to "false" if not "true"', async () => {
122 |       localStorageNameserviceService.setCurrentNameserviceDomainEnabled("false")
123 |       expect(await localStorageNameserviceService.getCurrentNameserviceDomainEnabled()).toEqual("false");
124 |     });
125 |   });
126 |   describe('removeCurrentNameserviceDomainEnabled', () => {
127 |     it('should remove the current nameservice domain enabled status', async () => {
128 |       sessionStorage.setItem('currentNameserviceDomainEnabled', "true")
129 |       localStorageNameserviceService.removeCurrentNameserviceDomainEnabled()
130 |       expect(sessionStorage.getItem('currentNameserviceDomainEnabled')).toEqual(null);
131 |     });
132 |   });
133 | 
134 | });
135 | 


--------------------------------------------------------------------------------
/src/app/inbox/inbox-messages/inbox-messages.component.ts:
--------------------------------------------------------------------------------
  1 | import { Component, OnInit, OnChanges, Input, Output, EventEmitter } from '@angular/core';
  2 | import { MailchainService } from 'src/app/services/mailchain/mailchain.service';
  3 | import { ReadService } from 'src/app/services/mailchain/messages/read.service';
  4 | import { InboundMail } from 'src/app/models/inbound-mail';
  5 | import { SearchPipe } from 'src/app/pipes/search-pipe/search-pipe.pipe';
  6 | import { AddressPipe } from 'src/app/pipes/address-pipe/address-pipe.pipe';
  7 | 
  8 | @Component({
  9 |   selector: '[inbox-messages]',
 10 |   templateUrl: './inbox-messages.component.html',
 11 |   styleUrls: ['./inbox-messages.component.scss'],
 12 |   providers: [SearchPipe, AddressPipe]
 13 | })
 14 | export class InboxMessagesComponent implements OnInit, OnChanges {
 15 |   @Input() messagesLoaded: boolean;
 16 |   @Input() currentAccount: string;
 17 |   @Input() currentProtocol: string;
 18 |   @Input() currentNetwork: string;
 19 |   @Input() inboxMessages: Array<any>;
 20 | 
 21 |   @Output() openMessage = new EventEmitter();
 22 |   @Output() inboxCounter = new EventEmitter<any>();
 23 | 
 24 |   public currentAccountInboxMessages: Array<any> = [];
 25 |   public searchText: string = '';
 26 |   public messagesNameRecords = {}
 27 | 
 28 |   constructor(
 29 |     private mailchainService: MailchainService,
 30 |     private readService: ReadService,
 31 |     private searchPipe: SearchPipe,
 32 |     private addressPipe: AddressPipe,
 33 |   ) {
 34 |   }
 35 | 
 36 |   /**
 37 |    * Emits an array with [address, inboxCount] for each of the addresses inputs
 38 |    * @param addresses an array of addresses
 39 |    */
 40 |   emitInboxCount(addresses: Array<any>) {
 41 | 
 42 |     addresses.forEach(address => {
 43 |       // emit message count for inbox component
 44 |       let inboxCount
 45 |       let unreadMsgs
 46 |       let uniqUnreadMsgs
 47 | 
 48 |       unreadMsgs = this.mailchainService.filterMessages(
 49 |         this.currentProtocol,
 50 |         this.inboxMessages,
 51 |         {
 52 |           status: "ok",
 53 |           readState: false,
 54 |           headersTo: address,
 55 |         }
 56 |       )
 57 | 
 58 |       uniqUnreadMsgs = this.mailchainService.dedupeMessagesByIds(unreadMsgs)
 59 | 
 60 |       inboxCount = uniqUnreadMsgs.length
 61 | 
 62 |       this.inboxCounter.emit([address, inboxCount]);
 63 |     });
 64 |   }
 65 | 
 66 |   /**
 67 |    * resolveSendersFromMessages of messages by name according to the currentNetwork and currentProtocol
 68 |    * @param messagesArray the array of messages
 69 |    */
 70 |   async resolveSendersFromMessages(messagesArray) {
 71 |     this.messagesNameRecords = await this.mailchainService.resolveSendersFromMessages(
 72 |       this.currentProtocol,
 73 |       this.currentNetwork,
 74 |       messagesArray
 75 |     )
 76 |   }
 77 | 
 78 |   /**
 79 |    * addMailToInboxMessages adds a decrypted message object to the inboxMessages array with the correct attributes
 80 |    * @param decryptedMsg the decrypted message object
 81 |    */
 82 |   addMailToInboxMessages(decryptedMsg) {
 83 |     decryptedMsg.senderIdenticon = this.generateIdenticon(decryptedMsg.headers.from)
 84 | 
 85 |     var msg = {
 86 |       ...new InboundMail,
 87 |       ...decryptedMsg
 88 |     }
 89 |     this.inboxMessages.push(msg)
 90 |   }
 91 | 
 92 |   /**
 93 |    * Handles message opening, including:
 94 |    *    Emit openMessage event
 95 |    *    Emit inboxCount
 96 |    *    Mark the message as read
 97 |    * @param mail the message to open
 98 |    */
 99 |   openMail(mail: any): void {
100 |     this.readService.markRead(mail["headers"]["message-id"]).subscribe(res => {
101 |       mail.read = true;
102 |       this.openMessage.emit(mail);
103 |       this.emitInboxCount([this.parseAddressFromMailchain(mail["headers"]["to"])])
104 |     })
105 |   }
106 | 
107 |   /**
108 |    * Returns the identicon for the mailchain formatted address
109 |    * @param address formatted <0x...@network.protocol> address
110 |    */
111 |   private generateIdenticon(address) {
112 |     return this.mailchainService.generateIdenticon(this.currentProtocol, address)
113 |   }
114 | 
115 |   /**
116 |    * Returns the extracted public address from mailchain formatted address
117 |    * @param address formatted <0x...@network.protocol> address
118 |    */
119 |   private parseAddressFromMailchain(address) {
120 |     return this.mailchainService.parseAddressFromMailchain(this.currentProtocol, address)
121 |   }
122 | 
123 |   /**
124 |    * Toggles a message `selected` attribute 
125 |    * @param message a message 
126 |    */
127 |   public selectMail(message: any): void {
128 |     message.selected = message.selected ? false : true;
129 |   }
130 | 
131 |   /**
132 |    * Selects all messages in the current selected address
133 |    */
134 |   public selectAll(): void {
135 |     for (var mail of this.currentAccountInboxMessages) {
136 |       mail.selected = true;
137 |     }
138 |   }
139 | 
140 |   /**
141 |    * Selects no messages
142 |    * NOTE: This de-selects all inbox messages, not just the current selected address.
143 |    */
144 |   public selectNone(): void {
145 |     for (var mail of this.inboxMessages) {
146 |       mail.selected = false;
147 |     }
148 |   }
149 | 
150 |   /**
151 |    * Selects the `read` messages of the current selected address
152 |   */
153 |   public selectRead(): void {
154 |     this.selectNone();
155 |     this.currentAccountInboxMessages.filter(mail => mail.read).forEach(mail => mail.selected = true);
156 |   }
157 | 
158 |   /**
159 |    * Selects the `unread` messages of the current selected address
160 |   */
161 |   public selectUnread(): void {
162 |     this.selectNone();
163 |     this.currentAccountInboxMessages.filter(mail => !mail.read).forEach(mail => mail.selected = true);
164 |   }
165 | 
166 |   /**
167 |    * Marks the currently selected messages as `read`.
168 |    */
169 |   public markSelectedAsRead(): void {
170 |     this.currentAccountInboxMessages.filter(message => message.selected).forEach(msg => {
171 |       var rcpt = this.parseAddressFromMailchain(msg["headers"]["to"])
172 |       // @TODO Add error handling
173 |       this.readService.markRead(msg["headers"]["message-id"]).subscribe(res => {
174 |         msg.read = true;
175 |         this.emitInboxCount([rcpt]);
176 |       })
177 |     });
178 |   }
179 | 
180 |   /**
181 |    * Marks the currently selected messages as `unread`.
182 |    */
183 |   markSelectedAsUnread(): void {
184 |     this.inboxMessages.filter(message => message.selected).forEach(msg => {
185 |       var rcpt = this.parseAddressFromMailchain(msg["headers"]["to"])
186 |       // @TODO Add error handling
187 |       this.readService.markUnread(msg["headers"]["message-id"]).subscribe(res => {
188 |         msg.read = false;
189 |         this.emitInboxCount([rcpt]);
190 |       })
191 |     });
192 |   }
193 | 
194 | 
195 |   async ngOnInit(): Promise<void> {
196 |     await this.getCurrentAccountInboxMessages()
197 |   }
198 | 
199 |   /**
200 |    * Get the inbox messages, filtered by 'currently selected account' > 'searchtext'.
201 |    * Dedupe message array - workaround for dupe messages @TODO: waiting on dupe bugfix in mailchain
202 |    */
203 |   async getCurrentAccountInboxMessages() {
204 |     if (this.currentProtocol && this.currentAccount) {
205 |       var inboxMessagesFilteredByAddress = this.addressPipe.transform(
206 |         this.inboxMessages, {
207 |         'protocol': this.currentProtocol,
208 |         'address': this.currentAccount
209 |       }
210 |       )
211 |       var inboxMessagesFilteredByAddressSearch: Array<any> = this.searchPipe.transform(
212 |         inboxMessagesFilteredByAddress,
213 |         this.searchText
214 |       )
215 |       this.currentAccountInboxMessages = []
216 |       // Dedupe messages
217 |       this.currentAccountInboxMessages = this.mailchainService.dedupeMessagesByIds(inboxMessagesFilteredByAddressSearch)
218 | 
219 |       // fetch names for senders
220 |       await this.resolveSendersFromMessages(this.currentAccountInboxMessages)
221 |     }
222 |   }
223 | 
224 |   async ngOnChanges(event): Promise<void> {
225 |     // Handle resetting the selected mails
226 |     if ('currentAccount' in event) {
227 |       this.selectNone()
228 |     }
229 |     await this.getCurrentAccountInboxMessages()
230 |   }
231 | 
232 | }
233 | 


--------------------------------------------------------------------------------
/src/app/services/mailchain/messages/send.service.spec.ts:
--------------------------------------------------------------------------------
  1 | import { TestBed } from '@angular/core/testing';
  2 | import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
  3 | 
  4 | import { SendService } from './send.service';
  5 | import { HttpHelpersService } from '../../helpers/http-helpers/http-helpers.service';
  6 | 
  7 | import { MailchainTestService } from '../../../test/test-helpers/mailchain-test.service';
  8 | import { ProtocolsService } from '../protocols/protocols.service';
  9 | import { ProtocolsServiceStub } from '../protocols/protocols.service.stub';
 10 | 
 11 | describe('SendService', () => {
 12 |   let sendService: SendService;
 13 |   let httpTestingController: HttpTestingController;
 14 |   let mailchainTestService: MailchainTestService
 15 | 
 16 |   beforeEach(() => {
 17 |     TestBed.configureTestingModule({
 18 |       providers: [
 19 |         SendService,
 20 |         HttpHelpersService,
 21 |         MailchainTestService,
 22 |         { provide: ProtocolsService, useClass: ProtocolsServiceStub },
 23 |       ],
 24 |       imports: [HttpClientTestingModule]
 25 |     });
 26 | 
 27 |     sendService = TestBed.inject(SendService);
 28 |     httpTestingController = TestBed.inject(HttpTestingController);
 29 |     mailchainTestService = TestBed.inject(MailchainTestService);
 30 | 
 31 |   });
 32 | 
 33 |   afterEach(() => {
 34 |     httpTestingController.verify();
 35 |   });
 36 | 
 37 |   it('should be created', () => {
 38 |     expect(sendService).toBeTruthy();
 39 |   });
 40 | 
 41 |   describe('initUrl', () => {
 42 |     it('should initialize the url', () => {
 43 |       expect(sendService['url']).toEqual('http://127.0.0.1:8080/api')
 44 |     });
 45 |   });
 46 | 
 47 |   describe('SendMail', () => {
 48 |     it('should send an outbound mail to the right url', () => {
 49 | 
 50 |       let outboundMailObject = mailchainTestService.outboundMailObject()
 51 |       let resResponse = mailchainTestService.sendMailResponse()
 52 | 
 53 |       let response = sendService.sendMail(outboundMailObject, 'ethereum', 'ropsten')
 54 | 
 55 |       response.subscribe(res => {
 56 |         expect(res["url"]).toEqual(resResponse["url"])
 57 |       })
 58 |       // handle open connections      
 59 |       const req = httpTestingController.expectOne(resResponse["url"]);
 60 |       expect(req.request.method).toBe("POST");
 61 |       req.flush(resResponse);
 62 | 
 63 |     })
 64 |     it('should send an outbound mail and return the right body', () => {
 65 | 
 66 |       let outboundMailObject = mailchainTestService.outboundMailObject()
 67 |       let resResponse = mailchainTestService.sendMailResponse()
 68 | 
 69 |       let response = sendService.sendMail(outboundMailObject, 'ethereum', 'ropsten')
 70 | 
 71 |       response.subscribe(res => {
 72 |         expect(res["body"]["body"]).toEqual(resResponse["body"])
 73 |       })
 74 | 
 75 |       // handle open connections
 76 |       const req = httpTestingController.expectOne(resResponse["url"]);
 77 |       expect(req.request.method).toBe("POST");
 78 |       req.flush(resResponse);
 79 | 
 80 |     })
 81 |     it('should send an outbound mail and get a 200 response', () => {
 82 | 
 83 |       let outboundMailObject = mailchainTestService.outboundMailObject()
 84 |       let resResponse = mailchainTestService.sendMailResponse()
 85 | 
 86 |       let response = sendService.sendMail(outboundMailObject, 'ethereum', 'ropsten')
 87 | 
 88 |       response.subscribe(res => {
 89 |         expect(res["status"]).toEqual(resResponse["status"])
 90 |       })
 91 | 
 92 |       // console.warn(httpTestingController, 97);
 93 | 
 94 |       // handle open connections
 95 |       const req = httpTestingController.expectOne(resResponse["url"]);
 96 |       expect(req.request.method).toBe("POST");
 97 |       req.flush(resResponse);
 98 | 
 99 |     })
100 | 
101 |     it('should send an outbound mail to the right network', () => {
102 |       let outboundMailObject = mailchainTestService.outboundMailObject()
103 |       let network = "mytestnet"
104 |       let response = sendService.sendMail(outboundMailObject, 'ethereum', network)
105 |       let url = `http://127.0.0.1:8080/api/messages?protocol=ethereum&network=${network}`
106 |       let body = null
107 | 
108 |       response.subscribe(res => {
109 |         expect(res["url"]).toEqual(url)
110 |       })
111 | 
112 |       // handle open connections
113 |       const req = httpTestingController.expectOne(url);
114 |       expect(req.request.method).toBe("POST");
115 |       req.flush(body);
116 |     })
117 | 
118 |     it('should specify envelope type "0x05" in the outbound mail', () => {
119 |       let outboundMailObject = mailchainTestService.outboundMailObject()
120 |       expect(outboundMailObject.envelope).toBe("0x05")
121 |     })
122 | 
123 |     xit('should error on send if envelope type is empty in the outbound mail', () => {
124 |       // TODO add test for: should error on send if envelope type is empty in the outbound mail
125 |       // let outboundMailObject = mailchainTestService.outboundMailObject()
126 |       // outboundMailObject.envelope = ""
127 |     })
128 | 
129 |     it('should specify public-key-encoding as "hex/0x-prefix" in the outbound mail', () => {
130 |       let outboundMailObject = mailchainTestService.outboundMailObject()
131 |       expect(outboundMailObject["message"]["public-key-encoding"]).toBe("hex/0x-prefix")
132 |     })
133 | 
134 |     xit('should error on send if public-key-encoding is empty in the outbound mail', () => {
135 |       // TODO add test for: should error on send if public-key-encoding is empty in the outbound mail
136 |       // let outboundMailObject = mailchainTestService.outboundMailObject()
137 |       // outboundMailObject["message"]["public-key-encoding"] = ""
138 |     })
139 | 
140 |     it('should specify public-key-kind as "secp256k1" in the outbound mail by default', () => {
141 |       let outboundMailObject = mailchainTestService.outboundMailObject()
142 |       expect(outboundMailObject["message"]["public-key-kind"]).toBe("secp256k1")
143 |     })
144 | 
145 |     xit('should error on send if public-key-kind is empty in the outbound mail', () => {
146 |       // TODO add test for: should error on send if public-key-kind is empty in the outbound mail
147 |       // let outboundMailObject = mailchainTestService.outboundMailObject()
148 |       // outboundMailObject["message"]["public-key-kind"] = ""
149 |     })
150 | 
151 |     it('should specify encryption-method-name as "aes256cbc" in the outbound mail', () => {
152 |       let outboundMailObject = mailchainTestService.outboundMailObject()
153 |       expect(outboundMailObject["encryption-method-name"]).toBe("aes256cbc")
154 |     })
155 | 
156 |     xit('should error on send if encryption-method-name is empty in the outbound mail', () => {
157 |       // TODO add test for: should error on send if encryption-method-name is empty in the outbound mail
158 |       // let outboundMailObject = mailchainTestService.outboundMailObject()
159 |       // outboundMailObject["encryption-method-name"] = ""
160 |     })
161 | 
162 |     it('should specify `envelope` in the outbound mail', () => {
163 |       let outboundMailObject = mailchainTestService.outboundMailObject()
164 |       expect(outboundMailObject["envelope"]).not.toBeUndefined()
165 |     })
166 | 
167 |     xit('should error on send if `envelope` is empty in the outbound mail', () => {
168 |       // TODO add test for: should error on send if envelope is empty in the outbound mail
169 |     })
170 | 
171 |     it('should specify content-type as "text/plain; charset=\"UTF-8\"" by default in the outbound mail', () => {
172 |       let outboundMailObject = mailchainTestService.outboundMailObject()
173 |       expect(outboundMailObject["content-type"]).toBe("text/plain; charset=\"UTF-8\"")
174 |     })
175 | 
176 |     it('should specify content-type as "text/plain; charset=\"UTF-8\"" when messageType = "plaintext" in the outbound mail', () => {
177 |       let outboundMailObject = mailchainTestService.outboundMailObjectPlainText()
178 |       expect(outboundMailObject["content-type"]).toBe("text/plain; charset=\"UTF-8\"")
179 |     })
180 | 
181 |     it('should specify content-type as "text/html; charset=\"UTF-8\"" when messageType = "html" in the outbound mail', () => {
182 |       let outboundMailObject = mailchainTestService.outboundMailObjectHtml()
183 |       expect(outboundMailObject["content-type"]).toBe("text/html; charset=\"UTF-8\"")
184 |     })
185 | 
186 |   })
187 | });
188 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Mailchain Web - LEGACY - [DEPRECATED]
  2 | 
  3 | You will be able to communicate with any web3 address with Mailchain. That means you can send and receive messages to and from blockchain addresses (aka accounts or wallets). 
  4 | 
  5 | It’s just like email but we’re convinced it’s better, it’s built for web3 but with a frenly user experience. You get a familiar inbox with:
  6 | 
  7 | - End-to-end encryption
  8 | - Decentralised object storage (IPFS, etc.)
  9 | - Name registries (ENS, etc)
 10 | - Is multi-protocol
 11 | - And... much more 🚀
 12 | 
 13 | ## Find out more
 14 | 
 15 | We'd :heart: for you to join our growing community on [Discord](https://discord.gg/2gqGpagbhe). It's the best place to reach us and get involved.
 16 | 
 17 | Follow [@mailchain_xyz](https://twitter.com/mailchain_xyz) on Twitter to hear about new releases and updates.
 18 | 
 19 | If Discord isn’t right for you, contact us via traditional [email](mailto:team@mailchain.co).
 20 | 
 21 | ------
 22 | 
 23 | [![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)
 24 | [![Build Status](https://travis-ci.com/mailchain/mailchain-web.svg?branch=master)](https://travis-ci.com/mailchain/mailchain-web)
 25 | [![Coverage Status](https://coveralls.io/repos/github/mailchain/mailchain-web/badge.svg?branch=master)](https://coveralls.io/github/mailchain/mailchain-web?branch=master)
 26 | 
 27 | <!-- @import "[TOC]" {cmd="toc" depthFrom=1 depthTo=6 orderedList=false} -->
 28 | 
 29 | <!-- code_chunk_output -->
 30 | 
 31 | * [MailchainWeb Readme](#mailchainweb-readme)
 32 | 	* [Welcome to Mailchain](#welcome-to-mailchain)
 33 | 	* [About Mailchain](#about-mailchain)
 34 | 		* [Introduction](#introduction)
 35 | 		* [Mailchain Message Lifecycle](#mailchain-message-lifecycle)
 36 | 	* [Getting Started](#getting-started)
 37 | 	* [Address Formats](#address-formats)
 38 | 		* [URL and Port Settings](#url-and-port-settings)
 39 | 		* [Browser Storage](#browser-storage)
 40 | 		* [Message Storage](#message-storage)
 41 | 	* [Development Info](#development-info)
 42 | 		* [Development server](#development-server)
 43 | 		* [Build](#build)
 44 | 		* [Running unit tests](#running-unit-tests)
 45 | 		* [Running end-to-end tests](#running-end-to-end-tests)
 46 | 	* [License](#license)
 47 | 
 48 | <!-- /code_chunk_output -->
 49 | 
 50 | ## Welcome to Mailchain
 51 | 
 52 | This repository contains the Mailchain Web Application that is powered by [https://github.com/mailchain/mailchain](https://github.com/mailchain/mailchain), built to the [Mailchain specification](https://github.com/mailchain/mailchain-specification).
 53 | 
 54 | ---
 55 | 
 56 | ## About Mailchain
 57 | 
 58 | Extract from the [Mailchain specification](https://github.com/mailchain/mailchain-specification):
 59 | 
 60 | ### Introduction
 61 | 
 62 | Mailchain enables blockchain-based email-like messaging with plain or rich text and attachment capabilities. Using blockchain protocols and decentralized storage, Mailchain delivers a simple, secure, messaging experience.
 63 | 
 64 | Account holders or owners of a public address often need to communicate in the context of the account or public address. Communication may relate to transactions, account actions or some type of notification.
 65 | 
 66 | Examples of use cases for blockchain messaging include invoicing, receipts, contacting users of a service or application developers.
 67 | 
 68 | The majority of blockchain protocols provide no standard way to handle messaging. Some account holders have sent messages as an encrypted or unencrypted string included in transaction data. Some applications work around the problem by asking users to link another method of contact (e.g. email address, phone number etc.) to an application. This compromises anonymity by asking users to link or reveal an identity. It also increases exposure to security risks, and relies on additional centralized services.
 69 | 
 70 | This proposal outlines how Mailchain gives users the ability to send and receive rich-media HTML messages between public addresses through a simple, email-like interface. All message contents and attachments are encrypted so only the intended recipient of the message can decrypt and view messages.
 71 | 
 72 | ### Mailchain Message Lifecycle
 73 | 
 74 | Mailchain is a simple, secure and practical standard which can be implemented across different blockchains. It uses underlying native blockchain protocol capabilities including addressing, immutability, data transmission, and cryptography.
 75 | 
 76 | The basic message flow is as follows:
 77 | 
 78 | * A user sends a message. The message is encrypted and stored using the recipient’s public key so that only the recipient can locate and decrypt the message contents. The encrypted location of the message is sent by the sender to the recipient in the data field of a transaction.
 79 | 
 80 | * To read a message, a recipient uses a corresponding private key to decrypt the location of the message from the data field of a transaction and decrypt the message contents.
 81 | 
 82 | ---
 83 | 
 84 | ## Getting Started
 85 | 
 86 | 1. To use the Mailchain Web Application, you need to be running the [mailchain application](https://github.com/mailchain/mailchain) which contains the api and configuration for messaging.
 87 | 
 88 | 2. Then to use the mailchain web interface, either:
 89 | 
 90 |     * download the files in `/dist`, or
 91 |     * go to https://inbox.mailchain.xyz
 92 | 
 93 | ## Address Formats
 94 | 
 95 | The following address formats are referenced:
 96 | 
 97 | | Address Format | Example | Notes |
 98 | | --- | --- | --- |
 99 | | Ethereum | `0xd5ab4ce3605cd590db609b6b5c8901fdb2ef7fe6` | Case insensitive |
100 | | Mailchain | `<0xd5ab4ce3605cd590db609b6b5c8901fdb2ef7fe6@ropsten.ethereum>` | Case insensitive |
101 | 
102 | ### URL and Port Settings
103 | 
104 | By default, the Mailchain web interface expects to communicate with the Mailchain application running on the localhost using port 8080.
105 | 
106 | To change this:
107 | 
108 | #### Change server settings on the Inbox page
109 | 
110 | 1. Click 'Settings' on the Inbox page
111 | 1. Make any updates
112 | 1. Click 'save'
113 | 
114 | #### Change server settings using url query parameters
115 | 
116 | It is possible to change the settings programatically using a url with params. For example, `http://localhost:4200/#/?web-protocol=http&host=localhost&port=8080` will configure the Inbox to use: `http` to contact `localhost` on port `8080`. The Inbox will set the values, then refresh the page.
117 | 
118 | | Query Parameter | Description |
119 | | --- | --- | 
120 | | `web-protocol` | The Internet protocol e.g. `http` or `https` | 
121 | | `host` | The host e.g. `localhost`, `127.0.0.1` or another host | 
122 | | `port` | The port e.g. `8080` |
123 | 
124 | ### Browser Storage
125 | The following values are cached in the browser session storage:
126 | 
127 | Key | Value
128 | | - | - |
129 | currentNetwork: | The current selected network (e.g. `ropsten`, `mainnet`)
130 | currentAccount: | The current selected account for this network
131 | currentProtocol: | The current selected blockchain protocol
132 | currentWebProtocol: | The current selected web protocol (e.g. `https` or `http`) for contacting the mailchain application
133 | currentPort: | The current selected port (e.g. `8080`) for contacting the mailchain application
134 | currentHost: | The current selected host (e.g. `127.0.0.1`, `localhost`, etc.) for contacting the mailchain application
135 | 
136 | ### Message Storage
137 | 
138 | The Mailchain web application does not store message contents.
139 | 
140 | ## Development Info
141 | 
142 | ### Requirements
143 | 
144 | node_js version 13
145 | 
146 | ### Development server
147 | 
148 | Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The app will automatically reload if you change any of the source files.
149 | 
150 | ### Build
151 | 
152 | Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory. Use the `--prod` flag for a production build.
153 | 
154 | ### Running unit tests
155 | 
156 | Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).
157 | 
158 | ## Security Review Status: pre-audit
159 | 
160 | The code in this repository has not been audited.
161 | 
162 | ## License
163 | 
164 | [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fmailchain%2Fmailchain-web.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fmailchain%2Fmailchain-web?ref=badge_large)
165 | 


--------------------------------------------------------------------------------