Part 4: Writing Onchain

In the previous parts, you successfully fetched offchain data and read from a smart contract. Now, you'll complete the "Onchain Calculator" by writing your computed result back to the blockchain.

What you'll do

• Use the CalculatorConsumer contract to receive workflow results
• Modify your workflow to write data to the blockchain using the EVM capability
• Execute your first onchain write transaction through CRE
• Verify your result on the blockchain

Step 1: The consumer contract

To write data onchain, your workflow needs a target smart contract (a "consumer contract"). For this guide, we have pre-deployed a simple CalculatorConsumer contract on the Sepolia testnet. This contract is designed to receive and store the calculation results from your workflow.

Here is the source code for the contract so you can see how it works:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import {ReceiverTemplate} from "./ReceiverTemplate.sol";

/**
 * @title CalculatorConsumer (Testing Version)
 * @notice This contract receives reports from a CRE workflow and stores the results of a calculation onchain.
 * @dev Inherits from ReceiverTemplate which provides security checks. The forwarder address must be
 * configured at deployment. Additional security checks (workflowId, workflowName, author) can be enabled via setter
 * functions.
 */
contract CalculatorConsumer is ReceiverTemplate {
  // Struct to hold the data sent in a report from the workflow
  struct CalculatorResult {
    uint256 offchainValue;
    int256 onchainValue;
    uint256 finalResult;
  }

  // --- State Variables ---
  CalculatorResult public latestResult;
  uint256 public resultCount;
  mapping(uint256 => CalculatorResult) public results;

  // --- Events ---
  event ResultUpdated(uint256 indexed resultId, uint256 finalResult);

  /**
   * @notice Constructor requires the forwarder address for security
   * @param _forwarderAddress The address of the Chainlink Forwarder contract (for testing: MockForwarder)
   * @dev The forwarder address enables the first layer of security - only the forwarder can call onReport.
   * Additional security checks can be configured after deployment using setter functions.
   */
  constructor(
    address _forwarderAddress
  ) ReceiverTemplate(_forwarderAddress) {}

  /**
   * @notice Implements the core business logic for processing reports.
   * @dev This is called automatically by ReceiverTemplate's onReport function after security checks.
   */
  function _processReport(
    bytes calldata report
  ) internal override {
    // Decode the report bytes into our CalculatorResult struct
    CalculatorResult memory calculatorResult = abi.decode(report, (CalculatorResult));

    // --- Core Logic ---
    // Update contract state with the new result
    resultCount++;
    results[resultCount] = calculatorResult;
    latestResult = calculatorResult;

    emit ResultUpdated(resultCount, calculatorResult.finalResult);
  }

  // This function is a "dry-run" utility. It allows an offchain system to check
  // if a prospective result is an outlier before submitting it for a real onchain update.
  // It is also used to guide the binding generator to create a method that accepts the CalculatorResult struct.
  function isResultAnomalous(
    CalculatorResult memory _prospectiveResult
  ) public view returns (bool) {
    // A result is not considered anomalous if it's the first one.
    if (resultCount == 0) {
      return false;
    }

    // Business logic: Define an anomaly as a new result that is more than double the previous result.
    // This is just one example of a validation rule you could implement.
    return _prospectiveResult.finalResult > (latestResult.finalResult * 2);
  }
}

The contract is already deployed for you on Sepolia at the following address: 0x95e10BaC2B89aB4D8508ccEC3f08494FcB3D23cb. You will use this address in your configuration file.

Step 2: Update your workflow configuration

Add the CalculatorConsumer contract address to your config.staging.json:

{
  "schedule": "*/30 * * * * *",
  "apiUrl": "https://api.mathjs.org/v4/?expr=randomInt(1,101)",
  "evms": [
    {
      "storageAddress": "0xa17CF997C28FF154eDBae1422e6a50BeF23927F4",
      "calculatorConsumerAddress": "0x95e10BaC2B89aB4D8508ccEC3f08494FcB3D23cb",
      "chainName": "ethereum-testnet-sepolia",
      "gasLimit": "500000"
    }
  ]
}

Step 3: Update your workflow logic

Now modify your workflow to write the final result to the contract. Writing onchain involves a two-step process:

1. Generate a signed report: Use runtime.report() to create a cryptographically signed report from your workflow data
2. Submit the report: Use evmClient.writeReport() to submit the signed report to the consumer contract

The TypeScript SDK uses Viem's encodeAbiParameters to properly encode the struct data according to the contract's ABI before generating the report.

Replace the entire content of onchain-calculator/my-calculator-workflow/main.ts with this final version.

Note: Lines highlighted in green indicate new or modified code compared to Part 3.

Key TypeScript SDK features for writing:

