Liquidity pools in Blockchain / Solidity - Mini Project: Build & Apply

Liquidity Pools

📖 Scenario: You are building a simple program to understand how liquidity pools work in blockchain. Liquidity pools hold two types of tokens and allow users to swap between them. Your program will track the amounts of two tokens in the pool and calculate the price ratio.

🎯 Goal: Create a program that sets up a liquidity pool with two tokens and their amounts, defines a fee percentage, calculates the price ratio of the tokens, and prints the result.

📋 What You'll Learn

Create a dictionary called liquidity_pool with keys 'TokenA' and 'TokenB' and values 1000 and 500 respectively

Create a variable called fee_percent and set it to 0.3

Calculate the price ratio of TokenA to TokenB and store it in a variable called price_ratio

Print the price_ratio with a descriptive message

💡 Why This Matters

🌍 Real World

Liquidity pools are used in decentralized finance (DeFi) to enable token swaps without a traditional exchange.

💼 Career

Understanding liquidity pools is important for blockchain developers working on DeFi platforms and smart contracts.

1

DATA SETUP: Create the liquidity pool dictionary

Create a dictionary called liquidity_pool with these exact entries: 'TokenA': 1000 and 'TokenB': 500

Blockchain / Solidity

# Create the liquidity_pool dictionary with TokenA and TokenB amounts
# Your code here

Hint

Use curly braces to create a dictionary with keys 'TokenA' and 'TokenB' and their amounts.

2

CONFIGURATION: Define the fee percentage

Create a variable called fee_percent and set it to 0.3

Blockchain / Solidity

liquidity_pool = {'TokenA': 1000, 'TokenB': 500}
# Define the fee_percent variable
# Your code here

Hint

Just assign 0.3 to the variable fee_percent.

3

CORE LOGIC: Calculate the price ratio

Calculate the price ratio of TokenA to TokenB by dividing liquidity_pool['TokenB'] by liquidity_pool['TokenA'] and store it in a variable called price_ratio

Blockchain / Solidity

liquidity_pool = {'TokenA': 1000, 'TokenB': 500}
fee_percent = 0.3
# Calculate price_ratio as TokenB divided by TokenA
# Your code here

Hint

Divide the amount of TokenB by the amount of TokenA to get the price ratio.

4

OUTPUT: Print the price ratio

Print the price_ratio with the exact message: print(f"Price ratio of TokenB to TokenA: {price_ratio}")

Blockchain / Solidity

liquidity_pool = {'TokenA': 1000, 'TokenB': 500}
fee_percent = 0.3
price_ratio = liquidity_pool['TokenB'] / liquidity_pool['TokenA']
# Print the price_ratio with a descriptive message
# Your code here

Hint

Use an f-string to print the message with the price_ratio variable.

Practice

1. What is the main purpose of a liquidity pool in blockchain?

easy

A. To allow users to trade tokens directly without a middleman

B. To create new tokens automatically

C. To store user passwords securely

D. To mine new blocks faster

Solution

1. Step 1: Understand liquidity pool function

   Liquidity pools let users trade tokens directly without needing a middleman like an exchange.

2. Step 2: Compare options to definition

   Only To allow users to trade tokens directly without a middleman describes this function correctly; others describe unrelated blockchain features.

3. Final Answer:

   To allow users to trade tokens directly without a middleman -> Option A

4. Quick Check:

   Liquidity pools enable direct token trading = B [OK]

Hint: Liquidity pools remove middlemen in token trading [OK]

Common Mistakes:

• Confusing liquidity pools with token creation
• Thinking liquidity pools mine blocks
• Assuming liquidity pools store passwords

2. Which of the following is the correct way to represent a liquidity pool share in code?

easy

A. shares = {'user1': 100, 'user2': 50}

B. shares = ['user1', 'user2', 100, 50]

C. shares = (100, 50, 'user1', 'user2')

D. shares = 'user1:100, user2:50'

Solution

1. Step 1: Identify data structure for mapping users to shares

   A dictionary (key-value pairs) is best to map user names to their share amounts.

