Forwards and Futures on currency

Two equivalent investment paths

Covered interest parity (CIP) says that a risk-free investment in U.S. dollars should deliver exactly the same payoff as a euro investment that is hedged back into dollars with a forward contract. Instead of just memorising the algebra, it helps to watch the cash split into both paths and reunite at maturity.

The interactive lab below follows $1,000 through both strategies and solves for the forward rate that keeps the outcomes identical. Adjust the market inputs to see how the forward contract must respond.

Tip

How to use the animation

• Move the sliders to set the spot exchange rate and the two 1-year interest rates.
  
• Adjusting a slider automatically replays the animation; use Play animation to rerun it on demand.
  
• Watch the forward rate update so the hedged foreign payoff lands exactly on the domestic payoff—no arbitrage.

Note

Spot and forward rates are quoted in USD per EUR (how many dollars one euro buys). The domestic rate is the U.S. continuously compounded risk-free rate \(r\), and the foreign rate is the euro continuously compounded risk-free rate \(r_f\).

Interactive lab: domestic vs. hedged foreign investment

formatUSD = (value, digits = 2) =>
  new Intl.NumberFormat("en-US", {
    style: "currency",
    currency: "USD",
    minimumFractionDigits: digits,
    maximumFractionDigits: digits
  }).format(value)

formatEUR = (value, digits = 2) =>
  new Intl.NumberFormat("de-DE", {
    style: "currency",
    currency: "EUR",
    minimumFractionDigits: digits,
    maximumFractionDigits: digits
  }).format(value)

formatPercent = value => `${(value * 100).toFixed(2)}%`
formatSpot = value => `$${value.toFixed(3)} per €1`
easeInOutCubic = t =>
  t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2

