Distribution Protocol

So how are the Zooz tokens going to be distributed? We know that drivers are rewarded with Zooz tokens that will be mined as they drive. The amount that they are rewarded for mining decreases with time, similar to the Bitcoin network. This curve, shown in Figure 6-1, has proven to work as an incentive for miners.

Figure 6-1. La’Zooz tokens

The team has created a community roadmap. The roadmap is a timeline of all future milestones in the La’Zooz project to hit in terms of development, marketing, and overall growth. They believe that early adopters should be rewarded more than late adopters and that people should be rewarded for referring others to the network.

The team decided to have two rounds of a presale to raise funds for the development of the project. This is the equivalent to raising a seed round to develop a prototype before going public via social media and blogs with the launch of your product. They’ve set up a multisignature coinbase vault that requires two out of three signatures to release the funds. The vault is just a multisig Bitcoin address to which anyone can send funds. If two of the three signers agree to release the funds, the funds are released to whomever sent the money.

The multisig is used as a smart contract that crowd sale buyers can send Bitcoin to and receive Zooz tokens in proportion to the amount they paid. Here are the three possible signers:

• A trusted member of the Bitcoin community

• An independent professional auditor

• A La’Zooz development community representative

As to how these people will be selected and by whom, this is still in the decision process. Eight percent of all the tokens sold during the crowd sale will be issued to all the presale buyers as a bonus. Why this number and why reissue funds at the crowd sale instead of just giving them a bonus for participating early on? It doesn’t make sense and it’s confusing.

A problem arises if there are many drivers in a region, but no riders; the same problem arises in the opposite situation. This is referred to classically as “the chicken and the egg” problem. La’Zooz aims to counteract it by using an algorithm to detect when there are a certain number of drivers in a particular region. If the number of drivers in the region reaches a certain threshold, the rider app will be activated and riders will only then be able to start requesting rides. This means that the app will be introduced region by region, just like Uber, and full deployment is decided programmatically rather than manually.

DAO Structure

La’Zooz aims to be a community-run network, meaning that there is no difference between creators and the users. Everyone who uses La’Zooz belongs to the same DAO. There is an end of the month vote during which members decide the weight of each member’s vote and the reward for each member in the community. Each member can only vote on voting weights for other members who they know (web of trust) as well as the amount of dividend that they receive.

The new weights are calculated on a mixed basis; 75 percent of the input comes from the new vote and 25 percent from the previous month’s vote. These are arbitrary numbers and can be tweaked, but it would be better, in my opinion, if it were allocated entirely to the new vote. Creating a DAO is a relatively new experience, and the easier you can make it for members to understand how to participate and exactly how your organizational processes work, the more likely your DAO will be successful. Each member must write down the work that they have done for the benefit of the network at the end of each month before the voting day. The members who vote on others can see their self-described track record and judge the significance on it.

There is never an obligation to vote, which is a good thing. Keep voting opt-in and members won’t feel pressured to act a certain way; if they do, they might leave for a freer DAO. Creating community guidelines is a practice in balancing rigidity and freedom and doing so at first in a centralized way to get an initial document out there as fast as possible (creating a team), and then collaboratively as the community adds to it.

La’Zooz went ahead and put out a collaborative white paper that describes their distribution mechanism, some of the math behind their distribution algorithm, their roadmap, and their vision. Ever since Satoshi released Bitcoin with an accompanying white paper, people who make a dapp tend to publish one as well. To add to the white-paper craze, several high-profile venture capitalists like David Johnson actually promote the use of publishing a white paper as the “right” way to release a dapp. I disagree. The right way to launch a dapp is to provide a real value proposition—something that no centralized competitor could accomplish—and explain it in the simplest way possible, using methods with which most people are familiar.

If that means a landing page for the information, a forum for your community with voting capabilities integrated, and an explainer video for your dapp, so be it. White papers are not necessary and can actually cause unnecessary confusion if all of your dapp’s related information is centralized into it, as is the case with La’Zooz. A white paper doesn’t have to double as a business plan, member roles, and everything else associated with your organization.

Be that as it may, the La’Zooz team went ahead and created a nonprofit legal organization in Israel to make sure they were cleared with the state. Every member in the community is rewarded and has a weighted vote on how the app moves forward, but the team itself forms the legal organization. A certain percentage of dividends will go to them during the reward phase at the end of the month, just like everyone else. Interestingly, they’ve stipulated in their by-laws to be legally contractually obliged to follow the orders of the community vote with the funds that they receive.

