Pricing an American FX Option using Quantlib

Question

I need some guidance on valuing American style FX options (spots and forwards) using quantlib in Python. Given the following parameters:

1. Domestic and foreign risk-free rates
2. Current market spot and forward points for the underlying asset (maturity at option exercise date plus tenor) - as an aside, does the maturity move forward for an early exercise of the option?
3. Approximate volatility of the underlying (by using historical prices)
4. Strike price
5. Expiration date
6. Maturity date

Here is what I have tried so far:

 # QuantLib date settings
        todayDate = ql.Date().todaysDate()
        ql.Settings.instance().evaluationDate = todayDate
        dayCount = ql.ActualActual()

        volatilityHandle = ql.BlackVolTermStructureHandle(
            ql.BlackConstantVol(todayDate, ql.NullCalendar(), ql.QuoteHandle(ql.SimpleQuote(req.Volatility)), dayCount)
        )

        # define the option
        option = ql.VanillaOption(
            ql.PlainVanillaPayoff(ql.Option.Call, req.StrikePrice), ql.AmericanExercise(req.ExpirationDate)
        )

        # build the process
        localInterestRateHandle = ql.YieldTermStructureHandle(
            ql.FlatForward(todayDate, req.LocalInterestRate / 100, dayCount)
        )
        # this is the one big issue - for FX options, both the domestic and 
        # foreign risk-free rates have to be considered, but the 
        # BlackScholesProcess does not cater for this.
        # foreignInterestRateHandle = ql.YieldTermStructureHandle(
        #     ql.FlatForward(todayDate, req.ForeignInterestRate / 100, dayCount)
        # )
        process = ql.BlackScholesProcess(
            ql.QuoteHandle(ql.SimpleQuote(req.SpotPrice + req.ForwardPoints)),
            localInterestRateHandle,
            volatilityHandle,
        )

        # set the pricing engine
        option.setPricingEngine(ql.MCAmericanEngine(process, "pseudorandom", timeSteps=100, requiredSamples=1000))
        return GetOptionValueResponse(OptionValue=option.NPV())

The biggest issue is that (as commented), the BlackScholesProcess does not cater for domestic and foreign RFRs. The GarmanKohlagenProcess does work for European options, but I have not seen a similar process for American options.

For more clarity, this is the request class passed to the function:

@dataclass
class GetOptionValueRequest:
    """The request parameters of the GetEuropeanOptionValue service."""

    SpotPrice: float
    """The latest spot price of the underlying asset."""
    ForwardPoints: float
    """The latest forward points of the underlying asset."""
    StrikePrice: float
    """The strike price of the option."""
    ExpirationDate: date
    """The expiration date of the option in days."""
    LocalInterestRate: float
    """The risk-free interest rate of the local currency as a percentage"""
    ForeignInterestRate: float
    """The risk-free interest rate of the foreign currency as a percentage"""
    Volatility: float
    """The volatility of the underlying asset"""

Answer 1

The GarmanKohlagenProcess manages both foreign and domestic curves and can be passed to every engine that asks for a GeneralizedBlackScholesProcess.

I wouldn't choose MCAmericanEngine, though; it uses a Longstaff-Schwarz simulation, and you probably don't need that complexity and the calculation time it requires. You're probably better off using either a binomial tree (with an engine like BinomialCRRVanillaEngine, or one of the others listed here) or a finite-difference model (with the FdBlackScholesVanillaEngine).

However, I'm afraid that VanillaOption only models spot options.