Gas Management

Efficient gas management is crucial for cross-chain operations in the IXFI Protocol. This guide covers gas estimation, payment methods, optimization strategies, and cost management across multiple blockchains.

Overview

Cross-chain transactions require gas on both source and destination chains. The IXFI Protocol provides several mechanisms to handle gas payments, estimate costs, and optimize gas usage for cross-chain operations.

Gas Architecture

Gas Payment Models

1. Prepaid Gas Model

Users pay gas costs upfront on the source chain:

contract PrepaidGasManager {
    mapping(string => uint256) public gasRates; // Gas price per destination chain
    mapping(string => uint256) public gasMultipliers; // Chain-specific multipliers
    
    event GasPaid(
        address indexed user,
        string indexed destinationChain,
        uint256 gasAmount,
        uint256 nativeAmount
    );
    
    function payGasForContractCall(
        string memory destinationChain,
        uint256 gasLimit
    ) external payable returns (bytes32 gasPaymentId) {
        uint256 requiredPayment = calculateGasCost(destinationChain, gasLimit);
        require(msg.value >= requiredPayment, "Insufficient gas payment");
        
        gasPaymentId = keccak256(abi.encode(
            msg.sender,
            destinationChain,
            gasLimit,
            block.timestamp
        ));
        
        // Store gas payment for relayer reimbursement
        gasPayments[gasPaymentId] = GasPayment({
            payer: msg.sender,
            destinationChain: destinationChain,
            gasLimit: gasLimit,
            amountPaid: msg.value,
            used: false
        });
        
        emit GasPaid(msg.sender, destinationChain, gasLimit, msg.value);
        return gasPaymentId;
    }
    
    function calculateGasCost(
        string memory destinationChain,
        uint256 gasLimit
    ) public view returns (uint256) {
        uint256 baseGasPrice = gasRates[destinationChain];
        uint256 multiplier = gasMultipliers[destinationChain];
        
        // Add 20% buffer for gas price fluctuations
        return (gasLimit * baseGasPrice * multiplier * 120) / (100 * 100);
    }
}

2. Token-Based Gas Payment

Pay gas fees using IXFI or other tokens:

contract TokenGasPayment {
    IERC20 public ixfiToken;
    mapping(string => uint256) public tokenGasRates; // IXFI per gas unit
    
    function payGasWithTokens(
        string memory destinationChain,
        uint256 gasLimit,
        uint256 tokenAmount
    ) external returns (bytes32 gasPaymentId) {
        uint256 requiredTokens = calculateTokenGasCost(destinationChain, gasLimit);
        require(tokenAmount >= requiredTokens, "Insufficient token amount");
        
        // Transfer tokens from user
        ixfiToken.transferFrom(msg.sender, address(this), tokenAmount);
        
        gasPaymentId = _createGasPayment(
            msg.sender,
            destinationChain,
            gasLimit,
            tokenAmount
        );
        
        emit TokenGasPaid(msg.sender, destinationChain, gasLimit, tokenAmount);
        return gasPaymentId;
    }
    
    function calculateTokenGasCost(
        string memory destinationChain,
        uint256 gasLimit
    ) public view returns (uint256) {
        uint256 tokenRate = tokenGasRates[destinationChain];
        uint256 baseCost = gasLimit * tokenRate;
        
        // Add buffer and convert to token units
        return (baseCost * 120) / 100;
    }
}

3. Gasless Transactions

Enable gasless transactions through meta-transactions:

contract GaslessExecutor {
    mapping(address => uint256) public nonces;
    mapping(address => uint256) public gasCredits;
    
    struct MetaTransaction {
        address from;
        string destinationChain;
        address targetContract;
        bytes payload;
        uint256 gasLimit;
        uint256 nonce;
        bytes signature;
    }
    
    function executeGasless(MetaTransaction memory metaTx) external {
        // Verify signature
        require(_verifySignature(metaTx), "Invalid signature");
        
        // Check gas credits
        require(gasCredits[metaTx.from] >= metaTx.gasLimit, "Insufficient gas credits");
        
        // Deduct gas credits
        gasCredits[metaTx.from] -= metaTx.gasLimit;
        nonces[metaTx.from]++;
        
        // Execute cross-chain call
        gateway.callContract(
            metaTx.destinationChain,
            Strings.toHexString(uint160(metaTx.targetContract), 20),
            metaTx.payload
        );
        
        emit GaslessExecuted(metaTx.from, metaTx.destinationChain, metaTx.gasLimit);
    }
    
    function addGasCredits(address user, uint256 amount) external {
        ixfiToken.transferFrom(msg.sender, address(this), amount);
        gasCredits[user] += amount;
        
        emit GasCreditsAdded(user, amount);
    }
}

