I believe this is self explanatory.

#74 is a WIP in this

We don't have any UI. Create UI. Simple.

Polish GUI because it looks crap.

It needs to run locally together with InfluxDB so we can show pretty graphs.

We need to make all functions calls to smart meter and connect smart meter to parity.

In this way, we can

• decouple dapp from parity
• make simulation calls easily

We need to feed fake data to smart meter. How? Python script generating random consumption and pretending the world is nice.

Parity is a Rust based ETH client. Let's have our environment (Parity, custom client, etc.) in a Docker so we can easily scale number of clients to emulate larger network.

Right now we have a Python Eve server which serves as our smart meter DB... and also a Node server which serves as our blockchain API... we should probably merge the two. Unless we keep them seperate?

Won't take long if you use something like http://docs.sequelizejs.com/ and SQLite, because fuck Mongo

#111

Frontend is a mess, needs clean up - break it down into JSX components and JS app logic.

Currently some bugs exist and we're not checking status of transaction. We need to check status and catch errors.

Contract should have an expiry date/time.

Upon that, the penalty system can work.

We don't really parity to serve the front end. Although it might be nice to do so bc we want more details for error handling. Other than that I don't think it's necessary to keep them connected.

Bring eve back or do sth else with that.

Currently our front end takes ages to load, need investigate

Todos:

• remove account and unlock settings in config.toml
• (maybe) remove keys as well

This is so that we can simply look them up in our state.contracts instead of having to make a bunch of extra calls to blockchain

So - wat to du.
Simulation only feeds real values into meter that means how much energy we produced (or consumed). Based on that, meter has to figure out whether to sell or consume. If we don't have a contract to consume energy from, we need to do a search for new one and buy energy from it.

Optionally this all can be governed by settings made from GUI (how much energy to buy, are we even allowed to buy automatically etc.)

Right now we have some functions defined in meter/blockchain.js which call stuff from contracts.

The front end is supposed to make calls to smart meter endpoints like /my_buyer_contracts/ in order to get this data into the dapp.

However, what's the point of doing this, if we can just import blockchain.js and call those functions directly?

The answer is obviously that the smart meter would add some extra functionality to those endpoints. One idea is to cache blockchain calls, for performance.

Deploy.sh and Ansible needs to run like smoothly.

Btw. i'm using this temporarily to kill stuff at the end of deploy, 'jobs -p' doesn't work the way it's used atm.

pids=""

cd $PROJ_DIR && pip3.5 install --user -r requirements.txt

cd $PROJ_DIR/client/meter && npm install && npm start &
pids="$pids $!"

cd $PROJ_DIR/simulation && python3 meter.py -e $ENERGY_MIN $ENERGY_MAX &
pids="$pids $!"

handler() {
    echo "Killing everything"
    echo $pids | xargs kill -9
}

trap handler SIGINT EXIT```

The basic simulation environment will have to

• simulate the exchange of energy between clients
• for each client, decide the amount of excess energy (possibly negative) produced based on simulation parameters
• dynamically (or not) create contracts to allow the exchange of energy
• verify enforcement of the smart contracts
• gather relevant data regarding effectiveness of different types of contracts

We need to create templates for smart contracts that regulate the exchange of energy on the network

This API will be used to communicate information such as energy input and output (how many units of energy we are putting/taking into/from the grid) and the information will be used to validate smart contracts.

No longer needed as the same info can be captured with a 0 amount.

Will instead be replaced with some logic for expiring contracts as in #31

On macOS/Linux python is by default python2, I thought we're using python3?

How are we displaying account balance? (ETH/GBP ?)

If energy is consumed by the payment did not go through, there should be ways to detect that and action taken.

Ideally, the UI should display

my seller contracts: how much energy is still not sold
my buyer contract(s): how much energy do i have