In this way, the DAO establishes itself as a liquid democracy. Everyone has a vote, voting is opt-in and delegated by weight, yet the creators are still represented. The representatives take care of most of the organizational complexity, but if at any point the community feels that they are corrupt or lack the necessary leadership to maintain and grow the network, they can propose and vote in a new set of representatives.

The reward mechanism described in the paper is murky and still in development. Giving people rewards for their work should come in the form of dividends. Internal currencies don’t offer liquidity at the outset; they only gain it as the network grows. We can think of internal tokens as shares in the network. A smart contract could be written to give a dividend out to every public-private keypair that holds Zooz tokens.

The dividend would be proportional to the amount of tokens that the address held. An altcoin called bitshares created by Dan Larimer uses a consensus algorithm called Delegated Proof of Stake that functions similarly. Whereas Zooz tokens could be thought of as shares in the La’Zooz DAO as well as an internal currency, the dividends could be in Bitcoin or just more Zooz. Bitcoins are more liquid, but Zooz have more potential for value. This is for the creator to decide, but I think Bitcoin would be nice to have as a dividend.

Architecture

Data storage and retrieval

We saw in our Mikro dapp that a DHT was used to store data and a BitTorrent transfer protocol was used to retrieve data. This was made possible by using IPFS, a culmination of both technologies. In OpenBazaar, a DHT was used as well but didn’t have replication built in, so it wasn’t as robust. If a node goes offline and no one views their data beforehand, that data goes offline, as well.

Figure 6-4. Zooz balance

In Lighthouse, the developer didn’t even attempt to use a decentralized data store because it was too difficult to implement. Instead, projects were broadcast over the Web and project files were shared and downloaded by participants to load into their instance of Lighthouse. So, how does La’Zooz deal with data? Well, we can see that there is a file named ServerComs in the source code. Server communication? That doesn’t sound very decentralized. Let’s take a look at three methods in that class:

public void registerToServer(String cellphone)
    {
        String url = StaticParms.BASE_SERVER_URL + "api_register";

        List<NameValuePair> params = new ArrayList<NameValuePair>();
        params.add(new BasicNameValuePair("cellphone", cellphone ));

        this.postRequestToServer(-1, -1, url, params);

    }

    public void 
      setLocation1dddsfsdfs(String UserId, String UserSecret, String data)
    {
        String url = StaticParms.BASE_SERVER_URL + "api_set_location";

        List<NameValuePair> params = new ArrayList<NameValuePair>();
        params.add(new BasicNameValuePair("user_id", UserId ));
        params.add(new BasicNameValuePair("user_secret", UserSecret ));
        params.add(new BasicNameValuePair("location_list", data ));
        this.postRequestToServer(-1, -1, url, params);
    }

    public void getUserKeyData(String UserId, String UserSecret)
    {
        String url = StaticParms.BASE_SERVER_URL + "api_get_user_key_data";
        List<NameValuePair> params = new ArrayList<NameValuePair>();
        params.add(new BasicNameValuePair("user_id", UserId ));
        params.add(new BasicNameValuePair("user_secret", UserSecret ));
        this.postRequestToServer(-1, -1, url, params);
    }

So, it seems like these three methods are getting user data, setting user location, and registering a user account with a server, respectively. And what is that BASE_SERVER_URL variable? Well in the class StaticParams, we find it defined:

public static final String BASE_SERVER_URL = "https://client.laZooz.org/";

It turns out that it’s storing and retrieving data from a central server. As someone who has been studying dapps for a while, I’m not surprised that much. There is so much noise in this space; projects can be really loud and have a lot of hype, followers, and promise, and it ends up that they cut corners on issues as critical as data storage. It could be for lack of finding great decentralized storage tools like IPFS, or just a lack of knowledge of how things should be done in a dapp to keep it sufficiently decentralized. The fact that user data is stored on a server makes the app similar to Uber, other than the fact that it’s using an internal currency and has a co-op-like structure, rather than a corporate one. There is an Android wrapper for IPFS that La’Zooz could have implemented. You can find it at https://github.com/dylanPowers/ipfs-android.