Gas Estimation

Dynamic Gas Estimation

contract GasEstimator {
    struct ChainGasInfo {
        uint256 baseGasPrice;
        uint256 priorityFee;
        uint256 blockGasLimit;
        uint256 avgBlockTime;
        uint256 congestionMultiplier;
    }
    
    mapping(string => ChainGasInfo) public chainGasInfo;
    mapping(bytes4 => uint256) public functionGasCosts;
    
    function estimateGasForCall(
        string memory destinationChain,
        bytes memory payload
    ) external view returns (
        uint256 estimatedGas,
        uint256 estimatedCost,
        uint256 confidence
    ) {
        // Base gas for cross-chain execution
        uint256 baseGas = 50000;
        
        // Function-specific gas estimation
        bytes4 selector = bytes4(payload);
        uint256 functionGas = functionGasCosts[selector];
        
        if (functionGas == 0) {
            // Estimate based on payload size
            functionGas = _estimateGasFromPayload(payload);
        }
        
        // Chain-specific adjustments
        ChainGasInfo memory gasInfo = chainGasInfo[destinationChain];
        uint256 chainMultiplier = gasInfo.congestionMultiplier;
        
        estimatedGas = (baseGas + functionGas) * chainMultiplier / 100;
        estimatedCost = estimatedGas * (gasInfo.baseGasPrice + gasInfo.priorityFee);
        
        // Confidence based on data freshness and volatility
        confidence = _calculateConfidence(destinationChain);
        
        return (estimatedGas, estimatedCost, confidence);
    }
    
    function _estimateGasFromPayload(bytes memory payload) internal pure returns (uint256) {
        // Base gas: 21000 + 4 gas per zero byte + 16 gas per non-zero byte
        uint256 dataGas = 0;
        
        for (uint256 i = 0; i < payload.length; i++) {
            if (payload[i] == 0) {
                dataGas += 4;
            } else {
                dataGas += 16;
            }
        }
        
        return 21000 + dataGas;
    }
    
    function updateGasInfo(
        string memory chainName,
        uint256 baseGasPrice,
        uint256 priorityFee,
        uint256 congestionMultiplier
    ) external onlyOracle {
        chainGasInfo[chainName] = ChainGasInfo({
            baseGasPrice: baseGasPrice,
            priorityFee: priorityFee,
            blockGasLimit: chainGasInfo[chainName].blockGasLimit,
            avgBlockTime: chainGasInfo[chainName].avgBlockTime,
            congestionMultiplier: congestionMultiplier
        });
        
        emit GasInfoUpdated(chainName, baseGasPrice, priorityFee);
    }
}

Real-Time Gas Oracle

class GasOracle {
    constructor() {
        this.providers = new Map();
        this.gasData = new Map();
        this.updateInterval = 30000; // 30 seconds
    }

    async initializeChains(chainConfigs) {
        for (const [chainName, config] of Object.entries(chainConfigs)) {
            this.providers.set(chainName, new ethers.JsonRpcProvider(config.rpc));
            await this.updateGasData(chainName);
        }

        // Start periodic updates
        setInterval(() => this.updateAllChains(), this.updateInterval);
    }

    async updateGasData(chainName) {
        const provider = this.providers.get(chainName);
        
        try {
            const feeData = await provider.getFeeData();
            const block = await provider.getBlock('latest');
            
            const gasData = {
                gasPrice: feeData.gasPrice,
                maxFeePerGas: feeData.maxFeePerGas,
                maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
                blockGasLimit: block.gasLimit,
                blockGasUsed: block.gasUsed,
                utilization: Number(block.gasUsed * 100n / block.gasLimit),
                timestamp: Date.now()
            };

            this.gasData.set(chainName, gasData);
            
            // Update congestion multiplier based on utilization
            const congestionMultiplier = this.calculateCongestionMultiplier(gasData.utilization);
            await this.updateChainMultiplier(chainName, congestionMultiplier);

        } catch (error) {
            console.error(`Failed to update gas data for ${chainName}:`, error);
        }
    }

