Update app.py

app.py

@@ -9,7 +9,6 @@ import threading
 from cryptography.fernet import Fernet
 import os
 import random
-import string
 
 STOCK_START_TIME = None
 STOCK_START_PRICE_AN = 1.27
@@ -129,8 +128,21 @@ def encrypt_value(value):
 def decrypt_value(encrypted_value):
     return cipher_suite.decrypt(encrypted_value.encode()).decode()
 
+_CACHED_CONNECT_SID = None
+_CACHED_BANK_BASE_URL = None
+_CACHED_REFERER = None
+
+def get_cached_credentials():
+    global _CACHED_CONNECT_SID, _CACHED_BANK_BASE_URL, _CACHED_REFERER
+    if _CACHED_CONNECT_SID is None:
+        _CACHED_CONNECT_SID = decrypt_value(ENCRYPTED_CONNECT_SID)
+        _CACHED_BANK_BASE_URL = decrypt_value(ENCRYPTED_BANK_BASE_URL)
+        _CACHED_REFERER = decrypt_value(ENCRYPTED_REFERER)
+        if not _CACHED_CONNECT_SID:
+            raise ValueError("connect.sid cookie is empty or invalid")
+    return _CACHED_CONNECT_SID, _CACHED_BANK_BASE_URL, _CACHED_REFERER
+
 def calculate_fee(amount):
-    """Calculate astratrader fee based on tiered structure"""
     if amount < 10:
         return 0
     elif amount < 25:
@@ -155,33 +167,34 @@ def calculate_fee(amount):
         return 50
 
 def calculate_claim_amounts(amount):
-    """Calculate send amount (+1%) and claim amount (-1%) for claim links"""
-    send_amount = max(1, int(amount * 1.01))
+    if amount > 50:
+        fee_percent = 0.02
+    else:
+        fee_percent = 0.01
     
-    claim_amount = max(1, int(amount * 0.99))
+    send_amount = max(1, int(amount * (1 + fee_percent)))
+    claim_amount = max(1, int(amount * (1 - fee_percent)))
     
-    return send_amount, claim_amount
+    return send_amount, claim_amount, fee_percent
 
-def generate_unique_code(length=4):
-    """Generate a unique alphanumeric code (must be called within app context)"""
-    chars = string.ascii_uppercase + string.digits
+def generate_unique_code():
     max_attempts = 100
     
     for _ in range(max_attempts):
-        code = ''.join(random.choice(chars) for _ in range(length))
+        code = str(uuid.uuid4())
         if not PaymentLink.query.filter_by(id=code).first() and not ClaimLink.query.filter_by(id=code).first():
             return code
     
-    return ''.join(random.choice(chars) for _ in range(length))
+    return str(uuid.uuid4())
 
-ENCRYPTED_CONNECT_SID = encrypt_value('s%3AchprkBWT1gzUWdCkJcWneCauTP73rb1-.tLvwxPgi6HFX3f1ULUt120nsbCJgODtlWpdp0cIluM0a')
+ENCRYPTED_CONNECT_SID = encrypt_value('s%3AchprkBWT1gzUWdCkJcWneCauTP73rb1-.tLvwxPgi6HFX3f1ULUt120nsbCJgODtlWpdp0cIluM0')
 ENCRYPTED_API_URL = encrypt_value('https://astra-bank-moh1812.replit.app/api/transactions')
 ENCRYPTED_REFERER = encrypt_value('https://astra-bank-moh1812.replit.app/')
 ENCRYPTED_ETAG = encrypt_value('W/"6e3-L0zHI4rHMa4nHmyewyA/4y+lL6c"')
 ENCRYPTED_BANK_BASE_URL = encrypt_value('https://astra-bank-moh1812.replit.app')
 
 class PaymentLink(db.Model):
-    id = db.Column(db.String(4), primary_key=True)
+    id = db.Column(db.String(36), primary_key=True)
     amount = db.Column(db.Integer, nullable=False)
     description = db.Column(db.String(500), nullable=False)
     recipient_email = db.Column(db.String(255), nullable=True)
@@ -192,7 +205,7 @@ class PaymentLink(db.Model):
         return f'<PaymentLink {self.id}: {self.amount} Astras>'
 
 class ClaimLink(db.Model):
-    id = db.Column(db.String(4), primary_key=True)
+    id = db.Column(db.String(36), primary_key=True)
     amount = db.Column(db.Integer, nullable=False) 
     send_amount = db.Column(db.Integer, nullable=False) 
     claim_amount = db.Column(db.Integer, nullable=False)  
@@ -375,6 +388,137 @@ def send_money(to_user_id, amount, description):
         print(f"Error sending money: {e}")
         return False, str(e)
 
