Liquidity pools in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Liquidity pools

User deposits tokens

↓

Tokens added to pool

↓

Pool holds reserves

↓

Users trade tokens via pool

↓

Pool updates reserves

↓

Users withdraw tokens + fees

↓

End

Users add tokens to a pool, which holds reserves. Traders swap tokens through the pool, changing reserves. Users can withdraw their share plus fees.

Execution Sample

Blockchain / Solidity

pool = {'tokenA': 1000, 'tokenB': 1000}
user_deposit = {'tokenA': 100, 'tokenB': 100}
pool['tokenA'] += user_deposit['tokenA']
pool['tokenB'] += user_deposit['tokenB']
print(pool)

This code shows a user adding tokens to a liquidity pool, increasing the pool's reserves.

Execution Table

Step	Action	Pool tokenA	Pool tokenB	Output
1	Initial pool reserves	1000	1000	{'tokenA': 1000, 'tokenB': 1000}
2	User deposits 100 tokenA	1100	1000	Updated tokenA reserve
3	User deposits 100 tokenB	1100	1100	Updated tokenB reserve
4	Print pool state	1100	1100	{'tokenA': 1100, 'tokenB': 1100}

💡 User deposit added, pool reserves updated, final pool state printed.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
pool['tokenA']	1000	1100	1100	1100
pool['tokenB']	1000	1000	1100	1100

Key Moments - 2 Insights

Why does the pool's tokenA reserve increase after the user deposit?

Because the user adds 100 tokenA to the pool, increasing the pool's tokenA reserve from 1000 to 1100 as shown in step 2 of the execution table.

Does the pool update both tokens at the same time?

No, the pool updates tokenA first (step 2), then tokenB (step 3), reflecting the separate deposit actions.

Visual Quiz - 3 Questions

Look at the execution table, what is the pool's tokenB reserve after step 2?

A 1000

B 1100

C 900

D 1200

💡 Hint

Check the 'Pool tokenB' column at step 2 in the execution table.

At which step does the pool's tokenA reserve become 1100?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Pool tokenA' column in the execution table.

If the user deposited 200 tokenB instead of 100, what would be the pool's tokenB reserve after step 3?

A 1100

B 1300

C 1200

D 1400

💡 Hint

Add 200 to the initial 1000 tokenB reserve shown in the variable tracker.

Concept Snapshot

Liquidity pools hold token reserves supplied by users.
Users deposit tokens, increasing pool reserves.
Traders swap tokens via the pool, changing reserves.
Users withdraw tokens plus fees earned.
Pool reserves update step-by-step with deposits and trades.

Full Transcript

Liquidity pools are smart contracts holding tokens from users. Users deposit tokens, which increases the pool's reserves. Traders swap tokens through the pool, changing the amounts held. Users can later withdraw their tokens plus fees earned from trades. In the example, a pool starts with 1000 tokens each of tokenA and tokenB. A user deposits 100 tokens of each. The pool's reserves update step-by-step, first tokenA then tokenB, ending with 1100 tokens each. This process is shown in the execution table and variable tracker. Key moments include understanding how deposits increase reserves and that tokens update separately. The visual quiz checks understanding of these steps. The snapshot summarizes the main points about liquidity pools and their token reserve updates.

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