• encodeAbiParameters(): From Viem, encodes structured data according to a contract's ABI
• parseAbiParameters(): From Viem, defines the parameter types for encoding
• runtime.report(): Generates a signed report using the consensus capability
• writeReport(): EVMClient method for submitting the signed report to a consumer contract
• txHash: The transaction hash returned after a successful write operation

Step 4: Run the simulation and review the output

Run the simulation from your project root directory (the onchain-calculator/ folder). Because there is only one trigger, the simulator runs it automatically.

cre workflow simulate my-calculator-workflow --target staging-settings --broadcast

Your workflow will now show the complete end-to-end execution, including the final log of the MyResult object containing the transaction hash.

Workflow compiled
2026-01-09T17:52:05Z [SIMULATION] Simulator Initialized

2026-01-09T17:52:05Z [SIMULATION] Running trigger trigger=cron-trigger@1.0.0
2026-01-09T17:52:06Z [USER LOG] Successfully fetched offchain value: 68
2026-01-09T17:52:06Z [USER LOG] Successfully read onchain value: 22
2026-01-09T17:52:06Z [USER LOG] Final calculated result: 90
2026-01-09T17:52:06Z [USER LOG] Updating calculator result for consumer: 0x95e10BaC2B89aB4D8508ccEC3f08494FcB3D23cb
2026-01-09T17:52:06Z [USER LOG] Writing report to consumer contract - offchainValue: 68, onchainValue: 22, finalResult: 90
2026-01-09T17:52:12Z [USER LOG] Waiting for write report response
2026-01-09T17:52:12Z [USER LOG] Write report transaction succeeded: 0x6346d9eeca2f2875131d38aa9903a216f16e3cc7188f0ac6a1d5cd1fcbfbf9e6
2026-01-09T17:52:12Z [USER LOG] View transaction at https://sepolia.etherscan.io/tx/0x6346d9eeca2f2875131d38aa9903a216f16e3cc7188f0ac6a1d5cd1fcbfbf9e6
2026-01-09T17:52:12Z [USER LOG] Workflow finished successfully! offchainValue: 68, onchainValue: 22, finalResult: 90, txHash: 0x6346d9eeca2f2875131d38aa9903a216f16e3cc7188f0ac6a1d5cd1fcbfbf9e6

Workflow Simulation Result:
 {
  "finalResult": 90,
  "offchainValue": 68,
  "onchainValue": 22,
  "txHash": "0x6346d9eeca2f2875131d38aa9903a216f16e3cc7188f0ac6a1d5cd1fcbfbf9e6"
}

2026-01-09T17:52:12Z [SIMULATION] Execution finished signal received
2026-01-09T17:52:12Z [SIMULATION] Skipping WorkflowEngineV2

• [USER LOG]: You can see all of your logger.info() calls showing the complete workflow execution, including the offchain value (68), onchain value (22), final calculation (90), and the transaction hash.
• [SIMULATION]: These are system-level messages from the simulator showing its internal state.
• Workflow Simulation Result: This is the final return value of your workflow. The MyResult object contains all the values (68 + 22 = 90) and the transaction hash confirming the write operation succeeded.

Step 5: Verify the result onchain

1. Check the Transaction

In your terminal output, you'll see a clickable URL to view the transaction on Sepolia Etherscan:

[USER LOG] View transaction at https://sepolia.etherscan.io/tx/0x...

Click the URL (or copy and paste it into your browser) to see the full details of the transaction your workflow submitted.

What are you seeing on a blockchain explorer?

You'll notice the transaction's to address is not the CalculatorConsumer contract you intended to call. Instead, it's to a Forwarder contract. Your workflow sends a secure report to the Forwarder, which then verifies the request and makes the final call to the CalculatorConsumer on your workflow's behalf. To learn more, see the Onchain Write guide.

2. Check the contract state

While your wallet interacted with the Forwarder, the CalculatorConsumer contract's state was still updated. You can verify this change directly on Etherscan:

• Navigate to the CalculatorConsumer contract address: 0x95e10BaC2B89aB4D8508ccEC3f08494FcB3D23cb.
• Expand the latestResult function and click Query. The values should match the finalResult, offchainValue, and onchainValue from your workflow logs.

This completes the end-to-end loop: triggering a workflow, fetching data, reading onchain state, and verifiably writing the result back to a public blockchain.

To learn more about implementing consumer contracts and the secure write process, see these guides:

• Building Consumer Contracts: Learn how to create your own secure consumer contracts with proper validation.
• Onchain Write Guide: Dive deeper into the write patterns.

Next steps

You've now mastered the complete CRE development workflow!

• Conclusion & Next Steps: Review what you've learned and find resources for advanced topics.