Smart Triggers

Verifiable events initiating Smart Workflow execution

Triggers can be blockchain events (contract logs, transaction states), API requests (workflow_dispatch), or time-based schedules (cron). Each type has different observation and verification patterns suited to its source.

Examples

Configuration

Trigger workflow manually via HTTP API request. Useful for on-demand execution, manual operations, or external system integrations.

Workflow Configuration

on:
  workflow_dispatch:

Trigger

HTTP POST request received at /workflows/ping/dispatches.

HTTP API Request

POST /workflows/0x4f3a7c9e2b5d8a1c4e7f0b3d6a9c2e5f8b1d4a7c0e3b6d9f2a5c8e1b4d7a0c3/dispatches

{
  "authority_signature": "0x4a7b9c3d8e2f1a5c6d9e3b7f2a5d8c1e4b7a9d3c6e2f5a8b1d4c7e9f3a6b2d5c",
  "authority_pubkey": "0x892b3c5e8d1f4a7c9e2b6d8a3f5c7e9b4d6a8c1e3b5d7a9c2e4f6b8d1a3c5e7",
  "payer_signature": "0x2f8a9d3c6e5b1f4a7c0e2b9d5a8c1e4f7b0a3d6c9e2f5a8b1d4c7e0f3a6b9d2",
  "payer_pubkey": "0x6d9a2c5e8f1b4d7a0c3e6b9d2f5a8c1e4b7d0a3c6e9f2b5d8a1c4e7f0b3d6a9",
  "timestamp": 1730485532000,
  "nonce": "0x7c3e9f2a5d8b1c4e7f0a3d6b9c2e5f8a1b4d7a0c3e6f9b2d5a8c1e4f7b0d3a6"
}

Workflow Hash:0x4f3a7c9e2b5d8a1c4e7f0b3d6a9c2e5f8b1d4a7c0e3b6d9f2a5c8e1b4d7a0c3Name:pingAuthority:0x892b3c5e8d1f4a7c9e2b6d8a3f5c7e9b4d6a8c1e3b5d7a9c2e4f6b8d1a3c5e7Payer:0x6d9a2c5e8f1b4d7a0c3e6b9d2f5a8c1e4b7d0a3c6e9f2b5d8a1c4e7f0b3d6a9Timestamp:1730485532000Nonce:0x7c3e9f2a5d8b1c4e7f0a3d6b9c2e5f8a1b4d7a0c3e6f9b2d5a8c1e4f7b0d3a6

Observation

Validator verifies authority and payer, creates trigger attestation.

Detection

Observation Code

// Validator's HTTP RPC handler
rpc_server.post("/workflows/:workflow_hash/dispatches", (req) => {
  const workflow_hash = req.params.workflow_hash; // Full 32-byte hash
  const {
    authority_signature, authority_pubkey,
    payer_signature, payer_pubkey,
    timestamp, nonce
  } = req.body;

  const workflow_config = get_workflow_config(workflow_hash);
  const now = Date.now();

  // Check timestamp is within acceptable range
  const MIN_TIMESTAMP = now - 5 * 60 * 1000;  // 5 min past
  const MAX_TIMESTAMP = now + 24 * 60 * 60 * 1000;  // 24 hrs future
  if (timestamp < MIN_TIMESTAMP || timestamp > MAX_TIMESTAMP) {
    return error("Timestamp out of range");
  }

  // Verify authority signature (permission)
  const auth_message = hash(workflow_hash + timestamp + nonce);
  if (!verify(auth_message, authority_signature, authority_pubkey)) {
    return error("Invalid authority signature");
  }

  // Check authority is authorized
  if (!workflow_config.authorized_keys.includes(authority_pubkey)) {
    return error("Authority not authorized");
  }

  // Verify payer signature (payment commitment)
  const payer_message = hash(workflow_hash + timestamp + nonce + authority_pubkey);
  if (!verify(payer_message, payer_signature, payer_pubkey)) {
    return error("Invalid payer signature");
  }

  // Check payer has sufficient balance (or deduct fees)
  if (!has_sufficient_balance(payer_pubkey, workflow_config.fee)) {
    return error("Insufficient payer balance");
  }

  // Create trigger with authority and payer proof
  const trigger = {
    workflow_hash,
    topic: "trigger.workflow_dispatch",
    data: {
      workflow_hash,
      timestamp,
      nonce,
      authority_signature,
      authority_pubkey,
      payer_signature,
      payer_pubkey
    }
  };

  // Validator signs and broadcasts
  broadcast(sign_message({
    message_type: "trigger",
    timestamp_ms: now,
    payload: trigger
  }));
});

Attestation

Trigger Attestation

{
  "content": {
    "message_type": "trigger",
    "timestamp_ms": 1730485532000,
    "payload": {
      "workflow_hash": "0x4f3a7c9e2b5d8a1c4e7f0b3d6a9c2e5f8b1d4a7c0e3b6d9f2a5c8e1b4d7a0c3",
      "topic": "trigger.workflow_dispatch",
      "data": {
        "workflow_hash": "0x4f3a7c9e2b5d8a1c4e7f0b3d6a9c2e5f8b1d4a7c0e3b6d9f2a5c8e1b4d7a0c3",
        "timestamp": 1730485532000,
        "nonce": "0x7c3e9f2a5d8b1c4e7f0a3d6b9c2e5f8a1b4d7a0c3e6f9b2d5a8c1e4f7b0d3a6",
        "authority_signature": "0x4a7b9c3d8e2f1a5c6d9e3b7f2a5d8c1e4b7a9d3c6e2f5a8b1d4c7e9f3a6b2d5c",
        "authority_pubkey": "0x892b3c5e8d1f4a7c9e2b6d8a3f5c7e9b4d6a8c1e3b5d7a9c2e4f6b8d1a3c5e7",
        "payer_signature": "0x2f8a9d3c6e5b1f4a7c0e2b9d5a8c1e4f7b0a3d6c9e2f5a8b1d4c7e0f3a6b9d2",
        "payer_pubkey": "0x6d9a2c5e8f1b4d7a0c3e6b9d2f5a8c1e4b7d0a3c6e9f2b5d8a1c4e7f0b3d6a9"
      }
    }
  },
  "signature": "0x8a3f9d7c2e5b1f4a6d8c3e9b7a5f2d4c8e1b6a9d3c7e2f5a8b4d1c6e9f3a7b2d",
  "signer": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb2"
}

Verification

Validators verify authority and payer authorization, all three signatures valid.

Verification Protocol

1. Check Topic

topic == "trigger.workflow_dispatch"

2. Check Workflow Exists

workflow_exists(workflow_name)

3. Verify Timestamp Range

now - 5min < timestamp < now + 24hrs

4. Verify Authority Signature

verify(hash(workflow_hash || timestamp || nonce), authority_signature, authority_pubkey)

