Final round of Obyte Autonomous Agents Developer Contest

Casper Niebe
Nov 1, 2019 · 24 min read
Image for post
Image for post

In a true firework display of creativity, skills, deep technical knowledge and in-depth understanding of capabilities and limitations of the Oscript language, the contestants gave everything they had for the final round. It turned out to be by far the best round we have seen of the contest. We said this about round 6 too, which shows that people are really getting to grips with Autonomous Agents!

Before taking a look at all the entries, please allow me to extend a warm and heartfelt thanks to everyone that has contributed to make this contest such an awesome experience, and for providing hours and hours of fun, excitement, surprises and of course also a fair bit of frustration having to pick three winners week after week.

The discipline of being creative on demand and having to come up with new ideas that allow developers to excel from a technical standpoint is insanely difficult. Let alone doing this from scratch every 2 weeks while climbing the steep learning curve and wrapping their heads around an entirely new scripting language and its syntax. Needless to say — this is an achievement only very few could master, and on behalf of the entire Obyte team, the contest jury,myself and every Obbie that exists, I can express my immense respect and admiration of all participants.

Autonomous Agents Entries For Round 7

This last round features 7 extremely cool entries. Not previously has the field of entries looked this strong, and it is important to highlight the fact that all of the participants knew absolutely nothing about Oscript or Autonomous Agents less than 3 months ago. To reach this level of expertise in this little time is simply stunning.

The first rounds mainly saw attempts at creating random numbers to be used in dice games, lotteries and similar simple games. Then we started to see several entries exploring the possibilities of using Autonomous Agents as safety deposits, some with more success than others. From the fourth round on the complexity rose significantly, and we started seeing entries with elaborate flows of data and user interaction. This round represents the culmination of what we have previously seen, so let’s take a look at where all this Oscripting has taken us.

Image for post
Image for post

Entry 1 — “Autonomous Auctioneer” by Frank Bee

The entry contains a lot of different parts, with the three primary parts being a decentralized marketplace, an escrow service and a dutch auction. Each of these three parts are utilized to create a super interesting and potentially extremely relevant use case.

The entry addresses several problems that existing similar centralized implementations have, such as Amazon and Ebay. Autonomous Agents act truly autonomously, and without the possibility of data-mining, multi-billion dollar corporations harvesting data about users of the platform.

A user lists a product on the marketplace and defines a set of rules for an auction. In a dutch auction, the price starts at a high price point and gradually decreases over time. Potential buyers are faced with the tricky task of waiting until the precise moment at which to make their bid.

If they wait too long, someone else might jump in and buy. If they are not patient enough, they risk end up paying a higher price than they could have bought the product for, had they been more patient. Anyone having experienced a dutch auction will know the nerve wrecking moment when you make a decision to raise your hand and take the deal, only to realize that someone else beat you to it by a second and a half! It is super fun, and from the seller’s point of view it potentially maximizes the price they get for the product.

In a previous round, we saw a similar entry (yet not quite as advanced as this one) that allows a seller to define all the different parameters for their specific auction.

After an auction is settled, the seller and the buyer face the next task — to exchange product and funds. This is where the second part of this entry kicks in — the escrow. To create an auction or to make a bid in one, users are required to provide their pairing code to the supporting chat bot built which makes the user experience easier. This enables the Autonomous Agent to literally connect the seller and buyer directly with each other. This is done through the GUI-wallet’s built in encrypted chat function. The seller and buyer can now exchange personal details like the delivery address and agree on other terms.

When the buyer receives the product, confirmation is made to the chat bot which then triggers the Autonomous Agent to release funds. The observant reader will of course recognize this particular point in the flow is a crucial one. At this point, the buyer is tasked with an additional interaction that he has no incentive to do. He got his product and he paid for it. Introducing an incentive for the buyer to confirm receipt of the product would be a great improvement to the use case. Maybe it could be required that the buyers add a refundable deposit to the amount paid or a chatbot feeding track and trace codes from a delivery company’s system to trigger the release of funds will be left for the authors to decide. The last part of the documentation actually also covers this particular problem area and suggests the use of an upcoming Obyte feature: “Contracts with Arbiter”.

