├── .babelrc
├── .eslintignore
├── .gitignore
├── LICENSE
├── README.md
├── contracts
    ├── DecentralizedSchedule.sol
    └── Migrations.sol
├── dist
    └── index.html
├── ethpm.json
├── migrations
    ├── 1_initial_migration.js
    └── 2_deploy_contracts.js
├── package.json
├── src
    ├── App.tsx
    ├── assets
    │   └── .gitkeep
    ├── components
    │   ├── Button.tsx
    │   ├── CreateForm.tsx
    │   ├── CreateSchedule.tsx
    │   ├── ErrorBox.ts
    │   ├── EthHeader.ts
    │   ├── InputElements.ts
    │   ├── StyleConstants.ts
    │   ├── Vote.tsx
    │   └── VotingForm.tsx
    ├── cryptoutils.ts
    ├── cryptoutils.tsx
    ├── environments
    │   ├── environment.prod.ts
    │   └── environment.ts
    ├── favicon.ico
    ├── index.tsx
    ├── model
    │   ├── EthModel.ts
    │   └── VotingModel.ts
    ├── styles.css
    ├── tsconfig.spec.json
    └── web3.ts
├── test
    └── blockchain-schedule.js
├── truffle.init.json
├── truffle.js
├── tsconfig.json
├── tsfmt.json
├── tslint.json
└── webpack.config.js


/.babelrc:
--------------------------------------------------------------------------------
1 | {
2 |   "presets": ["env"]
3 | }


--------------------------------------------------------------------------------
/.eslintignore:
--------------------------------------------------------------------------------
1 | tmp/**
2 | build/**
3 | node_modules/**
4 | contracts/**
5 | migrations/1_initial_migration.js
6 | migrations/2_deploy_contracts.js
7 | test/didle.js


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | build
2 | node_modules
3 | yarn-error.log


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Krzysztof Ciesielski
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Decentralized Scheduling
 2 | ========================
 3 | 
 4 | This is an example app demonstrating capabilities of Ethereum and decentralized apps on the blockchain.  
 5 | Detailed description in [this article](https://softwaremill.com/event-sourcing-on-blockchain/).
 6 | 
 7 | ## Prerequisites
 8 | 
 9 | - npm
10 | - [testrpc](https://github.com/ethereumjs/testrpc)
11 | 
12 | ## How to build
13 | 
14 | - Call `npm run truffle-compile` to build the smart contract.
15 | - Start testrpc by running `testrpc`.
16 | - Call `truffle deploy` to deploy the smart contract to your local test network.
17 | - Call `npm start` to run the client app.
18 | - Go to `localhost:8080` in your browser.
19 | 


--------------------------------------------------------------------------------
/contracts/DecentralizedSchedule.sol:
--------------------------------------------------------------------------------
  1 | pragma solidity ^0.4.13;
  2 | 
  3 | contract DecentralizedSchedule {
  4 |    
  5 |     // This is a type for a single proposal.
  6 |     struct Proposal {
  7 |         bytes32 name; 
  8 |         int128 voteCount; // number of accumulated votes
  9 |     }
 10 | 
 11 |     struct UserVote {
 12 |         bool voted;
 13 |         uint proposalIndex;
 14 |     }
 15 | 
 16 |     struct Voting {
 17 |         string name;
 18 |         Proposal[] proposals;
 19 |         mapping(address => UserVote) votes;
 20 |     }
 21 | 
 22 |     // Key here is the unique address generated for each voting, called "signer"
 23 |     mapping(address => Voting) public votings;
 24 | 
 25 |     function voteSummary(address signer) constant returns (string, bytes32[], int128[]) {
 26 |         return (votings[signer].name, proposalNames(signer), voteCounts(signer));
 27 |     }
 28 |     
 29 |     function voteCounts(address signer) constant returns (int128[]) {
 30 |         var ps = votings[signer].proposals;
 31 |         var arr = new int128[](ps.length);
 32 |         for (uint i = 0; i < ps.length; i++) {
 33 |             arr[i] = ps[i].voteCount;
 34 |         }
 35 |         return arr;
 36 |     }
 37 | 
 38 |     function proposalNames(address signer) constant returns (bytes32[] names) {
 39 |         var ps = votings[signer].proposals;
 40 |         var arr = new bytes32[](ps.length);
 41 |         for (uint i = 0; i < ps.length; i++) {
 42 |             arr[i] = ps[i].name;
 43 |         }
 44 |         return arr;
 45 |     }
 46 | 
 47 |     function proposalName(address signer, uint8 proposalIndex) constant returns (bytes32 name) {
 48 |         return votings[signer].proposals[proposalIndex].name;
 49 |     }
 50 |     
 51 |     function isEmpty(string str) constant returns (bool) {
 52 |         bytes memory tempEmptyStringTest = bytes(str);
 53 |         return (tempEmptyStringTest.length == 0);
 54 |     }
 55 |     
 56 |     function create(address signer, string name, bytes32[] proposalNames) {
 57 |         var voting = votings[signer];
 58 |         require(isEmpty(voting.name));
 59 |                
 60 |         /* // TODO validations of proposalNames, escape etc. */
 61 |         for (uint i = 0; i < proposalNames.length; i++) {                        
 62 |             voting.proposals.push(Proposal({
 63 |                 name: proposalNames[i],
 64 |                 voteCount: 0
 65 |             }));
 66 |         }
 67 |         voting.name = name;
 68 |         votings[signer] = voting;
 69 |     }
 70 | 
 71 |     event VoteSingle(address voter, address indexed signer, string voterName, uint8 proposal);
 72 | 
 73 |     function addressToString(address x) returns (string) {
 74 |         bytes memory s = new bytes(40);
 75 |         for (uint i = 0; i < 20; i++) {
 76 |             byte b = byte(uint8(uint(x) / (2**(8*(19 - i)))));
 77 |             byte hi = byte(uint8(b) / 16);
 78 |             byte lo = byte(uint8(b) - 16 * uint8(hi));
 79 |             s[2 * i] = char(hi);
 80 |             s[2*  i + 1] = char(lo);            
 81 |         }
 82 |         return string(s);
 83 |     }
 84 | 
 85 |     function char(byte b) returns (byte c) {
 86 |         if (b < 10) return byte(uint8(b) + 0x30);
 87 |         else return byte(uint8(b) + 0x57);
 88 |     }
 89 |         
 90 |     function addressKeccak(address addr) constant returns(bytes32) {
 91 |         // The "42" here stands for string length of an address
 92 |         return keccak256("\x19Ethereum Signed Message:\n420x", addressToString(addr));
 93 |     }
 94 | 
 95 |     function vote(string name, uint8 proposal, bytes32 prefixedSenderHash, bytes32 r, bytes32 s, uint8 v) returns (uint256) {
 96 |         require(addressKeccak(msg.sender) == prefixedSenderHash);
 97 |         var signer = ecrecover(prefixedSenderHash, v, r, s);
 98 |         var voting = votings[signer];
 99 |         require(!isEmpty(voting.name));
100 |         require(proposal < voting.proposals.length);
101 | 
102 |         var prevVote = voting.votes[msg.sender];
103 |         if (prevVote.voted) {
104 |             voting.proposals[prevVote.proposalIndex].voteCount -= 1;
105 |         }
106 |         else {
107 |             voting.votes[msg.sender].voted = true;
108 |         }
109 |         voting.votes[msg.sender].proposalIndex = proposal;
110 |         voting.proposals[proposal].voteCount += 1;
111 | 
112 |         VoteSingle(msg.sender, signer, name, proposal);
113 |     }
114 | }
115 | 


--------------------------------------------------------------------------------
/contracts/Migrations.sol:
--------------------------------------------------------------------------------
 1 | pragma solidity ^0.4.13;
 2 | 
 3 | contract Migrations {
 4 |   address public owner;
 5 |   uint public last_completed_migration;
 6 | 
 7 |   modifier restricted() {
 8 |     if (msg.sender == owner) _;
 9 |   }
10 | 
11 |   function Migrations() {
12 |     owner = msg.sender;
13 |   }
14 | 
15 |   function setCompleted(uint completed) restricted {
16 |     last_completed_migration = completed;
17 |   }
18 | 
19 |   function upgrade(address new_address) restricted {
20 |     Migrations upgraded = Migrations(new_address);
21 |     upgraded.setCompleted(last_completed_migration);
22 |   }
23 | }
24 | 


--------------------------------------------------------------------------------
/dist/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | 
 4 | <head>
 5 |   <meta charset="UTF-8"/>
 6 | </head>
 7 | 
 8 | <body>
 9 |   <div id="example"></div>
10 | 
11 |   <script src="/bundle.js"></script>
12 | </body>
13 | 
14 | </html>
15 | 


--------------------------------------------------------------------------------
/ethpm.json:
--------------------------------------------------------------------------------
1 | {
2 |     package_name: "blockchain-schedule",
3 |     version: "1.0.0",
4 |     description: "Distributed collaborative scheduling on Ethereum blockchain",
5 |     authors: [ "Krzysztof Ciesielski" ],
6 |     keywords: [ "ethereum", "doodle" ],
7 |     license: "MIT"
8 | }
9 | 


--------------------------------------------------------------------------------
/migrations/1_initial_migration.js:
--------------------------------------------------------------------------------
1 | var Migrations = artifacts.require("./Migrations.sol");
2 | 
3 | module.exports = function(deployer) {
4 |   deployer.deploy(Migrations);
5 | };
6 | 


--------------------------------------------------------------------------------
/migrations/2_deploy_contracts.js:
--------------------------------------------------------------------------------
1 | var DecentralizedSchedule = artifacts.require("./DecentralizedSchedule.sol");
2 | 
3 | module.exports = function(deployer) {
4 |   deployer.deploy(DecentralizedSchedule);
5 | };
6 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "react-truffle-ts",
 3 |   "version": "0.0.0",
 4 |   "license": "MIT",
 5 |   "scripts": {
 6 |     "truffle-compile": "truffle compile",
 7 |     "start": "webpack-dev-server --inline --content-base dist/ --history-api-fallback",
 8 |     "lint": "eslint --ext=js --ext=jsx --ignore-path .gitignore .",
 9 |     "build": "webpack",
10 |     "test": "mocha-webpack"
11 |   },
12 |   "private": true,
13 |   "dependencies": {
14 |     "@types/node": "^8.0.7",
15 |     "@types/react": "^15.0.33",
16 |     "@types/react-dom": "^15.5.1",
17 |     "bignumber": "^1.1.0",
18 |     "core-js": "^2.4.1",
19 |     "ethereumjs-util": "^5.1.2",
20 |     "immutability-helper": "^2.3.0",
21 |     "lodash": "^4.17.4",
22 |     "react": "^15.6.1",
23 |     "react-dom": "^15.6.1",
24 |     "react-router-dom": "^4.1.1",
25 |     "styled-components": "^2.1.1",
26 |     "web3": "^0.18.2",
27 |     "web3-loader": "^1.1.2"
28 |   },
29 |   "devDependencies": {
30 |     "@types/lodash": "^4.14.71",
31 |     "awesome-typescript-loader": "^3.2.1",
32 |     "babel-cli": "^6.22.2",
33 |     "babel-core": "^6.22.1",
34 |     "babel-eslint": "^6.1.2",
35 |     "babel-loader": "^6.2.10",
36 |     "babel-plugin-transform-runtime": "^6.22.0",
37 |     "babel-preset-env": "^1.1.8",
38 |     "babel-preset-es2015": "^6.22.0",
39 |     "babel-register": "^6.22.0",
40 |     "copy-webpack-plugin": "^4.0.1",
41 |     "css-loader": "^0.26.1",
42 |     "eslint": "^3.14.0",
43 |     "eslint-config-standard": "^6.0.0",
44 |     "eslint-plugin-babel": "^4.0.0",
45 |     "eslint-plugin-mocha": "^4.8.0",
46 |     "eslint-plugin-promise": "^3.0.0",
47 |     "eslint-plugin-standard": "^2.0.0",
48 |     "ethjs-account": "0.1.0",
49 |     "html-webpack-plugin": "^2.28.0",
50 |     "style-loader": "^0.13.1",
51 |     "truffle": "^3.4.6",
52 |     "truffle-contract": "^1.1.6",
53 |     "ts-node": "~2.0.0",
54 |     "tslint": "~4.4.2",
55 |     "typescript": "^2.4.1",
56 |     "webpack": "^2.2.1",
57 |     "webpack-dev-server": "^2.3.0"
58 |   }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/App.tsx:
--------------------------------------------------------------------------------
 1 | import * as React from 'react';
 2 | import { injectGlobal } from 'styled-components';
 3 | import {
 4 |     BrowserRouter as Router,
 5 |     Route,
 6 |     Link
 7 | } from 'react-router-dom';
 8 | 
 9 | import CreateSchedule from './components/CreateSchedule';
10 | import Vote from './components/Vote';
11 | 
12 | class App extends React.Component<{}, {}> {
13 | 
14 |     render() {
15 |         injectGlobal`
16 |   body {
17 |     font-family: 'Open Sans', sans-serif;
18 |     margin-top: 10%;
19 |     margin-left: 25%;
20 |     margin-right: 25%;
21 |   }
22 | `;
23 |         return (
24 |             <Router>
25 |                 <div className="container">
26 |                     <Route exact path="/" component={CreateSchedule} />
27 |                     <Route exact path="/vote" component={Vote} />
28 |                 </div>
29 |             </Router>
30 |         );
31 |     }
32 | }
33 | 
34 | export default App;
35 | 


