settle.test.js

import tap from 'tap'
import * as settle from './settle.js'

tap.test('passLine: comeout win', function (t) {
  const bets = {
    pass: {
      line: {
        amount: 5,
        isContract: false
      }
    }
  }

  const hand = {
    result: 'comeout win',
    diceSum: 7
  }

  const result = settle.passLine({ hand, bets })
  t.equal(result.payout.type, 'comeout win')
  t.equal(result.payout.principal, 5)
  t.equal(result.payout.profit, 5)
  t.notOk(result.bets.pass.line, 'pass line bet is cleared upon comeout win')

  t.end()
})

tap.test('passLine: comeout loss', function (t) {
  const bets = {
    pass: {
      line: {
        amount: 5,
        isContract: false
      }
    }
  }

  const hand = {
    result: 'comeout loss',
    diceSum: 3
  }

  const result = settle.passLine({ hand, bets })
  t.notOk(result.payout, 'no payout on a comeout loss')
  t.notOk(result.bets.pass.line, 'pass line bet is cleared upon comeout loss')

  t.end()
})

tap.test('passLine: point win', function (t) {
  const bets = {
    pass: {
      line: {
        amount: 5,
        isContract: true
      }
    }
  }

  const hand = {
    result: 'point win',
    diceSum: 10
  }

  const result = settle.passLine({ hand, bets })
  t.equal(result.payout.type, 'point win')
  t.equal(result.payout.principal, 5)
  t.equal(result.payout.profit, 5)
  t.notOk(result.bets.pass.line, 'pass line bet is cleared upon point win')

  t.end()
})

tap.test('passLine: point loss', function (t) {
  const bets = {
    pass: {
      line: {
        amount: 5,
        isContract: true
      }
    }
  }

  const hand = {
    result: 'seven out',
    diceSum: 7
  }

  const result = settle.passLine({ hand, bets })
  t.notOk(result.payout, 'no payout on seven out')
  t.notOk(result.bets.pass.line, 'pass line bet is cleared upon seven out')

  t.end()
})

tap.test('passLine: no bet', function (t) {
  const bets = {}

  const hand = {
    result: 'point win',
    diceSum: 8
  }

  const result = settle.passLine({ hand, bets })
  t.notOk(result.payout)
  t.end()
})

tap.test('passLine: bet, no win', function (t) {
  const bets = {
    pass: {
      line: {
        amount: 5,
        isContract: true
      }
    }
  }

  const hand = {
    result: 'neutral',
    diceSum: 11,
    point: 5
  }

  const result = settle.passLine({ hand, bets })
  t.notOk(result.payout)
  t.end()
})

tap.test('passOdds: odds bet, no win', function (t) {
  const bets = {
    pass: {
      line: {
        amount: 5,
        isContract: true
      },
      odds: {
        amount: 25,
        isContract: false
      }
    }
  }

  const hand = {
    result: 'neutral',
    isComeOut: false,
    point: 8,
    diceSum: 10
  }

  const result = settle.passOdds({ hand, bets })
  t.notOk(result.payout)
  t.strictSame(result.bets, bets, 'settled bets are same as initial bets')
  t.end()
})

tap.test('passOdds (4): odds bet, win', function (t) {
  const bets = {
    pass: {
      line: {
        amount: 5,
        isContract: true
      },
      odds: {
        amount: 15,
        isContract: false
      }
    }
  }

  const hand = {
    result: 'point win',
    isComeOut: true,
    point: 4,
    diceSum: 4
  }

  const result = settle.passOdds({ hand, bets })
  t.equal(result.payout.type, 'pass odds win')
  t.equal(result.payout.principal, 15)
  t.equal(result.payout.profit, 30)
  t.notOk(result.bets.pass.odds, 'pass odds bet is cleared')
  t.end()
})

tap.test('passOdds (5): odds bet, win', function (t) {
  const bets = {
    pass: {
      line: {
        amount: 5,
        isContract: true
      },
      odds: {
        amount: 20,
        isContract: false
      }
    }
  }

  const hand = {
    result: 'point win',
    isComeOut: true,
    point: 5,
    diceSum: 5
  }

  const result = settle.passOdds({ hand, bets })
  t.equal(result.payout.type, 'pass odds win')
  t.equal(result.payout.principal, 20)
  t.equal(result.payout.profit, 30)
  t.notOk(result.bets.pass.odds, 'pass odds bet is cleared')
  t.end()
})

