ErgoScript Acceptance Predicates: The Missing Primitive for Agent Payments

{
  // Acceptance predicate: task hash verification
  //
  // R5: expiry block height (SInt)
  // R6: expected task output hash (SColl[SByte], 32 bytes)
  //
  // To redeem: provide task output as context variable 0
  // Miners verify: blake2b256(output) == R6

  val expiry       = R5[Int].get
  val expectedHash = R6[Coll[Byte]].get

  val taskOutput   = getVar[Coll[Byte]](0).get   // provided at redemption
  val actualHash   = blake2b256(taskOutput)

  sigmaProp(
    HEIGHT < expiry       &&   // not expired
    actualHash == expectedHash  // task completed correctly
  )
}

import { OutputBuilder, SInt, SColl, SByte } from "@fleet-sdk/core";
import crypto from "crypto";

const EXPECTED_OUTPUT = "task result: the answer is 42";
const taskHash = crypto.createHash("sha256")
  .update(EXPECTED_OUTPUT).digest(); // use blake2b256 in production

// Create Note with acceptance predicate encoded in registers
const noteOutput = new OutputBuilder("5000000", receiverAddress)
  .setAdditionalRegisters({
    R5: SInt(currentHeight + 100),                  // expiry: 100 blocks
    R6: SColl(SByte, taskHash),                     // expected hash
  });
// The spending script must be set to the acceptance_predicate.ergo above

{
  // Acceptance predicate: task hash + authorized redeemer
  //
  // R5: expiry height
  // R6: task hash
  // R7: authorized redeemer public key (GroupElement)

  val expiry       = R5[Int].get
  val expectedHash = R6[Coll[Byte]].get
  val authorizedPK = R7[GroupElement].get    // specific agent's public key

  val taskOutput   = getVar[Coll[Byte]](0).get
  val actualHash   = blake2b256(taskOutput)

  // Both conditions must hold:
  // 1. Task was completed correctly
  // 2. Redeemer is the authorized agent (ZK proof, no key revealed)
  sigmaProp(
    HEIGHT < expiry             &&
    actualHash == expectedHash  &&
    proveDlog(authorizedPK)         // agent proves key ownership without revealing it
  )
}

// Orchestrator issues budget to sub-agents via Notes
// Each Note has a different acceptance predicate (different task hash)

const tasks = [
  { agent: agentA_address, task: "fetch weather data",   fee: "1000000" },
  { agent: agentB_address, task: "run sentiment model",  fee: "2000000" },
  { agent: agentC_address, task: "write summary report", fee: "3000000" },
];

const outputs = tasks.map(({ agent, task, fee }) => {
  const expectedHash = computeExpectedHash(task); // known output hash

  return new OutputBuilder(fee, agent)
    .setAdditionalRegisters({
      R5: SInt(currentHeight + 200),         // same deadline for all
      R6: SColl(SByte, expectedHash),        // task-specific acceptance
    });
});

// One transaction issues all three Notes
const tx = new TransactionBuilder(currentHeight)
  .from(orchestratorInputs)
  .to(outputs)
  .sendChangeTo(orchestratorAddress)
  .payMinFee()
  .build();

// Sub-agents redeem independently — no round-trip to orchestrator needed