escapeTeX = value =>
  String(value)
    .replace(/\u00A0/g, ' ')
    .replace(/\\/g, "\\\\")
    .replace(/\$/g, "\\$")
    .replace(/%/g, "\\%")
    .replace(/_/g, "\\_")
    .replace(/\{/g, "\\{")
    .replace(/\}/g, "\\}")
    .replace(/#/g, "\\#")
    .replace(/\^/g, "\\^")
    .replace(/&/g, "\\&")

texUSD = value => `\\text{${escapeTeX(formatUSD(value))}}`
texEUR = value => {
  const raw = formatEUR(value).replace(/€/g, '').trim()
  return `\\text{${escapeTeX(raw)}}\\,\\text{EUR}`
}
texSpotQuote = rate => `\\$${rate.toFixed(3)}\\,/\\,\\text{EUR}`
texForwardQuote = rate => `\\$${rate.toFixed(3)}\\,/\\,\\text{EUR}`
texPercent = value => `${(value * 100).toFixed(2)}\\%`

styleMath = (node, { size = "0.9rem", color = "#495057", weight = 500 } = {}) => {
  node.style.display = "block"
  node.style.fontSize = size
  node.style.color = color
  node.style.fontWeight = weight
  return node
}

mutable animationSeed = 0

viewof paritySettings = {
  const defaults = {
    spotRate: 1.07,
    domesticRate: 0.045,
    foreignRate: 0.02,
    amountUSD: 1000
  }

  const container = html`<div style="display: flex; flex-direction: column; gap: 0.75rem; padding: 1rem 1.2rem; border-radius: 12px; border: 1px solid #dee2e6; background: #f8f9fa;"></div>`

  const makeSlider = ({ flag, label, helper, min, max, step, value, formatter }) => {
    const wrapper = html`<div style="display: flex; flex-direction: column; gap: 0.35rem;"></div>`
    const header = html`<div style="display: flex; align-items: center; gap: 0.5rem; font-weight: 600; font-size: 0.95rem; color: #212529;">
      <span style="font-size: 1.4rem;">${flag}</span>
      <span>${label}</span>
    </div>`
    const slider = html`<input type="range" min="${min}" max="${max}" step="${step}" value="${value}" style="width: 100%;">`
    slider.style.accentColor = flag === "🇺🇸" ? "#1f4f9a" : flag === "🇪🇺" ? "#0c6291" : "#2f71d5"
    const helperRow = html`<div style="display: flex; justify-content: space-between; font-size: 0.85rem; color: #495057;">
      <span>${helper ?? ""}</span>
      <span style="font-variant-numeric: tabular-nums; font-weight: 600;">${formatter(value)}</span>
    </div>`
    const listeners = new Set()
    slider.addEventListener("input", event => {
      const val = Number(event.target.value)
      helperRow.lastChild.textContent = formatter(val)
      listeners.forEach(fn => fn(val))
    })
    wrapper.append(header, slider, helperRow)
    return {
      element: wrapper,
      setValue: val => {
        slider.value = val
        helperRow.lastChild.textContent = formatter(val)
      },
      onInput: fn => listeners.add(fn)
    }
  }

  const spotControl = makeSlider({
    flag: "🇺🇸→🇪🇺",
    label: "Spot rate S₀ (USD per EUR)",
    helper: "How many dollars buy €1 today?",
    min: 0.8,
    max: 1.35,
    step: 0.005,
    value: defaults.spotRate,
    formatter: value => `$${value.toFixed(3)}`
  })

  const domesticControl = makeSlider({
    flag: "🇺🇸",
    label: "Domestic rate r",
    helper: "1-year USD continuously compounded risk-free yield",
    min: 0,
    max: 0.12,
    step: 0.001,
    value: defaults.domesticRate,
    formatter: formatPercent
  })

  const foreignControl = makeSlider({
    flag: "🇪🇺",
    label: "Foreign rate r_f",
    helper: "1-year EUR continuously compounded risk-free yield",
    min: 0,
    max: 0.12,
    step: 0.001,
    value: defaults.foreignRate,
    formatter: formatPercent
  })

  container.append(spotControl.element, domesticControl.element, foreignControl.element)

  const state = { ...defaults }

  const update = (animate = true) => {
    container.value = { ...state }
    container.dispatchEvent(new CustomEvent("input", { bubbles: true }))
    if (animate) {
      mutable animationSeed += 1
    }
  }

  spotControl.onInput(val => {
    state.spotRate = val
    update()
  })

  domesticControl.onInput(val => {
    state.domesticRate = val
    update()
  })

  foreignControl.onInput(val => {
    state.foreignRate = val
    update()
  })

  const hint = html`<span style="color: #495057; font-size: 0.85rem;">Adjust a slider or press play to rerun the animation.</span>`
  const playButton = html`<button style="background: #1f4f9a; color: white; border: none; border-radius: 8px; padding: 0.45rem 0.9rem; font-weight: 600; cursor: pointer; transition: background 120ms ease;">Play animation</button>`
  playButton.addEventListener("mouseenter", () => {
    playButton.style.background = "#174079"
  })
  playButton.addEventListener("mouseleave", () => {
    playButton.style.background = "#1f4f9a"
  })
  playButton.addEventListener("click", event => {
    event.preventDefault()
    mutable animationSeed += 1
  })
  const buttonRow = html`<div style="display: flex; align-items: center; gap: 0.75rem; margin-top: 0.35rem;"></div>`
  buttonRow.append(hint, playButton)
  container.append(buttonRow)

  update(false)

  return container
}

parityData = {
  const { amountUSD, spotRate, domesticRate, foreignRate } = paritySettings
  const T = 1 // Time period is 1 year
  const usdStart = amountUSD
  const usdEnd = usdStart * Math.exp(domesticRate * T)
  const eurosNow = usdStart / spotRate
  const eurosEnd = eurosNow * Math.exp(foreignRate * T)
  const forwardRate = spotRate * Math.exp((domesticRate - foreignRate) * T)
  const usdEndHedged = eurosEnd * forwardRate
  const forwardPremium = forwardRate / spotRate - 1
  const parityGap = usdEndHedged - usdEnd
  return {
    usdStart,
    usdEnd,
    eurosNow,
    eurosEnd,
    forwardRate,
    forwardPremium,
    usdEndHedged,
    parityGap,
    T
  }
}

parityDiagram = {
  const { amountUSD, spotRate, domesticRate, foreignRate } = paritySettings
  const { usdStart, usdEnd, eurosNow, eurosEnd, forwardRate, usdEndHedged } = parityData
  const seed = animationSeed
  const container = html`<div style="position: relative; width: 100%; max-width: 760px; margin: 0.75rem auto 0;"></div>`
  const width = 760
  const height = 360
  const svg = DOM.svg(width, height)
  svg.setAttribute("viewBox", `0 0 ${width} ${height}`)
  svg.style.width = "100%"
  svg.style.height = "auto"
  svg.style.background = "#ffffff"
  svg.style.borderRadius = "16px"
  svg.style.boxShadow = "0 12px 28px rgba(15, 23, 42, 0.08)"
  svg.style.border = "1px solid #e9ecef"
  container.append(svg)

  const NS = "http://www.w3.org/2000/svg"
  const defs = document.createElementNS(NS, "defs")

  const makeMarker = ({ id, color }) => {
    const marker = document.createElementNS(NS, "marker")
    marker.setAttribute("id", id)
    marker.setAttribute("markerWidth", "10")
    marker.setAttribute("markerHeight", "7")
    marker.setAttribute("refX", "10")
    marker.setAttribute("refY", "3.5")
    marker.setAttribute("orient", "auto")
    marker.setAttribute("markerUnits", "strokeWidth")
    const arrow = document.createElementNS(NS, "path")
    arrow.setAttribute("d", "M 0 0 L 10 3.5 L 0 7 z")
    arrow.setAttribute("fill", color)
    marker.append(arrow)
    return marker
  }

  defs.append(makeMarker({ id: "arrow-blue", color: "#1f4f9a" }))
  defs.append(makeMarker({ id: "arrow-grey", color: "#868e96" }))
  defs.append(makeMarker({ id: "arrow-green", color: "#0ca678" }))
  svg.append(defs)

  const start = { x: 120, y: 190 }
  const topEnd = { x: 620, y: 90 }
  const topControl = { x: 320, y: 110 }
  const bottomEnd = { x: 620, y: 290 }
  const bottomControl = { x: 320, y: 280 }
  const hedgeControl = { x: 680, y: 200 }

  const makePath = ({ d, color, width = 5, marker, dash = false }) => {
    const path = document.createElementNS(NS, "path")
    path.setAttribute("d", d)
    path.setAttribute("fill", "none")
    path.setAttribute("stroke", color)
    path.setAttribute("stroke-width", width)
    path.setAttribute("stroke-linecap", "round")
    path.setAttribute("stroke-linejoin", "round")
    if (marker) {
      path.setAttribute("marker-end", `url(#${marker})`)
    }
    if (dash) {
      path.setAttribute("stroke-dasharray", "10 6")
    }
    svg.append(path)
    return path
  }

  const topPath = makePath({
    d: `M ${start.x} ${start.y} Q ${topControl.x} ${topControl.y} ${topEnd.x} ${topEnd.y}`,
    color: "#1f4f9a",
    marker: "arrow-blue"
  })

  const bottomPath = makePath({
    d: `M ${start.x} ${start.y} Q ${bottomControl.x} ${bottomControl.y} ${bottomEnd.x} ${bottomEnd.y}`,
    color: "#868e96",
    marker: "arrow-grey"
  })

  const hedgePath = makePath({
    d: `M ${bottomEnd.x} ${bottomEnd.y} Q ${hedgeControl.x} ${hedgeControl.y} ${topEnd.x} ${topEnd.y}`,
    color: "#0ca678",
    marker: "arrow-green"
  })

  const startCircle = document.createElementNS(NS, "circle")
  startCircle.setAttribute("cx", start.x)
  startCircle.setAttribute("cy", start.y)
  startCircle.setAttribute("r", 18)
  startCircle.setAttribute("fill", "#264653")
  startCircle.setAttribute("fill-opacity", "0.92")
  svg.append(startCircle)

  const topCircle = document.createElementNS(NS, "circle")
  topCircle.setAttribute("r", 10)
  topCircle.setAttribute("fill", "#1f4f9a")
  svg.append(topCircle)

  const bottomCircle = document.createElementNS(NS, "circle")
  bottomCircle.setAttribute("r", 10)
  bottomCircle.setAttribute("fill", "#868e96")
  svg.append(bottomCircle)

  const startPoint = topPath.getPointAtLength(0)
  topCircle.setAttribute("cx", startPoint.x)
  topCircle.setAttribute("cy", startPoint.y)
  bottomCircle.setAttribute("cx", startPoint.x)
  bottomCircle.setAttribute("cy", startPoint.y)

  const createLabel = ({ x, y, lines, anchor = "start", color = "#212529", weight = 500, size = 14 }) => {
    const text = document.createElementNS(NS, "text")
    text.setAttribute("x", x)
    text.setAttribute("y", y)
    text.setAttribute("text-anchor", anchor)
    text.setAttribute("fill", color)
    text.setAttribute("font-weight", weight)
    text.setAttribute("font-size", size)
    text.setAttribute("dominant-baseline", "hanging")
    text.style.opacity = 0
    text.style.transition = "opacity 320ms ease"
    const supPattern = /e\^\(([^)]+)\)/g
    lines.forEach((line, index) => {
      supPattern.lastIndex = 0
      const span = document.createElementNS(NS, "tspan")
      if (index > 0) {
        span.setAttribute("x", x)
      }
      span.setAttribute("dy", index === 0 ? 0 : "1.2em")
      let lastIndex = 0
      let match
      while ((match = supPattern.exec(line)) !== null) {
        if (match.index > lastIndex) {
          span.append(document.createTextNode(line.slice(lastIndex, match.index)))
        }
        span.append(document.createTextNode("e"))
        const superscript = document.createElementNS(NS, "tspan")
        superscript.setAttribute("baseline-shift", "super")
        superscript.setAttribute("font-size", "0.75em")
        superscript.textContent = `(${match[1]})`
        span.append(superscript)
        lastIndex = match.index + match[0].length
      }
      if (lastIndex < line.length) {
        span.append(document.createTextNode(line.slice(lastIndex)))
      }
      text.append(span)
    })
    svg.append(text)
    return text
  }

  const setLabelX = (label, x) => {
    label.setAttribute("x", x)
    label.querySelectorAll("tspan").forEach(span => {
      if (span.hasAttribute("x")) {
        span.setAttribute("x", x)
      }
    })
  }

  const keepLabelWithinBounds = (label, margin = 24) => {
    if (typeof label?.getBBox !== "function") return
    const bounds = label.getBBox()
    const originalX = Number(label.getAttribute("x"))
    if (Number.isNaN(originalX)) return
    const maxRight = width - margin
    const minLeft = margin
    let targetX = originalX
    if (bounds.x + bounds.width > maxRight) {
      targetX -= bounds.x + bounds.width - maxRight
    }
    if (bounds.x < minLeft) {
      targetX += minLeft - bounds.x
    }
    if (targetX !== originalX) {
      setLabelX(label, targetX)
    }
  }

  const startLabel = createLabel({
    x: start.x - 40,
    y: start.y - 60,
    anchor: "start",
    lines: [
      "Start in USD",
      `${formatUSD(usdStart)}`,
      "split into two paths"
    ],
    color: "#212529",
    weight: 600
  })
  startLabel.style.opacity = 1

  const topLabel = createLabel({
    x: topEnd.x - 90,
    y: topEnd.y - 60,
    anchor: "end",
    lines: [
      "Invest in 🇺🇸",
      `${formatUSD(usdStart)} × e^(${(domesticRate * 100).toFixed(2)}%)`,
      `= ${formatUSD(usdEnd)}`
    ],
    color: "#1f4f9a"
  })

  const bottomLabel = createLabel({
    x: bottomEnd.x - 40,
    y: bottomEnd.y + 16,
    anchor: "end",
    lines: [
      "Convert to 🇪🇺 at S₀",
      `${formatSpot(spotRate)} → ${formatEUR(eurosNow)}`,
      `Grow at e^(${(foreignRate * 100).toFixed(2)}%) → ${formatEUR(eurosEnd)}`
    ],
    color: "#495057"
  })

  const hedgeLabel = createLabel({
    x: topEnd.x - 30,
    y: topEnd.y + 55,
    anchor: "end",
    lines: [
      `Forward rate F₀ = $${forwardRate.toFixed(3)}/EUR`,
      `Hedged payoff = ${formatUSD(usdEndHedged)}`,
      "Matches domestic payoff ✓"
    ],
    color: "#0ca678"
  })
  keepLabelWithinBounds(hedgeLabel)

  const parityLabel = createLabel({
    x: topEnd.x,
    y: topEnd.y - 60,
    anchor: "middle",
    lines: [
      "No-arbitrage balance",
      `${formatUSD(usdEnd)} = ${formatUSD(usdEndHedged)}`
    ],
    color: "#212529",
    weight: 600,
    size: 15
  })

  const frameIds = new Set()
  const scheduleFrame = callback => {
    const id = requestAnimationFrame(time => {
      frameIds.delete(id)
      callback(time)
    })
    frameIds.add(id)
    return id
  }

  const timeouts = []
  const scheduleTimeout = (fn, delay) => {
    const id = setTimeout(fn, delay)
    timeouts.push(id)
  }

  const animateStroke = (path, duration, delay = 0) => {
    const length = path.getTotalLength()
    path.style.transition = "none"
    path.style.strokeDasharray = length
    path.style.strokeDashoffset = length
    path.getBoundingClientRect()
    scheduleTimeout(() => {
      path.style.transition = `stroke-dashoffset ${duration}ms ease-in-out`
      path.style.strokeDashoffset = 0
    }, delay)
  }

  const moveCircle = (circle, path, duration, delay = 0) => {
    const length = path.getTotalLength()
    const origin = path.getPointAtLength(0)
    circle.setAttribute("cx", origin.x)
    circle.setAttribute("cy", origin.y)
    let startTime = null
    const step = time => {
      if (startTime === null) startTime = time
      const elapsed = time - startTime
      if (elapsed < delay) {
        scheduleFrame(step)
        return
      }
      const t = Math.min((elapsed - delay) / duration, 1)
      const eased = easeInOutCubic(Math.max(0, t))
      const point = path.getPointAtLength(eased * length)
      circle.setAttribute("cx", point.x)
      circle.setAttribute("cy", point.y)
      if (t < 1) {
        scheduleFrame(step)
      }
    }
    scheduleFrame(step)
  }

  const topDuration = 1400
  const topDelay = 120
  animateStroke(topPath, topDuration, topDelay)
  moveCircle(topCircle, topPath, topDuration, topDelay)
  scheduleTimeout(() => {
    topLabel.style.opacity = 1
  }, topDelay + topDuration - 200)

  const bottomDelay = topDelay + 700
  const bottomDuration = 1400
  animateStroke(bottomPath, bottomDuration, bottomDelay)
  moveCircle(bottomCircle, bottomPath, bottomDuration, bottomDelay)
  scheduleTimeout(() => {
    bottomLabel.style.opacity = 1
  }, bottomDelay + bottomDuration - 200)

  const hedgeDelay = bottomDelay + bottomDuration + 200
  const hedgeDuration = 1000
  animateStroke(hedgePath, hedgeDuration, hedgeDelay)
  moveCircle(bottomCircle, hedgePath, hedgeDuration, hedgeDelay)
  scheduleTimeout(() => {
    hedgeLabel.style.opacity = 1
    parityLabel.style.opacity = 1
  }, hedgeDelay + hedgeDuration - 150)

  invalidation.then(() => {
    frameIds.forEach(id => cancelAnimationFrame(id))
    timeouts.forEach(id => clearTimeout(id))
  })

  return container
}