The jury all agreed that not only is this entry really carefully thought through, it also holds great potential to be realized when Autonomous Agents are launched on mainnet. It provides feasible solutions to a host of actual problems faced with current marketplaces. The jury noted that the encryption of seller and buyer pairing codes makes the solution safer but could very well be considered voodoo-magic by laymen. Since the chatbot has the private key anyway, it could be an option to have the pairing code stored to prevent the need for users from generating public/private keys themselves. It would introduce a required intermediary, though.

Autonomous Agent Definition

Autonomous Agent Address: 6Y4MHVF22KFJYY6LJBDU5GVOIUGPHAVF


Image for post
Image for post

Entry 2 — “EmailBank” by Vik

The term “not your keys, not your money” is a phrase often heard in the world of crypto. Time and time again people lose access to their wallets for various reasons. At Obyte, we can’t stress enough how important it is to keep a backup of your wallet since nobody else will be able to help you recover access to your funds should you lose it.

There are various solutions offering centralized secured storage of users funds, but it has also been seen that for every legit company offering this escrow service, there are many dishonest scammers trying to lure users into sending their funds or private keys to them. With one of crypto’s mantras supposedly being the death of banks, one might find it funny that those very same evangelists are from time to time seen claiming they of course keep their private key safely and securely locked up … in a bank’s safety deposit.

Several attempts have been made trying to solve this using all sorts of cryptographic shenanigans and hoop jumping. But Vik may very well have provided a super simple and extremely user friendly alternative to all previous attempts.

The idea is quite brilliant. The user transfers funds to the Autonomous Agent from an address that has previously been through the email attestation process.

Should the user then lose access to his wallet, all he needs to do is install a new one, do the email attestation process again from the new wallet, which changes the linked wallet address of that email. He can then make a claim to withdraw funds from the Autonomous Agent. This is done by simply sending a transaction to the AA from the new wallet address. The AA recognizes this as the new wallet address of a particular email address and allows withdrawal of funds to the new address instead of the previously attested one.

Of course, the solution relies on the user’s ability to keep access to his email safe, so you could argue that the problem hasn’t really been solved, but that it still exists, only in a different place or on a different technology.

But email will celebrate its 30th birthday in 2022, and unlike cryptocurrencies, email has become such an integral part of the life of people in developed countries, that most are used to methods for keeping access to email addresses secure and even regaining access should they lose it. Operating systems provide several safety mechanisms which could act as the first line of defence for cryptocurrency wallets. Further, even if a malicious user gained access to another user’s email account, it is rather unlikely that they would know that it could potentially be used to provide access to funds stored on an Autonomous Agent on the Obyte DAG.

So while the solution is of course not 100% bullet proof, the jury agrees that this is by far one of the more user friendly approaches that has been made. It does require users to keep funds on the AA rather than in their wallets though and this could potentially prevent some users from using it.

Autonomous Agent Definition

Autonomous Agent Address: WZCLMSGLXJ4VHD3G6OKT32KU4YQY5MA2

Documentation on the Obyte Discord in #aa-contest-entries

Image for post
Image for post

Entry 3 — “A Renting Guarantee Autonomous Agent (ARGAA)” by hey_monkey

When two parties enter into a rental agreement it is always a matter of trust between the two parties. If you rent a lawn mower from a nearby hardware store, the store often requires renters to pay a deposit to prevent their products from being stolen by the renter. In general there is a lot of trust involved in a rental agreement.

On numerous occasions hey_monkey has proven mastery of the Oscript language, his monkey skills are top notch. But to me, the even more amazing thing is how he manages to come up with new ideas for Autonomous Agents round after round. During the course of this contest, we have had the pleasure to experience no less than 12 novel, highly useful and high quality ideas realized by his hand.