--------------------------------------------------------------------------------
/src/assets/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/softwaremill/blockchain-schedule/60cbb6013730ba9288334944025dd100524d78ef/src/assets/.gitkeep


--------------------------------------------------------------------------------
/src/components/Button.tsx:
--------------------------------------------------------------------------------
 1 | import * as React from 'react'
 2 | import styled from 'styled-components'
 3 | import { DefaultFontSize } from './StyleConstants'
 4 | 
 5 | interface ButtonProps {
 6 |     className?: string
 7 |     primary?: boolean
 8 |     text: string
 9 |     onClick: (any) => void
10 | }
11 | 
12 | const Button = (props: ButtonProps) => <button type="button" className={props.className} onClick={props.onClick}>{props.text}</button>
13 | 
14 | const StyledButton = styled(Button) `
15 |     background: ${props => props.primary ? '#005dc9' : 'rgb(244, 244, 244)'};
16 |     border: 1px solid;
17 |     border-color: ${props => props.primary ? 'rgb(0,78,170)' : 'rgb(204, 204, 204)'};
18 |     border-radius: 4px;
19 |     color: ${props => props.primary ? 'rgb(238, 238, 238)' : 'rgb(50, 50, 50)'};
20 |     cursor: pointer;
21 |     font-size: ${DefaultFontSize};
22 |     line-height: 18px;
23 |     margin-right: 5px;
24 |     padding: 0 10px;
25 | `
26 | 
27 | export default StyledButton
28 | 


--------------------------------------------------------------------------------
/src/components/CreateForm.tsx:
--------------------------------------------------------------------------------
  1 | import * as React from 'react'
  2 | import styled from 'styled-components'
  3 | import Button from './Button'
  4 | import ErrorBox from './ErrorBox'
  5 | import Input, { ShortInput, InputLabel } from './InputElements'
  6 | import * as ethjs from 'ethjs-account'
  7 | import { withRouter } from 'react-router-dom'
  8 | 
  9 | export interface CreateScheduleState {
 10 |     name: string,
 11 |     options: Array<string>,
 12 |     newOption: string,
 13 |     formError: boolean,
 14 |     formErrorMsg: string
 15 | }
 16 | 
 17 | export interface CreateScheduleProps {
 18 |     contract: any
 19 |     account: any
 20 |     className?: string
 21 | }
 22 | 
 23 | class CreateForm extends React.Component<CreateScheduleProps, CreateScheduleState> {
 24 | 
 25 |     now() {
 26 |         return new Date().toJSON().slice(0, 10)
 27 |     }
 28 | 
 29 |     public constructor(props: CreateScheduleProps) {
 30 |         super(props)
 31 |         let utc: string = this.now()
 32 |         this.state = { name: "", options: [], newOption: utc, formError: false, formErrorMsg: "" }
 33 |         this.handleInputChange = this.handleInputChange.bind(this)
 34 |         this.addNewDate = this.addNewDate.bind(this)
 35 |         this.validInput = this.validInput.bind(this)
 36 |         this.createSchedule = this.createSchedule.bind(this)
 37 |         this.handleNameChange = this.handleNameChange.bind(this)
 38 |     }
 39 | 
 40 |     createSchedule(history: any) {
 41 |         if (this.state.options.length == 0) {
 42 |             this.setState({ formError: true, formErrorMsg: "Empty option list not allowed." })
 43 |         } else {
 44 |             const signer = ethjs.generate('892h@fsdf11ks8sk^2h8s8shfs.jk39hsoi@hohskd')
 45 |             const ballotId: string = signer.address
 46 |             const key: string = signer.privateKey
 47 | 
 48 | 
 49 |             this.props.contract.deployed()
 50 |                 .then(instance => instance.create(ballotId, this.state.name, this.state.options, { from: this.props.account, gas: 1334400 }))
 51 |                 .then(r => {
 52 |                     console.log("Contract executed")
 53 |                     history.push('/vote?key=' + key + '&b=' + r.receipt.blockNumber)
 54 |                 })
 55 |         }
 56 |     }
 57 | 
 58 |     addNewDate() {
 59 |         if (this.validInput()) {
 60 |             this.setState({
 61 |                 options: [...this.state.options, this.state.newOption],
 62 |                 newOption: this.now()
 63 |             });
 64 |         }
 65 |     }
 66 | 
 67 |     validInput(): boolean {
 68 |         if (this.state.options.some(x => x === this.state.newOption)) {
 69 |             this.setState({ formError: true, formErrorMsg: "Duplicates not allowed" })
 70 |             return false
 71 |         } else {
 72 |             this.setState({ formError: false })
 73 |             return true
 74 |         }
 75 |     }
 76 | 
 77 |     handleInputChange(event: React.SyntheticEvent<HTMLInputElement>) {
 78 |         this.setState({ newOption: event.currentTarget.value })
 79 |     }
 80 | 
 81 |     handleNameChange(event: React.SyntheticEvent<HTMLInputElement>) {
 82 |         this.setState({ name: event.currentTarget.value })
 83 |     }
 84 | 
 85 |     render() {
 86 |         const rows = this.state.options.map(opt => <li key={opt}>{opt}</li>)
 87 |         const CreateButton = withRouter(({ history }) => (
 88 |             <Button primary text="Create Event" onClick={() => { this.createSchedule(history) }} />))
 89 | 
 90 |         return (
 91 |             <div className={this.props.className}>
 92 |                 <InputLabel>Event name</InputLabel>
 93 |                 <Input value={this.state.name} onChange={this.handleNameChange} />
 94 |                 <ul>
 95 |                     {rows}
 96 |                 </ul>
 97 |                 <div>
 98 |                     <ShortInput value={this.state.newOption} onChange={this.handleInputChange} />
 99 |                     <Button text="Add" onClick={this.addNewDate} />
100 |                     <CreateButton />
101 |                 </div>
102 |                 {
103 |                     this.state.formError
104 |                         ? <ErrorBox><span>{this.state.formErrorMsg}</span></ErrorBox>
105 |                         : null
106 |                 }
107 | 
108 |             </div>
109 |         )
110 |     }
111 | }
112 | 
113 | const StyledForm = styled(CreateForm) `
114 |     background-color: #edf4fe;
115 |     border: 1px #d6d6d6 solid;
116 |     display: flex;
117 |     flex-direction: column;
118 |     padding: 5px;
119 |     width: 550px;
120 | `
121 | 
122 | export default StyledForm
123 | 


