🟣 Solana Integration Guide

# Python - Register Solana with non-EVM configuration
import requests
import time

def register_solana_chain(token):
    url = 'https://api.quub.exchange/v2/chains'
    headers = {
        'Authorization': f'Bearer {token}',
        'Content-Type': 'application/json',
        'Idempotency-Key': f'solana-mainnet-{int(time.time())}'
    }
    payload = {
        'chainId': 'solana-mainnet-beta',
        'name': 'Solana',
        'shortName': 'SOL',
        'networkType': 'MAINNET',
        'layer': 'L1',
        'nativeCurrency': 'SOL',
        'decimals': 9,
        'blockTime': 0.4,
        'confirmations': 32,
        'explorerUrl': 'https://explorer.solana.com',
        'docsUrl': 'https://docs.solana.com/',
        'genesisHash': '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d',
        'chainNamespace': 'SOLANA',
        'status': 'ACTIVE'
    }

    response = requests.post(url, json=payload, headers=headers)
    return response.json()

# Python - Configure Solana adapters with commitment levels
def configure_solana_adapters(token, api_keys=None):
    """Configure multiple Solana RPC adapters"""
    url = 'https://api.quub.exchange/v2/chain/adapters'

    adapters_config = [
        {
            'name': 'Solana Public RPC',
            'rpcEndpoint': 'https://api.mainnet-beta.solana.com',
            'priority': 3
        }
    ]

    # Add premium providers if API keys provided
    if api_keys:
        if 'helius' in api_keys:
            adapters_config.insert(0, {
                'name': 'Helius Primary',
                'rpcEndpoint': f"https://mainnet.helius-rpc.com/?api-key={api_keys['helius']}",
                'wsEndpoint': f"wss://mainnet.helius-rpc.com/?api-key={api_keys['helius']}",
                'priority': 0
            })

        if 'alchemy' in api_keys:
            adapters_config.insert(1, {
                'name': 'Alchemy Solana',
                'rpcEndpoint': f"https://solana-mainnet.g.alchemy.com/v2/{api_keys['alchemy']}",
                'priority': 1
            })

        if 'quicknode' in api_keys:
            adapters_config.append({
                'name': 'QuickNode Backup',
                'rpcEndpoint': api_keys['quicknode'],
                'priority': 2
            })

    results = []
    for config in adapters_config:
        headers = {
            'Authorization': f'Bearer {token}',
            'Content-Type': 'application/json',
            'Idempotency-Key': f"solana-{config['name'].lower().replace(' ', '-')}-{int(time.time())}"
        }

        payload = {
            'chainId': 'solana-mainnet-beta',
            'signerPolicy': 'MPC_CLUSTER',
            **config
        }

        response = requests.post(url, json=payload, headers=headers)
        results.append(response.json())

    return results

# Python - Handle Solana SPL token transfers
class SolanaSPLTokenManager:
    def __init__(self, org_id: str, token: str):
        self.org_id = org_id
        self.token = token
        self.base_url = 'https://api.quub.exchange/v2'
        self.chain_id = 'solana-mainnet-beta'

    def record_spl_token_transfer(self, tx_data: dict) -> dict:
        """Record SPL token transfer (similar to ERC-20 but on Solana)"""
        url = f'{self.base_url}/orgs/{self.org_id}/onchain/txs'
        headers = {
            'Authorization': f'Bearer {self.token}',
            'Content-Type': 'application/json',
            'X-Org-Id': self.org_id,
            'Idempotency-Key': f"solana-spl-{tx_data['signature']}"
        }

        # SPL token transfers have minimal SOL for transaction fee
        payload = {
            'chainId': self.chain_id,
            'hash': tx_data['signature'],
            'fromAddress': tx_data['sourceAccount'],
            'toAddress': tx_data['destAccount'],
            'value': '0',  # No SOL transferred (tokens only)
            'direction': tx_data.get('direction', 'OUTBOUND'),
            'status': self.map_commitment_status(tx_data.get('commitment', 'finalized')),
            'blockNumber': tx_data['slot'],
            'gasPrice': '0',
            'txFeeAmount': self.lamports_to_sol(tx_data.get('fee', 5000)),
            'refType': 'SPL_TOKEN_TRANSFER',
            'source': 'NODE'
        }

        response = requests.post(url, json=payload, headers=headers)
        return response.json()

    def lamports_to_sol(self, lamports: int) -> str:
        """Convert lamports to SOL (9 decimals)"""
        return str(lamports / 1e9)

    def map_commitment_status(self, commitment: str) -> str:
        """Map Solana commitment level to Quub status"""
        mapping = {
            'processed': 'PENDING',
            'confirmed': 'CONFIRMED',
            'finalized': 'CONFIRMED'
        }
        return mapping.get(commitment, 'PENDING')

    def record_bulk_spl_transfers(self, transfers: list) -> list:
        """Efficiently record multiple SPL token transfers"""
        results = []
        for transfer in transfers:
            try:
                result = self.record_spl_token_transfer(transfer)
                results.append(result)
            except Exception as e:
                print(f"Error recording transfer {transfer['signature']}: {e}")
                results.append({
                    'error': str(e),
                    'signature': transfer['signature']
                })

        return results

# Example usage
spl_manager = SolanaSPLTokenManager('org-uuid', token)

# USDC transfer on Solana
usdc_transfer = {
    'signature': '3KbvREZUat76wgWMtnJfWbJL74Vzh4U2eabVJa3Z3bb2fPtW8AREP5pbmRwUrxZCESbTomWpL7nZTMBKjgahmQdY',
    'sourceAccount': 'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
    'destAccount': 'FNpU3QJ3X1zJNTnvDh2V4JHmKJNrjhEZ5gKN2fJNJXVN',
    'slot': 250000000,
    'fee': 5000,  # 0.000005 SOL
    'commitment': 'finalized',
    'token_mint': 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',  # USDC
    'token_amount': '1000.00',
    'direction': 'OUTBOUND'
}

result = spl_manager.record_spl_token_transfer(usdc_transfer)
print(f"Recorded SPL token transfer: {result}")

# Python - Handle Solana's rent-exempt minimum requirements
class SolanaAccountManager:
    def __init__(self, org_id: str, token: str):
        self.org_id = org_id
        self.token = token
        self.base_url = 'https://api.quub.exchange/v2'
        self.rent_exempt_minimum = 0.00089088  # ~890,880 lamports for basic account

    def create_wallet_with_rent(self, wallet_data: dict) -> dict:
        """Create Solana wallet ensuring rent-exempt minimum"""
        url = f'{self.base_url}/orgs/{self.org_id}/wallets'
        headers = {
            'Authorization': f'Bearer {self.token}',
            'Content-Type': 'application/json',
            'X-Org-Id': self.org_id,
            'Idempotency-Key': f"solana-wallet-{int(time.time())}"
        }

        payload = {
            'chainId': 'solana-mainnet-beta',
            'walletType': wallet_data.get('walletType', 'HOT'),
            'label': wallet_data.get('label', 'Solana Wallet'),
            'signerPolicy': 'MPC_CLUSTER'
        }

        response = requests.post(url, json=payload, headers=headers)
        wallet = response.json()

        # Note: Ensure wallet has rent-exempt minimum
        print(f"Created wallet: {wallet.get('data', {}).get('address')}")
        print(f"⚠️  Ensure minimum balance of {self.rent_exempt_minimum} SOL for rent exemption")

        return wallet

    def check_rent_exempt_balance(self, balance_sol: float) -> dict:
        """Check if balance meets rent-exempt requirements"""
        is_rent_exempt = balance_sol >= self.rent_exempt_minimum

        return {
            'balance': balance_sol,
            'rentExemptMinimum': self.rent_exempt_minimum,
            'isRentExempt': is_rent_exempt,
            'deficit': max(0, self.rent_exempt_minimum - balance_sol)
        }

    def record_rent_collection(self, account_pubkey: str, lamports_collected: int) -> dict:
        """Record when Solana runtime collects rent from non-exempt accounts"""
        # Solana collects rent from accounts below rent-exempt threshold
        url = f'{self.base_url}/orgs/{self.org_id}/onchain/txs'
        headers = {
            'Authorization': f'Bearer {self.token}',
            'Content-Type': 'application/json',
            'X-Org-Id': self.org_id,
            'Idempotency-Key': f"solana-rent-{account_pubkey}-{int(time.time())}"
        }

        payload = {
            'chainId': 'solana-mainnet-beta',
            'hash': f'RENT_{account_pubkey}_{int(time.time())}',
            'fromAddress': account_pubkey,
            'toAddress': '11111111111111111111111111111111',  # System Program
            'value': str(lamports_collected / 1e9),
            'direction': 'OUTBOUND',
            'status': 'CONFIRMED',
            'refType': 'RENT_PAYMENT',
            'source': 'SYSTEM'
        }

        response = requests.post(url, json=payload, headers=headers)
        return response.json()

