Oracle Systems

1. A submission interface where solvers can submit their filled outputs. The submission interface should accept arbitrary packages for validation and then call the associated output settlement contract to check whether the payloads are valid. If submission is automatic by being capable of proving contract calls, events, or storage this requirement can be ignored. Oracle implementations can validate whether an output has been filled through the IAttester interface:
   Copy

   Ask AI

   interface IAttester {
     function hasAttested(
         bytes[] calldata payloads
     ) external view returns (bool);
   }
   

2. Implement the validation interfaces so attested (or filled) outputs can verify whether outputs have been filled:
   Copy

   Ask AI

     interface IInputOracle {
         function efficientRequireProven(
           bytes calldata proofSeries
       ) external view;
     }
   

• Submission or receive interfaces do not have to be standardized; they need to be documented so solvers can implement it.
• Oracle systems can either have automatic relaying or manual relaying.
• Trust assumptions for the oracle system needs to be explicit, so intent issuers and solvers can make informed decisions.

​

Implemented Validation Interfaces

1. Self-serve: Validation interfaces where submitting the payload generates an off-chain proof that must be collected and submitted on the input chain.
   • Polymer
   • Wormhole
2. Automatic: Validation interfaces where submitting the payload automatically delivers the associated proof on the input chain.
   • Hyperlane
   • Chainlink CCIP
   • Axelar
   • LayerZero

​

Polymer

• Low gas cost.
• Low latency for quick settlement.
• Polymer can only prove one output at a time requiring batch proving to be implemented on the solver side to optimise efficiency.
• Broadcast

event OutputFilled(
  bytes32 indexed orderId,
  bytes32 solver,
  uint32 timestamp,
  MandateOutput output,
  uint256 finalAmount
);

​

Wormhole

• Security through a decentralized guardian set.
• Supports batch proving of multiple outputs in a single VAA.
• Comparatively slow compared to alternatives.
• Broadcast

function submit(
  address source,
  bytes[] calldata payloads
) public payable returns (uint256 refund);

​

Hyperlane

• Highly customizable security modules.
• Supports batch proving of multiple outputs in a single message.
• Strong censorship guarantees.
• Automatic or manual relaying.

function submit(
  uint32 destinationDomain,
  address recipientOracle,
  uint256 gasLimit,
  bytes calldata customMetadata,
  address source,
  bytes[] calldata payloads
) public payable

​

Chainlink CCIP

• Security through Chainlink’s oracle network.
• Supports batch proving of multiple outputs in a single message.
• Comparatively slow and expensive compared to alternatives.

function submit(
  uint64 destinationChainSelector,
  bytes32 receiver,
  bytes calldata extraArgs,
  address source,
  bytes[] calldata payloads,
  address feeToken
)

​

Axelar

• Security through Axelar’s Proof of State network.
• Supports batch proving of multiple outputs in a single message.
• Automatic relaying.

submit(
  string calldata destinationChain,
  string calldata destinationAddress,
  address source,
  bytes[] calldata payloads
) public payable

​

LayerZero

• Customizable security
• Popular and broad chain compatibility.
• Supports batch proving of multiple outputs in a single message.
• Expensive

function submit(
  uint32 dstEid,
  address recipientOracle,
  address source,
  bytes[] calldata payloads,
  bytes calldata options
) external payable;

​

Bitcoin

import mempoolJS from "@catalabs/mempool.js";
const mainnet: boolean;
const {
  bitcoin: { transactions, blocks },
} = mempoolJS({
  hostname: "mempool.space",
  network: mainnet ? undefined : "testnet4",
});

export async function generateProof(
  txid: string,
): Promise<{ blockHeader: string; proof: Proof; rawTx: string }> {
  const tx = await transactions.getTx({ txid });

  const merkleProof = await transactions.getTxMerkleProof({ txid });
  // TODO: serialization version 1.
  const rawTx = await transactions.getTxHex({ txid });

  const blockHash = await blocks.getBlockHeight({
    height: merkleProof.block_height,
  });

  // Most endpoints provide transactions witness encoded.
  // The following function serves to strip the witness data.
  const rawTxWitnessStripped = removeWitnesses(rawTx);

  const blockHeader = await blocks.getBlockHeader({ hash: blockHash });

  return {
    blockHeader,
    proof: {
      txId: txid,
      txIndex: merkleProof.pos,
      siblings: merkleProof.merkle.reduce(
        (accumulator, currentValue) => accumulator + currentValue,
      ),
    },
    rawTx: rawTxWitnessStripped,
  };
}