Developing DAPPs from Ethereum to Blockstack

Zvezdin · May 19, 2017, 8:28pm

Hello. I’m an ethereum developer and I, very recently, found about blockstack. However, I wasn’t able to find out good documentation anywhere on your website that describes how this can be used for development (other than user authentication). So I will just ask my questions here.

I’ve currently got a DAPP (cryptocontract) running on Ethereum, that implements a share allocation system, voting system and payment system. But the maximum contract size, and transaction gas limits are huge limitations for me.

So. Is there a way for me to reuse/rewrite my contract for use with blockstack, so that I still get the guarantee that the application runs autonomously and nobody can alter the code, or it’s data (outside of the rules in the actual code)? The actual data is frequently changed (daily / weekly / monthly basis) but is only a result of the applicaiton’s execution.

What I was able to understand up until now is that you can offer different strategies for dealing with the problem, but I didn’t see anyting that solves the issue of centralized control. There has to be no single entity with control over the application.

How can this be implemented with the help of blockstack? Because of the lack of documentation, can you please explain in more details how things work and / or what do I need to do in order to achieve my goals?

Thank you.

ryan · May 20, 2017, 7:00pm

Hey @Zvezdin happy to help you out here.

Can you share some links to your app so I can take a look? I should be able to give you some direction specific to your application.

Also we’re working on more general documentation for dapp developers. This is coming soon.

Zvezdin · May 21, 2017, 7:32am

Hey @ryan.

I’m not sure if my question is related to the source code, because I’m asking for something general- guarantee that the data can only be changed by the code itsself. But here you go:

github.com

Zvezdin/obitcoin/blob/master/Obitcoin.sol

pragma solidity ^0.4.9;

contract Obitcoin{
    
    //events for all actions made by the contract. They are fired by the contract, then catched and processed by the web application
    //once an event is fired, it will always stay in the blockchain. This is the why our application can load all transactions that ever occurred within the contracy
    //the contract has no access to previously fired events. That's why firing events is always cheaper than saving the same amount of data in contract storage
    event TokenTransfer(uint16 indexed from, uint16 indexed to, uint16 indexed pool, int256 amount, uint time); //int256 because we can both remove and add tokens
    
    event MoneyTransfer(uint16 indexed from, uint16 indexed to, uint16 indexed pool, int256 amount, uint time);
    
    event SliceTransfer(uint16 indexed from, uint16 indexed to, uint16 indexed pool, int256 amount, uint time); //uint128 because we can only add slices
    
    event TokenPurchase(uint16 indexed from, uint16 indexed pool, uint128 amount, uint time);
    
	//event for the creaition of a pool, containing it's index for later access
    event PoolChanged(uint16 indexed from, uint16 indexed pool, bool added, uint time);
	
	//event to notify that someone has tried to access a method that he shouldn't have
	event UnauthorizedAccess(uint16 indexed from, address indexed fromAddress, uint time);

This file has been truncated. show original

This is my current Ethereum Cryptocontract. It simply has a few structs for members, pools (groups of members) and votes (to accept / decline a proposed change)… Generally the balance of each member in each pool can be changed as time passes, and each change needs to be accepted trough voting to take effect.

The contract has access control on multiple levels (who is allowed to call which method; lines 151-169) and fires events in the blockchain for each data change (lines 5-32).

Lines 171 - 277 are CRUD methods for the structs.
Lines 280-357 are for liquid democracy and voting on proposed changes.
Lines 359-511 are for balance changes of a pool’s members. Each member has a balance of tokens / slices / money in each pool, which are changed overtime according to a few rules.

How can this be implemented using Blockstack? I really need the guarantee that this system is autonomous and nobody can break it, even if he wants to.

Ps: when will this documentation for dapp developers be out?