optimisticOracleV2.ts

import {
  DisputePrice,
  ManagedOracleV2,
  ProposePrice,
  RequestPrice,
  SetBondCall,
  SetCustomLivenessCall,
  SetEventBasedCall,
  Settle,
} from "../../generated/ManagedOracleV2/ManagedOracleV2";
import { ManagedOracleV2Legacy } from "../../generated/ManagedOracleV2/ManagedOracleV2Legacy";
import { createOptimisticPriceRequestId, getManagedRequestId, getOrCreateOptimisticPriceRequest } from "../utils/helpers";
import { CustomBond, CustomLiveness } from "../../generated/schema";

import { Address, BigInt, Bytes, dataSource, log } from "@graphprotocol/graph-ts";
import { createCustomBondId } from "../utils/helpers/managedOracleV2";

/**
 * Retrieves a custom bond entity if one exists for the given parameters.
 *
 * IMPORTANT: Custom bonds are stored with a unique ID that includes the currency.
 * This means we can only find custom bonds that match the EXACT currency used in the request.
 * If a custom bond was set for a different currency, it will NOT be found here.
 *
 * This ensures that custom bonds are only applied when the currency matches,
 * preventing incorrect bond amounts from being applied to requests with different currencies.
 */
function getCustomBond(
  requester: Address,
  identifier: Bytes,
  ancillaryData: Bytes,
  currency: Bytes
): CustomBond | null {
  const id = createCustomBondId(requester, identifier, ancillaryData, currency);
  let customBondEntity = CustomBond.load(id);
  return customBondEntity ? customBondEntity : null;
}

function getCustomLiveness(requester: Address, identifier: Bytes, ancillaryData: Bytes): CustomLiveness | null {
  const managedRequestId = getManagedRequestId(requester, identifier, ancillaryData).toHexString();
  let customLivenessEntity = CustomLiveness.load(managedRequestId);
  return customLivenessEntity ? customLivenessEntity : null;
}

function getState(
  ooAddress: Address,
  requester: Address,
  identifier: Bytes,
  timestamp: BigInt,
  ancillaryData: Bytes
): string {
  const states = [
    "Invalid", // Never requested.
    "Requested", // Requested, no other actions taken.
    "Proposed", // Proposed, but not expired or disputed yet.
    "Expired", // Proposed, not disputed, past liveness.
    "Disputed", // Disputed, but no DVM price returned yet.
    "Resolved", // Disputed and DVM price is available.
    "Settled", // Final price has been set in the contract (can get here from Expired or Resolved).
  ];
  let oov2 = ManagedOracleV2.bind(ooAddress);
  let state = oov2.try_getState(requester, identifier, timestamp, ancillaryData);
  if (state.reverted) {
    log.warning("getState call reverted, returning Invalid state", []);
    return states[0]; // Return "Invalid" if the call fails
  }
  return states[state.value];
}

// - event: RequestPrice(indexed address,bytes32,uint256,bytes,address,uint256,uint256)
//   handler: handleOptimisticRequestPrice
// - event RequestPrice(
//     address indexed requester,
//     bytes32 identifier,
//     uint256 timestamp,
//     bytes ancillaryData,
//     address currency,
//     uint256 reward,
//     uint256 finalFee
//   );