5. Check Authority Authorized

workflow.authorized_keys.contains(authority_pubkey)

6. Verify Payer Signature

verify(hash(workflow_hash || timestamp || nonce || authority_pubkey), payer_signature, payer_pubkey)

7. Check Payer Has Balance

has_sufficient_balance(payer_pubkey, workflow.fee)

8. Verify Validator Signature

verify(message.content.hash(), signature, signer)

Challenge & Fraud Proof

// Challenge if authority unauthorized or signatures invalid
fn verify_and_challenge(
    signed_message: SignedMessage
) -> Result<()> {
    let trigger = signed_message.content.payload;
    let data = trigger.data;

    // Check topic first (cheap string comparison)
    if trigger.topic != "trigger.workflow_dispatch" {
        return submit_fraud_proof(InvalidTopic);
    }

    // Check workflow exists (cheap hashmap lookup)
    let workflow = get_workflow(&trigger.workflow_hash)
        .ok_or(submit_fraud_proof(WorkflowNotFound))?;

    // Check timestamp is within range (cheap comparison)
    let now = current_timestamp_ms();
    let min_ts = now - 5 * 60 * 1000;  // 5 min past
    let max_ts = now + 24 * 60 * 60 * 1000;  // 24 hrs future
    if data.timestamp < min_ts || data.timestamp > max_ts {
        return submit_fraud_proof(TimestampOutOfRange);
    }

    // Verify authority signature (expensive crypto)
    let auth_message = hash(&trigger.workflow_hash, &data.timestamp, &data.nonce);
    if !verify(
        &auth_message,
        &data.authority_signature,
        &data.authority_pubkey
    ) {
        return submit_fraud_proof(InvalidAuthoritySignature);
    }

    // Check authority authorized (cheap array lookup)
    if !workflow.authorized_keys.contains(&data.authority_pubkey) {
        return submit_fraud_proof(UnauthorizedAuthority);
    }

    // Verify payer signature (expensive crypto)
    let payer_message = hash(
        &trigger.workflow_hash,
        &data.timestamp,
        &data.nonce,
        &data.authority_pubkey
    );
    if !verify(
        &payer_message,
        &data.payer_signature,
        &data.payer_pubkey
    ) {
        return submit_fraud_proof(InvalidPayerSignature);
    }

    // Check payer has balance (cheap balance lookup)
    if !has_sufficient_balance(&data.payer_pubkey, workflow.fee) {
        return submit_fraud_proof(InsufficientPayerBalance);
    }

    // Verify validator signature last (expensive crypto)
    if !verify_signature(
        signed_message.content.hash(),
        &signed_message.signature,
        &signed_message.signer
    ) {
        return submit_fraud_proof(InvalidValidatorSignature);
    }

    Ok(())
}

Consensus

The network reaches agreement that the trigger is valid.

validator_1→✓ ATTESTED

validator_2→✓ ATTESTED

validator_3→✓ ATTESTED

validator_4→✓ ATTESTED

validator_5→○ OFFLINE

validator_6→✗ CHALLENGED→ SLASHED

✓ Quorum Reached

4/6 validators attested correctly

Threshold: ≥4 required (2/3 of 6)

→ Trigger accepted, workflow begins

✓Honest attestors (4): Proceed with workflow execution

○Offline (1): No response within timeout, no penalty

✗Challenged (1): Fraud proof submitted, challenger rewarded, attestor slashed

Configuration

Trigger workflow manually with input parameters. The echo workflow accepts a message parameter and returns it.

Workflow Configuration

on:
  workflow_dispatch:
    inputs:
      message:
        description: 'Message to echo'
        required: true
        type: string

Trigger

HTTP POST request with input parameters received.

HTTP API Request

POST /workflows/0x8e2d5a9c1f4b7e0a3d6c9f2b5e8a1c4f7b0d3a6c9e2f5b8d1a4c7e0f3b6d9a2/dispatches

{
  "authority_signature": "0x7d2e9f4a5b8c1d3e6a9b2c5d8e1f4a7b9c2d5e8f1a4b7d0c3e6f9a2d5b8c1e4",
  "authority_pubkey": "0x3f6a9c2e5b8d1f4a7c0e3b6d9a2c5e8f1b4d7a0c3e6b9d2f5a8c1e4b7d0a3c6",
  "payer_signature": "0x8c1e4b7d0a3c6e9f2b5d8a1c4e7f0b3d6a9c2e5f8b1d4a7c0e3b6d9f2a5c8e1",
  "payer_pubkey": "0x9f2b5d8a1c4e7f0b3d6a9c2e5f8b1d4a7c0e3b6d9f2a5c8e1b4d7a0c3e6f9b2",
  "timestamp": 1730485632000,
  "nonce": "0x4e7b0d3a6c9f2b5e8a1d4c7f0b3e6a9c2d5f8b1e4a7c0d3f6b9e2a5d8c1f4b7",
  "inputs": {
    "message": "Hello, World!"
  }
}

Workflow Hash:0x8e2d5a9c1f4b7e0a3d6c9f2b5e8a1c4f7b0d3a6c9e2f5b8d1a4c7e0f3b6d9a2Name:echoAuthority:0x3f6a9c2e5b8d1f4a7c0e3b6d9a2c5e8f1b4d7a0c3e6b9d2f5a8c1e4b7d0a3c6Payer:0x9f2b5d8a1c4e7f0b3d6a9c2e5f8b1d4a7c0e3b6d9f2a5c8e1b4d7a0c3e6f9b2Timestamp:1730485632000Nonce:0x4e7b0d3a6c9f2b5e8a1d4c7f0b3e6a9c2d5f8b1e4a7c0d3f6b9e2a5d8c1f4b7Input:{"message": "Hello, World!"}

Observation

Validator verifies authority and payer, creates trigger attestation with inputs.

Detection

Observation Code

