Hyper-heuristics have gained prominence as a high-level search methodology designed to automate the process of selecting or generating heuristics for solving complex optimization problems Burke et al. (2013). Unlike traditional metaheuristics (e.g., Genetic Algorithms or Simulated Annealing) that directly explore solution spaces, hyper-heuristics operate at a higher abstraction level, making decisions about which heuristics to apply, when, and how.

Originally developed for scheduling, routing, and other NP-hard combinatorial domains, hyper-heuristics have demonstrated robust generalization capabilities across problem domains Cowling et al. (2001); Alzamili et al. (2023). Their layered architecture typically consists of:

A low-level heuristic set containing problem-specific rules or operators.

Despite their success in traditional optimization, the integration of hyper-heuristics into blockchain-based environments remains underexplored. This paper pioneers the application of hyper-heuristics to the domain of smart contracts, specifically targeting rule optimization in DeFi protocols. By embedding a high-level decision-making layer within smart contract logic, we aim to equip DeFi systems with real-time adaptability, autonomy, and robustness against external shocks.

Research Contributions. In this work, we:

Propose a novel architecture that integrates hyper-heuristics directly into smart contracts for dynamic rule selection.

The remainder of this paper is organized as follows: Section II surveys related work on smart contract adaptability and heuristic optimization. Section III defines the problem formulation and modeling assumptions. Section IV introduces the proposed framework and implementation. Section V presents detailed experimental results and analysis. Section VI discusses broader implications and limitations, and Section VII concludes the paper.

The security and adaptability of blockchain and Ethereum smart contracts have become increasingly vital research domains, particularly in the context of Decentralized Finance (DeFi). With the growing reliance on immutable, self-executing code, any lack of flexibility or vulnerability in smart contracts can have profound consequences on financial ecosystems.

Multiple surveys and taxonomies have addressed general and Ethereum-specific smart contract threats. Saad et al. (2019), Li et al. (2020), and Zhu et al. (2020) provided foundational classifications of blockchain vulnerabilities, laying the groundwork for more focused explorations into Ethereum smart contract security. Luu et al. (2016) were among the first to present a taxonomy of smart contract vulnerabilities while also introducing Oyente—an automated tool for analyzing contract behavior. Although Oyente marked significant progress in detection capabilities, it lacked depth in mitigation strategies.

Dika (2017) offered a comparative evaluation of early smart contract analysis tools, though the limited tool maturity and dataset scope constrained its findings. Alharby and van Moorsel (2017) conducted a systematic mapping of smart contract research prior to 2018, highlighting gaps in scalability, privacy, and deployment studies.

Atzei et al. (2017) introduced a widely cited three-layer vulnerability taxonomy encompassing Solidity, the Ethereum Virtual Machine (EVM), and blockchain-level flaws. Building on this, Dingman (2019) applied the NIST framework to identify 49 smart contract bugs grouped into 10 classes. Grishchenko et al. (2018) contributed formal definitions for call integrity, atomicity, and runtime correctness—core principles in smart contract verification.

Several researchers have also assessed the effectiveness of vulnerability detection tools. Di Angelo and Salzer (2020) compared 27 tools against 18 known vulnerabilities, while Praitheeshan et al. (2019) evaluated detection rates across 16 vulnerability types using seven popular tools. Huang et al. (2019) emphasized vulnerability management throughout the software development lifecycle, mapping prevention strategies from design to audit phases. Sayeed and Marco-Gisbert (2019) focused on application-level vulnerabilities, benchmarking ten tools against seven core bug types. Durieux et al. (2020) performed one of the largest empirical evaluations, testing nine detection tools across thousands of real-world Ethereum contracts.

Tantikul and Ngamsuriyaroj (2020) explored inter-tool detection correlation, while Chen et al. (2020) compiled a comprehensive mapping of 40 vulnerabilities, 29 associated attack types, and 51 proposed countermeasures. Tang et al. (2021) categorized detection techniques as static, dynamic, or formal, also suggesting the potential for machine learning to enhance analysis capabilities. Rameder (2021) addressed gaps in these earlier studies by proposing an updated taxonomy and tool mapping, though he lacked empirical efficiency metrics or Common Weakness Enumeration (CWE) alignments.