export function handleOptimisticRequestPrice(event: RequestPrice): void {
  let network = dataSource.network();
  let isMainnet = network == "mainnet";
  let isGoerli = network == "goerli";

  log.warning(`(ancillary) OOV2 PriceRequest params: {},{},{}`, [
    event.params.timestamp.toString(),
    event.params.identifier.toString(),
    event.params.ancillaryData.toHex(),
  ]);
  let requestId = createOptimisticPriceRequestId(
    event.params.identifier,
    event.params.timestamp,
    event.params.ancillaryData
  );

  let request = getOrCreateOptimisticPriceRequest(requestId);

  request.identifier = event.params.identifier.toString();
  request.time = event.params.timestamp;
  request.ancillaryData = event.params.ancillaryData.toHex();
  request.requester = event.params.requester;
  request.currency = event.params.currency;
  request.reward = event.params.reward;
  request.finalFee = event.params.finalFee;
  request.requestTimestamp = event.block.timestamp;
  request.requestBlockNumber = event.block.number;
  request.requestLogIndex = event.logIndex;
  request.requestHash = event.transaction.hash;

  request.state = getState(
    event.address,
    event.params.requester,
    event.params.identifier,
    event.params.timestamp,
    event.params.ancillaryData
  );

  // workaround for L2 chains that don't support `callHandlers`
  // see readme for more info
  if (!isMainnet && !isGoerli) {
    let oov2 = ManagedOracleV2.bind(event.address);
    let result = oov2.try_getRequest(
      event.params.requester,
      event.params.identifier,
      event.params.timestamp,
      event.params.ancillaryData
    );

    if (!result.reverted) {
      // New ABI succeeded
      let requestSettings = result.value.requestSettings;
      request.bond = requestSettings.bond;
      request.eventBased = requestSettings.eventBased;
      request.customLiveness = requestSettings.customLiveness;
    } else {
      // Try legacy ABI (for contracts not yet upgraded)
      let oov2Legacy = ManagedOracleV2Legacy.bind(event.address);
      let legacyResult = oov2Legacy.try_getRequest(
        event.params.requester,
        event.params.identifier,
        event.params.timestamp,
        event.params.ancillaryData
      );

      if (!legacyResult.reverted) {
        let requestSettings = legacyResult.value.requestSettings;
        request.bond = requestSettings.bond;
        request.eventBased = requestSettings.eventBased;
        request.customLiveness = requestSettings.customLiveness;
      } else {
        log.warning("Both new and legacy getRequest calls failed for request {}", [requestId]);
      }
    }
  }

  // Look up custom bond and liveness values that may have been set before the request
  // Custom bonds are stored with a unique ID that includes the currency, so we only find
  // custom bonds that match the exact currency used in this request
  let customBond = getCustomBond(
    event.params.requester,
    event.params.identifier,
    event.params.ancillaryData,
    event.params.currency
  );
  if (customBond !== null) {
    const bond = customBond.customBond;
    const currency = customBond.currency;
    log.debug("custom bond of {} of currency {} was set for request Id: {}", [
      bond.toString(),
      currency.toHexString(),
      requestId,
    ]);
    // Apply the custom bond amount - the currency is guaranteed to match since
    // the custom bond ID includes the currency and we looked it up using the request's currency
    request.bond = bond;
  }

  let customLiveness = getCustomLiveness(event.params.requester, event.params.identifier, event.params.ancillaryData);
  if (customLiveness !== null) {
    const liveness = customLiveness.customLiveness;
    log.debug("custom liveness of {} was set for request Id: {}", [liveness.toString(), requestId]);
    request.customLiveness = customLiveness.customLiveness;
  }

  request.save();
}

// - event: ProposePrice(indexed address,indexed address,bytes32,uint256,bytes,int256,uint256,address)
//   handler: handleOptimisticProposePrice
// - event ProposePrice(
//     address indexed requester,
//     address indexed proposer,
//     bytes32 identifier,
//     uint256 timestamp,
//     bytes ancillaryData,
//     int256 proposedPrice,
//     uint256 expirationTimestamp,
//     address currency
// );

export function handleOptimisticProposePrice(event: ProposePrice): void {
  log.warning(`(ancillary) OOV2 PriceProposed params: {},{},{}`, [
    event.params.timestamp.toString(),
    event.params.identifier.toString(),
    event.params.ancillaryData.toHex(),
  ]);
  let requestId = createOptimisticPriceRequestId(
    event.params.identifier,
    event.params.timestamp,
    event.params.ancillaryData
  );

  let request = getOrCreateOptimisticPriceRequest(requestId);

  request.proposer = event.params.proposer;
  request.proposedPrice = event.params.proposedPrice;
  request.proposalExpirationTimestamp = event.params.expirationTimestamp;

  request.proposalTimestamp = event.block.timestamp;
  request.proposalBlockNumber = event.block.number;
  request.proposalLogIndex = event.logIndex;
  request.proposalHash = event.transaction.hash;

  request.state = getState(
    event.address,
    event.params.requester,
    event.params.identifier,
    event.params.timestamp,
    event.params.ancillaryData
  );

  // Look up custom bond and liveness values that may have been set before the request
  // Custom bonds are stored with a unique ID that includes the currency, so we only find
  // custom bonds that match the exact currency used in this request
  let customBond = getCustomBond(
    event.params.requester,
    event.params.identifier,
    event.params.ancillaryData,
    event.params.currency
  );
  if (customBond !== null) {
    const bond = customBond.customBond;
    const currency = customBond.currency;
    log.debug("custom bond of {} of currency {} was set for request Id: {}", [
      bond.toString(),
      currency.toHexString(),
      requestId,
    ]);
    // Apply the custom bond amount - the currency is guaranteed to match since
    // the custom bond ID includes the currency and we looked it up using the request's currency
    request.bond = bond;
  }

  let customLiveness = getCustomLiveness(event.params.requester, event.params.identifier, event.params.ancillaryData);
  if (customLiveness !== null) {
    const liveness = customLiveness.customLiveness;
    log.debug("custom liveness of {} was set for request Id: {}", [liveness.toString(), requestId]);
    request.customLiveness = customLiveness.customLiveness;
  }

  request.save();
}

