# The Flip Smart Contract part 8 : Bounty endpoint

Our contract is almost finished. We are able to initiate flips and generate their results, but at the moment we only have logic for generate a single flip result. We will write the bounty endpoint that will be call the previously written function `make_flip` for each initiated flip.

## Waiting flips

Earlier, when writing the storage, we wrote two values : `lastFlipId` and `lastBountyFlipId`.

Theses two values let us know which flips need to be made, the flips are in the range `lastBountyFlipId` (excluded) to `lastFlipId` (included).

Here is a timeline example, let's assume minimumBlockBounty is 2, meaning that a flip's result can only be generate two blocks after initialisation  : 

* Block 1 : Our contract is deployed
* Block 2 : Alice bets 0.5 $EGLD, flip with `id = 1` is created and `lastFlipId` is now `1`
* Block 4 : Bob calls bounty endpoint and makes Alice's flip, lastBountyFlipId is now 1
* Block 5 : Alice bets 0.5 $EGLD (flip with id 2), Bob bets 1 $EGLD (flip with id 3), `lastFlipId` is now `3`
* Block 6 : Charles bets 1 $EGLD (flip with id 4), `lastFlipId` is now `4`. Note that `lastBountyFlip` is still `1`, meaning that flips `2`, `3` and `4` are waiting for bounty.
* Block 7 : David call bounty endpoint and makes Alice and Bob flips but NOT Charles one because at least 2 blocks are required between the bet and the generation. `lastBountyFlipId` is now `3`
* Block 8 : David calls again bounty and makes Charles' flip, `lastBountyFlipId` is now 4, the same as `lastFlipId`, no flips are waiting for bounty.

## Bounty endpoint code

Here is the bounty endpoint code : 

```typescript
bounty(): void {
    const caller = this.blockchain.caller

    this.require(
        !this.blockchain.isSmartContract(caller),
        "caller is a smart contract"
    )

    const lastBountyFlipId = this.lastBountyFlipId().get()
    const lastFlipId = this.lastFlipId().get()

    this.require(
        lastBountyFlipId < lastFlipId,
        "last bounty flip id >= last flip id"
    )

    const currentBlockNonce = this.blockchain.currentBlockNonce

    let bountyFlipId = lastBountyFlipId

    while (bountyFlipId < lastFlipId) {
        const flipId = bountyFlipId + ManagedU64.fromValue(1)

        if (this.flipForId(flipId).isEmpty()) {
            break
        }

        const flip = this.flipForId(flipId).get()

        if (currentBlockNonce < flip.blockNonce + flip.minimumBlockBounty) {
            break
        }

        this.makeFlip(
            caller,
            flip
        )

        bountyFlipId = bountyFlipId + ManagedU64.fromValue(1)
    }

    this.require(
        bountyFlipId != lastBountyFlipId,
        "no bounty"
    )

    this.lastBountyFlipId().set(bountyFlipId)
}
```

With explanations above this code should not be difficult to read. The only new method used is `isSmartContract` that indicates if whether or not an address is a smart contract, here we don't want smart contracts to call this endpoint. A smart contract calling this endpoint has the ability to revert the transaction if the result doesn't suit it.&#x20;

Notice that we break the while loop if we cannot generate a flip's result for any reason because in a such case there is no chance next flips can be made (for the same reason).

## Next up

We finished writing our contract ! In the next part we will talk about testing.