changes to the chain to match mauve's logic (mvp)

[ninabreznik]

• register a role (=offer the service) (Encoder, Attestor, Hoster) => list for each role

• publishData

  Problem:

• registerHoster has the logic to assign the hypercore to the newly registered Hoster -> but how do we now also asign the hypercore to the encoder??

• we should instead emit event (selected encoders & selected hosters)

  Solution?

• additional logic in RegisterHoster/Register Encoder/Publish data
• each hypercore would have a count of how many hosters/encoder are available
• when new registerHoster or registerEncoder we check if count_Encoder >= min && count_Hoster >= min (min = 3) => then emit event (newHostingRequest)

• newHostingRequest emits 3 selected hosters and 3 selected encoders

• hoster triggers hosterReady(feedID, hoster pubKey) function
• chain emits event hosterReady
• publisher triggers Start a Challenge

[serapath]

const chainAPI = { registerHoster, registerEncoder, publishData }

function registerHoster (payload) {
  const hosterID = saveHoster(payload)
  const hostingEvents = calculateAsHoster(hosterID, payload)
  emitHostingEvents(hostingEvents)
}

function publishData (payload) {
  const feedID = saveHoster(payload)
  const hostingEvents = calculateAsPublisher(feedID, payload)
  emitHostingEvents(hostingEvents)
}

function registerEncoder (payload) {
  const encoderID = saveEncoder(payload)
  const hostingEvents = calculateAsEncoder(encoderID, payload)
  emitHostingEvents(hostingEvents)
}

/************************************************************************/
// INTERNAL
const underemployed_hosters = []
const unemployed_encoders = []
const waiting_feeds = []

function emitHostingEvents (hostingEvents) {
  if (!hostingEvents.length) return
  for (const [feedID, encoderID, hosterID] in hostingEvents) {
    emit(['NewPin', feedID, encoderID, hosterID]) 
  }
}

function calculateAsEncoder(encoderID, payload) {
  const events = []
  const len = Math.min(waiting_feeds.length, underemployed_hosters.length)
  for (var i = 0; i < len; i++) {
    events.push([waiting_feeds[i], encoderID, underemployed_hosters[i]])
  }
  return events  
}
function calculateAsHoster(hosterID, payload) {
  const events = []
  const len = Math.min(waiting_feeds.length, unemployed_encoders.length)
  for (var i = 0; i < len; i++) {
    events.push([waiting_feeds[i], , unemployed_encoders[i], hosterID])
  }
  return events  
}
function calculateAsPublisher(feedID, payload) {
  const events = []
  const len = Math.min(unemployed_encoders.length, underemployed_hosters.length)
  for (var i = 0; i < len; i++) {
    events.push([feedID, unemployed_encoders[i], underemployed_hosters[i]])
  }
  return events  
}

[jam10o-new]

my goal is to simplify the storage of challenges held by hosters from multiple storage values, to:

(hoster, archive) => HostedArchive

(or, use DoubleMap, so we can iterate over exclusively hosters to find all archives they host)

hoster, archive => HostedArchive

where

struct HostedArchive {
    encoded: SortedVec<(ChunkIndex, EncoderId)>,
    state: State,
}

enum State {
    Encoding,
    Ready(Vec<Challenge>),
}

enum Challenge {
   Active(blockNumber, chunk),
   Attesting(ChallengeAttestations),
}

the goal of which would be that we can drastically reduce the storage lookups when challenging a hoster