// - event: DisputePrice(indexed address,indexed address,indexed address,bytes32,uint256,bytes,int256)
//   handler: handleOptimisticDisputePrice
// - event DisputePrice(
//     address indexed requester,
//     address indexed proposer,
//     address indexed disputer,
//     bytes32 identifier,
//     uint256 timestamp,
//     bytes ancillaryData,
//     int256 proposedPrice
//   );

export function handleOptimisticDisputePrice(event: DisputePrice): void {
  log.warning(`(ancillary) OOV2 PriceDisputed params: {},{},{}`, [
    event.params.timestamp.toString(),
    event.params.identifier.toString(),
    event.params.ancillaryData.toHex(),
  ]);
  let requestId = createOptimisticPriceRequestId(
    event.params.identifier,
    event.params.timestamp,
    event.params.ancillaryData
  );

  let request = getOrCreateOptimisticPriceRequest(requestId);

  request.disputer = event.params.disputer;

  request.disputeTimestamp = event.block.timestamp;
  request.disputeBlockNumber = event.block.number;
  request.disputeLogIndex = event.logIndex;
  request.disputeHash = event.transaction.hash;

  request.state = getState(
    event.address,
    event.params.requester,
    event.params.identifier,
    event.params.timestamp,
    event.params.ancillaryData
  );

  request.save();
}

// - event: Settle(indexed address,indexed address,indexed address,bytes32,uint256,bytes,int256,uint256)
//   handler: handleOptimisticSettle
//  - event Settle(
//     address indexed requester,
//     address indexed proposer,
//     address indexed disputer,
//     bytes32 identifier,
//     uint256 timestamp,
//     bytes ancillaryData,
//     int256 price,
//     uint256 payout
// );

export function handleOptimisticSettle(event: Settle): void {
  log.warning(`(ancillary) OOV2 Settled params: {},{},{}`, [
    event.params.timestamp.toString(),
    event.params.identifier.toString(),
    event.params.ancillaryData.toHex(),
  ]);
  let requestId = createOptimisticPriceRequestId(
    event.params.identifier,
    event.params.timestamp,
    event.params.ancillaryData
  );

  let request = getOrCreateOptimisticPriceRequest(requestId);

  request.settlementPrice = event.params.price;
  request.settlementPayout = event.params.payout;

  if (!request.disputer || request.proposedPrice!.equals(event.params.price)) {
    request.settlementRecipient = request.proposer;
  } else {
    request.settlementRecipient = request.disputer;
  }

  request.settlementTimestamp = event.block.timestamp;
  request.settlementBlockNumber = event.block.number;
  request.settlementLogIndex = event.logIndex;
  request.settlementHash = event.transaction.hash;

  request.state = getState(
    event.address,
    event.params.requester,
    event.params.identifier,
    event.params.timestamp,
    event.params.ancillaryData
  );

  request.save();
}

export function handleSetCustomLiveness(call: SetCustomLivenessCall): void {
  log.warning(`OOV2 set custom liveness inputs: {},{},{},{}`, [
    call.inputs.timestamp.toString(),
    call.inputs.identifier.toString(),
    call.inputs.ancillaryData.toHex(),
    call.inputs.customLiveness.toString(),
  ]);
  let requestId = createOptimisticPriceRequestId(
    call.inputs.identifier,
    call.inputs.timestamp,
    call.inputs.ancillaryData
  );

  let request = getOrCreateOptimisticPriceRequest(requestId);
  request.customLiveness = call.inputs.customLiveness;

  request.save();
}

export function handleSetBond(call: SetBondCall): void {
  log.warning(`OOV2 set bond inputs: {},{},{},{}`, [
    call.inputs.timestamp.toString(),
    call.inputs.identifier.toString(),
    call.inputs.ancillaryData.toHex(),
    call.inputs.bond.toString(),
  ]);
  let requestId = createOptimisticPriceRequestId(
    call.inputs.identifier,
    call.inputs.timestamp,
    call.inputs.ancillaryData
  );

  let request = getOrCreateOptimisticPriceRequest(requestId);
  request.bond = call.inputs.bond;

  request.save();
}

export function handleSetEventBased(call: SetEventBasedCall): void {
  log.warning(`OOV2 set event based inputs: {},{},{}`, [
    call.inputs.timestamp.toString(),
    call.inputs.identifier.toString(),
    call.inputs.ancillaryData.toHex(),
  ]);
  let requestId = createOptimisticPriceRequestId(
    call.inputs.identifier,
    call.inputs.timestamp,
    call.inputs.ancillaryData
  );

  let request = getOrCreateOptimisticPriceRequest(requestId);
  request.eventBased = true;

  request.save();
}