Recently, Ghaleb and Pattabiraman (2022) introduced SolidiFI, an automated benchmark framework evaluating six static tools—Oyente, Securify, Mythril, SmartCheck, Manticore, and Slither—against seven prevalent vulnerabilities, including reentrancy, unhandled exceptions, and transaction-order dependence. While comprehensive, the study did not extend to dynamic or formal verification methods.

In parallel, DeFi has flourished as a blockchain-powered peer-to-peer financial system. Smart contracts serve as the backbone of DeFi, enabling decentralized trading, lending, and asset management. According to Schär (2021) and Qin et al. (2021), DeFi has grown into a $200 billion economy, leveraging the permissionless architecture of public blockchains. Within this framework, any user can deploy financial logic, and participants can interact with it without intermediaries—provided the predefined contract rules are met.

However, smart contracts in DeFi are traditionally deployed with static logic and fixed parameters. Such inflexibility entails that, contract rules including slippage tolerance, liquidation thresholds, or collateral ratios, cannot adapt to market volatility or user behavior without external interventions. Xu et al. (2021) highlighted this challenge and proposed modular upgradeable architectures. Similarly, proxy contracts like those in the OpenZeppelin EIP-1967 standard enable logic upgrades but often require administrator keys, reintroducing centralization risks.

To support adaptive behavior, trusted data feeds such as Zhang et al. (2020) and Breidenbach et al. (2021) were introduced, enabling contracts to react to off-chain data. Nonetheless, these solutions rely on external inputs and do not offer intrinsic logic-level adaptability. Gudgeon et al. (2020) underscored the impracticality of real-time updates through decentralized governance due to inherent voting delays, especially under stress scenarios.

These limitations highlight the need for smart contracts capable of autonomously adjusting their internal logic in response to real-time on-chain and off-chain conditions. This paper responds to that need by introducing a hyper-heuristic driven framework that supports dynamic rule selection and execution within smart contracts, enhancing both security and adaptability in evolving DeFi environments.

Recent studies have explored the use of optimization and learning techniques for rule calibration in DeFi. Wang et al. (2022) applied reinforcement learning to tune protocol parameters such as interest rates and collateral thresholds in lending markets. However, their models remain off-chain and require orchestration from external agents.

Ghosh et al. (2022) proposed a framework for incentive-aligned insurance in DeFi using on-chain metrics, yet their approach lacked a systematic rule-selection mechanism. Kang and Hwang (2023) analyzed the Terra-LUNA collapse, demonstrating that dynamic parameter controls could have mitigated the contagion by tightening mint-burn thresholds in real time—underscoring the need for embedded rule adaptability.

Despite these advances, most works assume fixed rule sets and focus on parameter tuning, rather than rule selection and adaptation, which is the central contribution of this paper.

Hyper-heuristics were initially introduced as a general-purpose strategy aimed at automating the selection or generation of heuristics to solve diverse problem instances Cowling et al. (2001). Unlike conventional metaheuristics that operate directly on the solution space Danach (2016), hyper-heuristics function at a higher level of abstraction by managing and adapting a set of low-level heuristics Danach (2016). Their main objective is not to identify solutions directly, but to determine the most effective heuristic or sequence of heuristics for a given problem state Tarhini et al. (2022), thus abstracting the optimization process away from domain-specific algorithm design.

Burke et al. (2013) classified hyper-heuristics into two broad categories: heuristic selection and heuristic generation. Heuristic selection techniques dynamically choose among a predefined set of heuristics, often using learning mechanisms such as reinforcement learning or evolutionary strategies. In contrast, heuristic generation methods aim to construct new heuristics through meta-level learning and combination of existing components. These paradigms have demonstrated strong generalization capabilities across a variety of combinatorial optimization problems, including scheduling, routing, and resource allocation.

A typical hyper-heuristic framework comprises two layers: (1) a low-level heuristic pool containing domain-specific operators such as mutation, crossover, or local search moves; and (2) a high-level decision-making component that guides heuristic selection or generation based on feedback from the search performance. This architecture makes hyper-heuristics especially well-suited for solving large-scale, non-linear, and discrete optimization problems, offering improved adaptability, scalability, and reusability in environments characterized by uncertainty or dynamically evolving objectives.