    calculateCongestionMultiplier(utilization) {
        if (utilization < 50) return 100; // No congestion
        if (utilization < 70) return 120; // Light congestion
        if (utilization < 85) return 150; // Moderate congestion
        if (utilization < 95) return 200; // High congestion
        return 300; // Extreme congestion
    }

    async estimateGasForOperation(chainName, operationType, payload) {
        const gasData = this.gasData.get(chainName);
        if (!gasData) throw new Error(`No gas data for chain: ${chainName}`);

        const baseGas = this.getBaseGasForOperation(operationType);
        const payloadGas = this.estimatePayloadGas(payload);
        const totalGas = baseGas + payloadGas;

        const congestionMultiplier = this.calculateCongestionMultiplier(gasData.utilization);
        const adjustedGas = Math.ceil(totalGas * congestionMultiplier / 100);

        return {
            estimatedGas: adjustedGas,
            gasPrice: gasData.gasPrice,
            maxFeePerGas: gasData.maxFeePerGas,
            estimatedCost: BigInt(adjustedGas) * gasData.gasPrice,
            confidence: this.calculateConfidence(gasData),
            congestionLevel: this.getCongestionLevel(gasData.utilization)
        };
    }

    getBaseGasForOperation(operationType) {
        const gasLimits = {
            'token_transfer': 100000,
            'contract_call': 150000,
            'contract_call_with_token': 200000,
            'complex_execution': 300000
        };

        return gasLimits[operationType] || 150000;
    }

    estimatePayloadGas(payload) {
        if (!payload) return 0;
        
        const bytes = ethers.getBytes(payload);
        let gas = 0;
        
        for (let i = 0; i < bytes.length; i++) {
            gas += bytes[i] === 0 ? 4 : 16;
        }
        
        return gas;
    }
}

Gas Optimization Strategies

1. Payload Optimization

contract OptimizedPayloads {
    // Instead of this (expensive)
    function expensiveCall(
        uint256 a,
        uint256 b,
        uint256 c,
        string memory text,
        address[] memory addresses
    ) external {
        // Function implementation
    }
    
    // Use this (optimized)
    function optimizedCall(bytes memory packedData) external {
        (
            uint256 a,
            uint256 b,
            uint256 c,
            string memory text,
            address[] memory addresses
        ) = abi.decode(packedData, (uint256, uint256, uint256, string, address[]));
        
        // Function implementation
    }
    
    // Even better: use packed encoding for similar types
    function superOptimizedCall(
        uint256 packedInts, // Pack multiple uint256s into one
        bytes memory packedData
    ) external {
        uint256 a = packedInts >> 128;
        uint256 b = (packedInts >> 64) & 0xFFFFFFFFFFFFFFFF;
        uint256 c = packedInts & 0xFFFFFFFFFFFFFFFF;
        
        // Decode other data as needed
    }
}

2. Batch Operations

contract BatchGasOptimizer {
    struct BatchCall {
        address target;
        bytes data;
        uint256 gasLimit;
    }
    
    function batchExecute(
        string memory destinationChain,
        BatchCall[] memory calls
    ) external {
        require(calls.length <= 10, "Too many calls");
        
        // Encode all calls into single payload
        bytes memory batchPayload = abi.encodeWithSignature(
            "executeBatch((address,bytes,uint256)[])",
            calls
        );
        
        gateway.callContract(
            destinationChain,
            Strings.toHexString(uint160(address(this)), 20),
            batchPayload
        );
    }
    
    function executeBatch(BatchCall[] memory calls) external onlyGateway {
        for (uint256 i = 0; i < calls.length; i++) {
            (bool success,) = calls[i].target.call{gas: calls[i].gasLimit}(calls[i].data);
            if (!success) {
                emit BatchCallFailed(i, calls[i].target);
            }
        }
    }
}

3. Smart Gas Scheduling