paritySummary = {
  const { spotRate, domesticRate, foreignRate } = paritySettings
  const { usdStart, usdEnd, eurosNow, eurosEnd, usdEndHedged, forwardRate, forwardPremium, parityGap } = parityData
  const container = html`<div style="display: flex; flex-direction: column; gap: 0.75rem; width: 100%; max-width: 760px; margin: 0.75rem auto 0;"></div>`
  const cards = html`<div style="display: grid; gap: 0.75rem; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));"></div>`

  const domesticCard = html`<div style="border: 1px solid #dee2e6; border-radius: 12px; padding: 0.9rem; background: #ffffff;"></div>`
  const domesticTitle = html`<div style="font-weight: 600; color: #1f4f9a; margin-bottom: 0.4rem;">🇺🇸 Domestic path</div>`
  const domesticFormula = styleMath(tex`${texUSD(usdStart)} \times e^{${texPercent(domesticRate)}}`)
  const domesticResult = html`<div style="font-size: 1.2rem; font-weight: 600; color: #1f4f9a; margin-top: 0.3rem;">${formatUSD(usdEnd)}</div>`
  domesticCard.append(domesticTitle, domesticFormula, domesticResult)

  const foreignCard = html`<div style="border: 1px solid #dee2e6; border-radius: 12px; padding: 0.9rem; background: #ffffff;"></div>`
  const foreignTitle = html`<div style="font-weight: 600; color: #495057; margin-bottom: 0.4rem;">🇪🇺 Foreign hedge</div>`
  const spotLine = styleMath(tex`\text{Spot: } ${texUSD(usdStart)} \div ${texSpotQuote(spotRate)} = ${texEUR(eurosNow)}`)
  const investLine = styleMath(tex`\text{Invest: } ${texEUR(eurosNow)} \times e^{${texPercent(foreignRate)}} = ${texEUR(eurosEnd)}`)
  const forwardLine = styleMath(tex`\text{Forward: } ${texEUR(eurosEnd)} \times ${texForwardQuote(forwardRate)} = ${texUSD(usdEndHedged)}`)
  forwardLine.style.marginBottom = "0.1rem"
  const foreignResult = html`<div style="font-size: 1.2rem; font-weight: 600; color: #0ca678; margin-top: 0.3rem;">${formatUSD(usdEndHedged)}</div>`
  foreignCard.append(foreignTitle, spotLine, investLine, forwardLine, foreignResult)

  const forwardCard = html`<div style="border: 1px solid #dee2e6; border-radius: 12px; padding: 0.9rem; background: #ffffff;"></div>`
  const forwardTitle = html`<div style="font-weight: 600; color: #0ca678; margin-bottom: 0.4rem;">Forward parity</div>`
  const forwardFormula = styleMath(tex`F_0 = S_0 \times e^{(r - r_f)T}`)
  const forwardValue = html`<div style="font-size: 1.2rem; font-weight: 600; color: #0ca678; margin-top: 0.3rem;">F₀ = $${forwardRate.toFixed(3)}/EUR</div>`
  const forwardPremiumLine = html`<div style="font-size: 0.85rem; color: #495057; margin-top: 0.3rem;">Forward premium: ${formatPercent(forwardPremium)}</div>`
  forwardCard.append(forwardTitle, forwardFormula, forwardValue, forwardPremiumLine)

  cards.append(domesticCard, foreignCard, forwardCard)
  container.append(cards)

  const gapDisplay = Math.abs(parityGap) < 0.005 ? "≈ $0.00" : formatUSD(parityGap)
  const equality = html`<div style="border-radius: 12px; border: 1px dashed #adb5bd; padding: 0.8rem 1rem; background: #f8f9fa; color: #212529; font-weight: 500;">
    Hedged foreign payoff – domestic payoff = ${gapDisplay}
  </div>`
  container.append(equality)

  return container
}