+def get_friend_requests():
+    max_retries = 3
+    for attempt in range(max_retries):
+        try:
+            connect_sid, base_url, referer = get_cached_credentials()
+            
+            if not connect_sid:
+                print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] ERROR: connect.sid cookie is empty!")
+                return []
+            
+            url = f"{base_url}/api/friends"
+            
+            headers = {
+                'accept': '*/*',
+                'accept-language': 'en-US,en;q=0.9',
+                'cache-control': 'no-cache',
+                'pragma': 'no-cache',
+                'priority': 'u=1, i',
+                'referer': referer,
+                'sec-ch-ua': '"Chromium";v="142", "Google Chrome";v="142", "Not_A Brand";v="99"',
+                'sec-ch-ua-mobile': '?1',
+                'sec-ch-ua-platform': '"Android"',
+                'sec-fetch-dest': 'empty',
+                'sec-fetch-mode': 'cors',
+                'sec-fetch-site': 'same-origin',
+                'user-agent': 'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Mobile Safari/537.36',
+                'Cookie': f'connect.sid={connect_sid}'
+            }
+            
+            cookies = {
+                'connect.sid': connect_sid
+            }
+            
+            response = requests.get(url, headers=headers, cookies=cookies, timeout=10)
+            
+            if response.status_code == 200:
+                return response.json()
+            elif response.status_code == 401:
+                if attempt < max_retries - 1:
+                    time.sleep((attempt + 1) * 2)
+                    continue
+                else:
+                    return []
+            else:
+                return []
+        except Exception as e:
+            if attempt < max_retries - 1:
+                time.sleep((attempt + 1) * 2)
+                continue
+            else:
+                return []
+    return []
+
+def accept_friend_request(friend_id):
+    max_retries = 3
+    for attempt in range(max_retries):
+        try:
+            connect_sid, base_url, referer = get_cached_credentials()
+            
+            if not connect_sid:
+                print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] ERROR: connect.sid cookie is empty!")
+                return False
+            
+            url = f"{base_url}/api/friends/{friend_id}/accept"
+            
+            headers = {
+                'accept': '*/*',
+                'accept-language': 'en-US,en;q=0.9',
+                'cache-control': 'no-cache',
+                'content-length': '0',
+                'origin': base_url,
+                'pragma': 'no-cache',
+                'priority': 'u=1, i',
+                'referer': referer,
+                'sec-ch-ua': '"Chromium";v="142", "Google Chrome";v="142", "Not_A Brand";v="99"',
+                'sec-ch-ua-mobile': '?1',
+                'sec-ch-ua-platform': '"Android"',
+                'sec-fetch-dest': 'empty',
+                'sec-fetch-mode': 'cors',
+                'sec-fetch-site': 'same-origin',
+                'user-agent': 'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Mobile Safari/537.36',
+                'Cookie': f'connect.sid={connect_sid}'
+            }
+            
+            cookies = {
+                'connect.sid': connect_sid
+            }
+            
+            response = requests.post(url, headers=headers, cookies=cookies, timeout=10)
+            
+            if response.status_code == 200:
+                return True
+            elif response.status_code == 401:
+                if attempt < max_retries - 1:
+                    time.sleep((attempt + 1) * 2)
+                    continue
+                else:
+                    return False
+            else:
+                return False
+        except Exception as e:
+            if attempt < max_retries - 1:
+                time.sleep((attempt + 1) * 2)
+                continue
+            else:
+                return False
+    return False
+
+def background_friend_request_checker():
+    while True:
+        try:
+            friends = get_friend_requests()
+            if isinstance(friends, list):
+                for friend in friends:
+                    if isinstance(friend, dict):
+                        friendship_status = friend.get('friendshipStatus')
+                        if friendship_status == 'pending':
+                            email = friend.get('email', 'unknown')
+                            friend_id = friend.get('id')
+                            print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Pending friend request from: {email}")
+                            
+                            if friend_id:
+                                if accept_friend_request(friend_id):
+                                    print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] ✓ Accepted friend request from {email}")
+                                else:
+                                    print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] ✗ Failed to accept friend request from {email}")
+        except Exception as e:
+            pass
+        
+        time.sleep(10)
+
 with app.app_context():
     db.create_all()
 
@@ -431,7 +575,7 @@ def create_payment_link():
 @app.route('/init-payment-check/<payment_id>')
 def init_payment_check(payment_id):
     try:
-        payment_link = PaymentLink.query.get_or_404(payment_id.upper())
+        payment_link = PaymentLink.query.get_or_404(payment_id)
         fee = calculate_fee(payment_link.amount)
         total_amount = payment_link.amount + fee
 