--------------------------------------------------------------------------------
/src/components/CreateSchedule.tsx:
--------------------------------------------------------------------------------
 1 | import * as React from 'react';
 2 | import * as Web3 from '../web3'
 3 | import CreateForm from './CreateForm'
 4 | import EthHeader from './EthHeader'
 5 | import * as loadContract from 'truffle-contract'
 6 | const ethArtifacts = require('../../build/contracts/DecentralizedSchedule.json')
 7 | 
 8 | export interface FormState {
 9 |     account: string
10 | }
11 | 
12 | export default class CreateSchedule extends React.Component<{}, FormState> {
13 | 
14 |     contract: any
15 |     web3: any
16 | 
17 |     constructor(props: any) {
18 |         super(props)
19 |         this.contract = loadContract(ethArtifacts)
20 |         this.state = { account: "" }
21 |     }
22 | 
23 |     componentDidMount() {
24 |         Web3.initWeb3((accs: string[], initializedWeb3: any) => {
25 |             this.web3 = initializedWeb3
26 |             this.contract.setProvider(this.web3.currentProvider)
27 | 
28 |             this.setState({
29 |                 account: accs[0]
30 |             })
31 |         });
32 |     }
33 | 
34 |     render() {
35 |         return (
36 |             <div>
37 |                 <div>
38 |                     <EthHeader>Current eth account: {this.state.account}</EthHeader>
39 |                 </div>
40 |                 <h1>New Event</h1>
41 |                 <CreateForm contract={this.contract} account={this.state.account} />
42 |             </div>
43 |         )
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/components/ErrorBox.ts:
--------------------------------------------------------------------------------
 1 | import styled from 'styled-components'
 2 | 
 3 | const ErrorBox = styled.div`
 4 |      margin: 5px;
 5 |      flex:1 1 auto;
 6 |      font-size: 13px;
 7 |      color: red;
 8 | `
 9 | 
10 | export default ErrorBox
11 | 


--------------------------------------------------------------------------------
/src/components/EthHeader.ts:
--------------------------------------------------------------------------------
1 | import styled from 'styled-components'
2 | 
3 | const EthHeader = styled.h2`
4 |       color: #AAA
5 | `
6 | 
7 | export default EthHeader
8 | 


--------------------------------------------------------------------------------
/src/components/InputElements.ts:
--------------------------------------------------------------------------------
 1 | import styled from 'styled-components'
 2 | import { DefaultFontSize } from './StyleConstants'
 3 | 
 4 | const Input = styled.input`
 5 |     border: 1px solid rgb(183, 183, 183);
 6 |     box-sizing: border-box;
 7 |     color: rgb(85, 85, 85);
 8 |     font-size: ${DefaultFontSize};
 9 |     height: 30px;
10 |     line-height: 15px;
11 |     margin-right: 10px;
12 |     padding: 4px 12px 4px 12px;
13 |     text-align: start;
14 |     width: 310px;
15 | `
16 | 
17 | export const ShortInput = Input.extend`
18 |     width: 155px;
19 | `
20 | 
21 | export const InputLabel = styled.label`
22 |       font-size: ${DefaultFontSize};
23 | `
24 | 
25 | export default Input
26 | 


--------------------------------------------------------------------------------
/src/components/StyleConstants.ts:
--------------------------------------------------------------------------------
1 | export const DefaultFontSize = "13px"
2 | 


--------------------------------------------------------------------------------
/src/components/Vote.tsx:
--------------------------------------------------------------------------------
  1 | import * as React from 'react'
  2 | import * as Web3 from '../web3'
  3 | import * as ethjs from 'ethjs-account'
  4 | import VotingForm from './VotingForm'
  5 | import { VoteData, VoteOption, VoterName, OptionIndex, EventName, VotingMap } from './../model/VotingModel'
  6 | import { EthAccount, BlockNumber } from './../model/EthModel'
  7 | import EthHeader from './EthHeader'
  8 | import styled from 'styled-components'
  9 | import * as loadContract from 'truffle-contract'
 10 | import * as cryptoutils from '../cryptoutils';
 11 | const ethArtifacts = require('../../build/contracts/DecentralizedSchedule.json')
 12 | 
 13 | export interface VotingState {
 14 |     eventName: EventName
 15 |     account: EthAccount
 16 |     availableOptions: Array<VoteOption>
 17 |     votes: VotingMap
 18 |     userName: VoterName
 19 |     userVote: OptionIndex
 20 | }
 21 | 
 22 | const UrlHint = styled.span`
 23 |     font-size: 12px;
 24 | `
 25 | 
 26 | export default class Vote extends React.Component<{}, VotingState> {
 27 | 
 28 |     contract: any
 29 |     web3: any
 30 |     id: EthAccount
 31 |     privKey: string
 32 |     creationBlock: BlockNumber
 33 | 
 34 | 
 35 |     constructor(props: any) {
 36 |         super(props)
 37 |         this.contract = loadContract(ethArtifacts)
 38 |         this.state = {
 39 |             account: "",
 40 |             eventName: "",
 41 |             availableOptions: [],
 42 |             votes: {},
 43 |             userName: "Anonymous",
 44 |             userVote: 0
 45 |         }
 46 |         this.castVote = this.castVote.bind(this)
 47 |         this.onUserNameUpdated = this.onUserNameUpdated.bind(this)
 48 |         this.loadSummary = this.loadSummary.bind(this)
 49 |         this.startListening = this.startListening.bind(this)
 50 |         this.onUserVoteUpdated = this.onUserVoteUpdated.bind(this)
 51 |         this.privKey = this.getParameterByName("key")
 52 |         this.creationBlock = +this.getParameterByName("b")
 53 |         this.id = ethjs.privateToAccount(this.privKey).address
 54 |     }
 55 | 
 56 |     loadSummary(loadedContract) {
 57 |         loadedContract.voteSummary.call(this.id).then((response: any) => {
 58 |             const options: Array<VoteOption> = response[1].map((optHex: string, index: number) => {
 59 |                 return {
 60 |                     name: this.web3.toUtf8(optHex),
 61 |                     voteCount: +response[2][index]
 62 |                 }
 63 |             })
 64 |             this.setState({
 65 |                 eventName: response[0],
 66 |                 availableOptions: options
 67 |             })
 68 |         })
 69 | 
 70 |     }
 71 | 
 72 |     startListening(loadedContract: any) {
 73 |         const voteEvents = loadedContract.VoteSingle({ signer: this.id }, { fromBlock: this.creationBlock, toBlock: 'latest' })
 74 |         voteEvents.watch((err: any, event: any) => {
 75 |             if (err) {
 76 |                 console.log(err)
 77 |             }
 78 |             else {
 79 |                 console.log("Event!")
 80 |                 const newVote: VoteData = {
 81 |                     name: event.args.voterName,
 82 |                     index: event.args.proposal
 83 |                 }
 84 |                 this.setState({
 85 |                     votes: { ...this.state.votes, [event.args.voter]: newVote }
 86 |                 })
 87 |             }
 88 |         })
 89 |     }
 90 | 
 91 |     componentDidMount() {
 92 |         Web3.initWeb3((accs: string[], initializedWeb3: any) => {
 93 |             this.web3 = initializedWeb3
 94 |             this.contract.setProvider(this.web3.currentProvider)
 95 | 
 96 |             this.setState({
 97 |                 account: accs[0]
 98 |             })
 99 | 
100 |             this.contract.deployed().then((instance: any) => {
101 |                 this.loadSummary(instance)
102 |                 this.startListening(instance)
103 |             })
104 | 
105 |         });
106 |     }
107 | 
108 |     castVote(event) {
109 |         this.contract.deployed().then((instance: any) => {
110 |             const sig = cryptoutils.signAddress(this.privKey, this.state.account)
111 |             instance.vote(this.state.userName, this.state.userVote, sig.h, sig.r, sig.s, sig.v, { from: this.state.account, gas: 160000 })
112 |                 .then(() => this.loadSummary(instance))
113 |         })
114 |     }
115 | 
116 |     getParameterByName(name) {
117 |         const url = window.location.href
118 |         name = name.replace(/[\[\]]/g, "\\$&")
119 |         const regex = new RegExp("[?&]" + name + "(=([^&#]*)|&|#|$)"),
120 |             results = regex.exec(url);
121 |         if (!results) return null
122 |         if (!results[2]) return ''
123 |         return decodeURIComponent(results[2].replace(/\+/g, " "))
124 |     }
125 | 
126 |     onUserVoteUpdated(event: any) {
127 |         this.setState({
128 |             userVote: +event.target.value
129 |         })
130 | 
131 |     }
132 | 
133 |     onUserNameUpdated(event: any) {
134 |         this.setState({
135 |             userName: event.target.value
136 |         })
137 |     }
138 | 
139 |     render() {
140 |         return (
141 |             <div>
142 |                 <EthHeader>Current ETH account: {this.state.account}</EthHeader>
143 |                 <UrlHint>To share this event, use following url: {window.location.href}</UrlHint>
144 |                 <VotingForm eventName={this.state.eventName} userName={this.state.userName} availableOptions={this.state.availableOptions} votes={this.state.votes} userVote={this.state.userVote} onUserVoteUpdated={this.onUserVoteUpdated} onUserNameUpdated={this.onUserNameUpdated} castVote={this.castVote} />
145 |             </div>
146 |         )
147 |     }
148 | }
149 | 


--------------------------------------------------------------------------------
/src/components/VotingForm.tsx:
--------------------------------------------------------------------------------
  1 | import * as React from 'react'
  2 | import { range, toPairs } from "lodash";
  3 | import Button from './Button'
  4 | import { VoteData, VoteOption, VoterName, OptionIndex, EventName, VotingMap } from './../model/VotingModel'
  5 | import { EthAccount } from './../model/EthModel'
  6 | import { ShortInput } from './InputElements'
  7 | import styled from 'styled-components'
  8 | import * as cryptoutils from '../cryptoutils';
  9 | 
 10 | export interface VotingFormProps {
 11 |     eventName: EventName
 12 |     availableOptions: Array<VoteOption>
 13 |     votes: VotingMap
 14 |     userName: VoterName
 15 |     userVote: OptionIndex
 16 |     onUserVoteUpdated: (any) => void
 17 |     onUserNameUpdated: (any) => void
 18 |     castVote: (any) => void
 19 | }
 20 | 
 21 | const VoteHeader = styled.thead`
 22 |     background-color: rgb(51, 133, 228);
 23 | `
 24 | 
 25 | const VoteHeaderCol = styled.th`
 26 |     font-size: 13px;
 27 |     color: white;
 28 |     font-style: normal;
 29 |     font-weight: normal;
 30 |     padding-bottom: 6px;
 31 |     padding-top: 5px;
 32 |     padding-left: 10px;
 33 |     padding-right: 10px;
 34 | `
 35 | 
 36 | const VoteCol = styled.td`
 37 |     background-color: rgb(178, 209, 249);
 38 |     vertical-align: middle;
 39 |     text-align: center;
 40 |     font-weight: normal;
 41 |     font-size: 23px;
 42 | `
 43 | 
 44 | const VoterNameCol = VoteCol.extend`
 45 |     font-size: 13px;
 46 | `
 47 | 
 48 | const VotesTable = styled.table`
 49 |     padding: 15px;
 50 | `
 51 | 
 52 | const VoterNameInput = ShortInput.extend`
 53 |     margin: 0px;
 54 |     width: inherit;
 55 | `
 56 | 
 57 | const EventHeader = styled.h2`
 58 |     color: rgb(85, 85, 85);
 59 | `
 60 | 
 61 | export default class VotingForm extends React.Component<VotingFormProps, {}> {
 62 | 
 63 |     constructor(props: VotingFormProps) {
 64 |         super(props)
 65 |         this.voteToRow = this.voteToRow.bind(this)
 66 |     }
 67 | 
 68 |     voteToRow(vote: [EthAccount, VoteData], index: number): JSX.Element {
 69 |         const voteData = vote[1]
 70 |         const cols = range(this.props.availableOptions.length).map(colIndex => {
 71 |             const colChar = voteData.index == colIndex ? '✓' : ''
 72 |             return <VoteCol key={String(colIndex)}>{colChar}</VoteCol>
 73 |         })
 74 |         return <tr key={voteData.name}><VoterNameCol key={voteData.name}>{voteData.name}</VoterNameCol>{cols}</tr>
 75 |     }
 76 | 
 77 |     render() {
 78 |         const maxVotes = Math.max(...this.props.availableOptions.map(opt => { return opt.voteCount }))
 79 |         const headers = [
 80 |             <VoteHeaderCol key="nameHeader">Voter name</VoteHeaderCol>,
 81 |             ...this.props.availableOptions.map(opt => <VoteHeaderCol key={opt.name}>{opt.name} ({opt.voteCount}){opt.voteCount === maxVotes ? ' 🏆' : ''}</VoteHeaderCol>)];
 82 | 
 83 |         const voteRows = toPairs(this.props.votes).map(this.voteToRow)
 84 |         const radioColumns = range(this.props.availableOptions.length).map(i =>
 85 |             <VoteCol key={String(i)}>
 86 |                 <input type="radio" value={String(i)} checked={this.props.userVote === i} onChange={this.props.onUserVoteUpdated} />
 87 |             </VoteCol>)
 88 | 
 89 |         return (
 90 |             <div>
 91 |                 <EventHeader>{this.props.eventName}</EventHeader>
 92 |                 <VotesTable>
 93 |                     <VoteHeader>
 94 |                         <tr>
 95 |                             {headers}
 96 |                         </tr>
 97 |                     </VoteHeader>
 98 |                     <tbody>
 99 |                         {voteRows}
100 |                         <tr>
101 |                             <td>
102 |                                 <VoterNameInput value={this.props.userName} onChange={this.props.onUserNameUpdated} />
103 |                             </td>
104 |                             {radioColumns}
105 |                         </tr>
106 |                     </tbody>
107 |                 </VotesTable>
108 |                 <Button onClick={this.props.castVote} text="Vote!" primary />
109 |             </div >
110 |         )
111 |     }
112 | }
113 | 


--------------------------------------------------------------------------------
/src/cryptoutils.ts:
--------------------------------------------------------------------------------
 1 | import * as eutil from 'ethereumjs-util'
 2 | 
 3 | export function signAddress(privKey, address) {
 4 |     const msg = new Buffer(address)
 5 |     const addressHash = eutil.hashPersonalMessage(Buffer.from(address)) // address+prefix, hashed
 6 |     const sig = eutil.ecsign(addressHash, Buffer.from(eutil.stripHexPrefix(privKey), 'hex'))
 7 | 
 8 |     return {
 9 |         h: eutil.bufferToHex(addressHash),
10 |         r: eutil.bufferToHex(sig.r),
11 |         s: eutil.bufferToHex(sig.s),
12 |         v: sig.v
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/cryptoutils.tsx:
--------------------------------------------------------------------------------
 1 | import * as eutil from 'ethereumjs-util'
 2 | 
 3 | export function signAddress(privKey, address) {
 4 |     const msg = new Buffer(address)
 5 |     const addressHash = eutil.hashPersonalMessage(Buffer.from(address)) // address+prefix, hashed
 6 |     const sig = eutil.ecsign(addressHash, Buffer.from(eutil.stripHexPrefix(privKey), 'hex'))
 7 | 
 8 |     return {
 9 |         h: eutil.bufferToHex(addressHash),
10 |         r: eutil.bufferToHex(sig.r),
11 |         s: eutil.bufferToHex(sig.s),
12 |         v: sig.v
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/environments/environment.prod.ts:
--------------------------------------------------------------------------------
1 | export const environment = {
2 |   production: true
3 | };
4 | 


--------------------------------------------------------------------------------
/src/environments/environment.ts:
--------------------------------------------------------------------------------
1 | // The file contents for the current environment will overwrite these during build.
2 | // The build system defaults to the dev environment which uses `environment.ts`, but if you do
3 | // `ng build --env=prod` then `environment.prod.ts` will be used instead.
4 | // The list of which env maps to which file can be found in `.angular-cli.json`.
5 | 
6 | export const environment = {
7 |   production: false
8 | };
9 | 


--------------------------------------------------------------------------------
/src/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/softwaremill/blockchain-schedule/60cbb6013730ba9288334944025dd100524d78ef/src/favicon.ico


--------------------------------------------------------------------------------
/src/index.tsx:
--------------------------------------------------------------------------------
 1 | import * as React from "react"
 2 | import * as ReactDOM from "react-dom"
 3 | 
 4 | import App from "./App"
 5 | 
 6 | ReactDOM.render(
 7 |     <App />,
 8 |     document.getElementById("example")
 9 | );
10 | 


--------------------------------------------------------------------------------
/src/model/EthModel.ts:
--------------------------------------------------------------------------------
1 | export type BlockNumber = number
2 | export type EthAccount = string
3 | 


--------------------------------------------------------------------------------
/src/model/VotingModel.ts:
--------------------------------------------------------------------------------
 1 | import { EthAccount } from './EthModel'
 2 | 
 3 | export type OptionName = string
 4 | export type VotingId = string
 5 | export type VotingKey = string
 6 | 
 7 | export interface VoteOption {
 8 |     name: OptionName
 9 |     voteCount: number
10 | }
11 | 
12 | export interface VoteData {
13 |     name: VoterName,
14 |     index: OptionIndex
15 | }
16 | 
17 | export type VoterName = string
18 | export type OptionIndex = number
19 | export type EventName = string
20 | export type VotingMap = {
21 |     [prop: string]: VoteData
22 | }
23 | 


--------------------------------------------------------------------------------
/src/styles.css:
--------------------------------------------------------------------------------
1 | .has-underline {
2 |   text-decoration: underline;
3 | }
4 | 


--------------------------------------------------------------------------------
/src/tsconfig.spec.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "sourceMap": true,
 4 |     "declaration": false,
 5 |     "moduleResolution": "node",
 6 |     "emitDecoratorMetadata": true,
 7 |     "experimentalDecorators": true,
 8 |     "lib": [
 9 |       "es2016"
10 |     ],
11 |     "outDir": "../out-tsc/spec",
12 |     "module": "commonjs",
13 |     "target": "es6",
14 |     "baseUrl": "",
15 |     "types": [
16 |       "jasmine",
17 |       "node"
18 |     ]
19 |   },
20 |   "files": [
21 |     "test.ts"
22 |   ],
23 |   "include": [
24 |     "**/*.spec.ts"
25 |   ]
26 | }
27 | 


--------------------------------------------------------------------------------
/src/web3.ts:
--------------------------------------------------------------------------------
 1 | import * as Web3 from 'web3'
 2 | 
 3 | export interface EthConnection {
 4 |     account: string,
 5 |     web3: any
 6 | }
 7 | 
 8 | export function initWeb3(cb: (accs: string[], initializedWeb3: any) => void): void {
 9 |     const newWeb3 = checkAndInstantiateWeb3()
10 | 
11 |     newWeb3.eth.getAccounts((err: any, accs: any) => {
12 |         if (err !== null) {
13 |             alert("There was an error fetching your accounts.")
14 |             return
15 |         }
16 | 
17 |         if (accs.length === 0) {
18 |             alert("Couldn't get any accounts! Make sure your Ethereum client is configured correctly.")
19 |             return
20 |         }
21 | 
22 |         cb(accs, newWeb3)
23 |     }
24 |     )
25 | }
26 | 
27 | function checkAndInstantiateWeb3(): any {
28 |     console.log("Instantiating web3")
29 |     // Checking if Web3 has been injected by the browser (Mist/MetaMask)
30 |     if (typeof window['web3'] !== 'undefined') {
31 |         console.warn("Using web3 detected from external source.")
32 |         // Use Mist/MetaMask's provider
33 |         return new Web3(window['web3'].currentProvider)
34 |     } else {
35 |         console.warn("No web3 detected. Falling back to http://localhost:8545.")
36 |         // fallback - use your fallback strategy (local node / hosted node + in-dapp id mgmt / fail)
37 |         return new Web3(new Web3.providers.HttpProvider("http://localhost:8545"))
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/test/blockchain-schedule.js:
--------------------------------------------------------------------------------
  1 | const DecentralizedSchedule = artifacts.require("DecentralizedSchedule");
  2 | import * as eutil from 'ethereumjs-util'
  3 | 
  4 | 
  5 | contract('DecentralizedSchedule', function(accounts) {
  6 | 
  7 |   const sender = accounts[0];
  8 |     
  9 |   it("should initialize a new voting", function() {
 10 |     const signer = accounts[1];
 11 |     let meta;
 12 |       
 13 |     return DecentralizedSchedule.deployed().then((instance) => {
 14 |       meta = instance;
 15 |       return meta.create(signer, "SoftwareMill Birr June 2017", ['aa', 'bb']);
 16 |     }).then(() => {
 17 |         return meta.voteSummary.call(signer);
 18 |     }).then((voting) => {
 19 |           assert.equal(voting[0], "SoftwareMill Birr June 2017");
 20 |           assert.equal(web3.toUtf8(voting[1][0]), ['aa']);
 21 |           assert.equal(web3.toUtf8(voting[1][1]), ['bb']);
 22 |         });
 23 |   });
 24 | 
 25 |   it("should not initialize a new voting when a voting exists for given signer", function() {
 26 |     const signer = accounts[2];
 27 |     let meta;
 28 | 
 29 |     return DecentralizedSchedule.deployed().then((instance) => {
 30 |       meta = instance;
 31 |       return meta.create(signer, "First voting", ['a', 'b']);
 32 |     }).then(() => {
 33 |         return meta.create(signer, "Second voting, for the same signer account", ['a', 'b']);
 34 |     }).catch((error)  => {
 35 |       return assert.equal(true, true);
 36 |     });
 37 |   });
 38 |   
 39 |   function signAddress(signer, address, meta) {
 40 |       const msg = new Buffer(address);
 41 |       const sig = web3.eth.sign(signer, '0x' + msg.toString('hex'));
 42 |       const res0 = eutil.fromRpcSig(sig);        
 43 |       const prefixStr = "\x19Ethereum Signed Message:\n";
 44 |       const prefix = new Buffer(prefixStr);
 45 |       const bufferToHash = Buffer.concat([prefix, new Buffer(String(msg.length)), msg]);
 46 |       const prefixedMsgHash = eutil.sha3(bufferToHash);
 47 |       
 48 |       return {
 49 |         h: eutil.bufferToHex(prefixedMsgHash),
 50 |         r: eutil.bufferToHex(res0.r),
 51 |         s: eutil.bufferToHex(res0.s),
 52 |         v: res0.v
 53 |       }
 54 |   }
 55 | 
 56 |   it("should emit an event when adding a vote", function() {
 57 |     const signer = accounts[7];
 58 |     let meta;
 59 |     const proposalIndex = 0; // 'x'
 60 |       
 61 |     return DecentralizedSchedule.deployed().then((instance) => {
 62 |       meta = instance;
 63 |       return meta.create(signer, "A meeting", ['x', 'y']);
 64 |     }).then(r => {
 65 |         const sig = signAddress(signer, sender, meta);
 66 |         return meta.vote("Bob", 0, sig.h, sig.r, sig.s, sig.v);
 67 |     }).then(r => {
 68 |        const voteEvents = meta.VoteSingle({signer: signer});
 69 |         voteEvents.watch(function(err, result) {
 70 |             if (err) {
 71 |                 console.log(err);
 72 |                 assert.equal(1, 0);
 73 |                 return;
 74 |             }
 75 |             const event = result.args;
 76 |             assert.equal(event.voter, sender);
 77 |             assert.equal(event.signer, signer);
 78 |             assert.equal(event.voterName, "Bob");
 79 |             assert.equal(event.proposal, 0);
 80 |             return;
 81 |         })
 82 |     });
 83 |   });   
 84 | 
 85 |   it("should override a vote", function() {
 86 |     const signer = accounts[4];
 87 |     let meta;
 88 |     let sig;
 89 |       
 90 |     return DecentralizedSchedule.deployed().then((instance) => {
 91 |       meta = instance;
 92 |       sig = signAddress(signer, sender, meta);
 93 |       return meta.create(signer, "A meeting", ['x', 'y']);
 94 |     }).then(r => {        
 95 |         return meta.vote("Bob", 0, sig.h, sig.r, sig.s, sig.v);
 96 |     }).then(r => {
 97 |         return meta.vote("Bob", 1, sig.h, sig.r, sig.s, sig.v);
 98 |     }).then(r => {
 99 |         return meta.voteSummary.call(signer);
100 |     }).then(summary => {
101 |         const voteCount = summary[2];
102 |         assert.equal(voteCount[0], "0");
103 |         assert.equal(voteCount[1], "1");
104 |     });
105 |   });   
106 | 
107 |   it("should sum votes", function() {
108 |     const signer = accounts[3];
109 |     const sender0 = accounts[0];
110 |     const sender1 = accounts[1];
111 |     const sender2 = accounts[2];
112 |       
113 |     let meta;
114 |     let sig0, sig1, sig2;
115 |       
116 |     return DecentralizedSchedule.deployed().then((instance) => {
117 |       meta = instance;
118 |       sig0 = signAddress(signer, sender0, meta);
119 |       sig1 = signAddress(signer, sender1, meta);
120 |       sig2 = signAddress(signer, sender2, meta);
121 |       return meta.create(signer, "A meeting", ['x', 'y']);
122 |     }).then(r => {        
123 |         return meta.vote("Sender0", 0, sig0.h, sig0.r, sig0.s, sig0.v, {from: sender0});
124 |     }).then(r => {
125 |         return meta.vote("Sender1", 0, sig1.h, sig1.r, sig1.s, sig1.v, {from: sender1});
126 |     }).then(r => {
127 |         return meta.vote("Sender2", 1, sig2.h, sig2.r, sig2.s, sig2.v, {from: sender2});
128 |     }).then(r => {
129 |         return meta.voteSummary.call(signer);
130 |     }).then(summary => {
131 |         const voteCount = summary[2];
132 |         assert.equal(voteCount[0], "2");
133 |         assert.equal(voteCount[1], "1");        
134 |     })
135 |   });   
136 | 
137 | });
138 | 


--------------------------------------------------------------------------------
/truffle.init.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "commands": {
 3 |     "Compile": "truffle compile",
 4 |     "Migrate": "truffle migrate",
 5 |     "Test": "truffle test",
 6 |     "Build Frontend": "npm run build",
 7 |     "Run Linter": "npm run lint",
 8 |     "Run Dev Server": "npm run dev"
 9 |   },
10 |   "epilogue": "Hint: Run the dev server via `npm run dev` to have your changes rebuilt automatically.\n\nMake sure you have an Ethereum client like the ethereumjs-testrpc running on http://localhost:8545."
11 | }
12 | 


--------------------------------------------------------------------------------
/truffle.js:
--------------------------------------------------------------------------------
 1 | // Allows us to use ES6 in our migrations and tests.
 2 | require('babel-register')
 3 | 
 4 | module.exports = {
 5 |   networks: {
 6 |     development: {
 7 |       host: "localhost",
 8 |       port: 8545,
 9 |       network_id: "*" // Match any network id
10 |     }
11 |   }
12 | };
13 | 
14 | mocha: {
15 |   useColors: true
16 | };
17 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "compilerOptions": {
 3 |         "outDir": "./dist/",
 4 |         "sourceMap": true,
 5 |         "newLine": "LF",  
 6 |         "module": "commonjs",
 7 |         "moduleResolution": "node",
 8 |         "target": "es6",
 9 |         "jsx": "react",
10 |         "allowJs": true
11 |     },
12 |     "include": [
13 |         "./src/**/*"
14 |     ]
15 | }
16 | 


--------------------------------------------------------------------------------
/tsfmt.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "baseIndentSize": 0,
 3 |   "indentSize": 4,
 4 |   "tabSize": 4,
 5 |   "indentStyle": 2,
 6 |   "newLineCharacter": "\r\n",
 7 |   "convertTabsToSpaces": true,
 8 |   "insertSpaceAfterCommaDelimiter": true,
 9 |   "insertSpaceAfterSemicolonInForStatements": true,
10 |   "insertSpaceBeforeAndAfterBinaryOperators": true,
11 |   "insertSpaceAfterConstructor": false,
12 |   "insertSpaceAfterKeywordsInControlFlowStatements": true,
13 |   "insertSpaceAfterFunctionKeywordForAnonymousFunctions": false,
14 |   "insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis": false,
15 |   "insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets": false,
16 |   "insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces": true,
17 |   "insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces": false,
18 |   "insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces": false,
19 |   "insertSpaceAfterTypeAssertion": false,
20 |   "insertSpaceBeforeFunctionParenthesis": false,
21 |   "placeOpenBraceOnNewLineForFunctions": false,
22 |   "placeOpenBraceOnNewLineForControlBlocks": false
23 | }
24 | 


--------------------------------------------------------------------------------
/tslint.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "rulesDirectory": [
  3 |     "node_modules/codelyzer"
  4 |   ],
  5 |   "rules": {
  6 |     "callable-types": true,
  7 |     "class-name": true,
  8 |     "comment-format": [
  9 |       true,
 10 |       "check-space"
 11 |     ],
 12 |     "curly": true,
 13 |     "eofline": true,
 14 |     "forin": true,
 15 |     "import-blacklist": [true, "rxjs"],
 16 |     "import-spacing": true,
 17 |     "indent": [
 18 |       true,
 19 |       "spaces"
 20 |     ],
 21 |     "interface-over-type-literal": true,
 22 |     "label-position": true,
 23 |     "max-line-length": [
 24 |       true,
 25 |       140
 26 |     ],
 27 |     "member-access": false,
 28 |     "member-ordering": [
 29 |       true,
 30 |       "static-before-instance",
 31 |       "variables-before-functions"
 32 |     ],
 33 |     "no-arg": true,
 34 |     "no-bitwise": true,
 35 |     "no-console": [
 36 |       true,
 37 |       "debug",
 38 |       "info",
 39 |       "time",
 40 |       "timeEnd",
 41 |       "trace"
 42 |     ],
 43 |     "no-construct": true,
 44 |     "no-debugger": true,
 45 |     "no-duplicate-variable": true,
 46 |     "no-empty": false,
 47 |     "no-empty-interface": true,
 48 |     "no-eval": true,
 49 |     "no-inferrable-types": [true, "ignore-params"],
 50 |     "no-shadowed-variable": true,
 51 |     "no-string-literal": false,
 52 |     "no-string-throw": true,
 53 |     "no-switch-case-fall-through": true,
 54 |     "no-trailing-whitespace": true,
 55 |     "no-unused-expression": true,
 56 |     "no-use-before-declare": true,
 57 |     "no-var-keyword": true,
 58 |     "object-literal-sort-keys": false,
 59 |     "one-line": [
 60 |       true,
 61 |       "check-open-brace",
 62 |       "check-catch",
 63 |       "check-else",
 64 |       "check-whitespace"
 65 |     ],
 66 |     "prefer-const": true,
 67 |     "quotemark": [
 68 |       true,
 69 |       "single"
 70 |     ],
 71 |     "radix": true,
 72 |     "semicolon": [
 73 |       "always"
 74 |     ],
 75 |     "triple-equals": [
 76 |       true,
 77 |       "allow-null-check"
 78 |     ],
 79 |     "typedef-whitespace": [
 80 |       true,
 81 |       {
 82 |         "call-signature": "nospace",
 83 |         "index-signature": "nospace",
 84 |         "parameter": "nospace",
 85 |         "property-declaration": "nospace",
 86 |         "variable-declaration": "nospace"
 87 |       }
 88 |     ],
 89 |     "typeof-compare": true,
 90 |     "unified-signatures": true,
 91 |     "variable-name": false,
 92 |     "whitespace": [
 93 |       true,
 94 |       "check-branch",
 95 |       "check-decl",
 96 |       "check-operator",
 97 |       "check-separator",
 98 |       "check-type"
 99 |     ],
100 | 
101 |     "directive-selector": [true, "attribute", "app", "camelCase"],
102 |     "component-selector": [true, "element", "app", "kebab-case"],
103 |     "use-input-property-decorator": true,
104 |     "use-output-property-decorator": true,
105 |     "use-host-property-decorator": true,
106 |     "no-input-rename": true,
107 |     "no-output-rename": true,
108 |     "use-life-cycle-interface": true,
109 |     "use-pipe-transform-interface": true,
110 |     "component-class-suffix": true,
111 |     "directive-class-suffix": true,
112 |     "no-access-missing-member": true,
113 |     "templates-use-public": true,
114 |     "invoke-injectable": true
115 |   }
116 | }
117 | 


--------------------------------------------------------------------------------
/webpack.config.js:
--------------------------------------------------------------------------------
 1 | var path = require('path')
 2 | 
 3 | module.exports = {
 4 |   entry: './src/index.tsx',
 5 |   output: {
 6 |     path: path.join(__dirname, 'dist'),
 7 |     filename: 'bundle.js'
 8 |   },
 9 |   resolve: {
10 |     extensions: ['.js', '.jsx', '.tsx', '.ts', '.json', '.sol']
11 |   },
12 |   devtool: "source-map",
13 |   devServer: {
14 |     contentBase: path.join(__dirname, '/dist/'),
15 |     inline: true,
16 |     host: '0.0.0.0',
17 |     port: 8080
18 |   },
19 |   module: {
20 |     rules: [
21 |       {
22 |         test: /\.tsx?$/,
23 |         loader: "awesome-typescript-loader",
24 |         exclude: /(node_modules|bower_components)/,
25 |      },
26 |       {
27 |         test: /\.scss$/,
28 |         use: [{
29 |           loader: 'style-loader' // creates style nodes from JS strings
30 |         }, {
31 |           loader: 'css-loader' // translates CSS into CommonJS
32 |         }, {
33 |           loader: 'sass-loader' // compiles Sass to CSS
34 |         }]
35 |       },
36 |       {
37 |         test: /\.css$/,
38 |         use: [ 'style-loader', 'css-loader' ]
39 |       },
40 |       {
41 |         test: /\.sol$/,
42 |         use: [
43 |             {loader: 'web3-loader'},
44 |             {loader: 'solc-loader'}
45 |         ]
46 |       }
47 |     ]
48 |   }
49 | }
50 | 


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