contract GasScheduler {
    struct ScheduledExecution {
        string destinationChain;
        address targetContract;
        bytes payload;
        uint256 executeAfter;
        uint256 maxGasPrice;
        address payer;
    }
    
    mapping(bytes32 => ScheduledExecution) public scheduledExecutions;
    
    function scheduleExecution(
        string memory destinationChain,
        address targetContract,
        bytes memory payload,
        uint256 delaySeconds,
        uint256 maxGasPrice
    ) external payable returns (bytes32 executionId) {
        executionId = keccak256(abi.encode(
            msg.sender,
            destinationChain,
            targetContract,
            payload,
            block.timestamp
        ));
        
        scheduledExecutions[executionId] = ScheduledExecution({
            destinationChain: destinationChain,
            targetContract: targetContract,
            payload: payload,
            executeAfter: block.timestamp + delaySeconds,
            maxGasPrice: maxGasPrice,
            payer: msg.sender
        });
        
        // Lock gas payment
        require(msg.value > 0, "Must pay for gas");
        
        emit ExecutionScheduled(executionId, delaySeconds, maxGasPrice);
    }
    
    function executeScheduled(bytes32 executionId) external {
        ScheduledExecution memory execution = scheduledExecutions[executionId];
        require(execution.payer != address(0), "Execution not found");
        require(block.timestamp >= execution.executeAfter, "Too early");
        
        // Check current gas price
        uint256 currentGasPrice = tx.gasprice;
        require(currentGasPrice <= execution.maxGasPrice, "Gas price too high");
        
        delete scheduledExecutions[executionId];
        
        // Execute with optimal gas conditions
        gateway.callContract(
            execution.destinationChain,
            Strings.toHexString(uint160(execution.targetContract), 20),
            execution.payload
        );
        
        emit ScheduledExecutionCompleted(executionId, currentGasPrice);
    }
}

Gas Monitoring and Analytics

Gas Usage Tracking

contract GasMonitor {
    struct GasMetrics {
        uint256 totalGasUsed;
        uint256 totalTransactions;
        uint256 averageGasUsed;
        uint256 maxGasUsed;
        uint256 minGasUsed;
        mapping(string => uint256) chainGasUsed;
    }
    
    mapping(address => GasMetrics) public userGasMetrics;
    GasMetrics public globalGasMetrics;
    
    event GasUsageRecorded(
        address indexed user,
        string indexed chain,
        uint256 gasUsed,
        uint256 gasCost
    );
    
    function recordGasUsage(
        address user,
        string memory chain,
        uint256 gasUsed,
        uint256 gasCost
    ) external onlyGateway {
        GasMetrics storage userMetrics = userGasMetrics[user];
        
        // Update user metrics
        userMetrics.totalGasUsed += gasUsed;
        userMetrics.totalTransactions++;
        userMetrics.chainGasUsed[chain] += gasUsed;
        
        if (gasUsed > userMetrics.maxGasUsed || userMetrics.maxGasUsed == 0) {
            userMetrics.maxGasUsed = gasUsed;
        }
        
        if (gasUsed < userMetrics.minGasUsed || userMetrics.minGasUsed == 0) {
            userMetrics.minGasUsed = gasUsed;
        }
        
        userMetrics.averageGasUsed = userMetrics.totalGasUsed / userMetrics.totalTransactions;
        
        // Update global metrics
        globalGasMetrics.totalGasUsed += gasUsed;
        globalGasMetrics.totalTransactions++;
        globalGasMetrics.averageGasUsed = globalGasMetrics.totalGasUsed / globalGasMetrics.totalTransactions;
        
        emit GasUsageRecorded(user, chain, gasUsed, gasCost);
    }
    
    function getGasEfficiencyScore(address user) external view returns (uint256) {
        GasMetrics storage metrics = userGasMetrics[user];
        if (metrics.totalTransactions == 0) return 0;
        
        uint256 userAverage = metrics.averageGasUsed;
        uint256 globalAverage = globalGasMetrics.averageGasUsed;
        
        if (globalAverage == 0) return 100;
        
        // Score: 100 = average, >100 = better than average, <100 = worse
        return (globalAverage * 100) / userAverage;
    }
}

Gas Alert System

class GasAlertSystem {
    constructor(gasOracle) {
        this.gasOracle = gasOracle;
        this.alerts = new Map();
        this.thresholds = {
            highGasPrice: ethers.parseUnits('50', 'gwei'),
            veryHighGasPrice: ethers.parseUnits('100', 'gwei'),
            extremeGasPrice: ethers.parseUnits('200', 'gwei')
        };
    }

