Reposting an offer in the posthook

In the smart offer tutorial the offer was fully taken by the taker at the end.

In case an offer is partially taken, the maker may want to repost a new offer for the residual.

Repost in posthook​

In the tutorial, the posthook emitted an event. However, since reposting is such a common action, it is already implemented for the simple cases - if you invoke super like below, then the base implementation of __posthookSuccess__ will repost the residual.

OfferMakerTutorial.sol

  function __posthookSuccess__(MgvLib.SingleOrder calldata order, bytes32 makerData)
    internal
    virtual
    override
    returns (bytes32)
  {
    emit OfferTakenSuccessfully(42);
    // repost offer residual if any
    return super.__posthookSuccess__(order, makerData);
  }
}

See entire file on GitHub

When writing posthooks to repost residuals there are both caveats and points to be aware:

• Use _updateOffer instead of posting a new offer. The old offer is not alive and can be reused (and the storage is possibly hot during the execution of the offer logic), this is cheaper than using _newOffer.
• Use the helper method __residualvalues__ supplied to calculate the residual (see example below).
• Beware that updates can fail, e.g., due to too low density.

• Make sure to refer to the guidelines on Safe offer logic guidelines.
• Note that the parameters to __posthookSuccess__ already point out the old offer. This can save storage since we do not have to store IDs of posted offers.
• Beware of gas usage changes on different code paths. As an example, the gas requirements for the tutorial increases to 80,000 to be able to repost.

If you need to write a custom hook, for instance, for reposting multiple offers, then it can be a good idea to look at the base implementation of __posthookSuccess__ (from MangroveOffer) below. A good exercise is to change the code above to emit the value returned from super and trigger the reposted and dust (see density) scenarios.

MangroveOffer.sol

function __posthookSuccess__(MgvLib.SingleOrder calldata order, bytes32 makerData)
  internal
  virtual
  returns (bytes32 data)
{
  // now trying to repost residual
  (uint newGives, Tick newTick) = __residualValues__(order);
  // Density check at each repost would be too gas costly.
  // We only treat the special case of `gives==0` or `wants==0` (total fill).
  // Note: wants (given by `inboundFromOutbound`) can be 0 due to rounding given the price. We could repost to get rid of the last gives at 0 wants,
  // but the maker does not need to give away these tokens for free, so we skip it.
  // Offer below the density will cause Mangrove to throw so we encapsulate the call to `updateOffer` in order not to revert posthook for posting at dust level.
  if (newGives == 0 || newTick.inboundFromOutbound(newGives) == 0) {
    return COMPLETE_FILL;
  }
  data = _updateOffer(
    OfferArgs({
      olKey: order.olKey,
      tick: newTick,
      gives: newGives,
      gasreq: order.offerDetail.gasreq(),
      gasprice: order.offerDetail.gasprice(),
      noRevert: true,
      fund: 0
    }),
    order.offerId
  );
  // logs if anything went wrong
  logRepostStatus(order, makerData, data);
}

See entire file on GitHub