# 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.0.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.