@@ -447,7 +591,7 @@ def init_payment_check(payment_id):
 @app.route('/check-payment/<payment_id>')
 def check_payment_status(payment_id):
     try:
-        payment_link = PaymentLink.query.get_or_404(payment_id.upper())
+        payment_link = PaymentLink.query.get_or_404(payment_id)
         fee = calculate_fee(payment_link.amount)
         total_amount = payment_link.amount + fee
 
@@ -472,7 +616,7 @@ def check_payment_status(payment_id):
 @app.route('/pay/<payment_id>', methods=['POST'])
 def process_payment(payment_id):
     try:
-        payment_link = PaymentLink.query.get_or_404(payment_id.upper())
+        payment_link = PaymentLink.query.get_or_404(payment_id)
 
         if payment_link.paid:
             return jsonify({'error': 'Payment already completed'}), 400
@@ -508,23 +652,21 @@ def process_payment(payment_id):
 
 @app.route('/check-link/<link_id>')
 def check_link(link_id):
-    """Check if a link ID exists and return its type"""
     try:
-        payment_link = PaymentLink.query.filter_by(id=link_id.upper()).first()
+        payment_link = PaymentLink.query.filter_by(id=link_id).first()
         if payment_link:
             return jsonify({
                 'exists': True,
                 'type': 'payment'
             })
         
-        claim_link = ClaimLink.query.filter_by(id=link_id.upper()).first()
+        claim_link = ClaimLink.query.filter_by(id=link_id).first()
         if claim_link:
             return jsonify({
                 'exists': True,
                 'type': 'claim'
             })
         
-        # Not found
         return jsonify({
             'exists': False
         }), 404
@@ -534,7 +676,7 @@ def check_link(link_id):
 
 @app.route('/pay/<payment_id>')
 def view_payment(payment_id):
-    payment_link = PaymentLink.query.get_or_404(payment_id.upper())
+    payment_link = PaymentLink.query.get_or_404(payment_id)
     fee = calculate_fee(payment_link.amount)
     total_amount = payment_link.amount + fee
     return render_template('payment.html',
@@ -566,7 +708,7 @@ def create_claim_link():
         if amount > 10000:
             return jsonify({'error': 'Maximum 10,000 Astras per claim link'}), 400
 
-        send_amount, claim_amount = calculate_claim_amounts(amount)
+        send_amount, claim_amount, fee_percent = calculate_claim_amounts(amount)
 
         claim_link = ClaimLink(
             id=generate_unique_code(),
@@ -594,11 +736,15 @@ def create_claim_link():
 
 @app.route('/claim/<claim_id>')
 def view_claim(claim_id):
-    claim_link = ClaimLink.query.get_or_404(claim_id.upper())
+    claim_link = ClaimLink.query.get_or_404(claim_id)
+    fee_percent = 0.02 if claim_link.amount > 50 else 0.01
+    fee = int(claim_link.amount * fee_percent)
     return render_template('claim.html',
                           amount=claim_link.amount,
                           send_amount=claim_link.send_amount,
                           claim_amount=claim_link.claim_amount,
+                          fee=fee,
+                          fee_percent=int(fee_percent * 100),
                           verified=claim_link.verified,
                           claimed=claim_link.claimed,
                           claimer_email=claim_link.claimer_email,
@@ -607,7 +753,7 @@ def view_claim(claim_id):
 @app.route('/check-claim-verification/<claim_id>')
 def check_claim_verification(claim_id):
     try:
-        claim_link = ClaimLink.query.get_or_404(claim_id.upper())
+        claim_link = ClaimLink.query.get_or_404(claim_id)
 
         if claim_link.verified:
             return jsonify({'verified': True})
@@ -630,7 +776,7 @@ def check_claim_verification(claim_id):
 def process_claim(claim_id):
     try:
         data = request.get_json()
-        claim_link = ClaimLink.query.get_or_404(claim_id.upper())
+        claim_link = ClaimLink.query.get_or_404(claim_id)
 
         if claim_link.claimed:
             return jsonify({'error': 'Claim link already used'}), 400
@@ -673,6 +819,10 @@ def handle_connect():
     pass
 
 if __name__ == '__main__':
-    thread = threading.Thread(target=background_stock_updates, daemon=True)
-    thread.start()
+    stock_thread = threading.Thread(target=background_stock_updates, daemon=True)
+    stock_thread.start()
+    
+    friend_thread = threading.Thread(target=background_friend_request_checker, daemon=True)
+    friend_thread.start()
+    
     socketio.run(app, debug=True, host='0.0.0.0', port=7860, allow_unsafe_werkzeug=True)