// Validator's HTTP RPC handler
rpc_server.post("/workflows/:workflow_hash/dispatches", (req) => {
  const workflow_hash = req.params.workflow_hash; // Full 32-byte hash
  const {
    authority_signature, authority_pubkey,
    payer_signature, payer_pubkey,
    timestamp, nonce, inputs
  } = req.body;

  const workflow_config = get_workflow_config(workflow_hash);
  const now = Date.now();

  // Check timestamp is within acceptable range
  const MIN_TIMESTAMP = now - 5 * 60 * 1000;  // 5 min past
  const MAX_TIMESTAMP = now + 24 * 60 * 60 * 1000;  // 24 hrs future
  if (timestamp < MIN_TIMESTAMP || timestamp > MAX_TIMESTAMP) {
    return error("Timestamp out of range");
  }

  // Verify authority signature (permission, includes inputs)
  const auth_message = hash(workflow_hash + timestamp + nonce + JSON.stringify(inputs));
  if (!verify(auth_message, authority_signature, authority_pubkey)) {
    return error("Invalid authority signature");
  }

  // Check authority is authorized
  if (!workflow_config.authorized_keys.includes(authority_pubkey)) {
    return error("Authority not authorized");
  }

  // Verify payer signature (payment commitment)
  const payer_message = hash(workflow_hash + timestamp + nonce + authority_pubkey + JSON.stringify(inputs));
  if (!verify(payer_message, payer_signature, payer_pubkey)) {
    return error("Invalid payer signature");
  }

  // Check payer has sufficient balance
  if (!has_sufficient_balance(payer_pubkey, workflow_config.fee)) {
    return error("Insufficient payer balance");
  }

  // Create trigger with authority, payer proof and inputs
  const trigger = {
    workflow_hash,
    topic: "trigger.workflow_dispatch",
    data: {
      workflow_hash,
      timestamp,
      nonce,
      authority_signature,
      authority_pubkey,
      payer_signature,
      payer_pubkey,
      inputs
    }
  };

  // Validator signs and broadcasts
  broadcast(sign_message({
    message_type: "trigger",
    timestamp_ms: now,
    payload: trigger
  }));
});

Attestation

Trigger Attestation

{
  "content": {
    "message_type": "trigger",
    "timestamp_ms": 1730485632000,
    "payload": {
      "workflow_hash": "0x8e2d5a9c1f4b7e0a3d6c9f2b5e8a1c4f7b0d3a6c9e2f5b8d1a4c7e0f3b6d9a2",
      "topic": "trigger.workflow_dispatch",
      "data": {
        "workflow_hash": "0x8e2d5a9c1f4b7e0a3d6c9f2b5e8a1c4f7b0d3a6c9e2f5b8d1a4c7e0f3b6d9a2",
        "timestamp": 1730485632000,
        "nonce": "0x4e7b0d3a6c9f2b5e8a1d4c7f0b3e6a9c2d5f8b1e4a7c0d3f6b9e2a5d8c1f4b7",
        "authority_signature": "0x7d2e9f4a5b8c1d3e6a9b2c5d8e1f4a7b9c2d5e8f1a4b7d0c3e6f9a2d5b8c1e4",
        "authority_pubkey": "0x3f6a9c2e5b8d1f4a7c0e3b6d9a2c5e8f1b4d7a0c3e6b9d2f5a8c1e4b7d0a3c6",
        "payer_signature": "0x8c1e4b7d0a3c6e9f2b5d8a1c4e7f0b3d6a9c2e5f8b1d4a7c0e3b6d9f2a5c8e1",
        "payer_pubkey": "0x9f2b5d8a1c4e7f0b3d6a9c2e5f8b1d4a7c0e3b6d9f2a5c8e1b4d7a0c3e6f9b2",
        "inputs": {
          "message": "Hello, World!"
        }
      }
    }
  },
  "signature": "0x5c8e1b4a7d0e3b6c9f2a5d8e1b4c7f0a3d6b9e2c5f8a1b4e7d0c3f6a9d2e5c8",
  "signer": "0x3b6c9f2a5d8e1b4c7f0a3d6b9e2c5f8a1b4e7d0c"
}

Verification

Validators verify authority and payer authorization, all three signatures valid.

Verification Protocol

1. Check Topic

topic == "trigger.workflow_dispatch"

2. Check Workflow Exists

workflow_exists(workflow_hash)

3. Verify Timestamp Range

now - 5min < timestamp < now + 24hrs

4. Verify Authority Signature

verify(hash(workflow_hash || timestamp || nonce || inputs), authority_signature, authority_pubkey)

5. Check Authority Authorized

workflow.authorized_keys.contains(authority_pubkey)

6. Verify Payer Signature

verify(hash(workflow_hash || timestamp || nonce || authority_pubkey || inputs), payer_signature, payer_pubkey)

7. Check Payer Has Balance

has_sufficient_balance(payer_pubkey, workflow.fee)

8. Verify Validator Signature

verify(message.content.hash(), signature, signer)

Challenge & Fraud Proof

// Challenge if authority/payer unauthorized or signatures invalid
fn verify_and_challenge(
    signed_message: SignedMessage
) -> Result<()> {
    let trigger = signed_message.content.payload;
    let data = trigger.data;

    // Check topic first (cheap string comparison)
    if trigger.topic != "trigger.workflow_dispatch" {
        return submit_fraud_proof(InvalidTopic);
    }

    // Check workflow exists (cheap hashmap lookup)
    let workflow = get_workflow(&trigger.workflow_hash)
        .ok_or(submit_fraud_proof(WorkflowNotFound))?;

    // Check timestamp is within range (cheap comparison)
    let now = current_timestamp_ms();
    let min_ts = now - 5 * 60 * 1000;  // 5 min past
    let max_ts = now + 24 * 60 * 60 * 1000;  // 24 hrs future
    if data.timestamp < min_ts || data.timestamp > max_ts {
        return submit_fraud_proof(TimestampOutOfRange);
    }

    // Verify authority signature with inputs (expensive crypto)
    let auth_message = hash(
        &trigger.workflow_hash,
        &data.timestamp,
        &data.nonce,
        &data.inputs
    );
    if !verify(
        &auth_message,
        &data.authority_signature,
        &data.authority_pubkey
    ) {
        return submit_fraud_proof(InvalidAuthoritySignature);
    }

    // Check authority authorized (cheap array lookup)
    if !workflow.authorized_keys.contains(&data.authority_pubkey) {
        return submit_fraud_proof(UnauthorizedAuthority);
    }

    // Verify payer signature with inputs (expensive crypto)
    let payer_message = hash(
        &trigger.workflow_hash,
        &data.timestamp,
        &data.nonce,
        &data.authority_pubkey,
        &data.inputs
    );
    if !verify(
        &payer_message,
        &data.payer_signature,
        &data.payer_pubkey
    ) {
        return submit_fraud_proof(InvalidPayerSignature);
    }

    // Check payer has balance (cheap balance lookup)
    if !has_sufficient_balance(&data.payer_pubkey, workflow.fee) {
        return submit_fraud_proof(InsufficientPayerBalance);
    }

    // Verify validator signature last (expensive crypto)
    if !verify_signature(
        signed_message.content.hash(),
        &signed_message.signature,
        &signed_message.signer
    ) {
        return submit_fraud_proof(InvalidValidatorSignature);
    }

    Ok(())
}

Consensus

The network reaches agreement that the trigger is valid.

validator_1→✓ ATTESTED

validator_2→✓ ATTESTED

validator_3→✓ ATTESTED

validator_4→✓ ATTESTED

validator_5→○ OFFLINE

validator_6→✗ CHALLENGED→ SLASHED

✓ Quorum Reached