Image for post
Image for post

But back to the entry for this round.

The Autonomous Agent is simple, yet beautiful and thoroughly implemented. We saw the same AA in a previous round, but for this round, the user experience has been significantly improved. The agent is now fully integrated with a chat bot and a web frontend/UI, making the user super simple even to not so tech savvy users.

Generally, we see the three main functions of the Autonomous Agent as being a way for an owner to create a product that others may rent. A renter sets a guarantee for the rental and a way for the owner to claim the funds on the guarantee. While it may seem rather simple, there are still quite a few exceptions that needs to be handled, and as always this is carefully done and no stone is left unturned. Users mistakenly transferring too much will be reimbursed, and necessary checks are implemented to reduce potential user errors.

The process is easily followed through on the web interface and the implementation of the Obyte URI protocol makes the use of the AA a matter of simple point and click. The real world application for the use case is obvious but it is also clear that it might be relevant to more than just regular crypto-enthusiasts who know their wallets inside out. Therefore, the decision to implement a Web UI and a chat bot for this particular entry makes a lot of sense.

One of the things that I have personally grown to appreciate about hey_monkey’s entries is the amount of documentation. The use cases are often rather complex and while it may make sense to the one developing it and the code being almost self-explanatory, trying to get a grasp of the full scope of the projects has proven extremely difficult on a lot of the entries throughout the contest. But by carefully documenting and even writing elaborate tutorials and guides accompanying the entries,hey_monkey has managed to make it very easy to understand the concept being implemented. The number of links below is solid proof of this.

Autonomous Agent Definition

Autonomous Agent Address: FISR6BC5HFEJ433MMGSSCW4NXUCOFXLA

Supporting website

Chatbot code

GitHub repository

Image for post
Image for post

Entry 4 — “Obotic” by whoisterencelee

Another of the masterful contributors to every single round (apart from the postponed 2nd round) is whoisterencelee. In an impressively short period of time, whoisterencelee has no only repeatedly demonstrated his mastery of the new Oscript language, but also understands how to use Obyte’s full potential to the maximum. By regularly accompanying Autonomous Agents with chatbots, elaborate articles describing the creative process all the way from idea to realized product, whoisterencelee has certainly lead by example. This round is no exception.

While the amount of Oscript code written explicitly for this round’s entry isn’t large, it embraces many of the previously built Autonomous Agents in one beautiful swoop.

The entry picks up on the previous round’s Autonomous Agent for distributed computing. Universities, pharmaceutical companies, weather forecasting organizations and an array of other companies often see themselves requiring vast amounts of computation power. While some institutions have this need as a core element of their business models, others, particularly universities, often find themselves having to build or rent access to computational power on a case-by-case basis.The cost of this is often enormous, and it isn’t hard to imagine that projects sometimes might not be realized simply because they would require too many resources to perform the required calculations.

The Obotic system — because this has grown from a simple Autonomous Agent into an entire system — provides a viable alternative to make it possible for those requiring computational power to incentivize a distributed network of clients to perform this task and it includes a monetary reward for those crunching the data.

To fully understand this massive complex of systems, clients, Autonomous Agents and mechanics, it is highly recommended you read the documentation on whoisterencelee’s entry from round 6. This is where it all starts. Then consider this carefully thought through flow chart describing in detail what the system is capable of and how it all works:

Needless to say, it would be far, far too time consuming and require far too many pages to explain every little detail from the above system, but worth nothing, though, is the mitigation of fraudulent results being submitted for the purpose of profit.

In terms of seeing this product in a real world scenario, the introduction of a voting system definitely improves on the feasibility. Whether it would hold up in a real world setting would probably require some careful stress testing and letting someone run a small sample of actual real world data through the system to see whether it works in practice.

An interesting point about this entry is that we regularly see entire blockchain projects built with the sole purpose of providing decentralized computation or decentralized data storage. Whoisterencelee’s entry proves that Obyte is not only capable of covering the scope of an entire blockchain/DLT project, it also has the potential to improve on existing ones by the use of so many features.