protected String doInBackground(String... params) {

             ServerCom bServerCom = new ServerCom(MainActivity.this);
            JSONObject jsonReturnObj=null;
            try {
                MySharedPreferences msp = MySharedPreferences.getInstance();
       bServerCom.getUserKeyData(msp.getUserId(MainActivity.this),
msp.getUserSecret(MainActivity.this));
                jsonReturnObj = bServerCom.getReturnObject();
            } catch (Exception e1) {
                e1.printStackTrace();
            }
            String serverMessage = "";
            try {
                if (jsonReturnObj == null)
                    serverMessage = "ConnectionError";
                else {
                    serverMessage = jsonReturnObj.getString("message");
                    if (serverMessage.equals("success")){
                        String ZoozBalance = 
jsonReturnObj.getString("Zooz_balance");

Contracts

At this point we’ve found that data is centralized on their server as well as the wallet node that connects to the Mastercoin network. Smart contracts would allow for an automated crowd sale, and they said they are using a coinbase multisig vault to release funds. But what about paying dividends? Automated escrow payments are the hallmark of smart contracts. The contract would live in the blockchain and, seeing how they are using the Bitcoin blockchain with the Mastercoin protocol, surely they must be using the Bitcoin scripting language to make their smart contracts. A quick look on the Ethereum home page leads us to find that La’Zooz is one of the projects using Ethereum for smart contracts.

Ethereum is great and their tools for building smart contracts are more mature than Bitcoin’s, but the fact of the matter is that their blockchain is unproven to work and they are going to have to massively reduce in size or spend forever playing “security whack-a-mole,” as Gavin Andresen (lead developer of Bitcoin) puts it. At its best, when the sidechain protocol is released, Ethereum will become a sidechain to Bitcoin, and if someone really needs to write Turing-complete contracts, they can, without being exposed to the risk of relying on the Ethereum blockchain to be secure with their internal currency. Using the Ethereum blockchain in the meantime is just not smart development if you want your dapp to be profitable.

Improvements

La’Zooz is an ambitious startup. It is trying to create the first DAO that involves a distributed workforce that receives dividends, has votes, and ties in with the existing legal infrastructure. It could just be using centralized data, wealth, and identity as a placeholder in its development stage. As for right now, although its intentions seem good enough, it seems to be placing itself at risk for the possibility of not one but several points of failure.

La’Zooz should use the colored-coins protocol to issue assets. Zooz tokens should be used as both shares in the network and as a currency. Dividends would be received by creating a smart contract to give all people in the network the dividends proportional to their stake in the network. The actual Zooz app could be an SPV wallet for colored coins for total decentralization, but if it wanted to use a web wallet for ease of development, it could use Coinprism.

The way La’Zooz structured its DAO is commendable. If it has legal contracts requiring those who are listed under the by-laws of its company in Israel to obey the will of the community vote, it has avoided the legal limbo associated with a DAO by complying with local regulation and sticking to the principles of decentralization via liquid democracy. Voting should happen in app as a feature that is just a tab on the sidebar.

Users should opt in to vote; anyone can submit a proposal for a feature request, new regions to focus marketing on, or leadership change. Anyone should be allowed to vote on those proposals. The voting forum would work Reddit-style, with the best votes being moved up to the top. The leadership or representatives of the DAO listed under the by-laws would enact these proposals, as they would legally be required.

The data should not be centralized, but that’s a given. A data storage and retrieval service that utilizes a DHT should be used like IPFS. Having a server on which the team can own all the data defeats the purpose of decentralization, although in the case of La’Zooz it might be a little different because it is legally bound to do only what the community wants. The community will most likely demand complete transparency. That transparency means none of its data can be sold to any third-party source without the community’s permission. Doing so would be illegal.

Jobs in the La’Zooz DAO should be either role-specific or full stack. Full stack professions are already emerging in the startup sector, but in the case of a DAO, full stack must mean not just in terms of engineering, but in terms of playing different roles throughout the company. That includes marketing, engineering, and customer relations. Hiring, reviewing, and firing employees in a decentralized way can be difficult. There should be no barrier to enter the DAO, and the review process is something La’Zooz has spoken about (voting on member rewards and voting weights). Firing could come up as a proposal by a disgruntled member.

Firing should essentially be the equivalent of banning someone in a distributed manner. A bad actor could be trying to DDoS the network or attempting to upload child porn. People should vote on firing the member (those who knew the member) and then the representatives in the DAO would ban that person’s address by implementing a blacklist in the blockchain stored locally on all nodes. That means if an address was on a blacklist, they would not be able to transact with any of the other nodes on the network. The blacklist would be stored in the blockchain so that all nodes could agree on it.

La’Zooz shouldn’t use Ethereum for smart contracts until the sidechain proposal is ready. The Bitcoin scripting language, though not fully Turing-complete, can handle most use cases that involve escrowing automatic payments.

Finally, La’Zooz shouldn’t concatenate all the instructions for its DAO into one white paper. Instead, it should modularize the data into many different easy-to-read parts for the layperson. It should be easy to find as well because web pages are more Google-friendly than PDFs.