Skip to content

Instantly share code, notes, and snippets.

@zah

zah/beacon_sync.nim

Created March 26, 2019 10:06
Show Gist options
  • Save zah/dbfafeed64b773d67a34627c1f20cc27 to your computer and use it in GitHub Desktop.
Save zah/dbfafeed64b773d67a34627c1f20cc27 to your computer and use it in GitHub Desktop.
Download ZIP
beacon_node RLPx protocols
Raw
beacon_sync.nim
type
BeaconSync* = object
template NetworkState*(P1822062: type BeaconSync): type =
ref[BeaconSyncState:ObjectType]
type
statusObj* = object
networkId*: uint64
latestFinalizedRoot*: Eth2Digest
latestFinalizedEpoch*: Epoch
bestRoot*: Eth2Digest
bestSlot*: Slot
template status*(T1822071: type BeaconSync): type =
statusObj
template msgId*(T1822073: type statusObj): int =
0
template msgProtocol*(T1822075: type statusObj): type =
BeaconSync
type
beaconBlockRootsObj* = object
roots*: seq[(Eth2Digest, Slot)]
template beaconBlockRoots*(T1822081: type BeaconSync): type =
beaconBlockRootsObj
template msgId*(T1822083: type beaconBlockRootsObj): int =
1
template msgProtocol*(T1822085: type beaconBlockRootsObj): type =
BeaconSync
type
beaconBlockHeadersObj* = object
blockHeaders*: seq[BeaconBlockHeaderRLP]
template beaconBlockHeaders*(T1822091: type BeaconSync): type =
beaconBlockHeadersObj
template msgId*(T1822093: type beaconBlockHeadersObj): int =
3
template msgProtocol*(T1822095: type beaconBlockHeadersObj): type =
BeaconSync
type
getBeaconBlockHeadersObj* = object
blockRoot*: Eth2Digest
slot*: Slot
maxHeaders*: int
skipSlots*: int
template getBeaconBlockHeaders*(T1822108: type BeaconSync): type =
getBeaconBlockHeadersObj
template msgId*(T1822110: type getBeaconBlockHeadersObj): int =
2
template msgProtocol*(T1822112: type getBeaconBlockHeadersObj): type =
BeaconSync
type
beaconBlockBodiesObj* = object
blockBodies*: seq[BeaconBlockBody]
template beaconBlockBodies*(T1822118: type BeaconSync): type =
beaconBlockBodiesObj
template msgId*(T1822120: type beaconBlockBodiesObj): int =
5
template msgProtocol*(T1822122: type beaconBlockBodiesObj): type =
BeaconSync
type
getBeaconBlockBodiesObj* = object
blockRoots*: seq[Eth2Digest]
template getBeaconBlockBodies*(T1822135: type BeaconSync): type =
getBeaconBlockBodiesObj
template msgId*(T1822137: type getBeaconBlockBodiesObj): int =
4
template msgProtocol*(T1822139: type getBeaconBlockBodiesObj): type =
BeaconSync
var p1822141 = initProtocol("bcs", 1, nil,
createNetworkState[ref[BeaconSyncState:ObjectType]])
var BeaconSyncProtocol = addr p1822141
template protocolInfo*(P1822143: type BeaconSync): ProtocolInfo =
BeaconSyncProtocol
proc status*(sendTo: Peer; networkId: uint64; latestFinalizedRoot: Eth2Digest;
latestFinalizedEpoch: Epoch; bestRoot: Eth2Digest; bestSlot: Slot): Future[
void] {.libp2pProtocol("hello", "1.0.0"), gcsafe.} =
let msgRecipient = getPeer(sendTo)
var writer = initRlpWriter()
const
perProtocolMsgId = 0
let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, BeaconSyncProtocol, 0)
append(writer, perPeerMsgId)
startList(writer, 5)
append(writer, networkId)
append(writer, latestFinalizedRoot)
append(writer, latestFinalizedEpoch)
append(writer, bestRoot)
append(writer, bestSlot)
let msgBytes = finish(writer)
return sendMsg(msgRecipient, msgBytes)
proc beaconBlockRoots*(sendTo: Peer; roots: openarray[(Eth2Digest, Slot)]): Future[
void] {.libp2pProtocol("rpc/beacon_block_roots", "1.0.0"), gcsafe.} =
let msgRecipient = getPeer(sendTo)
var writer = initRlpWriter()
const
perProtocolMsgId = 1
let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, BeaconSyncProtocol, 1)
append(writer, perPeerMsgId)
append(writer, roots)
let msgBytes = finish(writer)
return sendMsg(msgRecipient, msgBytes)
proc beaconBlockHeaders*(sendTo: ResponseWithId[beaconBlockHeadersObj];
blockHeaders: openarray[BeaconBlockHeaderRLP]): Future[
void] {.gcsafe.} =
let msgRecipient = getPeer(sendTo)
var writer = initRlpWriter()
const
perProtocolMsgId = 3
let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, BeaconSyncProtocol, 3)
append(writer, perPeerMsgId)
startList(writer, 2)
append(writer, sendTo.id)
append(writer, blockHeaders)
let msgBytes = finish(writer)
return sendMsg(msgRecipient, msgBytes)
template send*(r1822097: ResponseWithId[beaconBlockHeadersObj]; args1822099: varargs[
untyped]): auto =
beaconBlockHeaders(r1822097, args1822099)
proc getBeaconBlockHeaders*(sendTo: Peer; blockRoot: Eth2Digest; slot: Slot;
maxHeaders: int; skipSlots: int; timeout: Duration = milliseconds(
10000'i64)): Future[Option[beaconBlockHeadersObj]] {.
libp2pProtocol("rpc/beacon_block_headers", "1.0.0"), gcsafe.} =
let msgRecipient = getPeer(sendTo)
var writer = initRlpWriter()
const
perProtocolMsgId = 2
let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, BeaconSyncProtocol, 2)
append(writer, perPeerMsgId)
startList(writer, 5)
newFuture result
let reqId = registerRequest(msgRecipient, timeout, result, perPeerMsgId +
1)
append(writer, reqId)
append(writer, blockRoot)
append(writer, slot)
append(writer, maxHeaders)
append(writer, skipSlots)
let msgBytes = finish(writer)
linkSendFailureToReqFuture(sendMsg(msgRecipient, msgBytes), result)
proc beaconBlockBodies*(sendTo: ResponseWithId[beaconBlockBodiesObj];
blockBodies: openarray[BeaconBlockBody]): Future[void] {.
gcsafe.} =
let msgRecipient = getPeer(sendTo)
var writer = initRlpWriter()
const
perProtocolMsgId = 5
let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, BeaconSyncProtocol, 5)
append(writer, perPeerMsgId)
startList(writer, 2)
append(writer, sendTo.id)
append(writer, blockBodies)
let msgBytes = finish(writer)
return sendMsg(msgRecipient, msgBytes)
template send*(r1822124: ResponseWithId[beaconBlockBodiesObj]; args1822126: varargs[
untyped]): auto =
beaconBlockBodies(r1822124, args1822126)
proc getBeaconBlockBodies*(sendTo: Peer; blockRoots: openarray[Eth2Digest]; timeout: Duration = milliseconds(
10000'i64)): Future[Option[beaconBlockBodiesObj]] {.
libp2pProtocol("rpc/beacon_block_bodies", "1.0.0"), gcsafe.} =
let msgRecipient = getPeer(sendTo)
var writer = initRlpWriter()
const
perProtocolMsgId = 4
let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, BeaconSyncProtocol, 4)
append(writer, perPeerMsgId)
startList(writer, 2)
newFuture result
let reqId = registerRequest(msgRecipient, timeout, result, perPeerMsgId +
1)
append(writer, reqId)
append(writer, blockRoots)
let msgBytes = finish(writer)
linkSendFailureToReqFuture(sendMsg(msgRecipient, msgBytes), result)
proc BeaconSyncHandshake1822063(peer: Peer) {.gcsafe, async.} =
type
CurrentProtocol = BeaconSync
template networkState(p1822065: Peer): ref[BeaconSyncState:ObjectType] =
cast[ref[BeaconSyncState:ObjectType]](getNetworkState(p1822065.network,
BeaconSyncProtocol))
let
protocolVersion = 1
node = peer.networkState.node
networkId = peer.networkState.networkId
var
latestFinalizedRoot: Eth2Digest
latestFinalizedEpoch = node.state.data.finalized_epoch
bestRoot: Eth2Digest
bestSlot = node.state.data.slot
let m = await handshake(peer, timeout = 10.seconds, status(networkId,
latestFinalizedRoot, latestFinalizedEpoch, bestRoot, bestSlot))
if m.networkId != networkId:
await peer.disconnect(UselessPeer)
return
try:
let bestDiff = cmp((latestFinalizedEpoch, bestSlot),
(m.latestFinalizedEpoch, m.bestSlot))
if bestDiff == 0:
trace "Nothing to sync", peer = peer.remote
else:
let blockPool = peer.networkState.node.blockPool
if bestDiff > 0:
type
Root = (Eth2Digest, Slot)
var roots = newSeqOfCap[Root](128)
for i in int(m.bestSlot) .. int(bestSlot):
for r in blockPool.blockRootsForSlot(i.Slot):
roots.add((r, i.Slot))
await peer.beaconBlockRoots(roots)
else:
let roots = await peer.nextMsg(BeaconSync.beaconBlockRoots)
let headers = await peer.getBeaconBlockHeaders(bestRoot, bestSlot,
roots.roots.len, 0)
var bodiesRequest = newSeqOfCap[Eth2Digest](roots.roots.len)
for r in roots.roots:
bodiesRequest.add(r[0])
let bodies = await peer.getBeaconBlockBodies(bodiesRequest)
node.importBlocks(roots.roots, headers.get.blockHeaders,
bodies.get.blockBodies)
except CatchableError:
warn "Failed to sync with peer", peer, err = getCurrentExceptionMsg()
proc status_thunk(msgSender: Peer; _1822067: int; data1822069: Rlp) {.gcsafe,
libp2pProtocol("hello", "1.0.0"), async.} =
var rlp = data1822069
var msg {.noinit.}: statusObj
enterList(rlp)
msg.networkId = checkedRlpRead(msgSender, rlp, uint64)
msg.latestFinalizedRoot = checkedRlpRead(msgSender, rlp, Eth2Digest)
msg.latestFinalizedEpoch = checkedRlpRead(msgSender, rlp, Epoch)
msg.bestRoot = checkedRlpRead(msgSender, rlp, Eth2Digest)
msg.bestSlot = checkedRlpRead(msgSender, rlp, Slot)
proc beaconBlockRoots_thunk(msgSender: Peer; _1822077: int; data1822079: Rlp) {.gcsafe,
libp2pProtocol("rpc/beacon_block_roots", "1.0.0"), async.} =
var rlp = data1822079
var msg {.noinit.}: beaconBlockRootsObj
msg.roots = checkedRlpRead(msgSender, rlp, openarray[(Eth2Digest, Slot)])
proc beaconBlockHeaders_thunk(msgSender: Peer; _1822087: int; data1822089: Rlp) {.
gcsafe, async.} =
var rlp = data1822089
var msg {.noinit.}: beaconBlockHeadersObj
enterList(rlp)
let reqId = read(rlp, int)
msg.blockHeaders = checkedRlpRead(msgSender, rlp, openarray[BeaconBlockHeaderRLP])
resolveResponseFuture(msgSender,
perPeerMsgId(msgSender, beaconBlockHeadersObj), addr(msg),
reqId)
proc getBeaconBlockHeaders1822100(peer: Peer; reqId: int; blockRoot: Eth2Digest;
slot: Slot; maxHeaders: int; skipSlots: int) {.
libp2pProtocol("rpc/beacon_block_headers", "1.0.0"), gcsafe, async.} =
type
CurrentProtocol = BeaconSync
let response = ResponseWithId[beaconBlockHeadersObj](peer: peer, id: reqId)
const
perProtocolMsgId = 2
template networkState(p1822102: Peer): ref[BeaconSyncState:ObjectType] =
cast[ref[BeaconSyncState:ObjectType]](getNetworkState(p1822102.network,
BeaconSyncProtocol))
var s = slot.int
var headers = newSeqOfCap[BeaconBlockHeaderRLP](maxHeaders)
let db = peer.networkState.db
let blockPool = peer.networkState.node.blockPool
while headers.len < maxHeaders:
for r in blockPool.blockRootsForSlot(s.Slot):
headers.add(db.getBlock(r).get().toHeader)
if headers.len == maxHeaders:
break
inc s
await response.send(headers)
proc getBeaconBlockHeaders_thunk(msgSender: Peer; _1822104: int; data1822106: Rlp) {.
gcsafe, libp2pProtocol("rpc/beacon_block_headers", "1.0.0"), async.} =
var rlp = data1822106
var msg {.noinit.}: getBeaconBlockHeadersObj
enterList(rlp)
let reqId = read(rlp, int)
msg.blockRoot = checkedRlpRead(msgSender, rlp, Eth2Digest)
msg.slot = checkedRlpRead(msgSender, rlp, Slot)
msg.maxHeaders = checkedRlpRead(msgSender, rlp, int)
msg.skipSlots = checkedRlpRead(msgSender, rlp, int)
await(getBeaconBlockHeaders1822100(msgSender, reqId, msg.blockRoot, msg.slot,
msg.maxHeaders, msg.skipSlots))
proc beaconBlockBodies_thunk(msgSender: Peer; _1822114: int; data1822116: Rlp) {.
gcsafe, async.} =
var rlp = data1822116
var msg {.noinit.}: beaconBlockBodiesObj
enterList(rlp)
let reqId = read(rlp, int)
msg.blockBodies = checkedRlpRead(msgSender, rlp, openarray[BeaconBlockBody])
resolveResponseFuture(msgSender, perPeerMsgId(msgSender, beaconBlockBodiesObj),
addr(msg), reqId)
proc getBeaconBlockBodies1822127(peer: Peer; reqId: int; blockRoots: seq[Eth2Digest]) {.
libp2pProtocol("rpc/beacon_block_bodies", "1.0.0"), gcsafe, async.} =
type
CurrentProtocol = BeaconSync
let response = ResponseWithId[beaconBlockBodiesObj](peer: peer, id: reqId)
const
perProtocolMsgId = 4
template networkState(p1822129: Peer): ref[BeaconSyncState:ObjectType] =
cast[ref[BeaconSyncState:ObjectType]](getNetworkState(p1822129.network,
BeaconSyncProtocol))
var bodies = newSeqOfCap[BeaconBlockBody](blockRoots.len)
let db = peer.networkState.db
for r in blockRoots:
if (
let blk = db.getBlock(r)
blk.isSome):
bodies.add(blk.get().body)
await response.send(bodies)
proc getBeaconBlockBodies_thunk(msgSender: Peer; _1822131: int; data1822133: Rlp) {.
gcsafe, libp2pProtocol("rpc/beacon_block_bodies", "1.0.0"), async.} =
var rlp = data1822133
var msg {.noinit.}: getBeaconBlockBodiesObj
enterList(rlp)
let reqId = read(rlp, int)
msg.blockRoots = checkedRlpRead(msgSender, rlp, openarray[Eth2Digest])
await(getBeaconBlockBodies1822127(msgSender, reqId, msg.blockRoots))
registerMsg(BeaconSyncProtocol, 0, "status", status_thunk,
messagePrinter[statusObj], requestResolver[statusObj],
nextMsgResolver[statusObj])
registerMsg(BeaconSyncProtocol, 1, "beaconBlockRoots", beaconBlockRoots_thunk,
messagePrinter[beaconBlockRootsObj],
requestResolver[beaconBlockRootsObj],
nextMsgResolver[beaconBlockRootsObj])
registerMsg(BeaconSyncProtocol, 3, "beaconBlockHeaders", beaconBlockHeaders_thunk,
messagePrinter[beaconBlockHeadersObj],
requestResolver[beaconBlockHeadersObj],
nextMsgResolver[beaconBlockHeadersObj])
registerMsg(BeaconSyncProtocol, 2, "getBeaconBlockHeaders",
getBeaconBlockHeaders_thunk,
messagePrinter[getBeaconBlockHeadersObj],
requestResolver[getBeaconBlockHeadersObj],
nextMsgResolver[getBeaconBlockHeadersObj])
registerMsg(BeaconSyncProtocol, 5, "beaconBlockBodies", beaconBlockBodies_thunk,
messagePrinter[beaconBlockBodiesObj],
requestResolver[beaconBlockBodiesObj],
nextMsgResolver[beaconBlockBodiesObj])
registerMsg(BeaconSyncProtocol, 4, "getBeaconBlockBodies",
getBeaconBlockBodies_thunk, messagePrinter[getBeaconBlockBodiesObj],
requestResolver[getBeaconBlockBodiesObj],
nextMsgResolver[getBeaconBlockBodiesObj])
setEventHandlers(BeaconSyncProtocol, BeaconSyncHandshake1822063, nil)
registerProtocol(BeaconSyncProtocol)
Raw
devp2p.nim
type
devp2p* = object
type
helloObj* = object
version*: uint
clientId*: string
capabilities*: seq[Capability]
listenPort*: uint
nodeId*: array[RawPublicKeySize, byte]
template hello*(T1499567: type devp2p): type =
helloObj
template msgId*(T1499569: type helloObj): int =
0
template msgProtocol*(T1499571: type helloObj): type =
devp2p
type
sendDisconnectMsgObj* = object
reason*: DisconnectionReason
template sendDisconnectMsg*(T1499577: type devp2p): type =
sendDisconnectMsgObj
template msgId*(T1499579: type sendDisconnectMsgObj): int =
1
template msgProtocol*(T1499581: type sendDisconnectMsgObj): type =
devp2p
type
pingObj* = object
template ping*(T1499588: type devp2p): type =
pingObj
template msgId*(T1499590: type pingObj): int =
2
template msgProtocol*(T1499592: type pingObj): type =
devp2p
type
pongObj* = object
template pong*(T1499599: type devp2p): type =
pongObj
template msgId*(T1499601: type pongObj): int =
3
template msgProtocol*(T1499603: type pongObj): type =
devp2p
var p1499605 = initProtocol("p2p", 0, nil, nil)
var devp2pProtocol = addr p1499605
template protocolInfo*(P1499607: type devp2p): ProtocolInfo =
devp2pProtocol
proc hello*(sendTo: Peer; version: uint; clientId: string;
capabilities: seq[Capability]; listenPort: uint;
nodeId: array[RawPublicKeySize, byte]): Future[void] {.gcsafe.} =
let msgRecipient = getPeer(sendTo)
var writer = initRlpWriter()
const
perProtocolMsgId = 0
let perPeerMsgId = 0
append(writer, perPeerMsgId)
startList(writer, 5)
append(writer, version)
append(writer, clientId)
append(writer, capabilities)
append(writer, listenPort)
append(writer, nodeId)
let msgBytes = finish(writer)
return sendMsg(msgRecipient, msgBytes)
proc sendDisconnectMsg*(sendTo: Peer; reason: DisconnectionReason): Future[void] {.
gcsafe.} =
let msgRecipient = getPeer(sendTo)
var writer = initRlpWriter()
const
perProtocolMsgId = 1
let perPeerMsgId = 1
append(writer, perPeerMsgId)
append(writer, reason)
let msgBytes = finish(writer)
return sendMsg(msgRecipient, msgBytes)
proc ping*(sendTo: Peer): Future[void] {.gcsafe.} =
let msgRecipient = getPeer(sendTo)
var writer = initRlpWriter()
const
perProtocolMsgId = 2
let perPeerMsgId = 2
append(writer, perPeerMsgId)
let msgBytes = finish(writer)
return sendMsg(msgRecipient, msgBytes)
proc pong*(sendTo: Peer): Future[void] {.gcsafe.} =
let msgRecipient = getPeer(sendTo)
var writer = initRlpWriter()
const
perProtocolMsgId = 3
let perPeerMsgId = 3
append(writer, perPeerMsgId)
let msgBytes = finish(writer)
return sendMsg(msgRecipient, msgBytes)
proc hello_thunk(msgSender: Peer; _1499563: int; data1499565: Rlp) {.gcsafe, async.} =
var rlp = data1499565
var msg {.noinit.}: helloObj
enterList(rlp)
msg.version = checkedRlpRead(msgSender, rlp, uint)
msg.clientId = checkedRlpRead(msgSender, rlp, string)
msg.capabilities = checkedRlpRead(msgSender, rlp, seq[Capability])
msg.listenPort = checkedRlpRead(msgSender, rlp, uint)
msg.nodeId = checkedRlpRead(msgSender, rlp, array[RawPublicKeySize, byte])
proc sendDisconnectMsg_thunk(msgSender: Peer; _1499573: int; data1499575: Rlp) {.
gcsafe, async.} =
var rlp = data1499575
var msg {.noinit.}: sendDisconnectMsgObj
msg.reason = checkedRlpRead(msgSender, rlp, DisconnectionReason)
proc ping1499582(peer: Peer) {.gcsafe, async.} =
type
CurrentProtocol = devp2p
const
perProtocolMsgId = 2
discard peer.pong()
proc ping_thunk(msgSender: Peer; _1499584: int; data1499586: Rlp) {.gcsafe, async.} =
var rlp = data1499586
var msg {.noinit.}: pingObj
await(ping1499582(msgSender))
proc pong1499593(peer: Peer) {.gcsafe, async.} =
type
CurrentProtocol = devp2p
const
perProtocolMsgId = 3
discard
proc pong_thunk(msgSender: Peer; _1499595: int; data1499597: Rlp) {.gcsafe, async.} =
var rlp = data1499597
var msg {.noinit.}: pongObj
await(pong1499593(msgSender))
registerMsg(devp2pProtocol, 0, "hello", hello_thunk, messagePrinter[helloObj],
requestResolver[helloObj], nextMsgResolver[helloObj])
registerMsg(devp2pProtocol, 1, "sendDisconnectMsg", sendDisconnectMsg_thunk,
messagePrinter[sendDisconnectMsgObj],
requestResolver[sendDisconnectMsgObj],
nextMsgResolver[sendDisconnectMsgObj])
registerMsg(devp2pProtocol, 2, "ping", ping_thunk, messagePrinter[pingObj],
requestResolver[pingObj], nextMsgResolver[pingObj])
registerMsg(devp2pProtocol, 3, "pong", pong_thunk, messagePrinter[pongObj],
requestResolver[pongObj], nextMsgResolver[pongObj])
setEventHandlers(devp2pProtocol, nil, nil)
registerProtocol(devp2pProtocol)
Raw
gossip_sub.nim
type
GossipSub* = object
template State*(P1660534: type GossipSub): type =
ref[GossipSubPeer:ObjectType]
template NetworkState*(P1660536: type GossipSub): type =
ref[GossipSubNetwork:ObjectType]
type
subscribeForObj* = object
topic*: string
template subscribeFor*(T1660557: type GossipSub): type =
subscribeForObj
template msgId*(T1660559: type subscribeForObj): int =
0
template msgProtocol*(T1660561: type subscribeForObj): type =
GossipSub
type
emitObj* = object
topic*: string
msgId*: string
msg*: string
template emit*(T1660572: type GossipSub): type =
emitObj
template msgId*(T1660574: type emitObj): int =
1
template msgProtocol*(T1660576: type emitObj): type =
GossipSub
var p1660578 = initProtocol("gss", 1, createPeerState[ref[GossipSubPeer:ObjectType]],
createNetworkState[ref[GossipSubNetwork:ObjectType]])
var GossipSubProtocol = addr p1660578
template protocolInfo*(P1660580: type GossipSub): ProtocolInfo =
GossipSubProtocol
proc subscribeFor*(sendTo: Peer; topic: string): Future[void] {.gcsafe.} =
let msgRecipient = getPeer(sendTo)
var writer = initRlpWriter()
const
perProtocolMsgId = 0
let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, GossipSubProtocol, 0)
append(writer, perPeerMsgId)
append(writer, topic)
let msgBytes = finish(writer)
return sendMsg(msgRecipient, msgBytes)
proc emit*(sendTo: Peer; topic: string; msgId: string; msg: string): Future[void] {.gcsafe.} =
let msgRecipient = getPeer(sendTo)
var writer = initRlpWriter()
const
perProtocolMsgId = 1
let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, GossipSubProtocol, 1)
append(writer, perPeerMsgId)
startList(writer, 3)
append(writer, topic)
append(writer, msgId)
append(writer, msg)
let msgBytes = finish(writer)
return sendMsg(msgRecipient, msgBytes)
proc GossipSubHandshake1660537(peer: Peer) {.gcsafe, async.} =
type
CurrentProtocol = GossipSub
template state(p1660539: Peer): ref[GossipSubPeer:ObjectType] =
cast[ref[GossipSubPeer:ObjectType]](getState(p1660539, GossipSubProtocol))
template networkState(p1660541: Peer): ref[GossipSubNetwork:ObjectType] =
cast[ref[GossipSubNetwork:ObjectType]](getNetworkState(p1660541.network,
GossipSubProtocol))
info "GossipSub Peer connected", peer
let gossipNet = peer.networkState
for topic, _ in gossipNet.topicSubscribers:
peer.trySubscribing(topic)
proc GossipSubPeerDisconnect1660542(peer: Peer; reason: DisconnectionReason) {.
gcsafe, async.} =
type
CurrentProtocol = GossipSub
template state(p1660544: Peer): ref[GossipSubPeer:ObjectType] =
cast[ref[GossipSubPeer:ObjectType]](getState(p1660544, GossipSubProtocol))
template networkState(p1660546: Peer): ref[GossipSubNetwork:ObjectType] =
cast[ref[GossipSubNetwork:ObjectType]](getNetworkState(p1660546.network,
GossipSubProtocol))
info "GossipSub Peer disconnected", peer, reason
proc subscribeFor1660547(peer: Peer; topic: string) {.gcsafe, async.} =
type
CurrentProtocol = GossipSub
const
perProtocolMsgId = 0
template state(p1660549: Peer): ref[GossipSubPeer:ObjectType] =
cast[ref[GossipSubPeer:ObjectType]](getState(p1660549, GossipSubProtocol))
template networkState(p1660551: Peer): ref[GossipSubNetwork:ObjectType] =
cast[ref[GossipSubNetwork:ObjectType]](getNetworkState(p1660551.network,
GossipSubProtocol))
peer.state.subscribedFor.incl topic
proc subscribeFor_thunk(msgSender: Peer; _1660553: int; data1660555: Rlp) {.gcsafe,
async.} =
var rlp = data1660555
var msg {.noinit.}: subscribeForObj
msg.topic = checkedRlpRead(msgSender, rlp, string)
await(subscribeFor1660547(msgSender, msg.topic))
proc emit1660562(peer: Peer; topic: string; msgId: string; msg: string) {.gcsafe, async.} =
type
CurrentProtocol = GossipSub
const
perProtocolMsgId = 1
template state(p1660564: Peer): ref[GossipSubPeer:ObjectType] =
cast[ref[GossipSubPeer:ObjectType]](getState(p1660564, GossipSubProtocol))
template networkState(p1660566: Peer): ref[GossipSubNetwork:ObjectType] =
cast[ref[GossipSubNetwork:ObjectType]](getNetworkState(p1660566.network,
GossipSubProtocol))
if msgId in peer.networkState.handledMessages:
trace "Ignored previously handled message", msgId
return
peer.networkState.handledMessages.incl msgId
for p in peer.network.peers(GossipSub):
if msgId notin p.state.sentMessages and topic in p.state.subscribedFor:
p.state.sentMessages.incl msgId
asyncDiscard p.tryEmitting(topic, msgId, msg)
{.gcsafe.}:
let handler = peer.networkState.topicSubscribers.getOrDefault(topic)
if handler != nil:
handler(msg)
proc emit_thunk(msgSender: Peer; _1660568: int; data1660570: Rlp) {.gcsafe, async.} =
var rlp = data1660570
var msg {.noinit.}: emitObj
enterList(rlp)
msg.topic = checkedRlpRead(msgSender, rlp, string)
msg.msgId = checkedRlpRead(msgSender, rlp, string)
msg.msg = checkedRlpRead(msgSender, rlp, string)
await(emit1660562(msgSender, msg.topic, msg.msgId, msg.msg))
registerMsg(GossipSubProtocol, 0, "subscribeFor", subscribeFor_thunk,
messagePrinter[subscribeForObj], requestResolver[subscribeForObj],
nextMsgResolver[subscribeForObj])
registerMsg(GossipSubProtocol, 1, "emit", emit_thunk, messagePrinter[emitObj],
requestResolver[emitObj], nextMsgResolver[emitObj])
setEventHandlers(GossipSubProtocol, GossipSubHandshake1660537,
GossipSubPeerDisconnect1660542)
registerProtocol(GossipSubProtocol)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment