reduxu-chain

yeah, I am yet another blockchain implementation in javascript.

See example on https://codesandbox.io/s/34wm9xq8m5

Simple state container like implementation of the blockchain driven flowtype checked, this is in an super early stage and can fail...

Key concepts of reduxu-chain

• A tiny redux like implementation of the blockchain.
• Typed with flowtypes, styled by prettier.
• Allows minning the block or build some kind of smart contract.
• A consensus algorithm, simple proof-of-work or proof-of-stake implementation using nonce
• Built by rollup, it should work on web and node, but tried it for react-native

Table of Contents

• Installation
• Dependencies
• Usage
• Definitions
• Contribute
• License

Installation

Using yarn:

$ yarn add reduxu-chain

Dependencies

• mitt an awesome tiny library to broadcast a block notification through a middleware
• crypto-js is here to generate sha256 hash for each block

Usage

import rootReducer from "./rootReducer";
 
import {
    createStore,
    eventEmitterMiddleware,
    applyMiddleware,
    Block,
} from "reduxu-chain";
 
export default class ReduxuStore {
    constructor() {
        this.store = createStore(rootReducer);		
        applyMiddleware(this.store, eventEmitterMiddleware);		
    }
 
    addBlock(block) {
        return this.store.addBlock(block);
    }
    mineBlock(block) {
        return this.store.mineBlock(block);
    }
    getLastBlock() {
        return this.store.getLastBlock();
    }
    addTransaction() {
        // add transaction or define any smart contract
        const tx = {
            timestamp: new Date().getTime() / 1000,
        };
        this.store.dispatch({
            type: "ADD_TRANSACTION",
            tx,
        });
    }
 
    // Add a block into the local BlockChain
    mineChain(data) {
 
        // this one is the last as of now but might not be after minning
        const lastBlock = this.store.getLastBlock();
        const block = new Block({
            previousBlock: lastBlock,
            data,
        });
 
        // consensus algorithm
        return mineBlock(this.store, block).then(() => {
            // resolved the nonce, hash is valid, let's see if others resolved first	
            return store.addBlock(block).then((blockchain) => {
                // cool
                console.log("minning it");
            })
        });
    }
}
class MyComponent extends React.Component {
    addTransaction() {
        this.store1.addTransaction();
        this.setState({
            block1: {
                blockInfo: this.store1.getLastBlock(),
                transactions: this.store1.getLastBlock().data.length.toString(),
            },
        });
    }
    render() {
        return (
            <Card>
                <CardContent>
                    <Title>Store 1 Local Block Info</Title>
                    <Caption>
                        {this.state.block1.transactions} open transactions
                    </Caption>
                    <Paragraph>{JSON.stringify(this.state.block1.blockInfo)}</Paragraph>
                </CardContent>
            </Card>
        );
    }
}

Simple middleware to handle side effects using eventEmitterMiddleware ( or build yours )

let emitter = new mitt();
export default function eventEmitterMiddleware(MyStore: Store) {
    emitter.on("blocks_received", (action: Action) => {
        // update my local blockchain difficulty and blocks
        // the entire blockchain or just the lasts blocks to amend
        MyStore.replaceChain(action.newBlocks, action.difficulty);
    });
    return function(dispatch: *) {
        return function eventEmitterDispatch(action: Action) {
 
            if (action.type === "@Blockchain/NEW_BLOCK") {
                // fire an event when accepted a new block
                emitter.emit('blocks_received', action);
            }
            dispatch(action);
        };
    };
}

Definitions

The block

// @flow
 
interface IBlock {
    hash: string;
    // define your state, any kind of transaction state can be here
    +data: State;
    // serialized data, this might go through p2p, but I am not trackling that as of now
    _data: string;
    // optional props
    previousBlock?: IBlock;
    // integrity to the chain is validated in block each time.
    previousHash: string;
    // privates
    // timestamp to create the hash
    +timestamp: number;
    // validates the block after minning
    nonce: number;
}

Action creators

// @flow
 
export type BlockchainAction =
    | {
            // action dispatched when the store is created, and it is not handled by the middlewares 
            type: "@Blockchain/INIT",
        }
    | {
            // action dispatched when new block is added to the local chain
            type: "@Blockchain/NEW_BLOCK",
            newBlock: IBlock,
            difficulty: number,
        };

The blockchain

// @flow
 
interface IBlockChain {
    // the entire blockchain
    chain: Array<IBlock>;
    // amount of zeros before the hash, increments the nonce till get it right, this brings security to the transaction and it is kind of useless :)
    difficulty: number;
    // works along with getLastBlock() if this chain is last one, you did it.
    // emmits
    addBlock: (newBlock: IBlock) => Promise<*>;
    getLastBlock: () => IBlock; // returns a block that might not be the last one :(
    // replacing the local chain and trying to emit your change
    replaceChain: (newBlocks: Array<IBlock>, difficulty: number) => void;
    // minning a just a block
    mineBlock: (newBlock: IBlock) => Promise<*>;
}

Related projects

Awesome inspiring projects I looked into!!!

• https://github.com/lhartikk/naivechain

• https://github.com/SavjeeTutorials/SavjeeCoin

• https://github.com/alanguir/blockchain

• https://github.com/ykforerlang/tinyredux/

• https://github.com/abrkn/blockchain

Contribute

Thanks for taking the time to contribute!

Credits

This project was originally forked and inspired from blockchain-redux and the awesome work of Swizec Teller 👍

TODO

• Allows implementing a P2P communication through a redux applyMiddleware(somethingMiddlewareP2PLike)
• Allows designing your reducers to develop a transaction handler or your smart contract and data: State should be serialized.

License

MIT License