Congratulations and thank you to everyone that participated!

SWAPR implements a contract that allows clients to swap a token for an other in a trustless fashion, in a fashion similar to what Uniswap does in the ETH world by having a liquidity pool that earns transaction fees taken on what others exchanges.

When life gives you lemons, make lemonade. When life gives you a smart contract hackathon, make…AN ENTIRE DECENTRALIZED EXCHANGE?! We're fairly certain the username psq means "Pretty Spectacular Qoder", because this project exceeded all our expectations. It's become increasingly clear over the last few years that centralized exchanges present some concerning challenges. Having a single entity escrowing such a multitude of funds can be a security vulnerability. Not to mention the privacy question around KYC requirements to open an account on Binance, Gemini, or other popular exchanges run by a corporation. Decentralized exchanges will be absolutely critical in shifting power away from single points of failure, and giving it back to users. This ambitious submission implemented all of those features and functions needed to perform the trustless swaps, and even included a guides for running on a mocknet and performing the unit tests.

Included in the submission was an entire API for interacting with the project! It outlines all of the functions contained in the contract, with helpful descriptions of the functionality. This hacker also included a phenomenal "Further Thoughts" section of their repository in which they reflect on their experiences, the benefits and shortcomings of Clarity, and other observations on the Blockstack codebase. This type of feedback is so beneficial to our engineering team that is constantly queuing up features & improvements in the pipeline.

The Blind Poll smart contract enables users to host anonymous polls, where all submitted answers will be sealed until they're revealed by participants after the poll is closed.

Meanwhile, the contract comes with a fungible token named as BPT (Blind Poll Token) that serves as incentives for users to participate in the poll. Poll creators could choose to put aside some amount of BPT token as rewards for each valid participation, which will get distributed once participants reveal their answers.

Who get's to sit in shotgun? Who gets the last bite of cake? Who gets to start with the ball in overtime? The coin flip is a human legacy. A beautiful physical demonstration of equal probabilities. Unless you are a magician, there is nothing you can do to affect the outcome. It's a no-brainer that this mechanism should be implemented in smart contracts, and Friedger made it happen!

Basically, the contract that implements a read-only function returning a boolean value at random. Each block, a new random true-or-false value is created. It "flips" the coin by looking at the hash of a given block.

The coolest part of this submission, is that included in the documentation are the details for how the contract is used in a betting game. If the user bets on a certain outcome, and another user had already bet on the opposite outcome, the winner is awarded the jackpot!

This asset rental contract removes the need for trust in a property rental situation. This real-world applicable project solves a tangible problem, and removes the need for intermediaries like a lawyer or bank.

With this contract, negotiation can begin even if the contract is not signed yet. Once both parties agree to terms they can sign the contract. During contract duration, if the renter breaches contract by not paying, the owner is given control to either renew or end the contract. The owner also has the option to extend a grace period, or wave a specific month's fees. However, if the month ends and the owner did not waive payment, the renter would be in debt to the owner.

If the contract duration ended, both parties have the option to renegotiate. Any party can also request the contract be canceled, and would only cancel if both parties agree.

Everyone has that one story about a nightmare landlord. Putting that business logic in a trustless smart contract is the only way to totally avoid sensitive interpersonal, and maybe even legal, complications.

This contract is a pot for redistributing funds. Inspired by the "Mastodon Community Stimulus Redistribution Fund", which aimed at redistributing the US stimulus check to individuals that really need it.

The main issue with the original concept was in sending the donated amounts to the recipients. Centralized services like Paypal didn't like facilitating large amounts of government-distributed funds. This contract would trivialize that issue while still maintaining 100% transparency. This is also an example of cross contract communication with xmakina's Level 1 "endless-list" contract handling adding new recipients to the list.

Also a huge shoutout to this hacker for doing a live demo during our Phase II workshop. Seeing them walk through the code step by step was incredibly educational for beginners, and the real-world applicability helped to convey the potential of smart contracts in general.

This profit-sharing token is a non-fungible token that represents some dividable value into a number of given parts.

The token can be transferred for a price. The price is proposed by a buyer when expressing interest of buying (i.e. creating a call). Then the owner can sell the token to the buyer. When the new owner is re-selling parts of the token the profit will be shared with the previous owner.

Price of tokens or parts of a token, as well as the profit is represented in the contract through the fungible token usdt. The token is minted when creating a call. The amount of tokens show how much many was generated through the sale of the profit-sharing token.

This contract allows other contracts to maintain a bottomless, paged, list of items. It's an insanely useful module that can be used by other smart contracts to expand functionality.

It creates a map in clarity which uses page numbers. Each page contains ten items. A certain principal controls the list, and can add new items by calling a specific function. There are numerous other functions that allow you to interact with the list in interesting ways, and even the option to transfer control over to a different principal.