    async checkGasAlerts() {
        for (const [chainName, gasData] of this.gasOracle.gasData) {
            const currentPrice = gasData.gasPrice;
            
            if (currentPrice >= this.thresholds.extremeGasPrice) {
                this.sendAlert({
                    level: 'CRITICAL',
                    chain: chainName,
                    message: `Extreme gas prices: ${ethers.formatUnits(currentPrice, 'gwei')} gwei`,
                    recommendation: 'Consider delaying non-urgent transactions'
                });
            } else if (currentPrice >= this.thresholds.veryHighGasPrice) {
                this.sendAlert({
                    level: 'WARNING',
                    chain: chainName,
                    message: `Very high gas prices: ${ethers.formatUnits(currentPrice, 'gwei')} gwei`,
                    recommendation: 'Use gas scheduling for optimal costs'
                });
            } else if (currentPrice >= this.thresholds.highGasPrice) {
                this.sendAlert({
                    level: 'INFO',
                    chain: chainName,
                    message: `High gas prices: ${ethers.formatUnits(currentPrice, 'gwei')} gwei`,
                    recommendation: 'Consider gas optimization strategies'
                });
            }
        }
    }

    async suggestOptimalTiming(chainName, targetGasPrice) {
        const gasData = this.gasOracle.gasData.get(chainName);
        if (!gasData) return null;

        const currentPrice = gasData.gasPrice;
        
        if (currentPrice <= targetGasPrice) {
            return {
                execute: 'now',
                reason: 'Current gas price is acceptable'
            };
        }

        // Analyze historical patterns to suggest optimal timing
        const historicalData = await this.getHistoricalGasData(chainName, 24); // 24 hours
        const optimalHours = this.analyzeOptimalHours(historicalData);

        return {
            execute: 'later',
            suggestedHours: optimalHours,
            currentPrice: ethers.formatUnits(currentPrice, 'gwei'),
            targetPrice: ethers.formatUnits(targetGasPrice, 'gwei'),
            potentialSavings: this.calculateSavings(currentPrice, targetGasPrice)
        };
    }
}

Gas Refund Mechanisms

Automatic Gas Refunds

contract GasRefundManager {
    mapping(bytes32 => uint256) public gasRefunds;
    mapping(address => uint256) public userRefundBalance;
    
    event GasRefundIssued(bytes32 indexed commandId, address user, uint256 amount);
    event GasRefundClaimed(address indexed user, uint256 amount);
    
    function processGasRefund(
        bytes32 commandId,
        address user,
        uint256 gasUsed,
        uint256 gasPrice,
        uint256 paidAmount
    ) external onlyRelayer {
        uint256 actualCost = gasUsed * gasPrice;
        
        if (paidAmount > actualCost) {
            uint256 refundAmount = paidAmount - actualCost;
            userRefundBalance[user] += refundAmount;
            gasRefunds[commandId] = refundAmount;
            
            emit GasRefundIssued(commandId, user, refundAmount);
        }
    }
    
    function claimRefund() external {
        uint256 refundAmount = userRefundBalance[msg.sender];
        require(refundAmount > 0, "No refund available");
        
        userRefundBalance[msg.sender] = 0;
        
        (bool success,) = msg.sender.call{value: refundAmount}("");
        require(success, "Refund transfer failed");
        
        emit GasRefundClaimed(msg.sender, refundAmount);
    }
    
    function claimRefundInTokens(address token) external {
        uint256 refundAmount = userRefundBalance[msg.sender];
        require(refundAmount > 0, "No refund available");
        
        userRefundBalance[msg.sender] = 0;
        
        // Convert to token amount based on current rates
        uint256 tokenAmount = _convertToTokens(token, refundAmount);
        IERC20(token).transfer(msg.sender, tokenAmount);
        
        emit GasRefundClaimed(msg.sender, refundAmount);
    }
}

Best Practices

1. Gas Estimation

• Always add a buffer (10-20%) to gas estimates

• Monitor gas price trends before execution

• Use dynamic gas pricing for better efficiency

2. Payment Strategy

• Choose payment method based on cost efficiency

• Consider token-based payments during high ETH gas prices

• Implement gas scheduling for non-urgent transactions

3. Optimization Techniques

• Batch multiple operations when possible

• Optimize payload encoding

• Use compression for large data

4. Monitoring

• Track gas usage patterns

• Set up alerts for high gas prices

• Analyze efficiency metrics regularly

5. User Experience

• Provide clear gas cost estimates

• Offer multiple payment options

• Implement gasless options for small transactions

Resources

• Cross-Chain Architecture

• Token Transfers

• Meta Transactions

• API Reference