4/6 validators attested correctly

Threshold: ≥4 required (2/3 of 6)

→ Trigger accepted, workflow begins

✓Honest attestors (4): Proceed with workflow execution

○Offline (1): No response within timeout, no penalty

✗Challenged (1): Fraud proof submitted, challenger rewarded, attestor slashed

Configuration

Trigger workflow on a time-based schedule using cron syntax. Anchored to Ethereum block timestamps for verifiable, trustless execution.

Workflow Configuration

on:
  schedule:
    cron: "0 * * * *"  # Every hour at minute 0

Trigger

Ethereum block is mined with timestamp >= scheduled minute.

Block Mined (Schedule Anchor)

EthereumBlockMined(
  block_hash: 0xa7b3d8e2f1c5a9b4d7e3f8c2a6b9d5e1f4c7a3b8d2e6f9c1a5b8d4e7f3a9c6,
  // block_number: 21094523 (derivable from hash)
  // scheduled_minute: 1730494800 (derivable from cron)
)

Workflow:cleanupCron Expression:0 * * * * (hourly)Block Hash:0xa7b3d8e2f1c5a9b4d7e3f8c2a6b9d5e1f4c7a3b8d2e6f9c1a5b8d4e7f3a9c6

Observation

Validators watch blocks and attest to the first one after each scheduled time.

Detection

Observation Code

// Track recent firings (deque, bounded to last 2 minutes)
const fired_history = []; // [{workflow_name, scheduled_minute, timestamp}]
const HISTORY_TTL = 120; // 2 minutes in seconds

// Validator watches Ethereum blocks for schedules
eth.on("block", async (block) => {
  // Prune old entries (older than 2 minutes)
  const cutoff = block.timestamp - HISTORY_TTL;
  while (fired_history.length > 0 && fired_history[0].timestamp < cutoff) {
    fired_history.shift(); // Remove from front
  }

  const schedules = get_active_schedules();

  for (const schedule of schedules) {
    const scheduled_minute = get_cron_minute(schedule.cron);

    // Check if already fired for this minute
    const already_fired = fired_history.some(
      entry => entry.workflow_name === schedule.workflow_name &&
               entry.scheduled_minute === scheduled_minute
    );
    if (already_fired) continue;

    // First block after scheduled minute?
    if (block.timestamp >= scheduled_minute) {
      // Mark as fired
      fired_history.push({
        workflow_name: schedule.workflow_name,
        scheduled_minute,
        timestamp: block.timestamp
      });

      // Create trigger (compact: only cron + block_hash)
      const trigger = {
        workflow_name: schedule.workflow_name,
        topic: "trigger.schedule",
        data: {
          cron: schedule.cron,
          block_hash: block.hash  // Proves temporal ordering
        }
      };

      // Sign and broadcast
      const signed_message = sign_message({
        message_type: "trigger",
        timestamp_ms: Date.now(),
        payload: trigger
      });
      broadcast(signed_message);
    }
  }
});

Attestation

Trigger Attestation

{
  "content": {
    "message_type": "trigger",
    "timestamp_ms": 1730494812000,
    "payload": {
      "workflow_name": "cleanup",
      "topic": "trigger.schedule",
      "data": {
        "cron": "0 * * * *",
        "block_hash": "0xa7b3d8e2f1c5a9b4d7e3f8c2a6b9d5e1f4c7a3b8d2e6f9c1a5b8d4e7f3a9c6"
      }
    }
  },
  "signature": "0x6f9b2a5d8e1c4b7f0d3a6c9f2b5e8a1d4c7f0a3d6b9e2c5f8a1b4e7d0c3f6a9",
  "signer": "0x1f4b7e0d3c6f9b2a5d8e1c4b7f0a3d6b9e2c5f8a"
}

Verification

Validators derive scheduled_minute from cron and verify block timing, challenging if earlier block exists.

Verification Protocol

1. Check Topic

topic == "trigger.schedule"

2. Verify Block Exists

block = eth.getBlock(block_hash)

3. Compute Scheduled Minute

scheduled_minute = get_cron_minute(cron)

4. Verify Block After Schedule

block.timestamp >= scheduled_minute

5. Check No Earlier Block

!exists_earlier_block(block.number, scheduled_minute)

6. Verify Signature

verify(message.content.hash(), signature, signer)

Challenge & Fraud Proof

// Challenge with earlier valid block in same minute
fn verify_and_challenge(
    signed_message: SignedMessage
) -> Result<()> {
    let trigger = signed_message.content.payload;

    // Check topic first (cheap string comparison)
    if trigger.topic != "trigger.schedule" {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidTopic,
        });
        return Err("Invalid topic");
    }

    // Get block from hash (also validates hash exists)
    let block = eth_client.get_block_by_hash(&trigger.data.block_hash)?;

    // Compute scheduled minute from cron
    let scheduled_minute = get_cron_minute(&trigger.data.cron)?;

    // Verify block is after scheduled minute
    if block.timestamp < scheduled_minute {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: BlockBeforeSchedule,
        });
        return Err("Block before scheduled time");
    }

    // Challenge: find earlier block in same cron period
    let earlier_block = find_earlier_block_in_period(
        block.number,
        scheduled_minute
    );
    if let Some(earlier) = earlier_block {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: EarlierBlockExists {
                earlier_block_number: earlier.number,
                earlier_block_hash: earlier.hash,
            },
        });
        return Err("Earlier valid block exists");
    }

    // Verify signature last (expensive crypto operation)
    if !verify_signature(
        signed_message.content.hash(),
        signed_message.signature,
        signed_message.signer
    ) {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidSignature,
        });
        return Err("Invalid signature");
    }

    Ok(())
}

Consensus

The network reaches agreement that the trigger is valid.

validator_1→✓ ATTESTED

validator_2→✓ ATTESTED

validator_3→✓ ATTESTED

validator_4→✓ ATTESTED

validator_5→○ OFFLINE

validator_6→✗ CHALLENGED→ SLASHED

✓ Quorum Reached

4/6 validators attested correctly

Threshold: ≥4 required (2/3 of 6)

→ Trigger accepted, workflow begins

✓Honest attestors (4): Proceed with workflow execution

○Offline (1): No response within timeout, no penalty

✗Challenged (1): Fraud proof submitted, challenger rewarded, attestor slashed

Configuration

Monitor USDC Transfer events on Ethereum, filtered to only mint operations (transfers from the null address). Triggers when Circle creates new USDC tokens.

Workflow Configuration

on:
  ethereum:
    contract: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"  # Circle: USDC Token
    event: Transfer
    filters:
      from: "0x0000000000000000000000000000000000000000"  # only mints

Trigger

ERC20 Transfer event emitted on Ethereum.

ERC20 Transfer Event