tap.test('passOdds (6): odds bet, win', function (t) {
  const bets = {
    pass: {
      line: {
        amount: 5,
        isContract: true
      },
      odds: {
        amount: 25,
        isContract: false
      }
    }
  }

  const hand = {
    result: 'point win',
    isComeOut: true,
    point: 6,
    diceSum: 6
  }

  const result = settle.passOdds({ hand, bets })
  t.equal(result.payout.type, 'pass odds win')
  t.equal(result.payout.principal, 25)
  t.equal(result.payout.profit, 30)
  t.notOk(result.bets.pass.odds, 'pass odds bet is cleared')
  t.end()
})

tap.test('passOdds (8): odds bet, win', function (t) {
  const bets = {
    pass: {
      line: {
        amount: 5,
        isContract: true
      },
      odds: {
        amount: 25,
        isContract: false
      }
    }
  }

  const hand = {
    result: 'point win',
    isComeOut: true,
    point: 8,
    diceSum: 8
  }

  const result = settle.passOdds({ hand, bets })
  t.equal(result.payout.type, 'pass odds win')
  t.equal(result.payout.principal, 25)
  t.equal(result.payout.profit, 30)
  t.notOk(result.bets.pass.odds, 'pass odds bet is cleared')
  t.end()
})

tap.test('passOdds (9): odds bet, win', function (t) {
  const bets = {
    pass: {
      line: {
        amount: 5,
        isContract: true
      },
      odds: {
        amount: 20,
        isContract: false
      }
    }
  }

  const hand = {
    result: 'point win',
    isComeOut: true,
    point: 9,
    diceSum: 9
  }

  const result = settle.passOdds({ hand, bets })
  t.equal(result.payout.type, 'pass odds win')
  t.equal(result.payout.principal, 20)
  t.equal(result.payout.profit, 30)
  t.notOk(result.bets.pass.odds, 'pass odds bet is cleared')
  t.end()
})

tap.test('passOdds (10): odds bet, win', function (t) {
  const bets = {
    pass: {
      line: {
        amount: 5,
        isContract: true
      },
      odds: {
        amount: 15,
        isContract: false
      }
    }
  }

  const hand = {
    result: 'point win',
    isComeOut: true,
    point: 10,
    diceSum: 10
  }

  const result = settle.passOdds({ hand, bets })
  t.equal(result.payout.type, 'pass odds win')
  t.equal(result.payout.principal, 15)
  t.equal(result.payout.profit, 30)
  t.notOk(result.bets.pass.odds, 'pass odds bet is cleared')
  t.end()
})

tap.test('passOdds: odds bet, seven out', function (t) {
  const bets = {
    pass: {
      line: {
        amount: 5,
        isContract: true
      },
      odds: {
        amount: 25,
        isContract: false
      }
    }
  }

  const hand = {
    result: 'seven out',
    isComeOut: true,
    point: 8,
    diceSum: 7
  }

  const result = settle.passOdds({ hand, bets })
  t.notOk(result.payout, 'no payout')
  t.notOk(result.bets.pass.odds, 'pass odds bet is cleared')
  t.end()
})

tap.test('dontPassLine: comeout 2 wins', function (t) {
  const bets = { dontPass: { line: { amount: 5 } } }
  const hand = { result: 'comeout loss', diceSum: 2 }

  const result = settle.dontPassLine({ hand, bets })
  t.equal(result.payout.type, 'dont pass win')
  t.equal(result.payout.principal, 5)
  t.equal(result.payout.profit, 5)
  t.notOk(result.bets.dontPass.line, 'dont pass line bet is cleared on win')
  t.end()
})

tap.test('dontPassLine: comeout 3 wins', function (t) {
  const bets = { dontPass: { line: { amount: 5 } } }
  const hand = { result: 'comeout loss', diceSum: 3 }

  const result = settle.dontPassLine({ hand, bets })
  t.equal(result.payout.type, 'dont pass win')
  t.equal(result.payout.principal, 5)
  t.equal(result.payout.profit, 5)
  t.notOk(result.bets.dontPass.line, 'dont pass line bet is cleared on win')
  t.end()
})

tap.test('dontPassLine: comeout 12 is barred (push)', function (t) {
  const bets = { dontPass: { line: { amount: 5 } } }
  const hand = { result: 'comeout loss', diceSum: 12 }

  const result = settle.dontPassLine({ hand, bets })
  t.notOk(result.payout, 'no payout on bar 12')
  t.equal(result.bets.dontPass.line.amount, 5, 'bet carries over on bar 12')
  t.end()
})

