How to use pull-length-prefixed - 10 common examples

type: Type.RESPONSE,
                                status: Status.FAIL
                            })
                        )
                        return false
                    }
                }

                pull(
                    pull.once(
                        Message.encode({
                            type: Type.RESPONSE,
                            status: Status.FAIL
                        })
                    ),
                    lp.encode(),
                    conn
                )

                // Cancel stream by returning false
                return false
        }
    }

it('should create circuit', (done) => {
        pull(
          values([proto.CircuitRelay.encode({
            type: proto.CircuitRelay.Type.STATUS,
            code: proto.CircuitRelay.Status.SUCCESS
          })]),
          lp.encode(),
          collect((err, encoded) => {
            expect(err).to.not.exist()

            encoded.forEach((e) => dstShake.write(e))
            pull(
              values([Buffer.from('hello')]),
              lp.encode(),
              collect((err, encoded) => {
                expect(err).to.not.exist()

                encoded.forEach((e) => srcShake.write(e))
                lp.decodeFromReader(
                  dstShake,
                  (err, _msg) => {
                    expect(err).to.not.exist()
                    expect(_msg.toString()).to.equal('hello')

original.multiaddrs.add(multiaddr('/ip4/127.0.0.1/tcp/5002'))
    original.protocols.add('/echo/1.0.0')
    original.protocols.add('/ping/1.0.0')

    const input = msg.encode({
      protocolVersion: 'ipfs/0.1.0',
      agentVersion: 'na',
      publicKey: original.id.pubKey.bytes,
      listenAddrs: [multiaddr('/ip4/127.0.0.1/tcp/5002').buffer],
      observedAddr: multiaddr('/ip4/127.0.0.1/tcp/5001').buffer,
      protocols: Array.from(original.protocols)
    })

    pull(
      values([input]),
      lp.encode(),
      p[0]
    )

    identify.dialer(p[1], (err, info, observedAddrs) => {
      expect(err).to.not.exist()
      expect(info.id.pubKey.bytes)
        .to.eql(original.id.pubKey.bytes)

      expect(info.multiaddrs.has(original.multiaddrs.toArray()[0]))
        .to.eql(true)

      expect(multiaddr('/ip4/127.0.0.1/tcp/5001').equals(observedAddrs[0]))
        .to.eql(true)

      expect(info.protocols).to.eql(original.protocols)

original.multiaddrs.add(multiaddr('/ip4/127.0.0.1/tcp/5002'))
    original.protocols.add('/echo/1.0.0')
    original.protocols.add('/ping/1.0.0')

    const input = msg.encode({
      protocolVersion: 'ipfs/0.1.0',
      agentVersion: 'na',
      publicKey: original.id.pubKey.bytes,
      listenAddrs: [multiaddr('/ip4/127.0.0.1/tcp/5002').buffer],
      observedAddr: multiaddr('/ip4/127.0.0.1/tcp/5001').buffer,
      protocols: Array.from(original.protocols)
    })

    pull(
      values([input]),
      lp.encode(),
      p[0]
    )

    identify.dialer(p[1], (err, info, observedAddrs) => {
      expect(err).to.not.exist()
      expect(info.id.pubKey.bytes)
        .to.eql(original.id.pubKey.bytes)

      expect(info.multiaddrs.toArray())
        .to.eql(original.multiaddrs.toArray())

      expect(observedAddrs)
        .to.eql([multiaddr('/ip4/127.0.0.1/tcp/5001')])

      expect(info.protocols).to.eql(original.protocols)

listener.hopHandler.handle = (message, conn) => {
        expect(message.type).to.equal(proto.CircuitRelay.Type.HOP)

        expect(message.srcPeer.id.toString()).to.equal(relayMsg.srcPeer.id)
        expect(message.srcPeer.addrs[0].toString()).to.equal(relayMsg.srcPeer.addrs[0])

        expect(message.dstPeer.id.toString()).to.equal(relayMsg.dstPeer.id)
        expect(message.dstPeer.addrs[0].toString()).to.equal(relayMsg.dstPeer.addrs[0])

        done()
      }

      pull(
        values([proto.CircuitRelay.encode(relayMsg)]),
        lp.encode(),
        collect((err, encoded) => {
          expect(err).to.not.exist()
          encoded.forEach((e) => shake.write(e))
        })
      )
    })

libp2pNode.handle('/eth/block/sync/1.0.0', (conn) => {
      pull(
        pull.values(blocks),
        lp.encode(),
        conn
      )
    })
  }

function protoStreamEncode (codec: ProtoCodec): PullStreamThrough {
  return pull(
    pull.map(codec.encode),
    lp.encode()
  )
}

module.exports = (node) => node.handle(PROTOCOL_DELIVER_PUBKEY, (protocol, conn) => {
    pull(
        pull.once(node.peerInfo.id.pubKey.marshal()),
        lp.encode(),
        conn
    )
})

(conn, cb) => {
                pull(
                    pull.once(
                        Acknowledgement.create(
                            packet.oldChallenge,
                            packet.header.derivedSecret,
                            node.peerInfo.id
                        ).toBuffer()
                    ),
                    lp.encode(),
                    conn
                )
                cb()
            }
        ], cb)

node.handle(PROTOCOL_PAYMENT_CHANNEL, (protocol, conn) =>
        pull(
            conn,
            lp.decode({
                maxLength: Transaction.SIZE
            }),
            paramap(handleOpeningRequest, null, false),
            lp.encode(),
            conn
        )
    )