<p>Because <strong>firstGame</strong> is the contract that initialises the game, it needs to communicate somehow the generated <strong>threadToken</strong> to the external world (<strong>secondGame</strong> in this case). For this kind of communication <strong>Contract</strong> monad uses <strong>tell</strong> mechanism.</p>
<p>How does the info flow? You can see it in <strong>myTrace</strong> function in <code>Week07.TestStateMachine</code>.</p>
<ul>
<li><p>(1) <code>callEndpoint @&quot;first&quot; h1 fp</code> - Initialise the game, and <strong>firstGame</strong> contract internally tells the generated <strong>threadToken</strong> to anyone interested in it.</p>
</li>
<li><p>(2) <code>tt &lt;- getTT h1</code> - This function uses <strong>observableState</strong> function, which &quot;get the observable state w of a contract instance&quot;. In our case <strong>w</strong> in <strong>firstGame</strong> Contract is <strong>(Last ThreadToken)</strong>.</p>
</li>
</ul>
<pre><code>   firstGame :: forall s. FirstParams -&gt; Contract (Last ThreadToken) s Text ()
</code></pre>
<ul>
<li><p>(3) <code>let sp = SecondParams {...  spToken = tt ...}</code> - Build params for <strong>secondGame</strong> using <strong>threadToken</strong> generated by <strong>firstGame</strong> contract, <strong>tt</strong>.</p>
</li>
<li><p>(4) <code>callEndpoint @&quot;second&quot; h2 sp</code> - <strong>secondGame</strong> plays.</p>
</li>
</ul>
<p><strong>Notice that communication is not direct Contract to Contract but through observableState function</strong></p>
<pre><code>myTrace :: GameChoice -&gt; GameChoice -&gt; EmulatorTrace ()
myTrace c1 c2 = do
    Extras.logInfo $ &quot;first move: &quot; ++ show c1 ++ &quot;, second move: &quot; ++ show c2

    let w1 = knownWallet 1
    let w2 = knownWallet 2

    h1 &lt;- activateContractWallet w1 endpoints
    h2 &lt;- activateContractWallet w2 endpoints

    let pkh1      = mockWalletPaymentPubKeyHash w1
        pkh2      = mockWalletPaymentPubKeyHash w2
        stake     = 5_000_000
        deadline1 = slotToEndPOSIXTime def 5
        deadline2 = slotToEndPOSIXTime def 10

        fp = FirstParams
                { fpSecond         = pkh2
                , fpStake          = stake
                , fpPlayDeadline   = deadline1
                , fpRevealDeadline = deadline2
                , fpNonce          = &quot;SECRETNONCE&quot;
                , fpChoice         = c1
                }

    callEndpoint @&quot;first&quot; h1 fp   -- (1)

    tt &lt;- getTT                   -- (2)

    let sp = SecondParams         -- (3)
                { spFirst          = pkh1
                , spStake          = stake
                , spPlayDeadline   = deadline1
                , spRevealDeadline = deadline2
                , spChoice         = c2
                , spToken          = tt
                }

    void $ Emulator.waitNSlots 3  -- (4)

    callEndpoint @&quot;second&quot; h2 sp

    void $ Emulator.waitNSlots 10
  where
    getTT :: ContractHandle (Last ThreadToken) GameSchema Text -&gt; EmulatorTrace ThreadToken
    getTT h = do
        void $ Emulator.waitNSlots 1
        Last m &lt;- observableState      -- (2)
        case m of
            Nothing -&gt; getTT h
            Just tt -&gt; Extras.logInfo (&quot;read thread token &quot; ++ show tt) &gt;&gt; return tt
</code></pre>

