🔷 Ethereum Integration Guide

# Python - Register Ethereum Mainnet
import requests

def register_ethereum_chain(token):
    url = 'https://api.quub.exchange/v2/chains'
    headers = {
        'Authorization': f'Bearer {token}',
        'Content-Type': 'application/json',
        'Idempotency-Key': f'eth-mainnet-{int(time.time())}'
    }
    payload = {
        'chainId': 1,
        'name': 'Ethereum Mainnet',
        'shortName': 'ETH',
        'networkType': 'MAINNET',
        'layer': 'L1',
        'nativeCurrency': 'ETH',
        'decimals': 18,
        'blockTime': 12,
        'confirmations': 12,
        'explorerUrl': 'https://etherscan.io',
        'docsUrl': 'https://ethereum.org/en/developers/docs/',
        'genesisHash': '0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3',
        'chainNamespace': 'EVM',
        'status': 'ACTIVE'
    }

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

# Python - Configure Infura RPC Adapter
def configure_infura_adapter(token, api_key):
    url = 'https://api.quub.exchange/v2/chain/adapters'
    headers = {
        'Authorization': f'Bearer {token}',
        'Content-Type': 'application/json',
        'Idempotency-Key': f'eth-infura-{int(time.time())}'
    }
    payload = {
        'chainId': 1,
        'name': 'Infura Ethereum Backup',
        'rpcEndpoint': f'https://mainnet.infura.io/v3/{api_key}',
        'wsEndpoint': f'wss://mainnet.infura.io/ws/v3/{api_key}',
        'signerPolicy': 'MPC_CLUSTER',
        'priority': 1  # Backup adapter
    }

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

# Python - Create multiple Ethereum wallets
def create_eth_wallets(org_id, token, wallet_configs):
    """Create multiple Ethereum wallets for different purposes"""
    url = f'https://api.quub.exchange/v2/orgs/{org_id}/wallets'
    headers = {
        'Authorization': f'Bearer {token}',
        'Content-Type': 'application/json',
        'X-Org-Id': org_id
    }

    wallets = []
    for config in wallet_configs:
        headers['Idempotency-Key'] = f"eth-wallet-{config['purpose']}-{int(time.time())}"
        payload = {
            'chainId': 1,
            'address': config['address'],
            'type': config['type'],
            'label': config['label'],
            'tags': config.get('tags', [])
        }

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

    return wallets

# Example usage
configs = [
    {
        'purpose': 'hot',
        'address': '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0',
        'type': 'MPC',
        'label': 'Hot Wallet - Trading',
        'tags': ['hot', 'trading', 'high-frequency']
    },
    {
        'purpose': 'cold',
        'address': '0x8ba1f109551bD432803012645Ac136ddd64DBA72',
        'type': 'HARDWARE',
        'label': 'Cold Storage - Treasury',
        'tags': ['cold', 'treasury', 'long-term']
    }
]

wallets = create_eth_wallets('org-uuid', token, configs)

# Python - Comprehensive transaction recording with error handling
def record_eth_transaction(org_id, token, tx_data):
    """Record Ethereum transaction with full metadata"""
    url = f'https://api.quub.exchange/v2/orgs/{org_id}/onchain/txs'
    headers = {
        'Authorization': f'Bearer {token}',
        'Content-Type': 'application/json',
        'X-Org-Id': org_id,
        'Idempotency-Key': f"eth-tx-{tx_data['hash']}"
    }

    payload = {
        'chainId': 1,
        'hash': tx_data['hash'],
        'fromAddress': tx_data['from'],
        'toAddress': tx_data['to'],
        'value': str(tx_data['value']),  # Wei as string
        'direction': tx_data.get('direction', 'OUTBOUND'),
        'status': tx_data.get('status', 'PENDING'),
        'blockNumber': tx_data.get('blockNumber'),
        'gasPrice': str(tx_data['gasPrice']),
        'nonce': tx_data['nonce'],
        'txFeeAmount': str(tx_data.get('txFeeAmount', '0')),
        'source': tx_data.get('source', 'NODE')
    }

    # Add optional reference data if present
    if 'refType' in tx_data:
        payload['refType'] = tx_data['refType']
        payload['refId'] = tx_data['refId']

    try:
        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.HTTPError as e:
        print(f"Error recording transaction: {e}")
        return None

# Example: Bulk transaction recording
def record_eth_transactions_bulk(org_id, token, transactions):
    """Record multiple Ethereum transactions"""
    results = []
    for tx in transactions:
        result = record_eth_transaction(org_id, token, tx)
        if result:
            results.append(result)
    return results

# Python - Advanced transaction monitoring and reconciliation
import time
from typing import List, Dict
from enum import Enum

class TransactionStatus(Enum):
    PENDING = 'PENDING'
    CONFIRMED = 'CONFIRMED'
    FAILED = 'FAILED'