# Example usage
account_manager = SolanaAccountManager('org-uuid', token)

# Check if balance is rent-exempt
balance_check = account_manager.check_rent_exempt_balance(0.5)
print(f"Rent exempt: {balance_check['isRentExempt']}")
if not balance_check['isRentExempt']:
    print(f"⚠️  Need {balance_check['deficit']} more SOL for rent exemption")

# Python - Optimize for Solana's high transaction throughput
class SolanaHighThroughputRecorder:
    def __init__(self, org_id: str, token: str):
        self.org_id = org_id
        self.token = token
        self.base_url = 'https://api.quub.exchange/v2'
        self.batch_size = 100

    def process_slot_transactions(self, slot: int, transactions: list) -> dict:
        """Process all transactions from a Solana slot efficiently"""
        results = {
            'slot': slot,
            'total': len(transactions),
            'successful': 0,
            'failed': 0
        }

        # Process in batches
        for i in range(0, len(transactions), self.batch_size):
            batch = transactions[i:i + self.batch_size]
            batch_results = self._process_batch(batch)

            results['successful'] += batch_results['successful']
            results['failed'] += batch_results['failed']

        return results

    def _process_batch(self, transactions: list) -> dict:
        """Process a batch of transactions"""
        successful = 0
        failed = 0

        for tx in transactions:
            try:
                self.record_transaction(tx)
                successful += 1
            except Exception as e:
                print(f"Error recording transaction {tx.get('signature')}: {e}")
                failed += 1

        return {'successful': successful, 'failed': failed}

    def record_transaction(self, tx_data: dict) -> dict:
        """Record a single Solana transaction"""
        url = f'{self.base_url}/orgs/{self.org_id}/onchain/txs'
        headers = {
            'Authorization': f'Bearer {self.token}',
            'Content-Type': 'application/json',
            'X-Org-Id': self.org_id,
            'Idempotency-Key': f"solana-batch-{tx_data['signature']}"
        }

        payload = {
            'chainId': 'solana-mainnet-beta',
            'hash': tx_data['signature'],
            'fromAddress': tx_data['from'],
            'toAddress': tx_data['to'],
            'value': str(tx_data['lamports'] / 1e9),
            'direction': tx_data.get('direction', 'OUTBOUND'),
            'status': 'CONFIRMED',
            'blockNumber': tx_data['slot'],
            'gasPrice': '0',
            'txFeeAmount': str(tx_data.get('fee', 5000) / 1e9),
            'source': 'INDEXER'
        }

        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()
        return response.json()

    def calculate_throughput_stats(self, results: dict, time_seconds: float) -> dict:
        """Calculate TPS statistics"""
        tps = results['total'] / time_seconds
        success_rate = (results['successful'] / results['total'] * 100) if results['total'] > 0 else 0

        return {
            'totalTransactions': results['total'],
            'successful': results['successful'],
            'failed': results['failed'],
            'successRate': success_rate,
            'timeSeconds': time_seconds,
            'transactionsPerSecond': tps
        }

# Example usage
import time as time_module

high_throughput = SolanaHighThroughputRecorder('org-uuid', token)

# Simulate processing 3000 transactions from a single slot
start_time = time_module.time()

transactions = [
    {
        'signature': f'{i:064x}',
        'from': 'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
        'to': 'FNpU3QJ3X1zJNTnvDh2V4JHmKJNrjhEZ5gKN2fJNJXVN',
        'lamports': 1_000_000_000,
        'slot': 250000000,
        'fee': 5000
    }
    for i in range(3000)
]

results = high_throughput.process_slot_transactions(250000000, transactions)
elapsed = time_module.time() - start_time

stats = high_throughput.calculate_throughput_stats(results, elapsed)
print(f"Processed {stats['totalTransactions']} transactions in {stats['timeSeconds']:.2f}s")
print(f"Throughput: {stats['transactionsPerSecond']:.2f} TPS")
print(f"Success rate: {stats['successRate']:.2f}%")