# Lender

*Sui CLI Version: 1.18.0*

A simple lending protocol.

This quest features a portion of a simple lending protocol. This module provides the functionality
    for users to deposit and withdraw collateral, borrow and repay coins, and calculate their borrowing
    health factor. 

The quest is comprised of the following functionality:

- `deposit`: Let's a lender deposit collateral into the liquidity pool.
- `withdraw` : Let's lenders withdraw their collateral.
- `borrow` : Let's a borrower take out debt on a coin.

        Example
 
        Input
        code_type = SUI
        amount_to_borrow=100.00
        
        Explanation: This will take 100 SUI from the SUI pool
        and give it to the user who made the borrow call. 
- `repay` : Let's borrowers repay their debt.
- `calculate_health_factor`: Calculate's the health factor of a user's debt to collateral ratio. 


Suiss Bank

# Liquidity Pool

Sui *CLI Version: 1.15.2*

An AMM (automated market maker) Sui Move module.

This module provides the base functionality of an AMM that can be used to create a decentralized exchange on the Sui blockchain.

The quest is comprised of the following functionality:

- `create_liquidity_pool`: Creates a new liquidity pool for the two specified coins.

        Example
        
        Input
        coin_a = SUI
        coin_b = wBTC
        
        Explanation: Creates a new pool for SUI and wBTC. Users will be able to use this
        pool to swap SUI and wBTC.


- `supply_liquidity`: Supplies a liquidity pool with more liquidity
- `remove_liquidity`: Redeems some liquidity pool coins for pool liquidity.
- `swap_exact_a_for_b`: Swaps an exact amount of coin A for the maximum amount of coin B.
- `swap_exact_b_for_a`: Swaps an exact amount of coin B for the maximum amount of coin A.
- `swap_a_for_exact_b`:  Swaps the minimum amount of coin A for an exact amount of coin B.
- `swap_b_for_exact_a`: Swaps the minimum amount of coin B for an exact amount of coin A.

Pool Party

# Payment Streams

Sui *CLI Version: 1.15.2*

A payment streaming module for Sui Move. 

The module allows a user to stream a specific balance of a coin to the specified user. A stream is a payment that is sent to the receiver that can be claimed over time. Instead of receiving the full payment at once or being restricted to fixed installments, the receiver can claim the pending payments at any time. The receiver can close the stream at any time, which will send the claimed amount to the receiver and the unclaimed amount to the sender. 

The quest is comprised of the following functionality:

- `create_stream`: Creates a new stream

        Example
        
        Input
        receiver = 0xabc123
        amount = 45 SUI
        duration = 12 months
        
        Explanation: This will create a new stream that is sent to account, 
        0xabc123. The stream will send over 45 SUI over the course of the next
        12 months. The user can claim the pending as it increases over time.


- `claim_stream`: Allows the receiver of a stream to claim the amount that has been streamed so far.
- `close_stream`: Allows the receiver of a stream to close it. This sends the receiver the pending amount, while sending the unclaimed amount back to the sender.

Cash Flow

# NFT

Sui *CLI Version: 1.15.2*

A template for creating your own NFT collection on the Sui blockchain!

This module is a simple NFT module that allows the collection manager to mint tokens for users and allows users to combine their NFTs to create new ones. 

The quest is comprised of the following functionality:

- `mint_nft`: Allows the collection manager to mint a new token.
- `combine_nfts`: Takes the two input NFTs and combines them into a brand new NFT.
- `withdraw_sales`: Allows the collection manager to collect the profit from the token sales.

NFT Creator

# Sui Marketplace

Sui *CLI Version: 1.15.2*

An on-chain marketplace on the Sui blockchain.

This quest features a marketplace where users can create shops and sell items. Every shop is a global shared object that is managed by the shop owner, which is designated by the ownership of the shop owner capability. The shop owner can add items to their shop, unlist items, and withdraw the profit from their shop. Users can purchase items from shops and will receive a purchased item receipt for each item purchased.

The quest is comprised of the following functionality:

- `create_shop`: Creates a shop for a user which can hold items for sale.
- `add_item`: Create a new item listing
- `unlist_item`: Unlists an item to make it non-purchasable.
- `purchase_item`: Purchase item(s) from a listing.

        Example

        Input
        shop = 0xabc
        item_id = 3
        quantity = 6
        recipient = 0x123
        payment_coin
        
        Explanation: Allows a user to purchase 6 of item #3 from shop, 0xabc,
        and sends the purchase receipt to the recipient, 0x123.

Sui Marketplace

# NFT Lottery

*Sui CLI Version: 1.15.2*

An NFT Lottery smart contract for the Sui blockchain.

This quest features an NFT lottery where users can create their lotteries with an NFT as the prize. Lottery creators can withdraw the ticket sales once the lottery has been won and a winner is announced. 

The quest is comprised of the following functionality:

- `create`: Create a new lottery with an NFT as the prize
- `buy`: Purchase a ticket for a lottery

        Example

        Input
        ticket_number = 1932
        lottery = #3
        payment = 1.2 SUI
        recipient = 0xABC123
        
        Explanation: Purchases ticket #1932 for lottery #3 for 1.2 SUI 
        and sends it to the user at 0xABC123

- `claim_prize`: Redeem the winning lottery ticket for the prize NFT
- `withdraw`: Withdraw the ticket sales from the finished lottery

JPEG Jackpot

# Marketplace App

A marketplace frontend app. 

This quest features a marketplace where users can create shops and sell items. Sellers can create new listings and unlist items. Users can purchase items, review items and sellers, and add items to their watchlist.

The quest is comprised of the following functionality:

- **List a new item**: Lists a new item for sale.

        Example
        
        Input
        title = LG Monitors
        description = Ultra-wide curved LG monitors
        price = $74.99
        quantity = 15
        
        Explanation: This will list LG monitors for sale. Users can then add them to their
        carts or watchlist, purchase them and rate the item and seller. 

- **Purchase an item**: one sentence explanation
- **Add items to the cart**: one sentence explanation
- **Add item to watchlist**: Allow the creator of the offer to cancel the offer if it has not been joined
- **Create review for seller/item**: Leave a review and rating for sellers and items.

Marketplace App

# Over network Part 2 - Authentication