tap.test('dontPassLine: bar number is configurable via rules.dontPassBar', function (t) {
  const rules = { dontPassBar: 2 }
  const bets = { dontPass: { line: { amount: 5 } } }
  const hand = { result: 'comeout loss', diceSum: 2 }

  const result = settle.dontPassLine({ hand, bets, rules })
  t.notOk(result.payout, 'no payout when dontPassBar is 2 and dice show 2')
  t.equal(result.bets.dontPass.line.amount, 5, 'bet carries over on configured bar number')
  t.end()
})

tap.test('dontPassLine: default bar is 12 when rules.dontPassBar is absent', function (t) {
  const bets = { dontPass: { line: { amount: 5 } } }
  const hand = { result: 'comeout loss', diceSum: 12 }

  const result = settle.dontPassLine({ hand, bets })
  t.notOk(result.payout, 'no payout on default bar 12 with no rules provided')
  t.equal(result.bets.dontPass.line.amount, 5, 'bet carries over')
  t.end()
})

tap.test('dontPassLine: comeout 7 loses', function (t) {
  const bets = { dontPass: { line: { amount: 5 } } }
  const hand = { result: 'comeout win', diceSum: 7 }

  const result = settle.dontPassLine({ hand, bets })
  t.notOk(result.payout, 'no payout on comeout 7')
  t.notOk(result.bets.dontPass?.line, 'dont pass line bet is cleared on loss')
  t.end()
})

tap.test('dontPassLine: comeout 11 loses', function (t) {
  const bets = { dontPass: { line: { amount: 5 } } }
  const hand = { result: 'comeout win', diceSum: 11 }

  const result = settle.dontPassLine({ hand, bets })
  t.notOk(result.payout, 'no payout on comeout 11')
  t.notOk(result.bets.dontPass?.line, 'dont pass line bet is cleared on loss')
  t.end()
})

tap.test('dontPassLine: seven out wins', function (t) {
  const bets = { dontPass: { line: { amount: 5 } } }
  const hand = { result: 'seven out', diceSum: 7 }

  const result = settle.dontPassLine({ hand, bets })
  t.equal(result.payout.type, 'dont pass win')
  t.equal(result.payout.principal, 5)
  t.equal(result.payout.profit, 5)
  t.notOk(result.bets.dontPass?.line, 'dont pass line bet is cleared on win')
  t.end()
})

tap.test('dontPassLine: point win loses', function (t) {
  const bets = { dontPass: { line: { amount: 5 } } }
  const hand = { result: 'point win', diceSum: 8 }

  const result = settle.dontPassLine({ hand, bets })
  t.notOk(result.payout, 'no payout when shooter makes point')
  t.notOk(result.bets.dontPass?.line, 'dont pass line bet is cleared on loss')
  t.end()
})

tap.test('dontPassLine: no bet', function (t) {
  const bets = {}
  const hand = { result: 'seven out', diceSum: 7 }

  const result = settle.dontPassLine({ hand, bets })
  t.notOk(result.payout)
  t.end()
})

tap.test('dontPassLine: bet carries on neutral roll', function (t) {
  const bets = { dontPass: { line: { amount: 5 } } }
  const hand = { result: 'neutral', diceSum: 9, point: 6 }

  const result = settle.dontPassLine({ hand, bets })
  t.notOk(result.payout)
  t.equal(result.bets.dontPass.line.amount, 5, 'bet carries over')
  t.end()
})

tap.test('dontPassLine: bet carries on point set', function (t) {
  const bets = { dontPass: { line: { amount: 5 } } }
  const hand = { result: 'point set', diceSum: 8 }

  const result = settle.dontPassLine({ hand, bets })
  t.notOk(result.payout)
  t.equal(result.bets.dontPass.line.amount, 5, 'bet carries over after point set')
  t.end()
})

tap.test('comeLine: pending come bet wins immediately', (t) => {
  const bets = { come: { pending: [{ amount: 5 }] } }
  const hand = { result: 'neutral', diceSum: 11 }

  const result = settle.comeLine({ bets, hand })

  t.equal(result.payouts[0].type, 'come line win')
  t.equal(result.payouts[0].principal, 5)
  t.equal(result.payouts[0].profit, 5)
  t.notOk(result.bets.come)

  t.end()
})