And I am convinced that it is definitely this very aspect that whoisterencelee has seen and is aware of the potential of.

Autonomous Agent Definition

Autonomous Agent Address: UHW5KN3OR2VB6BZGCX7SC7MASZWC77L2


Image for post
Image for post

Entry 5 — “Contest Runner” by whoisterencelse

In an almost superhuman effort, having already submitted a huge entry for this last round, whoisterencelee had set his mind on even more, and was able to write the Contest Runner Autonomous Agent. Let it be known, that this particular entry would have been an extremely welcome entry for round 1 of this contest. As one of the jury members jokingly points out: The main negative side to this entry is that it was submitted in the last round.

The entry provides a lot of very useful features that will be really useful for future contests and competitions, be it for developers or other contests about Obyte. Anyone wanting to run a contest can set up a new one using this AA. In essence, a deadline is set and, the number of judges/jury members is defined .

The mechanics are quite simple and would also be relatively easy to build into a chat bot allowing judges to be identified by their wallets, being able to send notifications to judges upon new entries being submitted and generally helping the flow a bit.

Once the contest is running, judges can then vote on the entries by referencing the entry hashes that contestants provided on a separate medium.

It of course doesn’t allow judges to add more than a score, and it is often necessary to be able to make a brief statement or comment to accompany the vote, not only to provide reasoning for the judge’s decision, but also to give the contestants constructive feedback, allowing him to learn and improve and not just receive a grade. This, of course, might not be relevant in all contests, particularly where results can be either true or false, but for the more creative contests, the option to add a comment would be a welcome improvement.

Autonomous Agent Definition

Autonomous Agent Address: TVP5CG54ICOXUKZHSCW6YNJD6I6RT4OP

Documentation on #aa-contest-entries on Obyte Discord

Image for post
Image for post

Entry 6 — “Certificate of Deposit or get interest by staking this new asset…” by lion’s heart

Inspired by Richart Heart’s HEX project and definitely tapping into his ideology, lion’s heart introduces an Autonomous Agent that could be some speculator’s sweetest dream. The combined website and Autonomous Agent provide several features to allow speculation and interest generation from a staked amount of an asset.

Currently, the issued asset used for this test is called cods (not the fish) and users are offered a way to stake a given amount of that asset for a period of time. The bigger and longer the stake the better the return. Initially, all cods are issued and will be deposited on the AA. There will be an initial distribution round where GBYTE holders will receive an amount for free. The remaining amount will be distributed to those staking the asset with 4% of the remaining pool to be distributed among stakers. The more stakers, the less return on stake. This mechanic also results in a smaller and smaller amount being distributed as rounds pass by, gradually decreasing the amount to be shared between all stakers.

The Oscript for this entry is clean, well written and the accompanying website makes handling the different aspects really easy for users. So from a purely technical point of view, this entry is excellent. Whether or not it would be feasible in the real world is of course difficult to say, but it would very likely be limited to be relevant only to people already familiar with cryptocurrencies and who are into speculation and hope for a passive income.

One thing that might be possible to improve on, would be to eliminate the need for users to actively request accounting on a regular basis. This could be done from a chatbot triggering the AA at regular intervals, or simply by processing the accounting on all staked balances every time a triggering transaction is received to see if there are any pending payouts. The last solution would not make it completely regular but in a setting with lots of users interacting with it, it would probably be sufficiently often that users would at least have the feeling it ran automatically. Another idea could be to use one of the entries from past rounds, which introduces a monetary incentive for a user to trigger an AA at a specific date and time (or after that). This would likely also work and would be perfectly in line with the philosophy of speculators.

There are several examples on the Ethereum blockchain where similar use cases have been tried but few have managed to gain significant traction. So while the technical achievement for this entry is really high, the usefulness and ability to provide solutions to real world problems that requires distributed ledgers might not be as high for this particular AA.

