Interactive theorem provers (ITPs), such as Lean and Coq, can express formal proofs for a large category of theorems, from abstract math to software correctness. Consider Alice who has a Lean proof for some public statement T. Alice wants to convince the world that she has such a proof, without revealing the actual proof. Perhaps the proof shows that a secret program is correct or safe, but the proof itself might leak information about the program's source code. A natural way for Alice to proceed is to construct a succinct, zero-knowledge, non-interactive argument of knowledge (zkSNARK) to prove that she has a Lean proof for the statement T.
Web3 applications, which are built on blockchain and decentralized technologies, introduce a unique set of security threats compared to traditional web applications. In this chapter we are going to look at some common security threats for Web3 applications and best practices to mitigate these risks.
Carmit Hazay, Muthuramakrishnan Venkitasubramaniam, Mor Weiss
Abstract Leakage-resilient cryptography aims to protect cryptographic primitives from so-called “side channel attacks” that exploit their physical implementation to learn their input or secret state. Starting from the works of Ishai, Sahai and Wagner (CRYPTO‘03) and Micali and Reyzin (TCC‘04), most works on leakage-resilient cryptography either focus on protecting general computations, such as circuits or multiparty computation protocols, or on specific non-interactive primitives such as storage, encryption, and signatures. This work focuses on leakage resilience for the middle ground, namely for distributed and interactive cryptographic primitives. Our main technical contribution is designing the first secret sharing scheme that is equivocal , resists adaptive probing of a constant fraction of bits from each share, while incurs only a constant blowup in share size. Equivocation is a strong leakage-resilience guarantee, recently introduced by Hazay et al. (ITC, 2021). Our construction is obtained via a general compiler which we introduce, that transforms any secret sharing scheme into an equivocal scheme against adaptive leakage. An attractive feature of our compiler is that it respects additive reconstruction; namely, if the original scheme has additive reconstruction, then the transformed scheme has linear reconstruction. We extend our compiler to a general paradigm for protecting distributed primitives against leakage and show its applicability to various primitives, including secret sharing, verifiable secret sharing, function secret sharing, distributed encryption and signatures, and distributed zero-knowledge proofs. For each of these primitives, our paradigm transforms any construction of the primitive into a scheme that resists adaptive party corruptions, as well as adaptive probing leakage of a constant fraction of bits in each share when the share is stored in memory (but not when it is used in computations). Moreover, the transformation incurs only a constant blowup in the share size and respects additive reconstruction—an important feature for several of these primitives, such as function secret sharing and distributed encryption.
As concerns over privacy and trust escalate among individuals and corporations, traditional memory-based trust systems are increasingly seen as inadequate and undesirable. The rise of microservice architecture complicates this by making data paths harder to track. Given these concerns, the critical question arises: How can we establish trust or verify an entity’s credibility without collecting private information or relying on comparisons with pre-existing data, while knowing the exact data path of each request? To address this challenge, we introduce a lightweight, scalable, ZCube platform that employs nested Zero Knowledge Proofs (ZKPs), eliminating reliance on memory or evaluations based on past actions. This platform verifies and maintains trust in real-time without centralizing trust in any specific part of the system. It anticipates intentions and rigorously monitors them, ensuring operational integrity while preserving privacy. Distinctive for its ZKP trustless setup incorporating blockchain, each request begins anew and is rigorously monitored bidirectionally during execution. Our tests on the realistic example of a microservice-based distributed system, OpenTelemetry Demo, confirm that our novel approach— combining proof segmentation with plan adherence— exhibits fast response times of less than 200ms on average for most test cases. This ZCube platform surpasses traditional methods in efficiency and security. Our analysis shows comprehensive security and enhanced performance while effectively maintaining bidirectional trustlessness.
Oct 17, 2024·Companion Proceedings of the 2024 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity
Zero-knowledge virtual machines (zkVMs) enable verifiable computation on via succinct Zero-knowledge proofs (ZKPs). However, current zkVMs, still in development, show many bugs. This paper introduces a parameterized framework for the formal verification of zkVMs in Coq. We prove the soundness and completeness of the constraint generation algorithm from machine instructions to semantics-level constraints. Existing works target specific zkVMs, and require repeated proof work in this phase, whereas our proofs are parameterized and can be reused in development and by all zkVMs. We also demonstrate the generality of our framework by instantiation on two examples: Cairo VM and a simplified zkEVM.
For better or worse, non-fungible tokens (NFTs) are the most peculiar and least expected art market innovations of the early twenty-first century. This chapter provides a brief history of NFTs and the NFT market, beginning with the invention of blockchain technology, through the creation of the Bitcoin, Namecoin, and Ethereum blockchains, and the NFT phenomenon. It describes a selection of NFT projects and artists and provides a theoretical account of both the art market and the NFT market.
Physical Unclonable Functions (PUFs) and Hardware Security
Ken Lew, Arijet Sarker, Simeon Wuthier, Jinoh Kim · 6 authors
Computing and networking are increasingly implemented in software. We design and build a software build assurance scheme detecting if there have been injections or modifications in the various steps in the software supply chain, including the source code, compiling, and distribution. Building on the reproducible build and software bill of materials (SBOM), our work is distinguished from previous research in assuring multiple software artifacts across the software supply chain. Reproducible build, in particular, enables our scheme, as our scheme requires the software materials/artifacts to be consistent across machines with the same operating system/specifications. Furthermore, we use blockchain to deliver the proof reference, which enables our scheme to be distributed so that the assurance beneficiary and verifier are the same, i.e., the node downloading the software verifies its own materials, artifacts, and outputs. Blockchain also significantly improves the assurance efficiency. We first describe and explain our scheme using abstraction and then implement our scheme to assure Ethereum as the target software to provide concrete proof-of-concept implementation, validation, and experimental analyses. Our scheme enables more significant performance gains than relying on a centralized server thanks to the use of blockchain (e.g., two to three orders of magnitude quicker in verification) and adds small overheads (e.g., generating and verifying proof have an overhead of approximately one second, which is two orders of magnitude smaller than the software download or build processes).
Hao Zhou, Changxu Liu, Lan Yang, Li Shang · 5 authors
Zero-knowledge proof (ZKP) plays a significant role in privacy protection technology. However, the proof generation phase requires considerable time and hardware resources. In this phase, Number Theoretic Transform or Inverse Number Theoretic Transform (NTT/INTT) in polynomial computation, as well as Multiple Scalar Multiplication (MSM), are bottlenecks that dominate the execution time. In this paper, we propose a highly reconfigurable accelerator ReZK to accelerate ZKP proof generation phase, focusing on NTT/INTT and MSM. According to the configurations, ReZK can be configured as NTT, INTT, and MSM with variable sizes and bit-widths by adjusting the data path between on-chip memories and arithmetic cores. As the basic unit of arithmetic cores, the reconfigurable processing element (PE) in ReZK is composed of pipelined modular multipliers and modular adders that support variable bit-widths. It can perform butterfly or arithmetic operations. Based on the reconfigurable PEs, the ReZK core can implement NTT/INTT with different sizes and bit-widths, or a fully pipelined point adder (PADD). Additionally, we propose a modularized MSM scheduling architecture to support various bit-widths. The on-chip memories are also well organized for reuse. In NTT/INTT mode, 4-way 256-bit or 2-way 384-bit NTT/INTT can be computed in parallel. In MSM mode, for different elliptic curves, ReZK is capable of processing 4-way 256-bit or 2-way 384-bit MSM in parallel.
Arijet Sarker, Simeon Wuthier, Jinoh Kim, Jonghyun Kim · 5 authors
Cryptocurrency software implements cryptocurrency operations (including the distributed consensus protocol and peer-to-peer networking) and often involves the open-source community. We design a software assurance scheme for cryptocurrency and advance the cryptocurrency handshaking protocol by providing the verification capability of the Bitcoin software by peers and preventing any potential peer from establishing a connection with modified Bitcoin software. Since we focus on Bitcoin (the most popular cryptocurrency) for implementation and integration, we call our scheme Version++, built on and advancing the current Bitcoin handshaking protocol based on the Version message. Our Version++ protocol providing software assurance is distinguishable from previous research because it is permissionless, distributed, and lightweight for its cryptocurrency application. Our scheme is permissionless since it does not require a centralized trusted authority (unlike the remote software attestation techniques from trusted computing); it is distributed since the peer checks the software assurances of its own peer connections; and it is designed for efficiency/lightweight to support the dynamic nature of the peer connections and large-scale broadcasting in cryptocurrency networking. Utilizing Merkle Tree for the efficiency of the proof verification, we implement and test Version++ on Bitcoin software and conduct experiments in an active Bitcoin node prototype connected to the Bitcoin Mainnet. Our prototype-based performance analyses demonstrate the lightweight design of Version++. The peer-specific verification grows logarithmically with the number of software files in processing time and in storage. Furthermore, the Version++ verification overhead is small compared to the version-verack handshaking process; we measure the overhead to be 0.524% in our local networking environment between virtual machines and between 0.057% and 0.282% (depending on the peer location) in our more realistic cloud-based experiments with remote peer machines.
Yibin Xu, Tijs Slaats, Boris Düdder, Thomas Hildebrandt · 5 authors
Abstract Smart contracts executed on blockchains are interactive programs where external actors generate events that trigger function invocations. Events can be emitted by participants asynchronously. However, some functionalities should be restricted to participants inhabiting specific roles in the system, which might be dynamically adjusted while the system evolves. We argue that current smart contract languages adopting imperative programming paradigms require additional complicated access control code. Furthermore, smart contracts are often developed and evolved independently and cannot share a joint access control policy. This makes it challenging to ensure the correctness of access control properties and to maintain correctness when the contracts are adapted. We propose using dynamic condition response (DCR) graphs for role‐based and declarative access control for smart contracts and techniques for test‐driven modelling and refinement of DCR graphs to support the safe design and evolution of smart contracts. We show that they allow for capturing and visualizing a form of dynamic access control where access rights evolve as the contract state progresses. Their use supports the straightforward declaration of access control rights, improved code auditing, test‐driven modelling, and safe evolution of smart contracts and improves users' understanding.
Decompilation of binary code has arisen as a highly-important application in the space of Ethereum VM (EVM) smart contracts. Major new decompilers appear nearly every year and attain popularity, for a multitude of reverse-engineering or tool-building purposes. Technically, the problem is fundamental: it consists of recovering high-level control flow from a highly-optimized continuation-passing-style (CPS) representation. Architecturally, decompilers can be built using either static analysis or symbolic execution techniques. We present Shrnkr, a static-analysis-based decompiler succeeding the state-of-the-art Elipmoc decompiler. Shrnkr manages to achieve drastic improvements relative to the state of the art, in all significant dimensions: scalability, completeness, precision. Chief among the techniques employed is a new variant of static analysis context: shrinking context sensitivity. Shrinking context sensitivity performs deep cuts in the static analysis context, eagerly “forgetting” control-flow history, in order to leave room for further precise reasoning. We compare Shrnkr to state-of-the-art decompilers, both static-analysis- and symbolic-execution-based. In a standard benchmark set, Shrnkr scales to over 99.5% of contracts (compared to ∼95% for Elipmoc), covers (i.e., reaches and manages to decompile) 67% more code than Heimdall-rs, and reduces key imprecision metrics by over 65%, compared again to Elipmoc.
Ethereum enables the creation and execution of decentralized applications through smart contracts, that are compiled to Ethereum Virtual Machine (EVM) bytecode. Once deployed in the blockchain, the bytecode is immutable; hence, ensuring that smart contracts are bug-free before their deployment is of utmost importance. A crucial preliminary step for any effective static analysis of EVM bytecode is the extraction of the control-flow graph (CFG): this presents significant challenges due to potentially statically unknown jump destinations. In this paper we present a novel approach, based on abstract interpretation, aiming at building a sound CFG from EVM bytecode smart contracts. Our analysis, which is implemented in our static analyzer EVMLiSA, is based on a parametric abstract domain that approximates concrete execution stacks at each program point as an l-sized set of abstract stacks of maximal height h; the results of the analysis are then used to resolve the jump destinations at jump nodes. In our preliminary experiments, by fine-tuning the analysis parameters, EVMLiSA builds sound CFGs for all smart contracts where permanent storage-related opcodes do not influence jump destinations.
Proofs are powerful tools for integrity and privacy, enabling the verifier to delegate a computation and still verify its correct execution, and enabling the prover to keep the details of the computation private. Both CCP and ZKP can achieve soundness and zero-knowledge but with important differences. CCP relies on hardware trust assumptions, which yield high performance and additional confidentiality protection for the prover but may be unacceptable for some applications. CCP is also often easier to use, notably with existing code, whereas ZKP comes with a large prover overhead that may be unpractical for some applications.
A. S. Santhosh Kumar, S. (Sarah) Thompson, N. (Noor) Al-Zubaidi
The rapid adoption of multi-cloud architectures enables organizations to balance cost, performance, and resilience by distributing workloads across different providers. However, this distributed environment introduces significant security and access control challenges, including inconsistent policies, fragmented identity management, and heightened risks of insider threats and data breaches. Traditional access control models—such as Role-Based Access Control (RBAC) and Attribute-Based Access Control (ABAC)—struggle to provide unified enforcement across heterogeneous cloud platforms while ensuring transparency, auditability, and trust. This paper explores the potential of blockchain-based access control models to secure multi-cloud software systems by leveraging the immutability, decentralization, and consensus mechanisms of distributed ledger technology. Blockchain smart contracts can automate access control enforcement, eliminate reliance on centralized identity providers, and ensure tamper-proof audit trails of access decisions. Recent studies highlight that 80% of enterprises already operate in hybrid or multi-cloud environments (Flexera 2023), while 45% of cloud security incidents are linked to misconfigured or inconsistent access policies (IBM Cloud Security Report 2022)—underscoring the urgency for innovative solutions. We analyze blockchain-enhanced RBAC and ABAC frameworks, discuss hybrid on-chain/off-chain policy enforcement, and evaluate the trade-offs of performance, scalability, and compliance. Case studies from healthcare and financial systems illustrate how blockchain access models improve accountability and regulatory alignment (e.g., HIPAA, GDPR, PCI DSS) in mission-critical workloads. Furthermore, we address key challenges such as transaction latency, interoperability across cloud providers, and privacy-preserving access control. The paper concludes that blockchain-based access control provides a paradigm shift in securing multi-cloud environments, offering organizations a path toward transparent, verifiable, and adaptive identity and access management. By integrating blockchain with AI-driven monitoring and zero trust architectures, the future of multi-cloud security will move toward autonomous, trustless, and regulation-compliant ecosystems capable of sustaining the demands of next-generation digital services.
Authentication is a key technology that provides trusts in cyberspace. Anonymous credentials are aimed at providing user authentication and protecting users' privacy meanwhile. Existing anonymous credential protocols mostly rely on specific hardware to protect their credential secrets, the inconvenience of which and the fact that losses or damages of the hardware can make their identities unavailable significantly hamper large-scale deployments of these schemes. In this paper, based on Zhang et al.'s password-based credential techniques (NDSS'20), combined with cryptographic primitives such as non-interactive zero knowledge proofs and homomorphic encryption, we propose a secure and portable anonymous credential protocol which does not need tamper-resistant hardware. Our anonymous credentials are designed to be encrypted using passwords which can be implemented and deployed in software only in the user terminal. The structure of our (encrypted) credentials and the design of our verifier-designated authentication tokens ensure the resistance of our protocol against serious offline dictionary attacks. We further balance security and user privacy, and propose a concept of maximum authentication failure time limit combined with hash computation and zero-knowledge proofs against online dictionary attacks, which are more difficult to defend against in the anonymous authentication setting. Our protocol supports not only blind issuance of anonymous credentials but also anonymous authentication of users. From the perspective of the dominating exponentiation computations in anonymous credential protocols, our anonymous authentication protocol outperforms most existing schemes except the ones that do not provide blind issuance.
We present VirtSecIO, a hypervisor-based platform for executing secure modules. VirtSecIO provides the modules with secure paths to peripheral devices, which can be shared between the modules and the operating system. Moreover, VirtSecIO is a thin hypervisor with a negligible performance overhead and a minimal attack surface. We demonstrate VirtSecIO’s abilities by developing HyperWallet, a secure module that acts as a hardware crypto-wallet, without requiring any dedicated hardware.
Open access
Security and Verification in Computing
Advanced Malware Detection Techniques
Physical Unclonable Functions (PUFs) and Hardware Security
Mikel Cortes-Goicoechea, Tarun Mohandas-Daryanani, José L. Muñoz, Leonardo Bautista-Gomez
Abstract Modern public blockchains like Ethereum rely on p2p networks to run distributed and censorship-resistant applications. With its wide adoption, it operates as a highly critical public ledger. On its transition to become more scalable and sustainable, shifting to PoS without sacrificing the security and resilience of PoW, Ethereum offers a range of consensus client implementations to participate in the network. In this paper, we present a methodology to measure the performance of the consensus clients based on the latency to receive messages from the p2p network. The paper includes a study that identifies the incentives and limitations that the network experiences, presenting insights about the latency impact derived from running the different consensus implementations at different locations. Our study highlights the need for a holistic approach to node deployment, where hardware, software, and geographic factors have to be carefully considered. Properly dimensioned hardware is essential to mitigate latency-related performance issues and ensure the reliable operation of beacon nodes, especially in geographically distant locations.
The goal of this thesis is to verify smart contracts in Blockchain. In particular, we focus on smart contracts in Bitcoin and Solidity. In order to specify the correctness of smart contracts, we use weakest preconditions. For this, we develop a model of smart contracts in the interactive theorem prover and dependent type programming language Agda and prove the correctness of smart contracts in it. In the context of Bitcoin, our verification of Bitcoin scripts consists of non-conditional and conditional scripts. For Solidity, we refer to programs using object-oriented features of Solidity, such as calling of other contracts, full recursion, and the use of gas in order to guarantee termination while having a Turing-complete language. We have developed a simulator for Solidity-style smart contracts. As a main example, we executed a reentrancy attack in our model. We have verified smart contracts in Bitcoin and Solidity using weakest precondition in Agda. Furthermore, Agda, combined with the fact that it is a theorem prover and programming language, allows the writing of verified programs, where the verification takes place in the same language in which the program is written, avoiding the problem of translation from one language to another (with possible translation mistakes).
Mohammed Alghazwi, Tariq Bontekoe, Leon Visscher, Fatih Türkmen
Abstract Non-interactive zero-knowledge (NIZK) proofs of knowledge have proven to be highly relevant for securely realizing a wide array of applications that rely on both privacy and correctness . They enable a prover to convince any party of the correctness of a public statement for a secret witness . However, most NIZKs do not natively support proving knowledge of a secret witness that is distributed over multiple provers. Previously, collaborative proofs [54] have been proposed to overcome this limitation. We investigate the notion of composability in this setting, following the Commit-and-Prove design of LegoSNARK [19]. Composability allows users to combine different, specialized NIZKs (e.g., one for arithmetic circuits, one for boolean circuits, and one for range proofs) with the aim of reducing the proof generation time. Moreover, it opens the door to efficient realizations of many applications in the collaborative setting such as mutually exclusive prover groups, combining collaborative and single-party proofs and efficiently implementing publicly auditable secure multiparty computing (PA-MPC). We present the first, general definition for collaborative commitand- prove NIZK (CP-NIZK) proofs of knowledge and construct MPC protocols to enable their realization. We implement our protocols for two commonly used NIZKs, Groth16 and Bulletproofs, and evaluate their practicality in a variety of computational settings. Our findings indicate that composability adds only minor overhead, especially for large circuits. We also evaluated our construction in two application settings, one of which shows 18– $$55\times $$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mn>55</mml:mn> <mml:mo>×</mml:mo> </mml:mrow> </mml:math> runtime reduction when compared to prior works while requiring only a fraction ( $$0.2\%$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mn>0.2</mml:mn> <mml:mo>%</mml:mo> </mml:mrow> </mml:math> ) of the communication.
Abstract Suppose that a sequence of $${\varvec{n}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> </mml:math> cards, numbered 1 to $${\varvec{n}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> </mml:math> , is placed face up in random order. Let $${\varvec{k}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>k</mml:mi> </mml:mrow> </mml:math> be the number on the first card in the sequence. Then take the first $${\varvec{k}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>k</mml:mi> </mml:mrow> </mml:math> cards from the sequence, rearrange that subsequence of $${\varvec{k}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>k</mml:mi> </mml:mrow> </mml:math> cards in reverse order, and return them to the original sequence. Repeat this prefix reversal until the number on the first card in the sequence becomes 1. This is a one-player card game called Topswops. The computational complexity of Topswops has not been thoroughly investigated. For example, letting $${\varvec{f}}({\varvec{n}})$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mrow> <mml:mi>f</mml:mi> </mml:mrow> <mml:mo>(</mml:mo> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> <mml:mo>)</mml:mo> </mml:mrow> </mml:math> denote the maximum number of prefix reversals for Topswops with $${\varvec{n}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> </mml:math> cards, values of $${\varvec{f}}({\varvec{n}})$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mrow> <mml:mi>f</mml:mi> </mml:mrow> <mml:mo>(</mml:mo> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> <mml:mo>)</mml:mo> </mml:mrow> </mml:math> for $${\varvec{n}}\ge 20$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> <mml:mo>≥</mml:mo> <mml:mn>20</mml:mn> </mml:mrow> </mml:math> remain unknown. In general, there is no known efficient algorithm for finding an initial sequence of $${\varvec{n}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> </mml:math> cards that requires exactly $$\ell $$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mi>ℓ</mml:mi> </mml:math> prefix reversals for any integers $${\varvec{n}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> </mml:math> and $${\varvec{\ell }}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>ℓ</mml:mi> </mml:mrow> </mml:math> . In this paper, using a deck of cards, we propose a physical zero-knowledge proof protocol that allows a prover to convince a verifier that the prover knows an initial sequence of $${\varvec{n}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> </mml:math> cards that requires $${\varvec{\ell }}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>ℓ</mml:mi> </mml:mrow> </mml:math> prefix reversals without leaking knowledge of that sequence. We also deal with Botdrops, a variant of Topswops.
Luca Aceto, Daniele Gorla, Stian Lybech, Mohammad Hamdaqa
We continue the development of TinySol, a minimal object-oriented language based on Solidity, the standard smart-contract language used for the Ethereum platform. We first extend TinySol with exceptions and a gas mechanism, and equip it with a small-step operational semantics. Introducing the gas mechanism is fundamental for modelling real-life smart contracts in TinySol, since this is the way in which termination of Ethereum smart contracts is usually ensured. We then devise a type system for smart contracts guaranteeing that such programs never run out of gas at runtime. This is a desirable property for smart contracts, since a transaction that runs out of gas is aborted, but the price paid to run the code is not returned to the invoker.