Cross-chain settlement saga

# recipe: full
rflow_version: 1
name: cross-chain-settlement-saga
 
config:
  port: 3949
  db_connection: ${DATABASE_URL}
  max_concurrent_runs: 64
 
networks:
  # source: users lock funds in the escrow here
  - name: ethereum
    chain_id: 1
    rpc: ${ETH_RPC}
    confirmations: 12
  # destination: we settle to the recipient here
  - name: base
    chain_id: 8453
    rpc: ${BASE_RPC}
    confirmations: 6
 
# DEV ONLY raw mnemonic (from .env) - `rflow new` generates a fresh dev seed.
# Swap in a production signer before real funds ride on this config.
signer:
  raw:
    mnemonic: ${RAW_DANGEROUS_MNEMONIC}
 
relayers:
  # the settler wallet - pays recipients on the destination chain
  settler:
    networks: [base]
    speed: FAST
 
contracts:
  # the SOURCE-chain escrow: emits OrderOpened when a user locks funds and
  # OrderSettled when it releases our repayment after the settlement is proven
  Escrow:
    abi: ./abis/settlement.json
    addresses:
      ethereum: "0x1111111111111111111111111111111111111111"
 
budgets:
  # blast-radius cap on the destination payouts: at most 20 ETH/hour of
  # settlements no matter how many orders open
  settlement-hourly:
    window: 1h
    max_native_value: "20 ether"
    scope:
      relayers: [settler]
      networks: [base]
 
workflows:
  cross-chain-settlement:
    trigger:
      # a reorged open must never trigger a payout: fire only 12 blocks deep
      event:
        contract: Escrow
        name: OrderOpened
        network: ethereum
        confirmations: 12
        run_on: confirmed
        where: "${{ trigger.args.amount > wei('0', 18) }}"
    # one run per order id - concurrent opens of the same order are skipped
    concurrency:
      group: "settle-${{ trigger.args.orderId }}"
      on_conflict: skip
    budgets: [settlement-hourly]
    steps:
      # the money step, on the DESTINATION chain: pay the recipient natively.
      # Pre-flight simulated, gas-capped, dropped if the order's fill deadline
      # passed while we got here, then held until confirmed.
      - id: settle
        send_transaction:
          network: base
          relayer: settler
          to: "${{ trigger.args.recipient }}"
          value: "${{ trigger.args.amount }}"
          assert_sim:
            - "${{ sim.ok }}"
          gas:
            limit_from_simulation: true
            multiplier: 1.2
            max_price: "50 gwei"
          recheck: "${{ now() < trigger.args.fillDeadline }}"
          wait_for: confirmed
      # the async cross-chain leg: park - durably, for free - until the source
      # escrow releases our repayment, or 30m elapse and we compensate. Inside
      # the wait, trigger.* is the AWAITED OrderSettled event (see notes: pin a
      # concrete orderId literal when known, or cross-reference via state:).
      - id: release_wait
        wait_for:
          any:
            - event:
                contract: Escrow
                network: ethereum
                name: OrderSettled
                where: "${{ trigger.args.amount > wei('0', 18) }}"
                confirmations: 12
            - timeout: 30m
          on_timeout: { goto: { step: compensate } }
      - id: settled
        if: "${{ steps.release_wait.output.timed_out is not defined }}"
        notify:
          channel: ops
          message: "settled order ${{ trigger.args.orderId }} to ${{ trigger.args.recipient }} on base; source escrow released"
      # compensation: we paid on base but the source did not release in 30m.
      # Page a human - never auto-double-settle.
      - id: compensate
        if: "${{ steps.release_wait.output.timed_out is defined }}"
        notify:
          channel: ops
          message: "COMPENSATE order ${{ trigger.args.orderId }}: paid ${{ format_units(trigger.args.amount, 18) }} on base but source escrow did NOT release within 30m - investigate before any re-settle"
    on_failure: dead_letter
 
notifications:
  channels:
    ops:
      telegram:
        bot_token: ${TG_BOT_TOKEN}
        chat_id: ${TG_CHAT_ID}