tap.test('comeLine: pending come bet moves to point', (t) => {
  const bets = { come: { pending: [{ amount: 5 }] } }
  const hand = { result: 'neutral', diceSum: 4, point: 6 }

  const result = settle.comeLine({ bets, hand })

  t.notOk(result.payouts?.length)
  t.equal(result.bets.come.points[4][0].line.amount, 5)
  t.notOk(result.bets.come.pending)

  t.end()
})

tap.test('comeLine: come point win pays odds', (t) => {
  const bets = { come: { points: { 5: [{ line: { amount: 5 }, odds: { amount: 20 } }] } } }
  const hand = { result: 'neutral', diceSum: 5, point: 6 }

  const result = settle.comeLine({ bets, hand })

  const lineWin = result.payouts.find(p => p.type === 'come line win')
  const oddsWin = result.payouts.find(p => p.type === 'come odds win')

  t.equal(lineWin.profit, 5)
  t.equal(oddsWin.principal, 20)
  t.equal(oddsWin.profit, 30)
  t.notOk(result.bets.come)

  t.end()
})

tap.test('all: pass line win', (t) => {
  const bets = {
    pass: {
      line: {
        amount: 5,
        isContract: true
      },
      odds: {
        amount: 25,
        isContract: false
      }
    }
  }

  const hand = {
    result: 'point win',
    point: 6,
    diceSum: 6
  }

  const settled = settle.all({ bets, hand })

  t.equal(settled.payouts.total, 65)
  t.equal(settled.payouts.principal, 30)
  t.equal(settled.payouts.profit, 35)

  t.end()
})

tap.test('placeSix: win', (t) => {
  const bets = { place: { six: { amount: 6 } } }

  const hand = {
    result: 'neutral',
    isComeOut: false,
    diceSum: 6
  }

  const result = settle.placeSix({ bets, hand })

  t.equal(result.payout.type, 'place 6 win')
  t.equal(result.payout.profit, 7)
  t.equal(result.payout.principal, 6)
  t.notOk(result.bets.place.six)

  t.end()
})

tap.test('placeEight: win', (t) => {
  const bets = { place: { eight: { amount: 6 } } }

  const hand = {
    result: 'neutral',
    isComeOut: false,
    diceSum: 8
  }

  const result = settle.placeEight({ bets, hand })

  t.equal(result.payout.type, 'place 8 win')
  t.equal(result.payout.profit, 7)
  t.equal(result.payout.principal, 6)
  t.notOk(result.bets.place.eight)

  t.end()
})

tap.test('place bets: seven out removes bets', (t) => {
  const bets = { place: { six: { amount: 6 }, eight: { amount: 6 } } }

  const hand = {
    result: 'seven out',
    isComeOut: true,
    diceSum: 7
  }

  const settled = settle.all({ bets, hand })

  t.notOk(settled.place)
  t.equal(settled.payouts.total, 0)

  t.end()
})

tap.test('place bets: no action on comeout roll', (t) => {
  const bets = { place: { six: { amount: 6 }, eight: { amount: 6 } } }

  const hand = {
    result: 'comeout win',
    isComeOut: true,
    diceSum: 7
  }

  const settled = settle.all({ bets, hand })

  t.equal(settled.place.six.amount, 6)
  t.equal(settled.place.eight.amount, 6)
  t.equal(settled.payouts.total, 0)

  t.end()
})

tap.test('place bets: no action on comeout win 11', (t) => {
  const bets = { place: { six: { amount: 6 }, eight: { amount: 6 } } }

  const hand = {
    result: 'comeout win',
    isComeOut: true,
    diceSum: 11
  }

  const settled = settle.all({ bets, hand })

  t.equal(settled.place.six.amount, 6)
  t.equal(settled.place.eight.amount, 6)
  t.equal(settled.payouts.total, 0)

  t.end()
})

tap.test('place bet on 6 persists when point is 6', (t) => {
  const bets = { place: { six: { amount: 6 }, eight: { amount: 6 } } }

  const hand = {
    result: 'point set',
    isComeOut: false,
    diceSum: 6,
    point: 6
  }

  const settled = settle.all({ bets, hand })

  t.equal(settled.place.six.amount, 6)
  t.equal(settled.place.eight.amount, 6)
  t.equal(settled.payouts.total, 0)

  t.end()
})