Transfer(
  from: 0x0000000000000000000000000000000000000000,
  to: 0x55FE002aefF02F77364de339a1292923A15844B8,
  value: 100000000  // 100M USDC ($100M mint)
)

Tx Hash:0xcb2c6fc30630f02289221a04db1da220e00e2475e65a92980083bcd1ec1f07f6Log Index:470Block:23,699,722Timestamp:Oct-31-2025 20:29:23 UTC

Observation

Validators monitor contract logs and attest to Transfer events.

Detection

Observation Code

// Subscribe to USDC Transfer events
eth.on("log", {
  address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
  topics: [TRANSFER_TOPIC]
}, (log) => {
  // Create trigger
  const trigger = {
    workflow_name: "usdc-monitor",
    topic: "trigger.ethereum.event",
    data: {
      block_number: log.blockNumber,
      log_index: log.logIndex
    }
  };

  // Sign and broadcast
  const signed_message = sign_message({
    message_type: "trigger",
    timestamp_ms: Date.now(),
    payload: trigger
  });
  broadcast(signed_message);
});

Attestation

Trigger Attestation

{
  "content": {
    "message_type": "trigger",
    "timestamp_ms": 1730428163000,
    "payload": {
      "workflow_name": "usdc-monitor",
      "topic": "trigger.ethereum.event",
      "data": {
        "block_number": 23699722,
        "log_index": 470
      }
    }
  },
  "signature": "0x7d3f2e8a1c4b5d6e9f0a3c7b2d5e8f1a4c7b0d3e6a9c2f5b8d1e4a7c0f3b6e9d",
  "signer": "0x8f3a9e1d4b5c7a2f9e6d8c4b3a1f7e9d2c5b8a6f"
}

Verification

Validators verify onchain event data and challenge invalid attestations.

Verification Protocol

1. Check Topic

topic == "trigger.ethereum.event"

2. Verify Event On Chain

eth_getLogs(block_number)[log_index].topics[0] == TRANSFER_TOPIC

3. Verify Signature

verify(message.content.hash(), signature, signer)

Challenge & Fraud Proof

// Challenge if event or signature invalid
fn verify_and_challenge(
    signed_message: SignedMessage
) -> Result<()> {
    let trigger = signed_message.content.payload;

    // Check topic first (cheap string comparison)
    if trigger.topic != "trigger.ethereum.event" {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidTopic,
        });
        return Err("Invalid topic");
    }

    // Verify event exists on chain (block_number + log_index)
    let log = eth_node.get_log_at(
        trigger.data.block_number,
        trigger.data.log_index
    )?;

    if log.is_none() || log.topics[0] != TRANSFER_TOPIC {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: log,
        });
        return Err("Event not found or invalid");
    }

    // Verify signature last (expensive crypto operation)
    if !verify_signature(
        signed_message.content.hash(),
        signed_message.signature,
        signed_message.signer
    ) {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidSignature,
        });
        return Err("Invalid signature");
    }

    Ok(())
}

Consensus

The network reaches agreement that the trigger is valid.

validator_1→✓ ATTESTED

validator_2→✓ ATTESTED

validator_3→✓ ATTESTED

validator_4→✓ ATTESTED

validator_5→○ OFFLINE

validator_6→✗ CHALLENGED→ SLASHED

✓ Quorum Reached

4/6 validators attested correctly

Threshold: ≥4 required (2/3 of 6)

→ Trigger accepted, workflow begins

✓Honest attestors (4): Proceed with workflow execution

○Offline (1): No response within timeout, no penalty

✗Challenged (1): Fraud proof submitted, challenger rewarded, attestor slashed

Configuration

Monitor ENS domain registrations (ERC721 NFT mints). Triggers when new .eth domains are registered on Ethereum Name Service.

Workflow Configuration

on:
  ethereum:
    contract: "0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85"  # ENS: Base Registrar Implementation
    event: Transfer
    filters:
      from: "0x0000000000000000000000000000000000000000"  # only mints

Trigger

ENS name registered, Transfer event emitted.

ERC721 Transfer Event (ENS)

Transfer(
  from: 0x0000000000000000000000000000000000000000,
  to: 0xBdB41BfF7E828E2DC2d15EB67257455db818F1DC,
  tokenId: 32725979415724980685740053815555219754393211465605418713894938307004586787552
)

Tx Hash:0x1df2530358098eb5109ea131f73e5edbd1a4ca4a4ecd57682f8f363b19cda597Log Index:448Block:23,030,253Timestamp:Jul-30-2025 06:47:59 UTC

Observation

Validators monitor ENS contract logs and attest to registrations.

Detection

Observation Code

// Subscribe to ENS Transfer events
eth.on("log", {
  address: "0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85",
  topics: [TRANSFER_TOPIC]
}, (log) => {
  // Create trigger
  const trigger = {
    workflow_name: "ens-monitor",
    topic: "trigger.ethereum.event",
    data: {
      block_number: log.blockNumber,
      log_index: log.logIndex
    }
  };

  // Sign and broadcast
  const signed_message = sign_message({
    message_type: "trigger",
    timestamp_ms: Date.now(),
    payload: trigger
  });
  broadcast(signed_message);
});

Attestation

Trigger Attestation

{
  "content": {
    "message_type": "trigger",
    "timestamp_ms": 1722322079000,
    "payload": {
      "workflow_name": "ens-monitor",
      "topic": "trigger.ethereum.event",
      "data": {
        "block_number": 23030253,
        "log_index": 448
      }
    }
  },
  "signature": "0xc7f0a3d6b9e2c5f8a1b4e7d0c3f6b9d2e5a8c1f4b7e0d3a6c9f2b5e8a1d4c7f",
  "signer": "0x9e2d5c8f1b4a7d0e3b6c9f2a5d8e1b4c7f0a3d6b"
}

Verification

Validators verify onchain event data and challenge invalid attestations.

Verification Protocol

1. Check Topic

topic == "trigger.ethereum.event"

2. Verify Event On Chain

eth_getLogs(block_number)[log_index].topics[0] == TRANSFER_TOPIC

3. Verify Signature

verify(message.content.hash(), signature, signer)

Challenge & Fraud Proof

// Challenge if event or signature invalid
fn verify_and_challenge(
    signed_message: SignedMessage
) -> Result<()> {
    let trigger = signed_message.content.payload;

    // Check topic first (cheap string comparison)
    if trigger.topic != "trigger.ethereum.event" {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidTopic,
        });
        return Err("Invalid topic");
    }

    // Verify event exists on chain (block_number + log_index)
    let log = eth_node.get_log_at(
        trigger.data.block_number,
        trigger.data.log_index
    )?;

    if log.is_none() || log.topics[0] != TRANSFER_TOPIC {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: log,
        });
        return Err("Event not found or invalid");
    }

    // Verify signature last (expensive crypto operation)
    if !verify_signature(
        signed_message.content.hash(),
        signed_message.signature,
        signed_message.signer
    ) {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidSignature,
        });
        return Err("Invalid signature");
    }

    Ok(())
}

Consensus

The network reaches agreement that the trigger is valid.

validator_1→✓ ATTESTED

validator_2→✓ ATTESTED

validator_3→✓ ATTESTED

validator_4→✓ ATTESTED

validator_5→○ OFFLINE

validator_6→✗ CHALLENGED→ SLASHED

✓ Quorum Reached

4/6 validators attested correctly

Threshold: ≥4 required (2/3 of 6)

→ Trigger accepted, workflow begins

✓Honest attestors (4): Proceed with workflow execution

○Offline (1): No response within timeout, no penalty

✗Challenged (1): Fraud proof submitted, challenger rewarded, attestor slashed

Configuration

Monitor Ethereum transactions sent to Uniswap V2 Router. Triggers immediately when the transaction is included in a block (1 confirmation).

Workflow Configuration

on:
  ethereum:
    event: TransactionMined
    filters:
      to: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D"  # Uniswap V2 Router

Trigger

Ethereum transaction is mined and included in a block.

Transaction Mined Event

TransactionMined(
  txHash: 0x9f2c4b7a3e5d1c8f6b4a9e2d7c5f8a1b3e6d9c2f,
  blockNumber: 18500456,
  from: 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb2,
  to: 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D,
  status: 1  // Success
)

Tx Hash:0x9f2c4b7a3e5d1c8f6b4a9e2d7c5f8a1b3e6d9c2fBlock:18,500,456Confirmations:1Timestamp:Nov-01-2025 10:15:30 UTC

Observation

Validators watch mempool and blocks, attest when transaction is mined.

Detection

Observation Code

// Subscribe to transaction mined events
eth.on("transaction_mined", (tx) => {
  if (tx.to === UNISWAP_ROUTER) {
    // Create trigger
    const trigger = {
      workflow_name: "uniswap-monitor",
      topic: "trigger.ethereum.transaction",
      data: {
        tx_hash: tx.hash,
        block_number: tx.blockNumber
      }
    };

    // Sign and broadcast
    const signed_message = sign_message({
      message_type: "trigger",
      timestamp_ms: Date.now(),
      payload: trigger
    });
    broadcast(signed_message);
  }
});

Attestation

Trigger Attestation

{
  "content": {
    "message_type": "trigger",
    "timestamp_ms": 1730458530000,
    "payload": {
      "workflow_name": "uniswap-monitor",
      "topic": "trigger.ethereum.transaction",
      "data": {
        "tx_hash": "0x9f2c4b7a3e5d1c8f6b4a9e2d7c5f8a1b3e6d9c2f",
        "block_number": 18500456
      }
    }
  },
  "signature": "0x4a8e71c9d5f2b3a7e8c1f4d6b9a2e5c8d1f4b7a3e6c9f2d5b8a1e4c7f0d3b6e9",
  "signer": "0x3c7e2f9a4d1b6e8c5f2a9d7b4e1c8f6a3b9e2d5c"
}

Verification

Validators verify transaction exists in specified block.

Verification Protocol

1. Check Topic

topic == "trigger.ethereum.transaction"

2. Verify Transaction In Block

eth.getTransaction(tx_hash).block_number == block_number

3. Verify Signature

verify(message.content.hash(), signature, signer)

Challenge & Fraud Proof

// Challenge if tx not in block or signature invalid
fn verify_and_challenge(
    signed_message: SignedMessage
) -> Result<()> {
    let trigger = signed_message.content.payload;

    // Check topic first (cheap string comparison)
    if trigger.topic != "trigger.ethereum.transaction" {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidTopic,
        });
        return Err("Invalid topic");
    }

    // Verify transaction in claimed block
    let tx = eth_node.get_transaction(trigger.data.tx_hash)?;

    if tx.block_number != trigger.data.block_number {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: tx,
        });
        return Err("Transaction not in claimed block");
    }

    // Verify signature last (expensive crypto operation)
    if !verify_signature(
        signed_message.content.hash(),
        signed_message.signature,
        signed_message.signer
    ) {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidSignature,
        });
        return Err("Invalid signature");
    }

    Ok(())
}

Consensus

The network reaches agreement that the trigger is valid.

validator_1→✓ ATTESTED

validator_2→✓ ATTESTED

validator_3→✓ ATTESTED

validator_4→✓ ATTESTED

validator_5→○ OFFLINE

validator_6→✗ CHALLENGED→ SLASHED

✓ Quorum Reached

4/6 validators attested correctly

Threshold: ≥4 required (2/3 of 6)

→ Trigger accepted, workflow begins

✓Honest attestors (4): Proceed with workflow execution

○Offline (1): No response within timeout, no penalty

✗Challenged (1): Fraud proof submitted, challenger rewarded, attestor slashed

Configuration

Wait for an Ethereum transaction to achieve deep confirmation (12 blocks). Triggers only after the transaction is extremely unlikely to be reorganized.

Workflow Configuration

on:
  ethereum:
    event: TransactionFinalized
    confirmations: 12  # Deep confirmations

Trigger

Ethereum transaction reaches finality after 64 blocks.

Transaction Finalized Event

TransactionFinalized(
  txHash: 0x9f2c4b7a3e5d1c8f6b4a9e2d7c5f8a1b3e6d9c2f,
  blockNumber: 18500456,
  confirmations: 12,
  finalizedAt: 18500468  // 12 blocks later
)

Tx Hash:0x9f2c4b7a3e5d1c8f6b4a9e2d7c5f8a1b3e6d9c2fOriginal Block:18,500,456Finalized At:18,500,468Confirmations:12Timestamp:Nov-01-2025 10:18:00 UTC

Observation

Validators watch finalized blocks and attest to transaction finality.

Detection

Observation Code

// Monitor transaction confirmations
eth.on("transaction_finalized", (tx) => {
  if (tx.confirmations >= 12) {
    // Create trigger
    const trigger = {
      workflow_name: "safe-settlement",
      topic: "trigger.ethereum.finalized",
      data: {
        tx_hash: tx.hash,
        finalized_at: tx.blockNumber + 12
      }
    };

    // Sign and broadcast
    const signed_message = sign_message({
      message_type: "trigger",
      timestamp_ms: Date.now(),
      payload: trigger
    });
    broadcast(signed_message);
  }
});

Attestation

Trigger Attestation