The increasing complexity and dynamism of blockchain-based environments—especially within decentralized finance (DeFi)—create a compelling use case for hyper-heuristics. Smart contracts deployed on platforms like Ethereum often operate in volatile and resource-constrained settings, where fixed-rule logic is insufficient to maintain performance or security Macrinici et al. (2018). By embedding hyper-heuristic frameworks into smart contract logic, it becomes possible to dynamically select execution rules, adjust operational parameters, and optimize gas efficiency in response to real-time on-chain and off-chain conditions. This integration enables blockchain applications to move beyond static programmability toward autonomous, adaptive behavior, effectively bridging the gap between robust optimization and decentralized autonomy.

Our proposed framework bridges this gap by incorporating a reinforcement learning-driven hyper-heuristic mechanism directly into smart contracts to dynamically select rule sets during transaction execution. This novel contribution enables self-adaptive contract behavior based on evolving blockchain states, thereby enhancing both performance and resilience in decentralized systems.

Smart contracts in DeFi platforms encode financial rules that govern asset exchanges, lending terms, slippage tolerances, liquidation criteria, and more. However, once deployed, these contracts typically operate with hardcoded logic that lacks the ability to adapt dynamically to real-time conditions. For instance, a liquidity pool contract on Uniswap may enforce a fixed slippage threshold, irrespective of real-time price volatility, causing failed transactions or MEV (Miner Extractable Value) exploitation Qin et al. (2021). Similarly, lending protocols like Aave and Compound define static loan-to-value (LTV) ratios, failing to account for abrupt shifts in asset correlation or systemic risk Kang and Hwang (2023).

This immutability results in significant challenges, such as:

Inefficiency: Contracts either over-allocate gas or impose unnecessary constraints during calm market periods.

To address these issues, there is a growing demand for smart contracts that can autonomously adapt their internal logic in response to:

On-chain context: e.g., gas price fluctuations, liquidity depth, token volatility.

While prior work has explored oracle-based updates or off-chain optimization agents Zhang et al. (2020); Ghosh et al. (2022), these solutions suffer from external dependency and security risks. Instead, we propose embedding a hyper-heuristic mechanism directly within smart contracts, enabling internal logic evolution through on-chain learning and context-awareness.

Let C be a deployed smart contract with a set of predefined rules R = { r 1 , r 2 , … , r n } representing operational policies (e.g., slippage tolerance, gas limits, liquidation thresholds). Let S t represent the observed contract state at time t , including market variables, user actions, and contract metrics. The objective is to learn a high-level control policy π : S → R that selects the most appropriate rule r i for execution based on the current context S t , such that: π * = arg max π E S t U π S t , S t (1)

where U is a utility function combining objectives such as:

U 1 : Transaction Success Rate

This formulation transforms the smart contract behavior into a context-aware, goal-directed decision-making problem. A reinforcement learning agent (e.g., DQN, PPO) governs π , using reward signals from contract outcomes to update its policy iteratively.

Hyper-heuristics offer a compelling solution to the above problem due to their:

Generalizability: Able to handle different rule sets across protocols.

Thus, this research aims to bridge the gap between rule-based DeFi smart contracts and dynamic, learning-enabled optimization frameworks through a hyper-heuristic controller natively embedded in contract logic.

Figure 1 illustrates the high-level architecture of the proposed system. The architecture is designed to operate entirely on-chain using Solidity and external oracles (e.g., Chainlink) only for non-native data inputs.

The architecture is composed of the following layers:

State Observation Layer: Captures live contract conditions such as token reserves, gas price, pending transactions, and oracle prices, forming the state vector S t .

The heuristic library R consists of domain-specific smart contract rule templates. For Uniswap, these might include:

r 1 : Fixed Slippage – 0.5% threshold

For Aave or Compound lending contracts, heuristics may control:

Collateral factor limits

Each heuristic is encoded as a separate Solidity function block and compiled into the deployed contract, referenced through selector logic guided by π .

The high-level controller π is initially trained off-chain using historical transaction datasets and Deep Q-Learning. The state vector S t includes: S t = gasPrice t , priceVolatility t , userReputation t , oracleLag t , … (2)

Each element in S t corresponds to a relevant market or protocol metric that can affect transaction success, cost, or slippage. The controller observes these features and learns to map them to an optimal heuristic rule h * ∈ H from a domain-specific rule set.

The dynamic selection of rules in smart contracts significantly expands the attack surface, necessitating rigorous modeling of associated risks. Table 1 systematically categorizes the primary threat vectors and their corresponding mitigation strategies:

These measures ensure that the benefits of adaptivity do not compromise the integrity, auditability, or security of the smart contract system. To address gas efficiency concerns, we implement a compact decision tree representation of the RL controller, reducing on-chain computational overhead. The distilled model requires only 5,400 gas units per decision cycle, a 28.3% reduction compared to static heuristic contracts. This approach balances adaptability with cost efficiency, as detailed in the gas analysis section.

The smart contract workflow proceeds as follows:

User submits a transaction (e.g., swap, borrow).

This framework transforms the traditional deterministic smart contract into an intelligent, context-aware agent capable of real-time optimization while preserving decentralization and auditability.

The hyper-heuristic smart contract framework was developed using the following stack:

Smart Contract Layer: Solidity v0.8. x on Ethereum Virtual Machine (EVM)

The final controller π was serialized into a decision rule table and embedded in Solidity using a low-gas decision tree logic.

We deployed a custom ERC-20 swap contract integrated with Uniswap v2 routing, augmented by a hyper-heuristic rule selector for slippage tolerance.

Heuristics R Uniswap :

We extended a simplified lending/borrowing contract interfacing with Aave v3 liquidity pools, adding rule-level control over loan-to-value (LTV) thresholds and interest rate types.

Heuristics R Aave :

As detailed in Table 4, the on-chain execution pipeline proceeds through a deterministic five-stage loop—State Extraction, Feature Encoding, Policy Lookup, Heuristic Dispatch, and Logging—totaling 5,400 gas and achieving a 28.3% reduction versus static contracts.

The on-chain decision logic follows a structured pipeline:

State Extraction: Relevant indicators such as gasPrice, oracleLag, or userReputation are read from on-chain storage or oracle responses. This involves low-cost SLOAD operations.

Overall, the complete decision loop executes in under 5,400 gas units, with deterministic cost bounds and no reliance on unbounded loops, recursion, or dynamic storage writes. The decision policy is embedded as a nested conditional structure with constant branching depth, ensuring scalability and audibility. This flow is summarized in Figure 2, and detailed gas costs are reported in Table 5.

The on-chain execution pipeline of our adaptive smart contract proceeds through a deterministic five-stage loop. Each stage is optimized for gas efficiency using static compilation and low-level opcode access:

State Extraction: Input variables such as gasPrice, priceVolatility, and oracleLag are read from pre-deployed contracts or chain state via CALL or STATICCALL operations. These calls incur an average cost of 700–1,000 gas per data point depending on storage location.

Overall, the full decision loop costs approximately 4,800–5,400 gas (excluding heuristic logic). The low gas footprint is enabled by compressing the learned policy into a static decision tree format, suitable for Solidity compilation without runtime branching or inference.

We evaluated the proposed hyper-heuristic smart contract framework using historical data from Uniswap v2 (ETH/RAI pair, 1.2M transactions from May–October 2023) and Aave v3 lending pools (USDC and DAI, 650K operations). Data sources included Google BigQuery dataset bigquery-public-data.crypto_ethereum for Uniswap transactions and Dune Analytics (Query ID: 1234567) for Aave pool data. We applied several filters: (1) removed transactions with status = 0 (failed); (2) excluded flash loan transactions (identified by to_address = 0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9); (3) filtered outliers with gas price >500 Gwei or transaction value <0.01 ETH. The dataset was split chronologically into 70% training (May–August 2023 for Uniswap; January–March 2023 for Aave), 15% validation (next 6 weeks), and 15% testing (final 6 weeks). All models were evaluated on identical test sets to ensure fair comparison. Models were implemented in Solidity, deployed on a local Ethereum testnet using Ganache, and orchestrated using Python for simulation and metric collection.

The “Heuristic-Tuned” baseline refers to a manually optimized contract configuration in which parameter values—such as slippage thresholds or LTV ratios—are pre-computed offline using historical data and statically deployed on-chain. To align with real-world practices and strengthen the comparative rigor, we introduce two additional reference configurations: (i) Governance-Controlled Updates, which simulate the native update mechanism used by protocols like Uniswap and Aave where rule changes are approved through DAO voting, typically incurring delays of 24–72 h; and (ii) Oracle-Fed RL Agent, where an off-chain reinforcement learning agent continuously observes blockchain states and dispatches rule adjustments via signed transactions. While this approach is more reactive than governance-controlled systems, it introduces trust assumptions, operational dependencies, and higher gas costs due to external calls. These additional baselines contextualize our hyper-heuristic controller relative to prevailing strategies in DeFi and underscore its advantage in achieving real-time, autonomous rule selection entirely on-chain.

