service FundingAPI {
    rpc CreateFundingTransactionSubscription(CreateFundingTransactionSubscriptionRequest)
        returns (stream CreateFundingTransactionSubscriptionResponse);
}

from polymarket.v1 import funding_pb2

# Subscribe to all funding transactions for your accounts
request = funding_pb2.CreateFundingTransactionSubscriptionRequest(
    account_ids=[],
    transaction_types=[]
)

# Subscribe to deposits only
request = funding_pb2.CreateFundingTransactionSubscriptionRequest(
    account_ids=[],
    transaction_types=[funding_pb2.TRANSACTION_TYPE_DEPOSIT]
)

# Subscribe to specific account
request = funding_pb2.CreateFundingTransactionSubscriptionRequest(
    account_ids=["your-account-id"],
    transaction_types=[]
)

Deposit Flow:
PENDING → PROCESSING → ACKNOWLEDGED → COMPLETED

Deposit Failure:
PENDING → PROCESSING → CANCELLED

Withdrawal Flow:
PENDING → PROCESSING → COMPLETED

Refund Flow:
COMPLETED → PARTIALLY_REFUNDED → REFUNDED

import grpc
from datetime import datetime
from polymarket.v1 import funding_pb2
from polymarket.v1 import funding_pb2_grpc


class FundingTransactionStreamer:
    def __init__(self, grpc_server: str = "grpc-api.preprod.polymarketexchange.com:443"):
        self.grpc_server = grpc_server
        self.access_token = None
        self.last_server_time = None  # For resume capability

    def stream_funding_transactions(self, account_ids: list = None,
                                     transaction_types: list = None,
                                     resume_time=None):
        """Stream funding transaction state changes."""
        if not self.access_token:
            raise ValueError("Not authenticated. Please login first.")

        # Create credentials and channel
        credentials = grpc.ssl_channel_credentials()
        channel = grpc.secure_channel(self.grpc_server, credentials)
        stub = funding_pb2_grpc.FundingAPIStub(channel)

        # Create request
        request = funding_pb2.CreateFundingTransactionSubscriptionRequest(
            account_ids=account_ids or [],
            transaction_types=transaction_types or []
        )

        # Add resume_time if reconnecting
        if resume_time:
            request.resume_time.CopyFrom(resume_time)

        # Set up metadata with authorization
        metadata = [('authorization', f'Bearer {self.access_token}')]

        try:
            print("Starting funding transaction stream...")
            print(f"Account filters: {account_ids or 'ALL'}")
            print(f"Type filters: {transaction_types or 'ALL'}")
            print("-" * 60)

            response_stream = stub.CreateFundingTransactionSubscription(
                request, metadata=metadata
            )

            for response in response_stream:
                self._process_response(response)

        except grpc.RpcError as e:
            print(f"gRPC error: {e.code()} - {e.details()}")
            raise
        except KeyboardInterrupt:
            print("\nStream interrupted by user")
        finally:
            channel.close()

    def _process_response(self, response):
        """Process funding transaction change response."""
        # Store server_time for resume capability
        if response.HasField('server_time'):
            self.last_server_time = response.server_time

        for change in response.changes:
            tx = change.transaction
            print(f"\n[{datetime.now().strftime('%H:%M:%S')}] Transaction State Change")
            print(f"  Transaction ID: {tx.transaction_id}")
            print(f"  Type: {funding_pb2.FundingTransactionType.Name(tx.transaction_type)}")
            print(f"  Amount: {tx.amount} {tx.currency}")
            print(f"  Previous State: {funding_pb2.FundingTransactionState.Name(change.previous_state)}")
            print(f"  Current State: {funding_pb2.FundingTransactionState.Name(tx.transaction_state)}")
            print(f"  Account ID: {tx.account_id}")

            if tx.after_balance:
                print(f"  New Balance: {tx.after_balance}")

            print("-" * 60)


# Usage
if __name__ == "__main__":
    streamer = FundingTransactionStreamer()

    # Authenticate first (see Authentication docs)
    # streamer.access_token = "your_access_token"

    # Stream all funding transactions
    streamer.stream_funding_transactions()

    # Or filter by type
    streamer.stream_funding_transactions(
        transaction_types=[funding_pb2.TRANSACTION_TYPE_DEPOSIT]
    )

Starting funding transaction stream...
Account filters: ALL
Type filters: ALL
------------------------------------------------------------

[14:30:15] Transaction State Change
  Transaction ID: tx_abc123
  Type: TRANSACTION_TYPE_DEPOSIT
  Amount: 100.00 USD
  Previous State: TRANSACTION_STATE_PENDING
  Current State: TRANSACTION_STATE_PROCESSING
  Account ID: acct_xyz789
------------------------------------------------------------

[14:30:45] Transaction State Change
  Transaction ID: tx_abc123
  Type: TRANSACTION_TYPE_DEPOSIT
  Amount: 100.00 USD
  Previous State: TRANSACTION_STATE_PROCESSING
  Current State: TRANSACTION_STATE_COMPLETED
  Account ID: acct_xyz789
  New Balance: 250.00
------------------------------------------------------------

# On disconnect, reconnect with resume_time
if streamer.last_server_time:
    streamer.stream_funding_transactions(
        resume_time=streamer.last_server_time
    )