The CSV may contain extra whitespace, which should be handled appropriately.

Function Signature

def compute_fees_per_merchant(
    csv_str,
    base_rate_by_provider,
    completed_rate_by_provider_and_country,
    fx_to_usd
) -> str:
    pass

Input Parameters

• csv_str: CSV string containing transaction records.
• base_rate_by_provider: Mapping of payment providers to their standard processing rates.
• completed_rate_by_provider_and_country: Mapping of (payment_provider, buyer_country) pairs to completed-payment rates.
• fx_to_usd: Mapping of currency codes to USD conversion rates.

Transaction Statuses

The following statuses may appear:

• payment_completed
• payment_pending
• payment_failed
• refund_completed
• dispute_won
• dispute_lost

Fee Calculation Rules

1. Refunds

For refund_completed, the processing fee is zero.

fee_usd = 0

2. Completed Payments

For payment_completed, first convert the transaction amount to USD.

amount_usd = amount * fx_to_usd[currency]

Look up the completed-payment rate using the payment provider and buyer country.

fee_usd = amount_usd * completed_rate + 0.30

If the provider-country combination is missing, use the provider's base rate instead.

3. All Other Statuses

For payment_pending, payment_failed, dispute_won, and dispute_lost, use the provider's base rate.

amount_usd = amount * fx_to_usd[currency]
fee_usd = amount_usd * base_rate + 0.30

Fallback Rules

• If a completed-payment rate is missing, use the provider's base rate.
• If a payment provider is unknown, use a rate of 0.
• Non-refund transactions still incur the fixed $0.30 fee when the provider is unknown.
• If a currency is unknown, assume its USD conversion rate is 1.0.

Output Format

Return a CSV string with the following header:

merchant_id,total_fee_usd

• Aggregate the fees for all transactions belonging to each merchant.
• Round each merchant's final total to two decimal places.
• Sort the output rows by merchant_id in ascending order.

Additional Requirements

Discuss the time complexity and explain how you would test edge cases, including:

• Empty input
• Malformed CSV rows
• Missing provider-country rate mappings
• Unknown providers
• Unknown currencies
• Extra whitespace in CSV fields

Part 2: Parse Transactions and Compute Each User's Fees

Problem Statement

Given a CSV string containing payment transactions, calculate the total processing fee for each user.

Return a dictionary mapping each user to their total fee in integer USD cents.

Implement the function:

def solution(csv_string):
    pass

Input Format

When the input is non-empty, the CSV contains this exact header:

user,status,payment_provider,amount

Each subsequent row contains:

The amount is non-negative and has at most two decimal places.

Supported Payment Providers

Fee Calculation Rules

1. Completed, Failed, and Pending Payments

For the following statuses:

• payment_completed
• payment_failed
• payment_pending

Calculate the fee as:

fee = amount * provider_rate + 0.30

2. Lost Disputes

For dispute_lost, charge a flat fee of $15.00.

fee = 15.00

3. Refunds and Won Disputes

For refund_completed and dispute_won, the fee is zero.

fee = 0.00

Rounding and Accumulation

• Round each transaction's fee to the nearest cent using round-half-up rounding.
• Convert each rounded fee to integer cents.
• Add the integer cents to the user's running total.
• Round each transaction separately before accumulating the total.

For example:

100.00 * 0.029 + 0.30 = 3.20 USD
3.20 USD = 320 cents

Output Format

Return a dictionary mapping each user to their total fees in cents.

Every user appearing in the CSV must be included, even if their total fee is zero.

Ignore blank lines and rows with an empty user field. If the input is empty or contains only whitespace, return an empty dictionary.

Example 1

Input

csv_string = """user,status,payment_provider,amount
alice,payment_completed,card,100.00
bob,payment_failed,bank_transfer,50.00
alice,refund_completed,card,20.00
bob,dispute_lost,wallet,80.00"""

Output

{
    "alice": 320,
    "bob": 1580
}

Explanation

• Alice's completed card payment: 100.00 * 0.029 + 0.30 = 3.20 USD, or 320 cents.
• Alice's refund incurs no fee.
• Bob's failed bank transfer: 50.00 * 0.01 + 0.30 = 0.80 USD, or 80 cents.
• Bob's lost dispute adds 1500 cents.

Therefore, Alice owes 320 cents and Bob owes 1580 cents.

Example 2

Input

csv_string = """user,status,payment_provider,amount
alice,payment_pending,wallet,10.00
alice,payment_completed,wallet,0.99
carol,dispute_won,card,42.00"""

Output

{
    "alice": 76,
    "carol": 0
}

Explanation

• Alice's pending wallet payment: 10.00 * 0.015 + 0.30 = 0.45 USD, or 45 cents.
• Alice's completed wallet payment: 0.99 * 0.015 + 0.30 = 0.31485 USD, rounded half-up to $0.31, or 31 cents.
• Alice's total is 45 + 31 = 76 cents.
• Carol's won dispute incurs no fee, but Carol must still appear in the output.

Constraints

• (0 <= n <= 100000), where (n) is the number of transactions.
• The CSV has the exact header user,status,payment_provider,amount when non-empty.
• Amounts are non-negative decimal numbers with at most two decimal places.
• Providers are card, bank_transfer, or wallet.
• Statuses are payment_completed, payment_failed, payment_pending, refund_completed, dispute_lost, or dispute_won.

Hints

• Use a CSV parser such as Python's csv.DictReader.
• Use Decimal and ROUND_HALF_UP to avoid floating-point rounding errors.
• Accumulate integer cents instead of floating-point currency values.

Part 3: Compute Fees in USD Using Country-Specific Rates

Problem Statement

Given a CSV string of payment transactions and a currency-to-USD exchange-rate dictionary, calculate the total transaction-processing fee for each user in integer USD cents.

Unlike Part 2, the transaction amount may be in a currency other than USD. Additionally, completed-payment rates depend on both the payment provider and the buyer's country.

Implement the function:

def solution(csv_string, exchange_rates):
    pass

Input Format

When the input is non-empty, the CSV contains this exact header:

user,status,payment_provider,buyer_country,currency,amount

The exchange_rates dictionary maps each currency to the USD value of one unit of that currency.

For example:

exchange_rates = {
    "USD": 1.0,
    "EUR": 1.10,
    "GBP": 1.25
}

Step 1: Convert the Amount to USD

Convert each transaction amount using the exchange-rate dictionary.

converted_usd = amount * exchange_rates[currency]

Step 2: Calculate the Transaction Fee

A. Completed Payments

For payment_completed, the processing rate depends on both the provider and the buyer's country.

Calculate the fee as:

fee = converted_usd * country_specific_rate + 0.30

The wallet rate is always 1.8%, regardless of the country.