CC BY-SA 4.0
2022-03-04T12:00:19.250Z
Ouch, my bad, I didn't look at the test. The getTT method also explains the loop when I comment out the tell.
Mihai Codescu
CC BY-SA 4.0
2022-03-04T10:55:33.527Z
2022-03-04T11:11:53.443Z
2022-03-04T11:11:53.443Z
kindofdev
<p>In the <code>firstGame</code> function, we use the &quot;logging&quot; component of the contract to <code>tell</code> the thread token. It's not obvious to me where this is needed: is there an internal check in the <code>runStep</code> function that this token matches the one in the parameter, i.e. <code>SecondParams</code>? I commented out the line where <code>tt</code> is <code>told</code> and that results in an endless loop, while I expected a failure.</p>

<plutus-pioneer-program><statemachines><week07>
passing the thread token
# passing the thread token

(Asked by: username_0 on 2022-03-04)

In the `firstGame` function, we use the "logging" component of the contract to `tell` the thread token. It's not obvious to me where this is needed: is there an internal check in the `runStep` function that this token matches the one in the parameter, i.e. `SecondParams`? I commented out the line where `tt` is `told` and that results in an endless loop, while I expected a failure.

**Tags:** plutus-pioneer-program, statemachines, week07


---

## 1 answers

### Answer by username_1 on 2022-03-04. Score: 2 | Accepted answer

Because **firstGame** is the contract that initialises the game, it needs to communicate somehow the generated **threadToken** to the external world (**secondGame** in this case). For this kind of communication **Contract** monad uses **tell** mechanism.

How does the info flow? You can see it in **myTrace** function in `Week07.TestStateMachine`.

* (1) `callEndpoint @"first" h1 fp` - Initialise the game, and **firstGame** contract internally tells the generated **threadToken** to anyone interested in it.
* (2) `tt <- getTT h1` - This function uses **observableState** function, which "get the observable state w of a contract instance". In our case **w** in **firstGame** Contract is **(Last ThreadToken)**.

```
   firstGame :: forall s. FirstParams -> Contract (Last ThreadToken) s Text ()

```

* (3) `let sp = SecondParams {... spToken = tt ...}` - Build params for **secondGame** using **threadToken** generated by **firstGame** contract, **tt**.
* (4) `callEndpoint @"second" h2 sp` - **secondGame** plays.

**Notice that communication is not direct Contract to Contract but through observableState function**

```
myTrace :: GameChoice -> GameChoice -> EmulatorTrace ()
myTrace c1 c2 = do
    Extras.logInfo $ "first move: " ++ show c1 ++ ", second move: " ++ show c2

    let w1 = knownWallet 1
    let w2 = knownWallet 2

    h1 <- activateContractWallet w1 endpoints
    h2 <- activateContractWallet w2 endpoints

    let pkh1      = mockWalletPaymentPubKeyHash w1
        pkh2      = mockWalletPaymentPubKeyHash w2
        stake     = 5_000_000
        deadline1 = slotToEndPOSIXTime def 5
        deadline2 = slotToEndPOSIXTime def 10

        fp = FirstParams
                { fpSecond         = pkh2
                , fpStake          = stake
                , fpPlayDeadline   = deadline1
                , fpRevealDeadline = deadline2
                , fpNonce          = "SECRETNONCE"
                , fpChoice         = c1
                }

    callEndpoint @"first" h1 fp   -- (1)

    tt <- getTT                   -- (2)

    let sp = SecondParams         -- (3)
                { spFirst          = pkh1
                , spStake          = stake
                , spPlayDeadline   = deadline1
                , spRevealDeadline = deadline2
                , spChoice         = c2
                , spToken          = tt
                }

    void $ Emulator.waitNSlots 3  -- (4)

    callEndpoint @"second" h2 sp

    void $ Emulator.waitNSlots 10
  where
    getTT :: ContractHandle (Last ThreadToken) GameSchema Text -> EmulatorTrace ThreadToken
    getTT h = do
        void $ Emulator.waitNSlots 1
        Last m <- observableState      -- (2)
        case m of
            Nothing -> getTT h
            Just tt -> Extras.logInfo ("read thread token " ++ show tt) >> return tt

```

> **Comments:**
> **username_0**: Ouch, my bad, I didn't look at the test. The getTT method also explains the loop when I comment out the tell.  

---

