Update app.py

app.py

@@ -1,12 +1,89 @@
-from flask import Flask, render_template, request, redirect, url_for, jsonify
+from flask import Flask, render_template, request, redirect, url_for, jsonify, session
 from flask_sqlalchemy import SQLAlchemy
+from flask_socketio import SocketIO, emit
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 import requests
 import time
 import threading
 from cryptography.fernet import Fernet
 import os
+import random
+import string
+
+STOCK_START_TIME = None
+STOCK_START_PRICE_AN = 1.27
+STOCK_START_PRICE_ASTRAFOODS = 2.50
+STOCK_START_PRICE_NOVASWEETS = 0.85
+
+def get_an_price():
+    if STOCK_START_TIME is None:
+        return STOCK_START_PRICE_AN
+    
+    elapsed = time.time() - STOCK_START_TIME
+    steps = int(elapsed / 0.5)
+    
+    if steps == 0:
+        return STOCK_START_PRICE_AN
+    
+    random.seed(int(STOCK_START_TIME))
+    price = STOCK_START_PRICE_AN
+    
+    for i in range(steps):
+        volatility = random.uniform(-0.15, 0.15)
+        trend = 0.000014
+        change = volatility + trend
+        price += change
+        if price < 0.01:
+            price = 0.01
+    
+    return round(price, 2)
+
+def get_astrafoods_price():
+    if STOCK_START_TIME is None:
+        return STOCK_START_PRICE_ASTRAFOODS
+    
+    elapsed = time.time() - STOCK_START_TIME
+    steps = int(elapsed / 0.5)
+    
+    if steps == 0:
+        return STOCK_START_PRICE_ASTRAFOODS
+    
+    random.seed(int(STOCK_START_TIME) + 1000)
+    price = STOCK_START_PRICE_ASTRAFOODS
+    
+    for i in range(steps):
+        volatility = random.uniform(-0.02, 0.02)
+        trend = 0.0000028
+        change = volatility + trend
+        price += change
+        if price < 0.01:
+            price = 0.01
+    
+    return round(price, 2)
+
+def get_novasweets_price():
+    if STOCK_START_TIME is None:
+        return STOCK_START_PRICE_NOVASWEETS
+    
+    elapsed = time.time() - STOCK_START_TIME
+    steps = int(elapsed / 0.5)
+    
+    if steps == 0:
+        return STOCK_START_PRICE_NOVASWEETS
+    
+    random.seed(int(STOCK_START_TIME) + 2000)
+    price = STOCK_START_PRICE_NOVASWEETS
+    
+    for i in range(steps):
+        volatility = random.uniform(-0.20, 0.20)
+        trend = 0.000021
+        change = volatility + trend
+        price += change
+        if price < 0.01:
+            price = 0.01
+    
+    return round(price, 2)
 
 app = Flask(__name__)
 app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///astrapay.db'
@@ -14,6 +91,21 @@ app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
 app.config['SECRET_KEY'] = 'your-secret-key-here'
 
 db = SQLAlchemy(app)
+socketio = SocketIO(app, cors_allowed_origins="*", async_mode='threading')
+
+def background_stock_updates():
+    while True:
+        if STOCK_START_TIME is not None:
+            price_an = get_an_price()
+            price_astrafoods = get_astrafoods_price()
+            price_novasweets = get_novasweets_price()
+            
+            socketio.emit('stock_update', {
+                'an': price_an,
+                'astrafoods': price_astrafoods,
+                'novasweets': price_novasweets
+            })
+        time.sleep(0.5)
 
 def get_encryption_key():
     key_file = 'encryption.key'
@@ -37,14 +129,59 @@ def encrypt_value(value):
 def decrypt_value(encrypted_value):
     return cipher_suite.decrypt(encrypted_value.encode()).decode()
 