Autonomous Agent Definition


Accompanying Website including doumentation

Image for post
Image for post

Entry 7 — “Uptime Hedge” by Garage48 Cyber Security Hackathon Team (made in just 48 hours)

Submitted exactly on the deadline for this round, the Obyte developer Tarmo submitted this entry. The entry is credited to a team of developers rather than Tarmo. He attended a 2 day hackathon where he offered help, guidance and coding assistance to teams wanting to explore implement Obyte in their solutions.

Image for post
Image for post

The team of 5, including Tarmo as “visionary” set out to create an Autonomous Agent that would allow anyone to hedge against server downtime. We all know how annoying that can be, and according to the judges at the hackathon, being able to hedge against downtime creates a monetary incentive to cause downtime. So naturally, some of the mentors at the hackathon didn’t fail to point out the obvious: “This is like DDoS as a service”.

The entry itself is a bit difficult to evaluate as there is no Autonomous Agent built yet. However, they managed to get a website and a chatbot built in just 2 days, which is of course impressive in itself. Generally, the idea is definitely good and there is no doubt that hedging against negative events is a popular and highly profitable industry, as the mammoth global insurance industry demonstrates

One thing that is clear though, is that the UI is really cool and it is extremely easy to navigate and reach the function you need. The same goes for that chat bot version of the use case. Never before has it been this easy to reach the point where the missing AA results in a bounced payment. Further testing also becomes slightly problematic, as causing downtime at Amazon Web Services or Google Cloud could prove to pose a few practical problems.

Therefore, the entry doesn’t compare that easily with other entries but is definitely worth a look if others want inspiration from a nice and simple user interface on a responsive website.

UI / Website

Github (chat bot and React front-end)

Chatbot: Click the uptimeHedge logo to open it with testnet GUI wallet

Image for post
Image for post

Guide And Tutorial Entries For Round 7

When planning for the launch of Autonomous Agents started and the developer contest was conceived, it was clear that even though the documentation of the Oscript language and the getting started-guide was extensive, the additional help getting started as new to the concept would be key. It was therefore decided to add a special category to the contest, to incentivize the creation of more guides and tutorials. The results of this have been excellent. Since the very first round, we have seen various guides and tutorials created that will prove extremely valuable to new developers and the Obyte ecosystem in general, especially once Autonomous Agents go live

Right from the start, entries have been of remarkably high quality, and round after round contestants have helped build an extensive library of very useful articles, guides and examples. This round is no exception. With two new entries in the category, we once again saw different approaches to the difficult task of explaining something rather complex in a way that makes it easy to understand if you are new to the topic.

Entry 1 — “Use a web page to interact with Obyte powered AA” by hey_monkey

As has almost become tradition, hey_monkey found time to not only submit an entry for the developer contest, but also to write a guide/tutorial focusing on a general aspect that is related to the entry.

Once again, the quality of the tutorial is high and there is no doubt that this article will be really useful to other Autonomous Agent Developers when wanting to make their Agents more accessible for users.

The topic of this tutorial is, as stated in the title, how to make a website that will build the required data for a triggering action to an Autonomous Agent, and pass these on to the GUI-wallet by the use of the Obyte URI protocol.

There are great little examples documenting the code used on the website and it explains in detail how to make sure to handle the base64 encoding of the data into a valid URL that contains the Obyte URI. It also explains how problems might arise if the resulting string contains an equal sign. This must be stripped before being passed to the final result URL which will eventually be fed to the GUI wallet’s Send-screen, effectively helping the user to structure all the data required to not have the transaction bounced by the Autonomous Agent.

Link to entry

Image for post
Image for post

Entry 2 — “Update to Reviews of Autonomous Agent Techniques” by whoisterencelee

In this final round, whoisterencelee added further details to the architectural/technique focused tutorial, that will greatly aid developers establish best practices or learn from proven design patterns.