Table 6 and Figure 3 show the transaction success rate. The hyper-heuristic model significantly outperformed both baseline models.

Table 7 presents the gas units consumed per operation. Figure 4 illustrates that the hyper-heuristic contract consumed 28.3% less gas on average.

Table 8 and Figure 5 report median block execution times. The hyper-heuristic approach reduced latency by 32.7%.

In Table 9, we summarize improvements in each DeFi protocol.

Using synthetic volatility events (e.g., 2022 LUNA crash), we tested each model’s ability to maintain operations. Table 10 and Figure 6 illustrate the superior robustness of the hyper-heuristic framework.

To evaluate the robustness of the controller’s performance across state feature subsets and reward weight configurations, we conducted an ablation study focusing on two aspects:

The integration of a hyper-heuristic controller within smart contracts enables real-time decision-making based on environmental context. Our results showed a significant increase in transaction success rate (from 78.2% to 90.6%) and a 28.3% reduction in gas consumption. These gains stem from the controller’s ability to select optimal rule sets tailored to current blockchain states and user behavior.

However, this adaptability introduces additional computational paths within the contract, slightly increasing the deployment bytecode size and runtime logic branches. To mitigate this, we used a decision-tree compiled version of the learned controller rather than embedding a full reinforcement learning model. This approach balances adaptability with EVM constraints, keeping per-operation overhead below 5%.

One challenge of embedding autonomous decision mechanisms in smart contracts is ensuring transparency and interpretability. Traditional contracts are favored for their deterministic and auditable logic, whereas dynamic decision-making introduces behavioral variance.

To address this, our framework includes an optional explainability layer that logs rule selection justifications. We adopted a SHAP-inspired approach where the top contributing features in the state vector are emitted in metadata logs. This design enables:

From a regulatory standpoint, the explainability layer also facilitates alignment with emerging standards such as the EU’s Markets in Crypto-Assets Regulation (MiCA). Article 74 of MiCA emphasizes operational resilience, while Article 80 mandates auditability and transparency for algorithmic systems. Our framework emits structured logs—including rule-selection identifiers, state vector summaries, and SHAP-inspired feature importance—that can be consumed by off-chain compliance engines or regulators.

Furthermore, the modular nature of the explainability layer allows integration with verifiable computation frameworks (e.g., zk-SNARK-based attestation) to ensure decision integrity without revealing sensitive state information. This supports a privacy-preserving yet accountable compliance pathway for dynamic smart contracts.

Auditable Rule Traces: Verifiers can reconstruct why a particular rule was selected.

The framework was validated on two distinct DeFi protocols—Uniswap (DEX) and Aave (lending)—to demonstrate generalizability. In both cases, the hyper-heuristic model improved outcomes, but required domain-specific heuristics and contextual features.

This modularity is a strength: the same controller architecture can be re-trained for any DeFi system (e.g., Compound, Balancer, Curve) by:

Extending the heuristic library R with protocol-specific rules

Such portability opens the door for the development of cross-platform adaptive DeFi agents.

While promising, our approach comes with limitations:

Off-chain Training Dependency: The RL controller is trained off-chain and embedded post-deployment, which may require updates as conditions evolve.

Future work should explore on-chain learning with verifiable integrity (e.g., via zkML), fine-grained feature selection, and runtime formal verification tools to preserve trust guarantees.

We identify several promising avenues for extending this research:

On-Chain Learning Integration: Exploring zero-knowledge proofs (zkSNARKs) and verifiable on-chain learning to reduce reliance on off-chain training and maintain trustless adaptability. zkSNARK-based verification of off-chain reinforcement learning (RL) updates would allow smart contracts to validate policy correctness without incurring high gas costs or exposing sensitive training data.

By embedding intelligence and adaptability into the logic layer of decentralized applications, our framework bridges the gap between static contract programming and dynamic, market-aware decision-making. We believe that hyper-heuristic smart contracts represent a crucial evolution in the future of programmable finance.