class EthereumTransactionMonitor:
    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.confirmations_required = 12

    def get_pending_transactions(self) -> List[Dict]:
        """Fetch all pending Ethereum transactions"""
        url = f'{self.base_url}/orgs/{self.org_id}/onchain/txs'
        params = {
            'chainId': 1,
            'status': 'PENDING',
            'limit': 100
        }
        headers = {
            'Authorization': f'Bearer {self.token}',
            'X-Org-Id': self.org_id
        }

        response = requests.get(url, params=params, headers=headers)
        return response.json().get('data', [])

    def check_transaction_confirmations(self, tx_hash: str, current_block: int) -> int:
        """Calculate number of confirmations for a transaction"""
        # This would typically call your Ethereum node
        # For demo purposes, showing the pattern
        tx_block = self.get_transaction_block(tx_hash)
        if tx_block:
            return current_block - tx_block
        return 0

    def get_transaction_block(self, tx_hash: str) -> int:
        """Get block number for a transaction from your Ethereum node"""
        # Implementation would use web3.py or similar
        # web3.eth.get_transaction(tx_hash)['blockNumber']
        pass

    def monitor_and_update(self):
        """Main monitoring loop"""
        pending_txs = self.get_pending_transactions()

        for tx in pending_txs:
            confirmations = self.check_transaction_confirmations(
                tx['hash'],
                self.get_current_block()
            )

            if confirmations >= self.confirmations_required:
                self.update_transaction_status(
                    tx['id'],
                    TransactionStatus.CONFIRMED
                )
                print(f"Transaction {tx['hash']} confirmed with {confirmations} confirmations")
            elif confirmations > 0:
                print(f"Transaction {tx['hash']} has {confirmations}/{self.confirmations_required} confirmations")

    def update_transaction_status(self, tx_id: str, status: TransactionStatus):
        """Update transaction status (this would use PATCH endpoint if available)"""
        # Note: The spec doesn't show PATCH for onchain/txs,
        # so you might record a new status or use internal workflows
        pass

    def get_current_block(self) -> int:
        """Get current Ethereum block number"""
        # Implementation would use web3.py
        # web3.eth.block_number
        pass

# Usage
monitor = EthereumTransactionMonitor('org-uuid', token)
monitor.monitor_and_update()

# Python - Gas price monitoring and optimization
class EthereumGasOptimizer:
    def __init__(self, org_id: str, token: str):
        self.org_id = org_id
        self.token = token
        self.base_url = 'https://api.quub.exchange/v2'

    def get_gas_price_recommendation(self, priority: str = 'medium') -> int:
        """
        Get gas price recommendation based on network conditions
        Priority: low (safeLow), medium (standard), high (fast)
        """
        # This would typically call a gas oracle API
        # For example: Etherscan Gas Tracker, ETH Gas Station, or your node
        # Returns gas price in Wei

        gas_prices = {
            'low': 20_000_000_000,      # 20 Gwei
            'medium': 30_000_000_000,    # 30 Gwei
            'high': 50_000_000_000       # 50 Gwei
        }
        return gas_prices.get(priority, gas_prices['medium'])

    def estimate_transaction_cost(self, gas_limit: int, gas_price: int) -> Dict:
        """Estimate transaction cost in ETH and USD"""
        cost_wei = gas_limit * gas_price
        cost_eth = cost_wei / 1e18

        # Get ETH price (would call price oracle)
        eth_price_usd = self.get_eth_price()
        cost_usd = cost_eth * eth_price_usd

        return {
            'gas_limit': gas_limit,
            'gas_price_gwei': gas_price / 1e9,
            'total_cost_wei': cost_wei,
            'total_cost_eth': cost_eth,
            'total_cost_usd': cost_usd
        }

    def get_eth_price(self) -> float:
        """Get current ETH price in USD"""
        # Would call your price oracle or external API
        return 2000.0  # Example price

    def record_transaction_with_gas_estimate(self, tx_data: Dict) -> Dict:
        """Record transaction with gas cost tracking"""
        gas_estimate = self.estimate_transaction_cost(
            tx_data.get('gas_limit', 21000),
            int(tx_data['gasPrice'])
        )

        # Add gas cost data to transaction record
        tx_data_enhanced = {
            **tx_data,
            'txFeeAmount': str(gas_estimate['total_cost_eth']),
            'txFeeUsd': str(gas_estimate['total_cost_usd'])
        }

        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"eth-tx-{tx_data['hash']}"
        }

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

# Usage
gas_optimizer = EthereumGasOptimizer('org-uuid', token)
gas_price = gas_optimizer.get_gas_price_recommendation('medium')
cost_estimate = gas_optimizer.estimate_transaction_cost(21000, gas_price)
print(f"Estimated cost: {cost_estimate['total_cost_eth']} ETH (${cost_estimate['total_cost_usd']})")