The documentation now contains well more than 10 different techniques which are all described in great detail. The article begins with the ideation phase and gradually introduces aspects to take into consideration before even writing the first piece of code.

“A great beginning is halfway finished” as some say, so if you start out in the wrong direction you might end up in a situation where you hit a dead end on something and have to start all over from scratch. Therefore, the initial considerations are so important in any piece of development work, with Oscript being no exception.

The article then moves on to describe a myriad of techniques and different aspects that played important roles in the creation of whoisterencelee’s previous entries as well as his entries for this round.

It doesn’t cover a specific topic and might be a bit difficult for developers looking for a reference on how to achieve a specific task, but as an initial article on the do’s and don’ts, it will definitely be useful.

Link to entry

Image for post
Image for post

The Winners

As already stated several times throughout the already way too long announcement, this round saw some truly fantastic entries. The delay in this announcement is also proof of how difficult this round was to judge by the jury members.It has taken far longer than it should have, but better late than never, as they say.

Before announcing the winners, I would like to extend a heartfelt thank you to all the participants in this contest. Your tests and creative developing skills have helped Obyte weed out several bugs and be a direct reason for the introduction of several new features and additions to the Oscript language. Without your contributions, this process would have taken much longer and the time until Autonomous Agents are ready to be released to mainnet would have been significantly longer. So thank you, thank you, thank you very much!

And a final note before we get to the winners announcements: We saw several crashes of the testnet and the Oscript editor in the early stages of the contest. We feel relatively certain that there are no problems left now, but the Crash & Burn reward will remain active for the rest of 2019. This means that anyone capable of crashing the testnet full node or the Oscript editor will receive the Crash & Burn award and an eternal place in the hall of fame for having outsmarted Tony at his own game.

So even though the contest has now come to an end, there is still an opportunity to pick up more rewards related to exploring Oscript’s possibilities for writing Autonomous Agents. It is expected that Autonomous Agents will go live on mainnet within 1–2 months provided no further bugs are found. At this time, there is also a possibility that bounties for various specific tasks will be opened and we would of course appreciate the help of everyone of you.

But now — what I guess you’ve been eagerly waiting for — the announcement of the last round’s winners:

Third Place

Third place and a prize of 35 GB and 73.85 GBB goes to:

“A Renting Guarantee Autonomous Agent (ARGAA)” by hey_monkey

From a user’s point of view, this particular use case has really high relevance and represents an interesting solution that addresses the trust aspect between two parties who have no reason to trust each other.

As with previous entries, the Autonomous Agent is meticulously written but the accompanying chatbot was found to contain a few suboptimal decisions. The jury weighed the Autonomous Agent as most important and the added ease of use that the chatbot did introduce, made an already excellent entry even better.

Image for post
Image for post

Second Place

Second place and a prize of 70 GB and 147.7 GBB goes to:

“Certificate of Deposit” by Lion’s Heart

The Autonomous Agent contains a lot of really useful features as well as being written in a well structured way. While the usefulness might be a bit limited by probably only being relevant to cryptocurrency speculators, there would definitely be several elements that would be useful to others in other use cases.

Another factor in the jury’s decision was the nice and easy to use website built for it. It makes it a lot easier for users to interact with the Agent and to prevent potential user mistakes when entering values and clicking buttons on a website rather than manually typing parameters and values for data to be sent to the AA.

Image for post
Image for post

The Winner

For round seven of the Autonomous Agents Developer Contest, the winner of 140 GB and 295.554 GBB is:

“Autonomous Auctioneer” by Frank Bee

This entry manages to identify and solve not just one but several problems from the real world. It’s use as a potential backend for a market/auction website has phenomenal potential and while the additional features to allow for the exchange of funds and products could potentially be slightly improved, it doesn’t change the jury’s unanimous decision of awarding this entry a well deserved 1st place.

