DappWork

The decentralized marketplace for programming-related gig work!

Comment

Inspiration

The founder of Osmosis, Sunny Aggarwal told us that he would find it useful if there was a decentralized version of UpWork that DAOs could use.

What it does

It allows anyone, anywhere to create a bounty on-chain that includes a github link to an open issue with an associated ETH reward and anyone, anywhere to complete the bounty and be rewarded. The platform is fully anonymous and charges no fees (unlike platforms like UpWork which charge a fee). The current problem with other programming bounty marketplace platforms is that they require some type of KYC because of US regulations and this causes solving bounties to take more time and bars people from certain countries from being able to access this gig work. As such, we believe DappWork can not only provide more money for gig workers by eliminating fees, but also provide greater access to jobs for gig workers in developing countries.

Once a bounty hunter reviews the bounty and decides to solve it, she sends a pull request to that github repo with the solution. In the comment of that pull request, she includes the bounty's issue link followed by her ETH address. The bounty issuer can then review the pull request and if it meets her needs, she can merge it, thereby allowing the bounty reward to be ready to collected.

After the bounty hunter sees their pull request has been merged, she can then go to our website (which is still not yet finished, but in the meantime they can use our python-based user interface) and they can choose to close the bounty. They will need to provide their pull request link with which the bounty factory contract will use Chainlink to call the Github API and verify whether the pull request has been merged (this has not yet been implemented), verifies that the issue link in the comment body matches the issue link on the bounty being selected to be closed (currently only implemented off-chain in the python user interface), and then takes the ETH address part of the pull request comment body (this string manipulation is currently done off-chain but ideally would occur on-chain) and then calls a "close_bounty" function on the smart contract of that individual bounty and then changes the state of that bounty to closed and then sends the ETH reward to that ETH address.

How we built it

We built it with the following structure: There is a bounty factory smart contract that sort of acts like the main interface. From this contract, we can create individual bounty contracts, list them all, and interact with them (close them or withdraw the funds from them after their lockup period expired assuming they have not already been completed).

We also were working on a website we would use to interact with this application but we ran out of time.

Challenges we ran into

As we only recently learned solidity, we realized how difficult it was to do certain things in that language that is far easier in others, for example, string manipulation. Also, there were several functionalities we wanted to build but simply ran out of time. Here are some of them:

We wanted to implement the closing bounty sequence differently. Currently, this function can only be called by a specific ETH address that is hard coded into the contract (which I have provided the private key for if you'd like to try running the python user interface on your own machine, don't worry there aren't any real funds associated with that wallet). However, what we'd ideally like is that as soon as the Chainlink node fulfills the API request, it will then automatically run the checks mentioned above on-chain (does the github issue link on the pull request comment body match the one on the bounty? is the pull request merged? has the pull request not been updated after it was merged?) and then if those succeed, it would call the close bounty function which would only be able to be called in this fashion by the Chainlink node itself.

When trying to deploy our contract to other networks (Polygon, Avalanche, and Binance Smart Chain), we ran into issues when trying to verify our contracts on their etherscan equivalents (except for Polygon and of course Kovan). Also, we ran into issues when trying to find a chainlink node with a job id what would do the github API request properly on chains other than Kovan. As such, our contracts on these chains are able to create, view, and withdraw bounties, but we are not able to close them as this would require interacting with Chainlink.

Accomplishments that we're proud of

We are proud of having created an end-to-end flow of from the bounty issuer create a bounty all the way to a bounty hunter closing it and being rewarded. Admittedly, we wanted to do more of the computation on-chain, but because of time constraints we ended up doing parts of the computations (like string manipulation) in Python.

We are also proud of what we have made so far in terms of the front-end and its ability to read on-chain data.

What we learned

We learned how to write smart contracts in solidity and how to use Chainink to access public APIs. We also learned how to use web3-react.

What's next for DappWork

We are open to continue working on it afterwards after we get feedback from Sunny Aggarwal.

Built With

Share this project:

Updates