Enhancing Smart Contract Execution with Tagging in the DAG Architecture

With enhanced scalability and fast transaction times, DAG is a compelling choice for developers and enterprises looking to push the boundaries of decentralized applications. At the heart of these applications are smart contracts: automated agreements that execute themselves based on coded conditions, facilitating trustworthy transactions without intermediaries.
However, integrating smart contracts into a DAG environment presents unique challenges.

Challenges in Smart Contract Execution

Smart contracts require deterministic execution to ensure that outcomes are predictable and consistent across all network nodes. However, traditional DAG implementations can present challenges due to their inherently parallel nature, which might lead to discrepancies in transaction ordering. This variability can be problematic for smart contracts, where the order of transactions can affect the state and, thus, the outcomes of contracts.

How the Mazze Labs Addresses These Challenges

The Weighted Graph Ledger protocol is an innovative consensus mechanism that combines elements of blockchain and DAG technologies. It features a primary chain, known as the main tree chain, which confirms and orders transactions while also allowing for parallel processing of blocks that are not on the main tree chain to enhance throughput. This hybrid approach maintains the linear progression necessary for blockchain consistency and the benefits of DAG’s higher scalability.
In addition to the Weighted Graph Ledger protocol, we are introducing a tagging system that effectively organizes, prioritizes, and streamlines transactions to achieve high throughput rates. Tagging is particularly beneficial for managing smart contracts and other high-priority transactions, helping to ensure they are processed efficiently and correctly within the DAG architecture.
We apply specific tags to transactions that initiate or interact with smart contracts. These tags include additional metadata such as the contract address, function calls, and dependency information. By using the tags to manage dependencies and execution sequences, even across parallel blocks, we ensure that transactions affecting the same smart contract are processed in the correct order.

#[derive(Debug, Clone, Serialize, Deserialize)]
struct Tag {
    contract_address: String,
    function_signature: String,
    dependencies: Vec<String>,  
}

Tags also facilitate the batching of similar transactions for processing and merging compatible transactions into single blocks to maximize block space and processing efficiency.

What is coming next

We will launch a live testnet soon with limited capabilities while continuing to test internally how tagging transactions affect network throughput and performance by monitoring its impact on transaction processing speeds and overall network stability.