tap.test('place bet on 8 persists when point is 8', (t) => {
  const bets = { place: { six: { amount: 6 }, eight: { amount: 6 } } }

  const hand = {
    result: 'point set',
    isComeOut: false,
    diceSum: 8,
    point: 8
  }

  const settled = settle.all({ bets, hand })

  t.equal(settled.place.six.amount, 6)
  t.equal(settled.place.eight.amount, 6)
  t.equal(settled.payouts.total, 0)

  t.end()
})

tap.test('place bet on 6 pays on point win of 6', (t) => {
  const bets = { place: { six: { amount: 6 } } }

  const hand = {
    result: 'point win',
    isComeOut: true,
    diceSum: 6
  }

  const settled = settle.all({ bets, hand })

  t.notOk(settled.place.six)
  t.equal(settled.payouts.total, 13)

  t.end()
})

tap.test('place bet on 8 pays on point win of 8', (t) => {
  const bets = { place: { eight: { amount: 6 } } }

  const hand = {
    result: 'point win',
    isComeOut: true,
    diceSum: 8
  }

  const settled = settle.all({ bets, hand })

  t.notOk(settled.place.eight)
  t.equal(settled.payouts.total, 13)

  t.end()
})

// placeBetsOffOnComeOut rule and per-bet working flag

tap.test('place bet: table placeBetsOffOnComeOut:true blocks pay on custom come-out match', (t) => {
  const rules = { placeBetsOffOnComeOut: true, comeOutWin: [7, 11, 6] }
  const bets = { place: { six: { amount: 6 } } }
  const hand = { result: 'comeout win', isComeOut: true, diceSum: 6 }

  const settled = settle.all({ rules, bets, hand })

  t.equal(settled.place.six.amount, 6, 'place six carries over (not paid)')
  t.equal(settled.payouts.total, 0)
  t.end()
})

tap.test('place bet: table placeBetsOffOnComeOut:true carries over on come-out 7', (t) => {
  const rules = { placeBetsOffOnComeOut: true }
  const bets = { place: { six: { amount: 6 }, eight: { amount: 6 } } }
  const hand = { result: 'comeout win', isComeOut: true, diceSum: 7 }

  const settled = settle.all({ rules, bets, hand })

  t.equal(settled.place.six.amount, 6)
  t.equal(settled.place.eight.amount, 6)
  t.equal(settled.payouts.total, 0)
  t.end()
})

tap.test('place bet: table placeBetsOffOnComeOut:false allows pay on custom come-out match', (t) => {
  const rules = { placeBetsOffOnComeOut: false, comeOutWin: [7, 11, 6] }
  const bets = { place: { six: { amount: 6 } } }
  const hand = { result: 'comeout win', isComeOut: true, diceSum: 6 }

  const settled = settle.all({ rules, bets, hand })

  t.notOk(settled.place?.six, 'place six removed after win')
  t.equal(settled.payouts.total, 13)
  t.end()
})

tap.test('place bet: working:true on bet overrides table placeBetsOffOnComeOut:true', (t) => {
  const rules = { placeBetsOffOnComeOut: true, comeOutWin: [7, 11, 6] }
  const bets = { place: { six: { amount: 6, working: true } } }
  const hand = { result: 'comeout win', isComeOut: true, diceSum: 6 }

  const settled = settle.all({ rules, bets, hand })

  t.notOk(settled.place?.six, 'place six removed after win')
  t.equal(settled.payouts.total, 13)
  t.end()
})

tap.test('place bet: working:false on bet overrides table placeBetsOffOnComeOut:false', (t) => {
  const rules = { placeBetsOffOnComeOut: false, comeOutWin: [7, 11, 6] }
  const bets = { place: { six: { amount: 6, working: false } } }
  const hand = { result: 'comeout win', isComeOut: true, diceSum: 6 }

  const settled = settle.all({ rules, bets, hand })

  t.equal(settled.place.six.amount, 6, 'place six carries over (bet opted off)')
  t.equal(settled.payouts.total, 0)
  t.end()
})

tap.test('placeBet: throws for unsupported place number', (t) => {
  const bets = { place: { 5: { amount: 10 } } }
  const hand = { result: 'neutral', diceSum: 5, isComeOut: false }

  t.throws(
    () => settle.placeBet({ rules: {}, bets, hand, placeNumber: 5 }),
    /placeBet only supports 6 and 8/,
    'throws with a descriptive message for non-6/8 place number'
  )
  t.end()
})