-ENCRYPTED_CONNECT_SID = encrypt_value('s%3A7Bwbww_JK7pW55D-B57-3b7bi-FzrzEZ.ezXPafCUs8%2B9L632zAZaBD51TQfSnUXUwbga8Z9kyAo')
+def calculate_fee(amount):
+    """Calculate astratrader fee based on tiered structure"""
+    if amount < 10:
+        return 0
+    elif amount < 25:
+        return 1
+    elif amount < 100:
+        return 3
+    elif amount < 250:
+        return 5
+    elif amount < 300:
+        return 6
+    elif amount < 500:
+        return 8
+    elif amount < 1000:
+        return 10
+    elif amount < 2500:
+        return 22
+    elif amount < 3000:
+        return 24
+    elif amount < 5000:
+        return 24
+    else: 
+        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))
+    
+    claim_amount = max(1, int(amount * 0.99))
+    
+    return send_amount, claim_amount
+
+def generate_unique_code(length=4):
+    """Generate a unique alphanumeric code (must be called within app context)"""
+    chars = string.ascii_uppercase + string.digits
+    max_attempts = 100
+    
+    for _ in range(max_attempts):
+        code = ''.join(random.choice(chars) for _ in range(length))
+        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))
+
+ENCRYPTED_CONNECT_SID = encrypt_value('s%3AchprkBWT1gzUWdCkJcWneCauTP73rb1-.tLvwxPgi6HFX3f1ULUt120nsbCJgODtlWpdp0cIluM0a')
 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(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    id = db.Column(db.String(4), 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)
@@ -54,53 +191,104 @@ class PaymentLink(db.Model):
     def __repr__(self):
         return f'<PaymentLink {self.id}: {self.amount} Astras>'
 
+class ClaimLink(db.Model):
+    id = db.Column(db.String(4), 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)  
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    verified = db.Column(db.Boolean, default=False) 
+    claimed = db.Column(db.Boolean, default=False)  
+    claimer_email = db.Column(db.String(255), nullable=True)
+
+    def __repr__(self):
+        return f'<ClaimLink {self.id}: {self.amount} Astras>'
+
 def get_transactions():
     url = decrypt_value(ENCRYPTED_API_URL)
     referer = decrypt_value(ENCRYPTED_REFERER)
-    etag = decrypt_value(ENCRYPTED_ETAG)
     connect_sid = decrypt_value(ENCRYPTED_CONNECT_SID)
 
     headers = {
         'accept': '*/*',
         'accept-language': 'en-US,en;q=0.9',
-        'if-none-match': etag,
+        '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': '?0',
-        'sec-ch-ua-platform': '"macOS"',
+        '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 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36'
+        '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'
     }
 
     cookies = {
-        'sidebar_state': 'true',
         'connect.sid': connect_sid
     }
 
     try:
+        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Fetching transactions from API: {url}")
         response = requests.get(url, headers=headers, cookies=cookies, timeout=10)
-        return response.json()
+        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] API Response Status: {response.status_code}")
+        
+        transactions = response.json()
+        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] API Response: Received {len(transactions) if isinstance(transactions, list) else 'N/A'} transactions")
+        
+        if isinstance(transactions, list) and len(transactions) > 0:
+            print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Latest transaction: ID={transactions[0].get('id')}, Amount={transactions[0].get('amount')}, Type={transactions[0].get('transactionType')}, CreatedAt={transactions[0].get('createdAt')}")
+        
+        return transactions
     except Exception as e:
-        print(f"Error fetching transactions: {e}")
+        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Error fetching transactions: {e}")
         return []
 
-def check_for_payment(amount, existing_transaction_ids):
+def check_for_payment(amount):
     try:
+        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Checking for payment: Amount={amount}")
         transactions = get_transactions()
-
+        current_time = time.time()
+        one_minute_ago = current_time - 60 
+        
+        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Checking transactions from last minute (since {datetime.fromtimestamp(one_minute_ago).strftime('%Y-%m-%d %H:%M:%S')})")
+        
+        matching_transactions = []
         for transaction in transactions:
-            transaction_id = transaction.get('id')
-            if (transaction_id not in existing_transaction_ids and
-                transaction.get('amount') == amount and
+            if (transaction.get('amount') == amount and
                 transaction.get('transactionType') == 'received'):
-                return transaction
-
+                
+                matching_transactions.append(transaction)
+                print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Found matching transaction: ID={transaction.get('id')}, Amount={transaction.get('amount')}, CreatedAt={transaction.get('createdAt')}")
+                
+                created_at_str = transaction.get('createdAt')
+                if created_at_str:
+                    try:
+                        iso_str = created_at_str.replace('Z', '+00:00')
+                        created_at = datetime.fromisoformat(iso_str)
+                        created_at_timestamp = created_at.timestamp()
+                        
+                        age_seconds = current_time - created_at_timestamp
+                        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Transaction age: {age_seconds:.2f} seconds")
+                        
+                        if created_at_timestamp >= one_minute_ago:
+                            print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] ✓ Payment found! Transaction ID: {transaction.get('id')}")
+                            return transaction
+                        else:
+                            print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Transaction too old (>{age_seconds:.2f}s), skipping")
+                    except Exception as e:
+                        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Error parsing timestamp: {e}")
+                        continue
+        
+        if matching_transactions:
+            print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Found {len(matching_transactions)} matching transaction(s) but none within last minute")
+        else:
+            print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] No matching transactions found for amount {amount}")
+        
         return None
     except Exception as e:
-        print(f"Error checking for payment: {e}")
+        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Error checking for payment: {e}")
         return None
 
 def get_user_uuid(email):
@@ -199,23 +387,30 @@ def create_payment_link():
     try:
         data = request.get_json()
 
-        if not data or 'amount' not in data or 'description' not in data:
+        if not data or 'amount' not in data or 'description' not in data or 'recipient_email' not in data:
             return jsonify({'error': 'Missing required fields'}), 400
 
         amount = data['amount']
         description = data['description']
-        recipient_email = data.get('recipient_email', '').strip() if data.get('recipient_email') else None
+        recipient_email = data.get('recipient_email', '').strip()
 
         if not isinstance(amount, int) or amount <= 0:
             return jsonify({'error': 'Invalid amount'}), 400
 
+        if amount > 10000:
+            return jsonify({'error': 'Maximum 10,000 Astras per payment link'}), 400
+
         if not description or len(description.strip()) == 0:
             return jsonify({'error': 'Description cannot be empty'}), 400
 
+        if not recipient_email:
+            return jsonify({'error': 'Recipient email is required'}), 400
+
         payment_link = PaymentLink(
+            id=generate_unique_code(),
             amount=amount,
             description=description.strip(),
-            recipient_email=recipient_email if recipient_email else None
+            recipient_email=recipient_email
         )
 
         db.session.add(payment_link)
@@ -236,14 +431,14 @@ 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)
-
-        transactions = get_transactions()
-        existing_ids = [tx.get('id') for tx in transactions]
+        payment_link = PaymentLink.query.get_or_404(payment_id.upper())
+        fee = calculate_fee(payment_link.amount)
+        total_amount = payment_link.amount + fee
 
         return jsonify({
-            'existing_transaction_ids': existing_ids,
-            'amount': payment_link.amount
+            'amount': payment_link.amount,
+            'fee': fee,
+            'total_amount': total_amount
         })
 
     except Exception as e:
@@ -252,16 +447,11 @@ 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)
+        payment_link = PaymentLink.query.get_or_404(payment_id.upper())
+        fee = calculate_fee(payment_link.amount)
+        total_amount = payment_link.amount + fee
 
