Show how to construct a send-constrained channel from a receive-constrained channel, and vice versa. Hint: use a trusted node connected to the given channel.

What will be an ideal response?

Let rc be a receive-constrained channel. We shall show how to construct a channel s(rc), which is send- constrained.
We use a trusted node N. When it receives a message m, it uses the receive-constrained channel to return to the sender a signed hash sig{h(m, t)}, where t is the time by N's clock.

Let c be any (possibly unconstrained) channel connecting the parties that we wish to be able to communicate. We construct s(rc) from c and N. The rules for sending and receiving on s(rc) are as follows:
```
To send m on s(rc):

send m to N

receive < t, sig{h(m, t)}> from N over rc send on c.
To receive m on s(rc):

receive on c verify h = sig{h(m, t)}
verify currency of t and freshness of h

Discard m if verification fails, else receive m.
```
We assume that the receivers' clocks are synchronised to N's clock. The timestamp (and hence state of the sender) is deemed current if it is within a given bound of the time on the receiver's clock. To prevent replay attacks, the receiver need remember the hashes for only a limited time: older messages will have a non-current timestamp.
In a similar fashion, we can implement a receive-constrained channel from a send-constrained channel. All messages are sent (over any channel) to a trusted node, which stores them. Receivers must use a particular send-constrained channel to reach that node, which responds with the next message for them.