We thought this was an integral building block for smart contract, but also wanted to give a shoutout to this hacker's Advanced submission which built on this and used their Endless List contract in a powerful implementation!

This hacker was thinking big, and built on the project with level of difficulty. The submission was a prototype for tying tasks from multiple blockchains together in a workflow.

Their Level 0 submission is a basic task manager that simulates change in a workflow's task or sub-task status. With their Level 1 submission however, they kicked it up a notch and added status and timestamps from the Stacks blockchain. There are five different types of statuses: not used, not started, in process, completed, and cancelled. Adding timestamps to the status only provides more information to the user, and allows them better decision-making power. This is certainly a real-world applicable project, that would be used in many project management situations.

This election smart contract is a sample application where an administrator controls adding new candidates, stoping and starting registrations, and stopping and starting voting. Voters are allowed to vote only once if an election is open for voting, and admins can only add new candidates if registration is set to open.

A super useful voting contract with real-world impact. Elections in the real-world are extremely complex and are sometimes biased by intermediaries. Removing the need for trust from the equation, and putting the logic on the blockchain, is a way to increase security and privacy for all participants.

This contract establishes NFTs in the Clarity language, and implements all the functions needed to interact with them. A digital asset is defined as a space of sha-256 hashes.

It also defines "projects" as spaces of these digital assets. NFTs can then be minted as digital collectibles, and are assigned to an owner address. This allows a platform to charge a small minting fee (business models for the win!). Finally, the contract sets up functionality for marketplaces and auctions. What good is a digital collectible if you can't sell it when it accrues value?!

Everyone has that one horrible hotel experience. You land after a long flight, haul your suitcase all the way into downtown, and skulk shuffle up to the front desk only to find that the room you reserved months ago has been given away last minute to another party!

Having corporations like AirBnB, Expedia, or Kayak controlling all information around room reservations establishes a single point of failure. Putting this logic on the blockchain would aid in disintermediating the entire hospitality industry, which can be notoriously plagued by process debt.

All the functionality is here. A customer needs to check that they have the right amount of funds for a downpayment. A check is also made to ensure the room is still available for rent. The customers downpayment is then deposited in the owner's account to reserve the room. Finally, the remaining balance is deposited in the owner's account to officially confirm the reservation.

This is an intriguing project that implements conference ticket sales in a smart contract. A conference owner is designated as a principal, start time and end time is set, and ticket price is calibrated. To buy a ticket for the conference, you call the buy-ticket function, and then "enter" the conference by calling the enter-conference function.

It is a simple but extremely real-world applicable submission that implements all of the functions needed to facilitate an auction. The contract can create a bid, get a start price, get the highest bid, get the highest bidder, get the latest bid, and get the winner if the max bid count has been reached.

Humans have been transferring value through auctions since the ancient Greek forum. It's a traditional way of giving multiple people a shot to purchase an asset at competitive pricing. It's only natural this mechanism would eventually migrate to the blockchain! This project is a basic smart contract used to buy assets in an auction that follow a certain set of rules. Each auction will be ended after five turns. If five turns is not reached, the asset will remain with the asset owner. However, the fastest bidder with the highest bid will end up being the winner.

For all those individuals who aren't exactly "Morning People", this may just be the smart contract for you…

Let's imagine you set up an alarm clock that links to the blockchain. You want to incentivize people to wake you up in the morning! This hacker thought really creatively, and used the blockchain to wakeup bright-eyed and bushy tailed.

The clock uses an oracle to initialize the alarm when the time is right. You don't want users to be able to activate the alarm whenever they want! That then allows users to bid on the wake-up time by sending $STX, and it's winner takes all! However, the sleeper is able to click the snooze button. This gives 10% of the bounty to the person who triggered it. If the sleeper decides to wake up and click an "Awake" button, it awards to full bounty and resets the timer.

This simple contract implements a high score tracker using branching logic (if statements) and maps in Clarity. First, an initial score is set. The current high score can be queried at any time. When a user submits a new score, the contract checks it against the current high score. If the new score is higher than the current high score, the scoreboard is updated and the new entry becomes the high score. If the new score is lower than the current high score, nothing changes. Intuitively, the contract also has a function for users to change the name associated with their score!

Project management applications have taken off immensely in the last decade. Apps like Trello, Asana, or Jira allow you to create tasks and track them to completion. This is important, sensitive data though that users would prefer to be in control of. Putting this business logic on the blockchain ensures security and ownership.

This submission did just that, and implemented a basic workflow and sub-task structure into a Clarity smart contract. There are five different types of statuses: not used, not started, in process, completed, and cancelled. A team could use this project during a software development sprint to track feature completion, release versions, task delegation, and much more.