tap.test('dontComeLine: pending bet wins immediately on 2', (t) => {
  const bets = { dontCome: { pending: [{ amount: 5 }] } }
  const hand = { result: 'neutral', diceSum: 2 }

  const result = settle.dontComeLine({ bets, hand })

  t.equal(result.payouts[0].type, 'dont come line win')
  t.equal(result.payouts[0].principal, 5)
  t.equal(result.payouts[0].profit, 5)
  t.notOk(result.bets.dontCome)
  t.end()
})

tap.test('dontComeLine: pending bet wins immediately on 3', (t) => {
  const bets = { dontCome: { pending: [{ amount: 5 }] } }
  const hand = { result: 'neutral', diceSum: 3 }

  const result = settle.dontComeLine({ bets, hand })

  t.equal(result.payouts[0].type, 'dont come line win')
  t.equal(result.payouts[0].principal, 5)
  t.equal(result.payouts[0].profit, 5)
  t.notOk(result.bets.dontCome)
  t.end()
})

tap.test('dontComeLine: pending bet loses immediately on 7', (t) => {
  const bets = { dontCome: { pending: [{ amount: 5 }] } }
  const hand = { result: 'seven out', diceSum: 7 }

  const result = settle.dontComeLine({ bets, hand })

  t.notOk(result.payouts?.length)
  t.notOk(result.bets.dontCome)
  t.end()
})

tap.test('dontComeLine: pending bet loses immediately on 11', (t) => {
  const bets = { dontCome: { pending: [{ amount: 5 }] } }
  const hand = { result: 'neutral', diceSum: 11 }

  const result = settle.dontComeLine({ bets, hand })

  t.notOk(result.payouts?.length)
  t.notOk(result.bets.dontCome)
  t.end()
})

tap.test('dontComeLine: pending bet pushes on 12', (t) => {
  const bets = { dontCome: { pending: [{ amount: 5 }] } }
  const hand = { result: 'neutral', diceSum: 12 }

  const result = settle.dontComeLine({ bets, hand })

  t.equal(result.payouts[0].type, 'dont come line push')
  t.equal(result.payouts[0].principal, 5)
  t.equal(result.payouts[0].profit, 0)
  t.notOk(result.bets.dontCome)
  t.end()
})

tap.test('dontComeLine: pending bet moves to point', (t) => {
  const bets = { dontCome: { pending: [{ amount: 5 }] } }
  const hand = { result: 'neutral', diceSum: 8 }

  const result = settle.dontComeLine({ bets, hand })

  t.notOk(result.payouts?.length)
  t.equal(result.bets.dontCome.points[8][0].line.amount, 5)
  t.notOk(result.bets.dontCome.pending)
  t.end()
})

tap.test('dontComeLine: established bet wins on seven out', (t) => {
  const bets = { dontCome: { points: { 8: [{ line: { amount: 5 } }] } } }
  const hand = { result: 'seven out', diceSum: 7 }

  const result = settle.dontComeLine({ bets, hand })

  t.equal(result.payouts[0].type, 'dont come line win')
  t.equal(result.payouts[0].principal, 5)
  t.equal(result.payouts[0].profit, 5)
  t.notOk(result.bets.dontCome)
  t.end()
})

tap.test('dontComeLine: established bet loses when point is rolled', (t) => {
  const bets = { dontCome: { points: { 8: [{ line: { amount: 5 } }] } } }
  const hand = { result: 'neutral', diceSum: 8 }

  const result = settle.dontComeLine({ bets, hand })

  t.notOk(result.payouts?.length)
  t.notOk(result.bets.dontCome)
  t.end()
})

tap.test('dontComeLine: established bet carries over on neutral roll', (t) => {
  const bets = { dontCome: { points: { 8: [{ line: { amount: 5 } }] } } }
  const hand = { result: 'neutral', diceSum: 5 }

  const result = settle.dontComeLine({ bets, hand })

  t.notOk(result.payouts?.length)
  t.equal(result.bets.dontCome.points[8][0].line.amount, 5)
  t.end()
})

tap.test('dontComeLine: no bet', (t) => {
  const bets = {}
  const hand = { result: 'neutral', diceSum: 8 }

  const result = settle.dontComeLine({ bets, hand })

  t.notOk(result.payouts)
  t.end()
})