An introduction into the authentication system of the [Over network](https://network.overmind.xyz/).

This quest is the first part of the Over Network FE series. Learn how the authentication of the Over Network works by creating profiles for new users. 

The quest is comprised of the following functionality:

- **Create Account**: Creates a new profile for the user and logs them in to the app.

        Example
        
        Input
        username = joe_shmoe
        param2 = Joe
        
        Explanation: This will create a new profile by uploading the account data 
        and logging the new user into the app. 
    

Over Network Pt 2

# Over Network

*Aptos CLI Version: 2.1.0*

An on-chain social network.

This quest features an on-chain social network platform. Users own and manage their accounts through NFTs and can post, comment, and like on the decentralized platform.

The quest is comprised of the following functionality:

- `create_account`: Creates a new account for the user.

        Input
        username = "mind slayer 3000"
        
        Explanation: The account with the username: "mind slayer 3000" will 
        be created for the user, as long as the account is not yet registered.

- `post`: publishes a new post.
- `comment`: Adds a comment onto a user’s post.
- `like`: likes a user’s post or comment.
- `follow`: follows an account.

Over Network

# Oracle of Delphi

*Aptos CLI Version: 2.3.1*

An implementation of a price oracle module. 

This quest features a price oracle module using the ‘push model’. The oracle admin account routinely submits prices for coin pairs and anyone can use those prices on chain.

The quest is comprised of the following functionality:

- `update_price_feed`: Let the admin account update a price for a coin pair.

        Example
        
        Input
        pair = "APT/USDC"
        price = 691000000
        confidence = 00001000
        
        Explanation: Admin submits the following price and confidence for the "APT/USDC" 
        coin pair. This will either update the existing price or initialize the price.
        The confidence means that the price is accurate within +/- .00001 APT. So there 
        would be a range of 6.91001 APT and 6.90999 APT

- `get_price`: Allows anyone to retrieve a copy of the price of a request pair to use on chain.

Oracle of Delphi

# Sport fantasy

*Aptos CLI Version: 2.1.0*

A decentralized fantasy soccer platform.

This community-built quest features a decentralized fantasy soccer platform. Every match week, users build teams of 3 players to compete for the highest score. At the end of the match week, the teams with the highest ranking scores will earn a price of APT. 

The quest is comprised of the following functionality:

- `create_team`: Allows a user to create a new team for the current match week.

        Example
    
        Input
        player_1 = Joe
        player_2 = Megan
        player_3 = Taylor
        
        Explanation: This will create a new team NFT with the three chosen players. The 
        team NFT is sent to the team creator. 


- `claim_reward`: Lets team owners claim a reward for their team once the match week stats have been announced.
- `announce_with_stats`: Allows the admin of the platform to submit the player stats for the current match week.

Copa de Overmind

# Pay me a River - Remastered

A real-time payment platform for the Aptos blockchain.

This quest features a web-based platform for real-time payments on the Aptos blockchain. Users can send and receive payments of APT (Aptos Coin) that are streamed and updated every second. 

The quest is comprised of the following functionality:

- **Starting payments**: Users can create a payment to start streaming APT to another user.

Example

```
Input
recipient = 0x123...abc
duration = 1 year
amount = 300 APT

Explanation: This will create a new payment to 0x123...abc. The payment amount 
will 300 APT which will be streamed to the recipient over the next year. 
```

- **Claiming APT**: Once a stream has started, the recipient can claim the streamed amount so far anytime they wish.
- **Viewing stream rate**: Users sending or receiving a streamed payment can also view their current stream rate which display their overall stream rate that incorporates all of their in and outgoing payments.
- **Managing streams**: The platform provides users with all of the management power of their in and outgoing payment streams.
- **Viewing stream history**: Users can view the history of each individual stream they are sending and receiving.

Pay me a River - Remastered

# Liquidity Pools

*Aptos CLI Version: 2.0.3*

An implementation of an AMM (automated market maker) liquidity pool.

This quest features an implementation of a liquidity pool that can be used in an Aptos decentralized exchange structure. Shares of the pools are represented by liquidity pool coins. 

The quest is comprised of the following functionality:

- `create_liquidity_pool`: Creates a new liquidity pool for a specific coin pair.

Example

```
Input

Explanation: This will create a new liquidity pool for the specified coin pair. 
```

- `supply_liquidity`: Supplies liquidity to a liquidity pool and outputs liquidity pool coins representing shares of the pool.
- `remove_liquidity`: Removes liquidity from a liquidity pool in exchange for liquidity pool coins.
- `swap`: Swaps the two coins in a specified liquidity pool.

Example
```
Input
coin_a_in = CoinA, 
amount_coin_a_out = 89, 
coin_b_in = CoinB, 
amount_coin_b_out = 23

Explanation: This will execute a swap for the given coin amounts. Will take in 
coin_a_in and swap it for amount_coin_b_out. Will take in coin_b_in and swap it
for amount_coin_a_out.
```

Infinity Pool

# Dawn of Design 
Visit the demo Dapp [here](https://birthday-bot.overmind.xyz).

This quest features a web application that is an automated on-chain gift-giving Dapp. Use the platform to create gifts that hold APT coins that the recipient can open on their birthday. 

The quest is comprised of the following functionality:

- **Creating gifts**: Let users create gifts of APT for others.
    
    ![Gift creator card](https://drive.google.com/uc?id=17MM4yyWbi69tabRye-wy8eGLJTRRzqNU)
 
    

Example

```
Input
Recipient's address = 0x633...076
Gift amount = 1.25 APT
Birthday = 10/22/2023

Explanation: Creates a new gift that holds 1.25 APT and can be claimed by
the account at 0x633...076 on or after December 22nd, 2023. 
```

- **Cancel sent gifts**: Users can cancel gifts that have not been opened by the recipient yet. The gift amount will be refunded to the user.
    
    ![List of sent gifts](https://drive.google.com/uc?id=1ZvMubpIPYiIiGGJQlTF0VkCTXsPrVM9G)
    
- Claim gifts: Claim a received gift on or after the gift’s release date.
    
    ![List of received gifts](https://drive.google.com/uc?id=1gXXZIzzD_ZEpGLFvlODOU6ulqNxk8PZK)
   
    

Example

```markdown
Input
From = 0x72f...80b
Amount = 0.4 APT
Release time = 8/3/2023

Explanation:Sends the 1.25 APT from 0x633...076 to the recipient's 
account. 
```

- **View gift history**: Views all gift creation, cancelation, and claiming that is relevant to the user.

    ![History table](https://drive.google.com/uc?id=1OXSbNv-MnffdR1GFA1qCwUBxlsIkjUeZ)

Dawn of Design

# Village builder

*Aptos CLI Version: 2.0.3*

An on-chain, village-building game.

This module features a village-building game where users can create and manage their own on-chain village. Village owners can build and upgrade their village’s buildings. Village ownership is managed with NFTs.

The quest is comprised of the following functionality:

- `build_village`: Creates a new village for a player.

Example

```
Input
name = "Joe's village"
description= "This my special village"

Explanation: This creates a new village and NFT for Joe called "Joe's village". 
```

- `upgrade_building`: Lets the village owner to upgrade a building in their village.

Example

```markdown
Input
param1 = value1
village_id = 5
building_id = 2

Explanation: Upgrades the building with ID 2, in village #5. 
```

Village Buidler

# One for All
*Aptos CLI Version: 2.0.3*

A platform for creating resource accounts that can be used by multiple people.

This module allows anyone to create resource accounts (called common accounts) that are controlled by an admin and can be used by multiple accounts. 

The quest is comprised of the following functionality:

- `create_common_account`: Create a new common account.
- `add_account`: Add an account to a common account's list of users.

Example

```markdown
Input
common_account = 0x111
claimer = 0x222

Explanation: The account, 0x222, will be added to the common accounts list of 
addresses that can use the resource account.
```

- `remove_account`: Remove an account from a common account's list of approved users
- `acquire_signer`: Gives the caller the ability to use the common account.

Example

```markdown
Input
acquirer = 0x222 (signer)
common_account = 0x111

Explanation: As long as the acquirer is an approved user for this
common account, this function will give the acquirer access to the common 
account.
```

One for All

# Heads up

*Aptos CLI Version: 2.0.2*

An implementation of a coin flip predicting game.

This quest features a platform where users can attempt to predict 10 consecutive coin flips. If their predictions are correct, they win a prize. 

The quest is comprised of the following functionality:

 `guess_flips`: Submits the 10 coin flip guesses for a user

Example
```
Input:
flips = [0, 1, 0, 0, 0, 1, 1, 0, 1, 0] 

Explanation: The user submits their guesses for the 10 consecutive coin flips. 
The guessed coin flips are heads, tails, heads, heads, heads, tails, tails, heads, tails, and heads.
````

`provide_flip_results`: Allows the admin to provide the coin flip results to compare against a user’s guesses. If the user guesses correctly, a prize will be rewarded to them

Heads Up

*Aptos CLI Version: 2.3.2*

The on-chain revival of 90’s nostalgic children’s toy: Tamagotchi pets!

This quest features an NFT collection of digital pets that require regular feedings and playtime to stay alive.

The quest is comprised of the following functionality:

`adopt_pet`: Let users adopt a new digital pet.

Example

```
Input
pet_name = "Ruffles"
pet_type_code = 0

Explanation: Mints, a new NFT representing the digital pet, Josh. The pet type 
code represents the species of the new digital pet, in this case, a dog!**
```

`buy_pet_food`: Buy pet food to feed the digi-pets.
`buy_pet_toy`: Buy a pet toy to help keep the digi-pets happy.
`feed_pet`: Feed a pet, restoring its health.

Example 

```markdown
Input
pet_to_feed = 0xADA
amount_to_feed = 23

Explanation: Will restore 23 health for the Digi-pet, 0xADA.
```

`play_with_pet`: Play with a pet, restoring their happiness.

A Dev's Best Friend

*Aptos CLI Version: 2.0.2*

The classic game, Tic Tac Toe, brought onto the blockchain!

This quest features the on-chain implementation of Tic Tac Toe.

The quest is comprised of the following functionality:

- `create_game`: Let users create a new game.
- `mark_space`: Let a player mark their space during their turn of a game.

Example

```
Input
game_id = 8
row_number = 1
column_number = 0

Explanation: Will mark the spot at 1,0 at game #8 for the player.

   |   | O                     |   | O
-----------                 -----------
   | X | X        --->       O | X | X
-----------                 -----------
   |   |                       |   |  
```

Tic Tac Toe

*Aptos CLI Version: 2.0.2*

The on-chain version of the popular vocabulary game, Wordle!

This module is the on-chain implementation of the game, Wordle. Users have a certain number of guesses to guess the hidden word. Users will get feedback on each attempt. If a user guesses the correct word within the number of guesses, they win the prize money. 

The quest is comprised of the following functionality:

`guess_word`: Allows a user to submit a guess.

Example

```markdown
Input
word = "wordle"

Explanation: Submits the word, "wordle", for the user's guess. If the guess
is correct, the user gets the prize. If the guess is incorrect, the user 
loses one guess. 
```

Word, Hold On

*Aptos CLI Version: 2.0.2*

A DAO governance structure featuring proposal execution, unique voting mechanisms, and role-based governance.

The module determines vote eligibility based on DAO membership, tracks voting weight and state through the token’s associated property map, and executes proposals after verification of execution hashes. 

The quest is comprised of the following functionality:

`create_proposal` - Create a proposal by providing the requested proposal data.

`vote` - Mark the user’s NFT as voted and read the vote weight from the property map to submit their votes.

`update_governance_config` - Update the parameters which govern the governance structure.

Example:

```markdown
Input: 
minimum_voting_threshold = 1000
voting_duration_seconds = 3600

Explanation: 
The GovernanceConfig resource will be updated and now proposals in this
governance structure will require a minimum of 1000 votes to pass and proposals will last 
1 hour before closing, unless resolved earlier.
```

`add_approved_script_hash` - Once a proposal has passed, its execution hash must be added to the list of approved hashes.

`resolve` - Resolves a proposal and gives the execution script the ability to act as the module’s resource account.

Example

```
Input: 
proposal_id = 5, 
signer_key = "resource account signer", 
signer_description = "signer cap of the module's resource account"

Explanation: 
This gives the proposal #5's script the ability to use the
module's resource account.
```

`mint_governance_token` - Mint a token for members participating in governance and set correct roles in the property maps.

Senate of the Overmind

*Aptos CLI Version: 2.0.2*

The on-chain version of the classic thought experiment, Prisoner’s Dilemma.

Two players go head to head for a chance to win a prize, each player having the ability to split or steal the money. The game has three possible outcomes: the players agree to split the money, a greedy player betrays the selfless player and steals the money, or both players attempt to steal the money and walk away with nothing.

The quest is comprised of the following functionality:

`create_game`: Creates new games

`submit_decision`: Submits a player’s decision to either split or steal the prize money.

`reveal_decision`: Players reveal their decision. If both players have revealed their decisions, the outcome is determined and the prize money is distributed accordingly.

Example

```
Input: 
game_id = 4
salt = "example_salt"

Explanation: 
Assuming this is the second player to reveal their submission inside 
the game the salt is checked against each decision type to validate the player's
decision. When detected that both player's decisions have been revealed the 
outcome is determined and the prize money is distributed accordingly.
```

Split or Steal

*Aptos CLI Version: 2.0.1*

An NFT fractionalizing platform for Aptos NFTs.

This module lets you fractionalize a NFT into a collection of fungible tokens, that can be traded like any other token. Be the majority of the tokens to have the ability to recall all tokens and claim the original NFT.

The quest is comprised of the following functionality:

`split`: Deposit the original NFT and create a new collection of split tokens.

Example:

```
Input: 
nf_token_address = 0x123, 
split_token_name = "Split",
split_token_symbol = "SPL",
split_token_description = "Fractional of NFT at 0x123",
split_token_supply = 1000
split_token_call_threshold = 700,
split_token_call_price = 100000000
split_token_icon_uri = "ipfs://split"
split_token_project_uri = ""ipfs://project"

Explanation: 
The original NFT at 0x123 will be deposited and 1000 split tokens 
will be minted to the depositor. Whoever holds 700 or more of the split tokens 
has the ability to recall the tokens and claim the original NFT.
```

`call`: The user who owns the majority of the split tokens may claim the original NFT but must pay the difference between the split tokens they hold and the total supply.

`exchange_split_tokens_for_call_payment`: Users that hold split tokens for a NFT that has been claimed can exchange their tokens for their worth in Aptos coins.

Slice the JPEG

*Aptos CLI Version: 2.0.1*

A decentralized platform that allows peer-to-peer trading between APT (Aptos Coin) and fiat.

The module allows two parties (buyer and seller) to come together in a decentralized way to conduct a purchase of APT for fiat. In the case of a dispute, an on-chain arbiter is set at the offer’s creation, they will be in charge of handling any dispute.

The quest is comprised of the following functionality:

`create_offer` : Allow users to create a buy or sell offer

Example

```
Input:
arbiter = 0x00a1b
apt_amount = 1000000000
usd_amount = 70
sell_apt = true

Explanation: 
An offer with an offer_id will be created and listed, offering to sell 10 APT 
for 70 USD. The creator's 10 APT will be locked into the resource account and 0x00a1b 
will be the only address able to handle arbitration.
```

`complete_offer` : Allows the fulfilment of offers after both parties involved have agreed with no further disputes

`cancel_offer` : Allow the creator of the offer to cancel the offer if it has not been joined

`open_dispute` : Opens a dispute for a specific offer

`resolve_dispute` : Allows the arbiter to resolve the dispute

Example

```markdown
Input: 
offer_id = 8
transfer_to_creator = false

Explanation: 
offer_id 8 will be removed from the list of offers and the 
arbiter settled with the counterparty.
```

Broker it Yourself

*Aptos CLI Version: 1.0.18*

A chance to test your knowledge on the Aptos capability module.

This module mocks a bank robbery where you must move past each step of the heist. At each stage, a question is posed and the correct answer grants a unique Capability to unlock the next stage. Unlock all of the stages to capture the flag and complete the heist.

The quest is comprised of the following functionality:

`enter_bank`, `take_hostage`, `get_keycard`, `open_vault` -  Checks your answer to the stage’s posed question, and if it is correct, provides you the capability to move on to the next stage.

`get_flag` - Collects all of the stages’ answers to retrieve the module’s flag and completes the heist.

Capability Heist

*Aptos CLI Version: 1.0.18*

An implementation of popular collections of NFTs that can breed and be combined.

This module lets users create collections of dragon and longsword NFTs. Dragon NFTs can be bred to mint new dragon NFTs while longsword NFTs can be smelted and combined into an improved longsword. 

The quest is comprised of the following functionality:

`create_dragon_collection` - Create a new collection of a new dragon race with defined starting stats.

`create_sword_collection` - Create a new collection of a new sword type with defined stats.

Example:

```markdown
Input:
name = "Winged Swords"
description = "Elegant wings adorn the pommel of these swords"
uri = "ipfs://...."
combine_amount = 10
property_values = [100, 50]
ability_property = "Fly"

Explanation: 
A new collection called Winged Swords will be created. All the sword NFTs
belonging to this collection will have starting values of 100 attack power and 50
durability. Additionally, NFTs belonging to this collection grant the ability to fly
in game. In order to upgrade winged swords, 10 original swords must be smelted.
```

`create_dragon` - Mints a new dragon NFT.

`create_sword` - Mints a new sword NFT.

`breed_dragons` - Freezes two dragon NFTs according to breeding duration and produce a breeding record. Breeds two dragon NFTs to start process of creating a new dragon NFT.

Example:

```markdown
Input: 
collection_name = "Fire Dragons"
first_dragon_creation_number = 1
second_dragon_creation_number = 2

Explanation: 
Dragon NFT #1 and #2 of the Fire Dragon collection will start
breeding to create a brand new Fire Dragon NFT. 
```

`hatch_dragons` - After breeding duration has expired, mint a new baby dragon NFT.

`combine_swords` - Burn a certain amount of sword NFTs for a new sword NFT with improved stats.

Longswords & Dragons

*Aptos CLI Version: 1.0.12*

A new, on-chain implementation of the popular Cookie Clicker game.

This module is an on-chain version of Cookie Clicker where users click to earn diamonds. Users can purchase auto-miners with their diamonds to increase their production.

The quest is comprised of the following functionality:

`click`: Mine a diamond.

`claim`: Claim all diamonds that have been auto-mined.

`upgrade`: Purchase an upgrade for auto-miners.

Example:

```markdown
Input:
upgrade_index =  1
upgrade_amount = 2

Explanation: 
Purchases two more Aptomingos upgrades. These two upgrades cost 
50 diamonds and adds an additional 60 diamonds per minute to the user's 
auto-mining.
```

Diamonds are for Clicking

*Aptos CLI Version: 1.0.12*

An on-chain version of the classic game, Bingo.

This module allows for users to host a game of Bingo which will charge every user with an entry fee of Aptos coins. The winner of the bingo game will receive the sum of entry fees as the game prize.

The quest is comprised of the following functionality:

`create_game`: Creates a new Bingo game.

`insert_number`: Lets the game admin add drawn numbers to the game. 

`join_game`: Allow participants to submit their Bingo board after paying the entry fee.

`bingo`: Check if conditions for bingo then rewards the winning player with the prize money.

Example:

```markdown
Input:
game_name = "Overmind Weekly Bingo"

Explanation: 
When a player calls this with a winning board, they will be 
rewarded with the prize money and the bingo game will end.
```

AptoBingo

*Aptos CLI Version: 1.0.12*

A real-time payment system which allows users to pay and claim crypto.

This modules allows users to create, accept, and cancel real-time payment streams. These streamed balances are updated every time a user claims their payments.

The quest is comprised of the following functionality:

`create_stream` - Create a payment stream.

Example:

```markdown
Input:
receiver_address = 0x123
amount = 1000000000000
length_in_seconds = 31536000

Explanation: 
Creates a new stream with 0x123 as the recipient. The stream will 
send 10,000 Aptos coin over the next year (31,526,000 seconds).
```

`accept_stream` - Allow the recipient to accept a stream.

`claim_stream` - Claims the payments streamed so far.

`cancel_stream` - Cancel the listed stream.

Pay me a River

*Aptos CLI Version: 1.0.12*

A platform for betting with your NFTs as collateral.

This module lets users create bets where the two players enter their NFT as collateral. The winner takes all NFTs!

The quest is comprised of the following functionality:

`join_game` - Allows an opponent to join a game and put up their portion of NFTs as collateral.

Example

```markdown
Input: 
game_address: 0x1234
creators = [0x125, 0x736]
collection_names = ["Abstract", "Abstract"]
token_names: ["Moon", "Sun"]
property_versions: [1, 1]

Explanation: 
The opponent enters to game at address 0x1234 by betting 2 NFTs. Both of
them are from the "Abstract" Collection but were created by different creators and have
their own names and version numbers.
```

`play_game` - Record the outcome of the game.

`claim` - Rewards the winer of the bet with all the NFTs.

NFTango

*Aptos CLI Version: 1.013*

An automated platform to help you distribute Aptos coins (APT) to your friends as birthday gifts.

This module stores a record of your friends, their birthdays, and the amount of APT to send to them as presents, allowing them to claim their gifts on their birthdays. 

The quest is comprised of the following functionality:

`initialize_distribution` - Initializes the birthday contract with a list of friends, birthdays, and the amounts to send.

Example

```markdown
Input: 
- addresses = [0x1, 0x2, 0x3]
- amounts = [100, 200, 300]
- birthday_timestamps = [1690000004, 1690000005, 1690000006]

Explanation: 
With the above inputs; the Address “0x1” will be able to claim 
an amount of “100” Aptos coins after the timestamp “1690000004”.
```

`add_birthday_gift` - Adds a friend from the gifting list.

`remove_birthday_gift` - Removes a friend from the gifting list.

`claim_birthday_gift` - Allows a friend to claim their present on their birthday.