Someone once said: "Elections have consequences." Well then I say they better have the security of the blockchain!

It may seem like a simple mechanism, but it's the beauty of the blockchain that allows something as basic as voting to occur in a trustless manner. This contract sets up the infrastructure for voting between two candidates.

All the functions you would think a voting contract would need are here! You can call get-winner to see the winner of the vote. The get-allow-vote enables voting. There are functions to vote for each of candidate #1 and candidate #2. Finally, the close-vote function ends the round of voting and locks in a winner.

Gitpod is a powerful tool that allows you to configure a dynamic development environment totally contained within a web browser. Traditionally, coding projects required you to have a desktop text editor correctly configured with directories, dependencies, various libraries, and installed plugins. Gitpod is an open source web-based IDE that can be modified and tailored to your specific needs. Friedger built a sharable Gitpod configuration for Clarity that allows you to dive straight into development while bypassing a lot of the tedious setup.

This particular Gitpod configures the Clarity REPL, a stacks node, the Blockstack CLI, and two useful Clarity plugins for Visual Studio Code. This then allows devs of all experience levels to immediately begin experimenting with Clarity using the numerous sample contracts contained within the Gitpod. If you are familiar with Visual Studio Code, then you'll feel right at home. The file directory, text editor, and terminal window are at your fingertips.

Another crucial component to the project was a JsonRCPPRovider that connects to the Stacks 2.0 testnet. When testing Clarity contacts, clarity-js-sdk provides a Client object that can make contract calls and query the state of a Clarity program. However, the Client requires a Provider object that knows how to execute these queries. The default provider connects to a Clarity VM using clarity-cli. This was sufficient for unit testing Clarity contracts, but would have to be tediously rewritten using stacks-transactions-js when devs wanted to execute queries on the stacks blockchain. Developers can now use the same Client objects to make calls and queries on the Stacks blockchain using this JsonRCPPRovider.

If that wasn't enough, the project also included two informational demo videos that overview the project and its features. The first video is a general summary of the platform, while the second video walks you through running unit tests and deploying contracts using the JsonRpcProvider.

Meet Lumio, a platform that enables that drag-and-drop, modular, component-based development for Clarity smart contracts. Lumio is a reactive, in-browser IDE with a sleek UI that beginners can use to tinker with Clarity, learn more about its potential, and immediately start experimenting with smart contracts.

The "mind-blown" moment happens when you toggle the switch at the top of the page between 'Lumio' and 'Clarity'. When Lumio is selected, it will show you the visual representation of your smart contract denoted by symbol objects. However when the toggle is flipped to Clarity, the visual aspect of the smart contract is translated into the actual Clarity code that is hiding behind the modular Lumio representation. This is perfect for those blockchain beginners that know what their smart contract should accomplish, but aren't exact sure how it will be implemented.

Lumio is the perfect petri dish for throwing ideas at the Clarity wall and seeing what sticks. It's surprisingly effortless to walk through the business logic of a potential smart contract in your head, and then use Lumio to drag functional components into the contract as you need them. Gone are the days of tearing through pages of documentation for that one niche function definition! Having a navigation bar containing every code snippet you could ever need will drastically reduce the overhead required to start your Clarity adventure.

Enter Léo Pradel! He rose to Blockstack fame by developing a decentralized alternative to Medium, called Sigle, that uses Blockstack ID for login and Gaia storage hubs for data. This time around he chose to tackle that problem of blockchain wallet management by crafting a DevTool that helps you manage not only wallets, but contracts too, on the Stacks blockchain. Built in a squeaky-clean Electron app, the Blockstack DevTool is a simple but functional tool that adds quality-of-life improvements to Clarity development. First, you add a specific project directory. The contracts folder is automatically detected and populates the app with data. It's then broken down into two main pages: Accounts & Contracts.

The Accounts page allows you to easily generate a 12-word mnemonic phrase that ten stacks wallets are then derived from. Easy access to the private keys of these accounts is provided for simple reusability with the Blockstack CLI. This will drastically increase the ease at which you can test your project.

The Contracts page is your one-stop-shop for managing the smart contracts your project uses. It has a list of all the contacts it detected in your contracts folder, but also has a form for deploying new contracts to the blockchain with a single click. A user can denote not only the gas fee and contract name, but even the specific account that they want the contract to be deployed from! These seemingly basic features will shave hours off of longer development cycles.

In addition to the account and contract housekeeping it enables, the DevTool also implemented some simple widgets to streamline development such as a $STX faucet and the ability to send and receive $STX.

The Blockstack DevTool is a nifty little piece of tooling that will give any developer administrative superpowers over their project. Anyone who has constructed a $STX transaction in Terminal knows how valuable a tool like this could be to their workflow