-        existing_ids_str = request.args.get('existing_ids', '')
-        if existing_ids_str:
-            existing_ids = existing_ids_str.split(',')
-        else:
-            transactions = get_transactions()
-            existing_ids = [tx.get('id') for tx in transactions]
-
-        payment_transaction = check_for_payment(payment_link.amount, existing_ids)
+        payment_transaction = check_for_payment(total_amount)
 
         if payment_transaction:
             return jsonify({
@@ -282,7 +472,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)
+        payment_link = PaymentLink.query.get_or_404(payment_id.upper())
 
         if payment_link.paid:
             return jsonify({'error': 'Payment already completed'}), 400
@@ -292,15 +482,17 @@ def process_payment(payment_id):
 
         if payment_link.recipient_email:
             try:
+                fee = calculate_fee(payment_link.amount)
+                amount_to_send = payment_link.amount - fee
                 user_uuid = get_user_uuid(payment_link.recipient_email)
                 if user_uuid:
                     success, result = send_money(
                         to_user_id=user_uuid,
-                        amount=payment_link.amount,
+                        amount=amount_to_send,
                         description=payment_link.description
                     )
                     if success:
-                        print(f"Successfully sent {payment_link.amount} Astras to {payment_link.recipient_email}")
+                        print(f"Successfully sent {amount_to_send} Astras to {payment_link.recipient_email} (fee: {fee})")
                     else:
                         print(f"Failed to send money: {result}")
                 else:
@@ -314,11 +506,41 @@ def process_payment(payment_id):
         db.session.rollback()
         return jsonify({'error': str(e)}), 500
 
+@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()
+        if payment_link:
+            return jsonify({
+                'exists': True,
+                'type': 'payment'
+            })
+        
+        claim_link = ClaimLink.query.filter_by(id=link_id.upper()).first()
+        if claim_link:
+            return jsonify({
+                'exists': True,
+                'type': 'claim'
+            })
+        
+        # Not found
+        return jsonify({
+            'exists': False
+        }), 404
+        
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
 @app.route('/pay/<payment_id>')
 def view_payment(payment_id):
-    payment_link = PaymentLink.query.get_or_404(payment_id)
+    payment_link = PaymentLink.query.get_or_404(payment_id.upper())
+    fee = calculate_fee(payment_link.amount)
+    total_amount = payment_link.amount + fee
     return render_template('payment.html',
                                 amount=payment_link.amount,
+                                fee=fee,
+                                total_amount=total_amount,
                                 description=payment_link.description,
                                 paid=payment_link.paid,
                                 payment_id=payment_link.id,
@@ -328,5 +550,129 @@ def view_payment(payment_id):
 def bank():
     return render_template('bank.html')
 
+@app.route('/create-claim-link', methods=['POST'])
+def create_claim_link():
+    try:
+        data = request.get_json()
+
+        if not data or 'amount' not in data:
+            return jsonify({'error': 'Missing required fields'}), 400
+
+        amount = data['amount']
+
+        if not isinstance(amount, int) or amount <= 0:
+            return jsonify({'error': 'Invalid amount'}), 400
+
+        if amount > 10000:
+            return jsonify({'error': 'Maximum 10,000 Astras per claim link'}), 400
+
+        send_amount, claim_amount = calculate_claim_amounts(amount)
+
+        claim_link = ClaimLink(
+            id=generate_unique_code(),
+            amount=amount,
+            send_amount=send_amount,
+            claim_amount=claim_amount
+        )
+
+        db.session.add(claim_link)
+        db.session.commit()
+
+        claim_url = url_for('view_claim', claim_id=claim_link.id, _external=True)
+
+        return jsonify({
+            'success': True,
+            'claim_id': claim_link.id,
+            'claim_url': claim_url,
+            'send_amount': send_amount,
+            'claim_amount': claim_amount
+        })
+
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/claim/<claim_id>')
+def view_claim(claim_id):
+    claim_link = ClaimLink.query.get_or_404(claim_id.upper())
+    return render_template('claim.html',
+                          amount=claim_link.amount,
+                          send_amount=claim_link.send_amount,
+                          claim_amount=claim_link.claim_amount,
+                          verified=claim_link.verified,
+                          claimed=claim_link.claimed,
+                          claimer_email=claim_link.claimer_email,
+                          claim_id=claim_link.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())
+
+        if claim_link.verified:
+            return jsonify({'verified': True})
+
+        payment_transaction = check_for_payment(claim_link.send_amount)
+
+        if payment_transaction:
+            claim_link.verified = True
+            db.session.commit()
+            print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Claim link {claim_id} verified")
+            return jsonify({'verified': True})
+        else:
+            return jsonify({'verified': False})
+
+    except Exception as e:
+        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Error checking claim verification: {e}")
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/claim/<claim_id>', methods=['POST'])
+def process_claim(claim_id):
+    try:
+        data = request.get_json()
+        claim_link = ClaimLink.query.get_or_404(claim_id.upper())
+
+        if claim_link.claimed:
+            return jsonify({'error': 'Claim link already used'}), 400
+
+        if not claim_link.verified:
+            return jsonify({'error': 'Claim link not verified yet'}), 400
+
+        if not data or 'email' not in data:
+            return jsonify({'error': 'Email is required'}), 400
+
+        email = data['email'].strip()
+        if not email:
+            return jsonify({'error': 'Email cannot be empty'}), 400
+
+        user_uuid = get_user_uuid(email)
+        if not user_uuid:
+            return jsonify({'error': 'User not found'}), 404
+
+        success, result = send_money(
+            to_user_id=user_uuid,
+            amount=claim_link.claim_amount,
+            description=f'Claim link {claim_id}'
+        )
+
+        if success:
+            claim_link.claimed = True
+            claim_link.claimer_email = email
+            db.session.commit()
+            return jsonify({'success': True, 'message': f'{claim_link.claim_amount} Astras sent to {email}'})
+        else:
+            return jsonify({'error': f'Failed to send money: {result}'}), 500
+
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': str(e)}), 500
+
+
+@socketio.on('connect')
+def handle_connect():
+    pass
+
 if __name__ == '__main__':
-    app.run(debug=True, host='0.0.0.0', port=7860)
+    thread = threading.Thread(target=background_stock_updates, daemon=True)
+    thread.start()
+    socketio.run(app, debug=True, host='0.0.0.0', port=7860)