{
  "content": {
    "message_type": "trigger",
    "timestamp_ms": 1730458680000,
    "payload": {
      "workflow_name": "safe-settlement",
      "topic": "trigger.ethereum.finalized",
      "data": {
        "tx_hash": "0x9f2c4b7a3e5d1c8f6b4a9e2d7c5f8a1b3e6d9c2f",
        "finalized_at": 18500468
      }
    }
  },
  "signature": "0x9e2d5c8f1b4a7d0e3b6c9f2a5d8e1b4c7f0a3d6b9e2c5f8a1b4e7d0c3f6a9d2",
  "signer": "0x5f2a9d7b4e1c8f6a3b9e2d5c8a1f4b7e0d3c6f9b"
}

Verification

Validators verify transaction is in finalized block.

Verification Protocol

1. Check Topic

topic == "trigger.ethereum.finalized"

2. Verify Confirmations

current_block - tx.block_number >= 12

3. Verify Signature

verify(message.content.hash(), signature, signer)

Challenge & Fraud Proof

// Challenge if not deeply confirmed or signature invalid
fn verify_and_challenge(
    signed_message: SignedMessage
) -> Result<()> {
    let trigger = signed_message.content.payload;

    // Check topic first (cheap string comparison)
    if trigger.topic != "trigger.ethereum.finalized" {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidTopic,
        });
        return Err("Invalid topic");
    }

    // Verify transaction has 12+ confirmations
    let tx = eth_node.get_transaction(trigger.data.tx_hash)?;
    let current = eth_node.get_block_number()?;

    if current - tx.block_number < 12 {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: (tx, current),
        });
        return Err("Insufficient confirmations");
    }

    // Verify signature last (expensive crypto operation)
    if !verify_signature(
        signed_message.content.hash(),
        signed_message.signature,
        signed_message.signer
    ) {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidSignature,
        });
        return Err("Invalid signature");
    }

    Ok(())
}

Consensus

The network reaches agreement that the trigger is valid.

validator_1→✓ ATTESTED

validator_2→✓ ATTESTED

validator_3→✓ ATTESTED

validator_4→✓ ATTESTED

validator_5→○ OFFLINE

validator_6→✗ CHALLENGED→ SLASHED

✓ Quorum Reached

4/6 validators attested correctly

Threshold: ≥4 required (2/3 of 6)

→ Trigger accepted, workflow begins

✓Honest attestors (4): Proceed with workflow execution

○Offline (1): No response within timeout, no penalty

✗Challenged (1): Fraud proof submitted, challenger rewarded, attestor slashed

Configuration

Monitor Bitcoin transactions and wait for 6 confirmations (standard for finality). Triggers after ~1 hour when transaction is deeply confirmed.

Workflow Configuration

on:
  bitcoin:
    event: TransactionConfirmed
    confirmations: 6  # Standard for finality

Trigger

Bitcoin transaction receives 6+ confirmations.

Bitcoin Transaction Event

TransactionConfirmed(
  txid: a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2,
  blockHeight: 820456,
  confirmations: 6,
  value: 50000000  // 0.5 BTC in satoshis
)

txid:a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2Block Height:820,456Confirmations:6Timestamp:Nov-01-2025 14:22:18 UTC

Observation

Validators watch Bitcoin blocks and attest when confirmation threshold is reached.

Detection

Observation Code

// Monitor Bitcoin confirmations
btc.on("transaction_confirmed", (tx) => {
  if (tx.confirmations >= 6) {
    // Create trigger
    const trigger = {
      workflow_name: "btc-payment",
      topic: "trigger.bitcoin.confirmed",
      data: {
        txid: tx.txid,
        block_height: tx.blockHeight
      }
    };

    // Sign and broadcast
    const signed_message = sign_message({
      message_type: "trigger",
      timestamp_ms: Date.now(),
      payload: trigger
    });
    broadcast(signed_message);
  }
});

Attestation

Trigger Attestation

{
  "content": {
    "message_type": "trigger",
    "timestamp_ms": 1730473338000,
    "payload": {
      "workflow_name": "btc-payment",
      "topic": "trigger.bitcoin.confirmed",
      "data": {
        "txid": "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2",
        "block_height": 820456
      }
    }
  },
  "signature": "0x2f5a8b4d1c6e9f3a7b2d5c8e1b4a7d0e3c6f9b2a5d8e1c4b7f0d3a6c9f2b5e8",
  "signer": "0x6a9c2f5b8d1e4a7c0f3b6e9d2c5f8a1b4e7d0c3f"
}

Verification

Validators verify transaction depth in blockchain.

Verification Protocol

1. Check Topic

topic == "trigger.bitcoin.confirmed"

2. Verify Confirmations

current_height - tx.block_height >= 6

3. Verify Signature

verify(message.content.hash(), signature, signer)

Challenge & Fraud Proof

// Challenge if not confirmed or signature invalid
fn verify_and_challenge(
    signed_message: SignedMessage
) -> Result<()> {
    let trigger = signed_message.content.payload;

    // Check topic first (cheap string comparison)
    if trigger.topic != "trigger.bitcoin.confirmed" {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidTopic,
        });
        return Err("Invalid topic");
    }

    // Verify transaction has 6+ confirmations
    let tx = btc_node.get_transaction(trigger.data.txid)?;
    let current = btc_node.get_block_height()?;

    if current - tx.block_height < 6 {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: (tx, current),
        });
        return Err("Insufficient confirmations");
    }

    // Verify signature last (expensive crypto operation)
    if !verify_signature(
        signed_message.content.hash(),
        signed_message.signature,
        signed_message.signer
    ) {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidSignature,
        });
        return Err("Invalid signature");
    }

    Ok(())
}

Consensus

The network reaches agreement that the trigger is valid.

validator_1→✓ ATTESTED

validator_2→✓ ATTESTED

validator_3→✓ ATTESTED

validator_4→✓ ATTESTED

validator_5→○ OFFLINE

validator_6→✗ CHALLENGED→ SLASHED

✓ Quorum Reached

4/6 validators attested correctly

Threshold: ≥4 required (2/3 of 6)

→ Trigger accepted, workflow begins

✓Honest attestors (4): Proceed with workflow execution

○Offline (1): No response within timeout, no penalty

✗Challenged (1): Fraud proof submitted, challenger rewarded, attestor slashed

Configuration

Monitor new Bitcoin blocks being mined (approximately every 10 minutes). Useful for periodic tasks or tracking chain tip progression.

Workflow Configuration

on:
  bitcoin:
    event: BlockMined
    filters:
      min_block_height: 820000

Trigger

Bitcoin block is mined at specified height.

Bitcoin Block Mined Event

BlockMined(
  blockHash: 00000000000000000002a7c4c1e48d76c5a37902165a270156b7a8d72728a054,
  blockHeight: 820456,
  timestamp: 1730471538,
  difficulty: 92671576265849
)

Block Hash:00000000000000000002a7c4c1e48d76c5a37902165a270156b7a8d72728a054Block Height:820,456Timestamp:Nov-01-2025 14:18:58 UTC

Observation

