Source-linked AI summary
Optimized Execution of Business Processes on Blockchain
Luciano García-Bañuelos, Alexander Ponomarev, Marlon Dumas, Ingo Weber
TL;DR
Collaborative business-process execution on blockchain avoids central authorities but is constrained by the cost of recording and updating state. The paper compiles BPMN models into Solidity contracts with space-optimized process-state encoding and compares them with a prior translator. The method significantly reduces gas consumption and achieves higher throughput relative to the baseline.
Problem
Blockchain process execution is feasible, but its cost depends strongly on ledger data volume and smart-contract update frequency.
Method
The paper translates BPMN models into minimized Petri nets and compiles them into Solidity smart contracts encoding process-state and task enablement with space-optimized structures.
Results
The optimized method significantly reduces gas consumption and achieves higher throughput relative to a previous baseline.
Takeaways & Limitations
The method is a building block toward a blockchain-based collaborative business-process execution engine.
Takeaways & Limitations
The method covers control-flow relations and data conditions for a core BPMN subset, excluding issues such as access control, timer events, subprocesses, and boundary events.
Abstract
from arXiv · showhide
Blockchain technology enables the execution of collaborative business processes involving untrusted parties without requiring a central authority. Specifically, a process model comprising tasks performed by multiple parties can be coordinated via smart contracts operating on the blockchain. The consensus mechanism governing the blockchain thereby guarantees that the process model is followed by each party. However, the cost required for blockchain use is highly dependent on the volume of data recorded and the frequency of data updates by smart contracts. This paper proposes an optimized method for executing business processes on top of commodity blockchain technology. The paper presents a method for compiling a process model into a smart contract that encodes the preconditions for executing each task in the process using a space-optimized data structure. The method is empirically compared to a previously proposed baseline by replaying execution logs, including one from a real-life business process, and measuring resource consumption.
1 Introduction
Blockchain supports collaborative business processes among parties without a central authority, but blockchain-based execution is resource-sensitive. This paper addresses that challenge by compiling BPMN models into optimized Solidity smart contracts and evaluating them against prior work.
- Blockchain maintains a replicated, tamper-proof transaction ledger without requiring a central authority.
- Smart contracts encode business rules on blockchain and inherit execution guarantees from the protocols preserving ledger integrity.
- Peer-to-peer blockchain execution can replace trusted intermediaries in collaborative supply chain and logistics processes.
- Blockchain cost depends strongly on recorded data volume and smart-contract update frequency, motivating reductions in code and maintained data.
- The proposed method minimizes BPMN models into Petri nets and compiles them into Solidity contracts using a space-optimized state structure.
- Evaluation replays artificial and real-world execution logs, including a process log containing over 5,000 traces, while measuring paid gas resources.
2 Background and Related Work
Blockchain combines a replicated linked-list data structure with a network of participating machines and can execute smart contracts. Prior process-execution work established feasibility but exposed substantial resource-optimization concerns.
- Blockchain Technology: A blockchain is both a replicated linked list of transaction-containing blocks and the network of machines maintaining that data structure.
- Blockchain Technology: Consensus and cryptographic chaining make accepted blockchain history difficult to alter, while proof-of-work miners create new blocks.
- Smart Contracts: Smart contracts are scripts triggered by transactions that can read and write blockchain state and enforce resulting transaction rules.
- Smart Contracts: Ethereum treats smart contracts as first-class elements, compiling Solidity into bytecode executed by the Ethereum Virtual Machine.
- Smart Contracts: Ethereum gas assigns operation costs, making data writes substantially more expensive than reads and bytecode size relevant to deployment cost.
- Related Work: Prior work generated instance contracts from a factory using participants’ public keys and restricted execution to authorized parties.
- Related Work: The prior representation uses Boolean variables for tasks and join-gateway incoming edges, although Solidity stores each Boolean in an 8-bit integer.
- Related Work: A vision for blockchain collaborations based on Business Artifacts lacked an implementation and did not consider optimization issues.
3 Method
The method compiles a BPMN process model into Solidity through Petri-net translation, dataflow analysis, reduction, and space-optimized state encoding.
- Transformation pipeline: The method transforms a BPMN process model into a Petri net, analyzes dataflow conditions, reduces the net, and compiles it into Solidity.The transformation pipeline removes invisible transitions and spurious places before compilation.
- From BPMN to Petri nets: BPMN tasks and events become labeled Petri-net transitions, while unlabeled τ transitions encode gateways introduced by the transformation rules.The resulting net is a workflow net with designated start and end places, under assumed soundness and safeness properties.
- Petri-net reduction: Reduction rules fuse series of transitions or places and address τ transitions created by combinations of decision gateways.Applying the rules produces progressively smaller equivalent nets, including the minimized net illustrated for the running example.
- Dataflow analysis: Dataflow analysis propagates gateway conditions along paths and combines them into guards attached to transitions in the minimized Petri net.For example, the algorithm propagates P and Q so that a downstream task receives guard P∧Q.
- From minimized Petri net to Solidity: The generated Solidity contract encodes the Petri-net marking as one bit per place and stores predicate values as a separate bit array.The contract simulates token firing, while transition execution evaluates the guards needed to determine enabled transitions.
- From minimized Petri net to Solidity: When the total number of places and predicates is at most 256, marking and predicates can be merged into one unsigned integer variable.This additional optimization reduces the number of blockchain-stored state variables.
4 Evaluation
The evaluation compares default and optimized Solidity translators on gas cost, conformance correctness, and throughput using four datasets, including a real-world invoicing log. The optimized contracts preserved correctness, reduced gas costs across traces, and completed 500 invoicing instances in fewer blocks.
- Evaluation goals and setup: The evaluation measures gas cost, conformance-checking correctness, and scalability by comparing default and optimized process contracts.The contracts were compiled to EVM bytecode and deployed on a private Ethereum blockchain.
- Datasets: Four datasets support the evaluation, including supply chain, incident management, insurance claims, and a real-world invoicing process.The invoicing log contained 65,905 events and produced 5,316 conforming traces, including 49 distinct traces.
- Gas costs and correctness: The experiments replayed distinct traces and recorded deployment gas, invocation gas, rejected non-conforming transactions, and successful process completion.The replayer sent events individually through a trigger that packaged them into blockchain transactions.
- Gas costs and correctness: 100% conformance-checking correctness was maintained, and every trace for every model incurred less gas with the optimized translator.Weighted-average costs also incorporated trace frequencies, including all 5,316 invoicing traces.
- Throughput: 500 optimized invoicing instances completed after 511 blocks, compared with 739 blocks for default, while optimized throughput was higher most of the time.The initial throughput reflected the block gas limit, allowing approximately 5 optimized versus 4 default instance creations per block.
5 Conclusion
The paper presents a Solidity compilation method that uses a space-optimized process-state representation to reduce execution costs and improve throughput. Its scope remains limited to selected control-flow and data-condition features of BPMN.
- The method compiles BPMN process models into deployable Solidity smart contracts that enforce correct process-instance execution on Ethereum.
- A bit array with a minimized number of bits encodes process state, reducing gas consumption and the operations needed for each process step.
- The experimental evaluation found significantly lower gas consumption and higher throughput than a previous baseline.
- The method covers control-flow relations and data-condition evaluation but does not address process-instance party binding or access control.
- The implementation targets a core BPMN subset, excluding timer events, subprocesses, and boundary events.