Parse Onchain Fills

Equity direct fills and escrow fills execute through the DFlow orchestrator program: DF1ow4tspfHX9JwWJsAb9epbkA8hmpSEAtxXy1V27QBH.

Event Format

The program emits events with Anchor’s emit_cpi!: it invokes itself, and the event is the data of that inner instruction. Events do not appear in the transaction logs. To find events, read meta.innerInstructions[*].instructions[*] and keep the instructions whose program is the orchestrator and whose data starts with the event tag. The program signs the inner instruction with its event authority PDA, derived from the seed "__event_authority". Each event’s data has this layout:

Byte(s)	Field	Value
0-7	Anchor event instruction tag	`[228, 69, 165, 46, 81, 203, 154, 29]`
8-15	Event discriminator	See Event Discriminators
16+	Event fields	Borsh-encoded, little-endian

Read fill data from these events, not from the instructions that produced them.

Event Discriminators

Event	Discriminator
`RfqOrderEvent`	`[66, 127, 128, 23, 148, 246, 251, 41]`
`SwapEvent`	`[64, 198, 205, 232, 38, 8, 113, 226]`
`FeeEvent`	`[73, 79, 78, 127, 184, 213, 13, 220]`
`FeeWithdrawalEvent`	`[16, 65, 174, 145, 108, 22, 33, 184]`

Order Event Types

Each transition of an escrow fill (order) emits exactly one RfqOrderEvent. Its event_type field records the transition:

Value	Type	When It Is Emitted
`1`	Open	The transaction the user signed opens the order.
`2`	Fill	A later transaction fills the order and closes it.
`3`	Cancel	The account in the `maker` field closes the order at or before its last fillable slot.
`4`	Expire	Any account closes the order after its last fillable slot.

Every order has one Open event and, once a transaction closes it, one terminal event: Fill, Cancel, or Expire.

Order Event Byte Layout

RfqOrderEvent fields, with offsets after the 16-byte prefix. Add 16 for the offset in the instruction data.

Offset	Field	Type	Open	Fill	Cancel, Expire
0	`event_type`	u8	`1`	`2`	`3` or `4`
1	`builder_code`	u16	Set	Set	Set
3	`order`	Pubkey	Set	Set	Set
35	`maker`	Pubkey	Set	Set	Set
67	`refund_wallet`	Pubkey	Set	Set	Set
99	`destination_wallet`	Pubkey	Set	Set	Set
131	`input_mint`	Pubkey	Set	Set	Set
163	`input_amount`	u64	Escrowed	Filled	`0`
171	`output_mint`	Pubkey	Set	Set	Set
203	`output_amount`	u64	Required for a full fill	Delivered	`0`
211	`fee_mint`	Pubkey	Fee mint, or default	Fee mint, or default	Default pubkey
243	`fee_amount`	u64	`0`	Charged, or `0` if skipped	`0`
251	`refund_amount`	u64	`0`	Input returned	Input returned

The event fields are 259 bytes, so the full instruction data is 275 bytes.

Detecting Escrow Fill Outcomes

Parse the Open event from the transaction the user signed. Read the order field, the onchain address of the order.
Watch later transactions for an RfqOrderEvent with the same order and event_type = 2 (Fill).
Handle the other terminal types: event_type = 3 (Cancel) or 4 (Expire) means the order did not fill.

Fill, Cancel, and Expire transactions include the order’s refund_wallet, so the app can subscribe to transactions that mention it to detect closes.

Escrow Fill Volume Calculation

In Fill events, use:

input_mint / input_amount
output_mint / output_amount

For an escrow fill, one of the two mints is USDC. When USDC is the input, input_amount includes the fee, which refund_amount returns if the fee was skipped; when USDC is the output, output_amount is net of the fee. A Fill transaction also emits a SwapEvent for the same amounts, with amm set to the orchestrator program id. Count either the RfqOrderEvent or the SwapEvent for an escrow fill, not both.

Escrow Fill Fee Calculation

Fill events carry:

fee_mint
fee_amount

fee_amount is the platform fee charged on the fill. The same transaction emits a FeeEvent when a fee was paid; its amount is the amount that reached the fee account. Sum fee_amount for fees charged. For fees received, sum FeeEvent.amount over the events whose account is the app’s fee account.

Direct Fill Events

A fill (executionMode: sync) does not emit RfqOrderEvent. Its transaction emits a SwapEvent for each leg of the route, with amm set to the orchestrator program id for the equity leg, and a FeeEvent for each transfer to the fee account: the platform fee and any positive-slippage capture. See Relevant IDL Fields for both layouts.

Relevant IDL Fields

SwapEvent fields, with offsets after the 16-byte prefix:

Offset	Field	Type
0	`amm`	Pubkey
32	`input_mint`	Pubkey
64	`input_amount`	u64
72	`output_mint`	Pubkey
104	`output_amount`	u64

FeeEvent fields, with offsets after the 16-byte prefix:

Offset	Field	Type
0	`account`	Pubkey
32	`mint`	Pubkey
64	`amount`	u64

RfqOrderEvent field meanings:

Field	Description
`builder_code`	The order’s builder code, as recorded at open
`order`	Onchain address of the order; links all of its events
`maker`	Account recorded on the order as its filler
`refund_wallet`	The request’s `revertWallet` if set, otherwise the user; returned input goes to its token account for `input_mint`
`destination_wallet`	Wallet that receives the fill’s output
`input_mint`	Mint of the order’s input
`output_mint`	Mint of the order’s output
`fee_mint`	Mint of the platform fee; the default pubkey when the order has no fee

Decode the Events

This example fetches a transaction with jsonParsed encoding, which lists each inner instruction’s programId, and decodes its RfqOrderEvent and FeeEvent entries.

import "dotenv/config";

import { PublicKey } from "@solana/web3.js";
import bs58 from "bs58";

const SOLANA_RPC_URL = process.env.SOLANA_RPC_URL ?? "https://api.mainnet-beta.solana.com";

const ORCHESTRATOR_PROGRAM_ID = "DF1ow4tspfHX9JwWJsAb9epbkA8hmpSEAtxXy1V27QBH";
const EVENT_IX_TAG = Buffer.from([228, 69, 165, 46, 81, 203, 154, 29]);
const RFQ_ORDER_EVENT = Buffer.from([66, 127, 128, 23, 148, 246, 251, 41]);
const FEE_EVENT = Buffer.from([73, 79, 78, 127, 184, 213, 13, 220]);
const EVENT_TYPES: Record<number, string> = { 1: "Open", 2: "Fill", 3: "Cancel", 4: "Expire" };

async function getTransaction(signature: string) {
  const response = await fetch(SOLANA_RPC_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: 1,
      method: "getTransaction",
      params: [
        signature,
        { encoding: "jsonParsed", commitment: "confirmed", maxSupportedTransactionVersion: 1 },
      ],
    }),
  });
  const { result, error } = await response.json();
  if (error) throw new Error(`getTransaction failed: ${error.message}`);
  if (!result) throw new Error(`Transaction ${signature} not found`);
  return result;
}

type RawEvent = { discriminator: Buffer; fields: Buffer };

function collectEvents(tx: any): RawEvent[] {
  const events: RawEvent[] = [];
  for (const group of tx.meta?.innerInstructions ?? []) {
    for (const ix of group.instructions) {
      if (ix.programId !== ORCHESTRATOR_PROGRAM_ID || !ix.data) continue;
      const data = Buffer.from(bs58.decode(ix.data));
      if (data.length < 16 || !data.subarray(0, 8).equals(EVENT_IX_TAG)) continue;
      events.push({ discriminator: data.subarray(8, 16), fields: data.subarray(16) });
    }
  }
  return events;
}

const pubkeyAt = (buf: Buffer, offset: number) =>
  new PublicKey(buf.subarray(offset, offset + 32)).toBase58();

function decodeRfqOrderEvent(fields: Buffer) {
  return {
    eventType: EVENT_TYPES[fields.readUInt8(0)] ?? `Unknown(${fields.readUInt8(0)})`,
    builderCode: fields.readUInt16LE(1),
    order: pubkeyAt(fields, 3),
    refundWallet: pubkeyAt(fields, 67),
    destinationWallet: pubkeyAt(fields, 99),
    inputMint: pubkeyAt(fields, 131),
    inputAmount: fields.readBigUInt64LE(163),
    outputMint: pubkeyAt(fields, 171),
    outputAmount: fields.readBigUInt64LE(203),
    feeMint: pubkeyAt(fields, 211),
    feeAmount: fields.readBigUInt64LE(243),
    refundAmount: fields.readBigUInt64LE(251),
  };
}

function decodeFeeEvent(fields: Buffer) {
  return {
    account: pubkeyAt(fields, 0),
    mint: pubkeyAt(fields, 32),
    amount: fields.readBigUInt64LE(64),
  };
}

const signature = "TRANSACTION_SIGNATURE";
if (signature === "TRANSACTION_SIGNATURE") {
  throw new Error("Replace TRANSACTION_SIGNATURE with an equity transaction signature.");
}

for (const { discriminator, fields } of collectEvents(await getTransaction(signature))) {
  if (discriminator.equals(RFQ_ORDER_EVENT)) console.log(decodeRfqOrderEvent(fields));
  if (discriminator.equals(FEE_EVENT)) console.log(decodeFeeEvent(fields));
}

Equities

Recipes

Concepts

Parse Onchain Fills

Event Format

Event Discriminators

Order Event Types

Order Event Byte Layout

Detecting Escrow Fill Outcomes

Escrow Fill Volume Calculation

Escrow Fill Fee Calculation

Direct Fill Events

Relevant IDL Fields

Decode the Events

​Event Format

​Event Discriminators

​Order Event Types

​Order Event Byte Layout

​Detecting Escrow Fill Outcomes

​Escrow Fill Volume Calculation

​Escrow Fill Fee Calculation

​Direct Fill Events

​Relevant IDL Fields

​Decode the Events

Event Format

Event Discriminators

Order Event Types

Order Event Byte Layout

Detecting Escrow Fill Outcomes

Escrow Fill Volume Calculation

Escrow Fill Fee Calculation

Direct Fill Events

Relevant IDL Fields

Decode the Events