Validators monitor Bitcoin blockchain and attest to new blocks.

Detection

Observation Code

// Subscribe to new Bitcoin blocks
btc.on("block_mined", (block) => {
  if (block.height >= MIN_BLOCK_HEIGHT) {
    // Create trigger
    const trigger = {
      workflow_name: "block-monitor",
      topic: "trigger.bitcoin.block",
      data: {
        block_hash: block.hash,
        block_height: block.height
      }
    };

    // Sign and broadcast
    const signed_message = sign_message({
      message_type: "trigger",
      timestamp_ms: Date.now(),
      payload: trigger
    });
    broadcast(signed_message);
  }
});

Attestation

Trigger Attestation

{
  "content": {
    "message_type": "trigger",
    "timestamp_ms": 1730471538000,
    "payload": {
      "workflow_name": "block-monitor",
      "topic": "trigger.bitcoin.block",
      "data": {
        "block_hash": "00000000000000000002a7c4c1e48d76c5a37902165a270156b7a8d72728a054",
        "block_height": 820456
      }
    }
  },
  "signature": "0x8e1f3a6c9d2b5f7e4a1c8d6b3f9e2a5c7d4b1e8f6a9c2f5b8d1e4a7c0f3b6e9",
  "signer": "0x4d1b6e8c5f2a9d7b4e1c8f6a3b9e2d5c8a1f4b7e"
}

Verification

Validators verify block exists at claimed height.

Verification Protocol

1. Check Topic

topic == "trigger.bitcoin.block"

2. Verify Block On Chain

btc.getBlockHeader(block_hash).height == block_height

3. Verify Signature

verify(message.content.hash(), signature, signer)

Challenge & Fraud Proof

// Challenge if block mismatch or signature invalid
fn verify_and_challenge(
    signed_message: SignedMessage
) -> Result<()> {
    let trigger = signed_message.content.payload;

    // Check topic first (cheap string comparison)
    if trigger.topic != "trigger.bitcoin.block" {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidTopic,
        });
        return Err("Invalid topic");
    }

    // Verify block exists at claimed height
    let block = btc_node
        .get_block_header(trigger.data.block_hash)?;

    if block.is_none() || block.height != trigger.data.block_height {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: block,
        });
        return Err("Block not found or height mismatch");
    }

    // Verify signature last (expensive crypto operation)
    if !verify_signature(
        signed_message.content.hash(),
        signed_message.signature,
        signed_message.signer
    ) {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidSignature,
        });
        return Err("Invalid signature");
    }

    Ok(())
}

Consensus

The network reaches agreement that the trigger is valid.

validator_1→✓ ATTESTED

validator_2→✓ ATTESTED

validator_3→✓ ATTESTED

validator_4→✓ ATTESTED

validator_5→○ OFFLINE

validator_6→✗ CHALLENGED→ SLASHED

✓ Quorum Reached

4/6 validators attested correctly

Threshold: ≥4 required (2/3 of 6)

→ Trigger accepted, workflow begins

✓Honest attestors (4): Proceed with workflow execution

○Offline (1): No response within timeout, no penalty

✗Challenged (1): Fraud proof submitted, challenger rewarded, attestor slashed

Configuration

Watch a specific Solana account for state changes. Triggers on any modification to the account data (~400ms slot times for high-frequency updates).

Workflow Configuration

on:
  solana:
    event: AccountChanged
    account: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"  # USDC on Solana

Trigger

Solana account data changes (balance, owner, or data).

Solana Account Change Event

AccountChanged(
  account: EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v,
  slot: 245678901,
  lamports: 5000000000,
  data: [...],  // Account data changed
  owner: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
)

Account:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1vSlot:245,678,901Timestamp:Nov-01-2025 16:45:12 UTC

Observation

Validators subscribe to account updates and attest to changes.

Detection

Observation Code

// Subscribe to Solana account changes
solana.on("account_change", {
  account: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
}, (update) => {
  // Create trigger
  const trigger = {
    workflow_name: "usdc-solana-monitor",
    topic: "trigger.solana.account",
    data: {
      account: update.pubkey,
      slot: update.slot
    }
  };

  // Sign and broadcast
  const signed_message = sign_message({
    message_type: "trigger",
    timestamp_ms: Date.now(),
    payload: trigger
  });
  broadcast(signed_message);
});

Attestation

Trigger Attestation

{
  "content": {
    "message_type": "trigger",
    "timestamp_ms": 1730480712000,
    "payload": {
      "workflow_name": "usdc-solana-monitor",
      "topic": "trigger.solana.account",
      "data": {
        "account": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
        "slot": 245678901
      }
    }
  },
  "signature": "0x1a4c7f0d3b6e9a2c5f8b1d4e7a0c3f6b9d2e5a8c1f4b7e0d3a6c9f2b5e8a1d4",
  "signer": "0x7b4e1c8f6a3b9e2d5c8a1f4b7e0d3c6f9b2a5d8e"
}

Verification

Validators verify account state onchain.

Verification Protocol

1. Check Topic

topic == "trigger.solana.account"

2. Verify Account At Slot

solana.getAccountInfo(account, slot) != null

3. Verify Signature

verify(message.content.hash(), signature, signer)

Challenge & Fraud Proof

// Challenge if account state mismatch or signature invalid
fn verify_and_challenge(
    signed_message: SignedMessage
) -> Result<()> {
    let trigger = signed_message.content.payload;

    // Check topic first (cheap string comparison)
    if trigger.topic != "trigger.solana.account" {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidTopic,
        });
        return Err("Invalid topic");
    }

    // Verify account exists at claimed slot
    let account = solana_node
        .get_account_info(trigger.data.account, trigger.data.slot)?;

    if account.is_none() {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: None,
        });
        return Err("Account not found at slot");
    }

    // Verify signature last (expensive crypto operation)
    if !verify_signature(
        signed_message.content.hash(),
        signed_message.signature,
        signed_message.signer
    ) {
        submit_fraud_proof(FraudProof {
            attester: signed_message.signer,
            claim: signed_message.clone(),
            proof: InvalidSignature,
        });
        return Err("Invalid signature");
    }

    Ok(())
}

Consensus

The network reaches agreement that the trigger is valid.

validator_1→✓ ATTESTED

validator_2→✓ ATTESTED

validator_3→✓ ATTESTED

validator_4→✓ ATTESTED

validator_5→○ OFFLINE

validator_6→✗ CHALLENGED→ SLASHED

✓ Quorum Reached

4/6 validators attested correctly

Threshold: ≥4 required (2/3 of 6)

→ Trigger accepted, workflow begins

✓Honest attestors (4): Proceed with workflow execution

○Offline (1): No response within timeout, no penalty

✗Challenged (1): Fraud proof submitted, challenger rewarded, attestor slashed

Smart Workflows

Smart Actions