Problem: In-Memory Payment and Friendship System

Design and implement an in-memory payment system with simple social features. The system must process a sequence of requests, including:

1. Register a user: Create a new user account.
2. Send a friend request: Initiate a friendship between two existing users.
3. Accept a friend request: Finalize a friendship based on a previously sent request.
4. Transfer money: Move funds between two users.

Rules and Requirements

• Users and Balances

  • Each user has a unique user_id (string), a balance (integer amount, e.g., cents), and a list or set of friends (other user IDs).

• Friend Requests

  • A friend request is initiated with a unique req_id, user1, and user2. Both user1 and user2 must be existing users.
  • An accept-friend request contains its own unique req_id and the req_id of the original friend request to accept.
  • Users become friends only when an accept-friend request is successfully processed.

• Transfers

  • Money can only be transferred between users who are already friends.
  • A transfer request specifies a unique req_id, from_user, to_user, and an amount (must be > 0).
  • A transfer must fail if:
    • Either user does not exist.
    • The users are not friends.
    • from_user does not have sufficient balance.
  • On success, amount is subtracted from from_user.balance and added to to_user.balance.

• Error Handling

  • If a request is invalid (e.g., refers to an unknown user, a non-existent friend request ID, attempts to accept a friend request twice), the system should indicate failure for that request.
  • Define and document reasonable behavior for repeated or conflicting requests.

Interface

Design classes and methods using an object-oriented approach. A possible interface (names/signatures can be adjusted for clarity) is provided below:

class PaymentSystem:
    def register_user(self, user_id: str, initial_balance: int) -> bool:
        """Register a new user with given balance. Return False if user_id already exists."""

    def send_friend_request(self, req_id: str, user1: str, user2: str) -> bool:
        """Store a friend request identified by req_id. Return False on invalid input or duplicate req_id."""

    def accept_friend_request(self, req_id: str, original_req_id: str) -> bool:
        """Accept the previously stored friend request with ID original_req_id. Return False if original_req_id doesn't exist, is already accepted, or users are invalid."""

    def transfer(self, req_id: str, from_user: str, to_user: str, amount: int) -> bool:
        """Transfer amount from from_user to to_user if they are friends and balance is sufficient. Return True on success, False otherwise."""

Implementation Details

• Maintain all necessary internal state in memory (no external database required).
• Enforce the friendship and balance constraints for transfers.
• Correctly handle the indirection where a friend-accept request refers to an earlier friend-request by its req_id.
• You may ignore concurrency in the basic solution, but you can optionally comment on how you would make operations atomic under multiple threads.