2. Step 2: Check options for dictionary syntax

   shares = {'user1': 100, 'user2': 50} uses a dictionary with user keys and numeric values, which is correct syntax and logic.

3. Final Answer:

   shares = {'user1': 100, 'user2': 50} -> Option A

4. Quick Check:

   Use dictionary for user-share mapping = A [OK]

Hint: Use dictionaries to map users to their shares [OK]

Common Mistakes:

• Using lists instead of dictionaries for key-value pairs
• Incorrect tuple ordering for mapping
• Using string instead of structured data

3. Given this Python code simulating a liquidity pool token ratio update:

pool = {'tokenA': 1000, 'tokenB': 2000}
new_tokenA = 100
new_tokenB = 200
pool['tokenA'] += new_tokenA
pool['tokenB'] += new_tokenB
price_ratio = pool['tokenB'] / pool['tokenA']
print(round(price_ratio, 2))

What is the printed output?

medium

A. 1.90

B. 2.20

C. 2.0

D. 3.00

Solution

1. Step 1: Calculate updated token amounts in pool

   tokenA = 1000 + 100 = 1100; tokenB = 2000 + 200 = 2200

2. Step 2: Compute price ratio and round

   price_ratio = 2200 / 1100 = 2.0; rounded to 2 decimals is 2.0

3. Final Answer:

   2.0 -> Option C

4. Quick Check:

   2200 ÷ 1100 = 2.0 [OK]

Hint: Add tokens first, then divide for ratio [OK]

Common Mistakes:

• Dividing before adding new tokens
• Rounding incorrectly
• Mixing tokenA and tokenB values

4. This code snippet tries to update a liquidity pool but has a bug:

pool = {'tokenA': 500, 'tokenB': 1000}
new_tokenA = 50
new_tokenB = 100
pool['tokenA'] =+ new_tokenA
pool['tokenB'] =+ new_tokenB
print(pool)

What is the bug?

medium

A. The dictionary keys 'tokenA' and 'tokenB' are misspelled

B. The operator '=+' is incorrect; should be '+='

C. The print statement is missing parentheses

D. The new_token variables should be strings, not integers

Solution

1. Step 1: Identify operator usage in assignment

   The code uses '=+' which is not a valid operator; it assigns positive new_tokenA instead of adding.

2. Step 2: Correct operator for addition assignment

   The correct operator is '+=' to add new_tokenA to pool['tokenA'] and similarly for tokenB.

3. Final Answer:

   The operator '=+' is incorrect; should be '+=' -> Option B

4. Quick Check:

   Use '+=' to add values in place [OK]

Hint: Use '+=' to add and assign in one step [OK]

Common Mistakes:

• Confusing '=+' with '+=' operator
• Assuming print needs no parentheses in Python 3
• Thinking keys are misspelled

5. You want to write a function that calculates each user's share percentage in a liquidity pool given a dictionary of shares like {'Alice': 300, 'Bob': 700}. Which code correctly returns a new dictionary with user names and their share percentages rounded to 2 decimals?

hard

A. def calc_shares(shares):
total = len(shares)
return {user: amount / total for user, amount in shares.items()}

B. def calc_shares(shares):
total = sum(shares.keys())
return {user: amount / total for user, amount in shares.items()}

C. def calc_shares(shares):
total = sum(shares.values())
return [round(amount / total * 100, 2) for amount in shares.values()]

D. def calc_shares(shares):
total = sum(shares.values())
return {user: round(amount / total * 100, 2) for user, amount in shares.items()}

Solution

1. Step 1: Calculate total shares correctly

   Sum the values of the shares dictionary to get total tokens contributed.

2. Step 2: Compute percentage per user and round

   Use dictionary comprehension to divide each user's amount by total, multiply by 100, and round to 2 decimals.

3. Final Answer:

   def calc_shares(shares): total = sum(shares.values()) return {user: round(amount / total * 100, 2) for user, amount in shares.items()} -> Option D

4. Quick Check:

   Sum values, divide each, round = correct share % [OK]

Hint: Sum values, then divide each share by total and round [OK]

Common Mistakes:

• Summing keys instead of values
• Returning list instead of dictionary
• Using length instead of sum for total