Why the payoffs match

Both paths start with the same $1,000. Under no-arbitrage, the forward rate for a contract with maturity \(T\) must satisfy

\[ F_0 = S_0 e^{(r - r_f)T} \]

where \(r\) and \(r_f\) are the continuously compounded risk-free rates. The animation enforces this equality by solving for \(F_0\) after you set the inputs (with \(T=1\) year).

• If \(r > r_f\), the forward trades at a premium to spot (\(F_0 > S_0\)) so that the foreign investment does not beat the domestic path.
• If \(r < r_f\), the forward trades at a discount (\(F_0 < S_0\)), offsetting the foreign yield advantage.
• Any deviation of the actual forward quote from \(F_0\) signals a covered interest arbitrage opportunity: borrow in the cheaper currency, invest in the higher-yielding one, and lock the forward to harvest the spread.

Forwards vs. Futures Prices

The formula for the no-arbitrage forward rate, \(F_0\), assumes that the interest rates \(r\) and \(r_f\) are constant over the life of the contract. Under this assumption, the price of a currency futures contract is identical to the forward price.

In reality, interest rates are stochastic. This introduces a key difference between forwards and futures:

• Forwards are settled only at maturity.
  
• Futures are marked-to-market daily, meaning profits and losses are settled every day.

If the foreign currency strengthens unexpectedly, futures traders receive immediate cash profits, which they can reinvest at the prevailing (and possibly changed) interest rates. If the currency weakens, they have to fund immediate losses.

This daily settlement mechanism means that the futures price will be higher than the forward price if the exchange rate is positively correlated with domestic interest rates. This is because positive correlation allows profits from a rising exchange rate to be reinvested at higher-than-average rates—an advantage over forwards that must be priced into the futures contract. Conversely, the futures price will be lower if the correlation is negative. For most short-term contracts on major currencies, this correlation effect is small, and the forward and futures prices are therefore very close.