The obvious mistakes that could have easily made their way into this entry was carefully considered, and instead of stopping at the initial dutch auction, an additional feature to help buyer and seller exchange goods and funds was added. This decision to focus on an entire use case instead of a specific element in a flow of events, also proved to the jury, that this is an Autonomous Agent that has the potential to add significant value to the Obyte ecosystem if introduced when Autonomous Agents go live on the mainnet.

Image for post
Image for post

Honorable mentions

Before looking at the best guides/tutorials, we would like to step a bit outside the usual format to celebrate two more of the entries submitted in this round. The quality of these entries deserves to be highlighted and the authors deserve to know the reasoning that their entries didn’t make it into the top-3 in this round. The main reason of course being the number of high quality entries in the round. We will therefore add an additional 10 GB and 21.111 GBB for these entries:

“Obotic” by whoisterencelee

The entry proves mastery of the Oscript language. The complexity is extremely high and there are a few questions left unanswered. There is no doubt that distributed computing, incentivized or not, has a huge potential, and there is a reason that several DLT projects have this as their sole purpose. The use case, as implemented in this entry, does pose some future obstacles that will need gradual developing the project and refining some of the mechanics introduced.

The voting to assess whether a result is valid or not may be gamed in the current state. It might be possible to solve it, but it will require additional research. The potential clients for the system will have a quite steep learning curve before they can make use of the platform and there would be a need for a lot of headless wallets to be spun up in order to provide the distributed computing. The existing models for this type of system are already well established and will be difficult to overtake. Rather, a cooperation with existing distributed computing projects to provide the layer of economic incentives could be a potential path to follow.

“EmailBank” by Vik

The jury finds that the entry actually addresses, and to some extent also manages to solve, one of the really big problems in crypto. However, all jury members pointed to the fact, that the email attestation bot is effectively introduced as a single point of failure and that in this regard, it could be considered as having the same significance as a custody service.

There is no doubt the solution would prove sufficient as long as the owner of the email attestation bot decides not to exploit its ability to retrieve access to funds and that this would be a very unlikely scenario. But in crypto, an industry that often has a lot of money at stake, the only safe way to make sure others don’t get access to your funds, is to keep your private key safe and a backup securely stored.

Image for post
Image for post

Best Guide/Tutorial

The round featured two entries and once again we saw whoisterencelee going head to head against hey_monkey.

But just as with the Autonomous Agents, a winner must be selected, and for this round the jury found that the entry providing the best and most useful description for the reader and the winner of the 55 GB and 116.05 GBB is:

“Use a web page to interact with Obyte powered AA” by hey_monkey

The tutorial covers a single topic in great detail and walks the user through the different aspects of the topic step by step. This format works really well for new developers wanting to dig deeper into a specific topic or problem area that they need assistance solving.

Image for post
Image for post

Closing statements

It has been said over and over again throughout this announcement, but it is hard to thank the participants enough. Round after round we have witnessed contestants contribute hundreds of hours of work and it has been amazing to follow the journey some of the regular developers have been on. From uneasy baby steps to showing complete mastery of the Oscript language, knowing how to circumvent boundaries, exploring how the impossible could become possible and actively playing a significant role in the development of the largest feature addition to the Obyte platform since its launch almost 3 years ago.

And as a final remark, do keep experimenting with the Oscript editor, keep the debate going, keep requesting new features or methods to be added and do keep trying to break things. And keep an eye on the Obyte Discord for a potential bounty program that we are currently discussing how we could introduce.

On behalf of the entire Obyte core team, thank you to the developers and everyone who followed the contests round after round.


A distributed ledger without middlemen

Medium is an open platform where 170 million readers come to find insightful and dynamic thinking. Here, expert and undiscovered voices alike dive into the heart of any topic and bring new ideas to the surface. Learn more

Follow the writers, publications, and topics that matter to you, and you’ll see them on your homepage and in your inbox. Explore

If you have a story to tell, knowledge to share, or a perspective to offer — welcome home. It’s easy and free to post your thinking on any topic. Write on Medium

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store