const [host, port] = config.chain

const name = `chain`

LESEZEICHEN: `@TODO: fix shit! 1`

// generate `logkeeper`

// => provide `port` because we want it to listen

const log = await logkeeper(name, { path: '/logs', port })

scheduler = blockgenerator({ blockinterval, intrinsics }, log.sub('blockgenerator'), async blockMessage => {

const { number, startTime } = blockMessage.data

const currentBlock = header.number = number

const temp = [...mempool]

mempool = []

try {

while (temp.length) {

if ((performance.now() - startTime) < (blockinterval - 200)) {

const extrinsic = temp.shift() // later take out the ones which offers highest gas

await extrinsic()

} else {

const text = `not able to execute the remaining ${temp.length} extrinsics in mempool during blockinterval`

log({ type: 'warn', data: text })

mempool = [...temp, ...mempool]

emitBlock()

return

}

}

emitBlock()

} catch (error) {

const stack = error.stack

log({ type: 'Error', data: { text: 'failed-mempool', stack } })

}

async function emitBlock () {

log({ type: 'eventpool', data: { text: `event pool in emitBlock`, data: eventpool } })

const temp_pool = [...eventpool]

eventpool = []

temp_pool.forEach(([log, message]) => {

log({ type: 'chain', data: { text: `emit chain event`, data: JSON.stringify(message) } })

})

const promises = Object.entries(connections).map(([name, { ws, handler }]) => new Promise((resolve, reject) => {

ws.send(JSON.stringify(blockMessage))

temp_pool.forEach(([log, message]) => { handler(message) })

resolve()

}))

await Promise.all(promises)

log({ type: 'current-block', data: currentBlock })

}

})

// --------------------------------------------------------------------------

// LESEZEICHEN3: '@TODO: ...'

// const wss = new WebSocket.Server({ path: '/', port }, after)

// function after () {

// log({ type: 'chain', data: `running on http://${host}:${wss.address().port}` })

// }

// wss.on('connection', onconnection)

const on = {

fail: event => {},

open: event => {},

data: event => {},

exit: event => {},

}

// this connects, but await only resolves when connection is established

// => but if ocnnection breaks, send will fail!

// => or send is append!

// =>

const node = await io(name, ({ ws, request }) => {

onconnection(ws, request)

})

// const node = await io(name, ({ type, data }) => on[type](data))

// const { send } = node

log({ type: 'connection' })

// --------------------------------------------------------------------------

function onconnection (ws, req) {

const ip = req.socket.remoteAddress

const port = req.socket.remotePort

log({ type: 'connection-from', data: { ip, port } })

ws.on('message', onmessage)

ws.on('open', onopen)

ws.on('error', onerror)

ws.on('close', onclose)

// --------------------------------------------------------------------------

async function onmessage (message) {

var { flow, type, data } = JSON.parse(message)

const [from, id] = flow

// log({ type: 'extrinsic', data: { type, flow, messsage: JSON.parse(message) } })

const method = queries[type]

if (method) {

const result = await method(data, from, data => {

// _log({ type: 'chain', data: [`send data after "${type}" to: ${from}`] })

ws.send(JSON.stringify({ cite: [flow], type: 'data', data }))

})

if (result === undefined) return log({ type: 'error', data: { text: 'Query not found', type, flow, message: JSON.parse(message) } })

const msg = { cite: [flow], type: 'done', data: result }

// _log({ type: 'chain', data: [`sending "${type}" to: ${from}`] })

return void ws.send(JSON.stringify(msg))

}

if (!connections[from] && DB.lookups.userByAddress[data.address]) {

const userlog = log.sub(from)

connections[from] = { name: from, counter: 0, ws, log: userlog, handler: data => ws.send(JSON.stringify({ data })) }

}

if (id === 0 && type === 'newUser') {

mempool.push(() => makeNewUser(data, from, ws))// a new connection

} else {

mempool.push(() => {

signAndSend(type, flow, data, from, data => {

// _log({ type: 'chain', data: [`send data after "${type}" to: ${from}`] })

ws.send(JSON.stringify({ cite: [flow], type: 'data', data }))

})

})

}

}

function onopen () {

log('======= OPEN =======')

}

function onerror (err) {

log('======= ERROR =======')

log(err)

}

function onclose () {

log('[ERROR] unexpected closing of chain connection for', name)

}

}

/******************************************************************************

async function signAndSend (msgtype, flow, data, name, status) {

const { log, ws } = connections[name]

log({ type: 'execute-extrinsic', data: msgtype })

try {

if (msgtype === 'submitStorageChallenge') {

log({ type: 'chain', data: { text: 'Message type is submitStorageChallenge' } })

data = storage_report_codec.decode(data, log)

}

const { type, args, nonce, address } = data

status({ events: [], status: { isInBlock:1 } })

const user = await _getUser(address, { name, nonce }, status)

if (!user) return void log({ type: 'chain', data: [`UNKNOWN SENDER of: ${data}`] }) // TODO: maybe use status() ??

else if (type === 'publishPlan') _publish_plan(user, { name, nonce }, status, args)

else if (type === 'registerForWork') _register_for_work(user, { name, nonce }, status, args)

else if (type === 'amendmentReport') _amendment_report(user, { name, nonce }, status, args)

else if (type === 'submitStorageChallenge') _storage_challenge_report(user, { name, nonce }, status, args)

else if (type === 'submitPerformanceChallenge') _performance_challenge_report(user, { name, nonce }, status, args)

// else if ...

else ws.send(JSON.stringify({ cite: [flow], type: 'error', data: 'unknown type' }))

} catch (error) {

log({ type: 'Error', data: { type: msgtype, error } })

}

}

/******************************************************************************

async function makeNewUser (data, from, ws) {

const { args, nonce, address } = data

// 1. do we have that user in the database already?

if (from && address && !connections[from] && !DB.lookups.userByAddress[address]) {

const userlog = log.sub(from)

connections[from] = { name: from, counter: 0, ws, log: userlog, handler: data => ws.send(JSON.stringify({ data })) }

// TODO: ...

if (!messageVerifiable(data)) return // TODO: verify MICRO PROOF OF WORK

_newUser(args, from, address, userlog)

// 2. is the message verifiable, pubkeys, noisekeys, signatures?

// 3. => add user and address and user data to database

}

else return ws.send(JSON.stringify({

cite: [flow], type: 'error', data: 'name is already taken'

}))

// return

}

const keyBuf = b4a.from(key, 'hex')

const id = DB.lookups.userIDByNoiseKey[keyBuf.toString('hex')]

return id

const { contract_id } = data

const reuse = { encoders: [], attesters: [], hosters: [] }

const amendment_id = await init_amendment(contract_id, reuse, log)

log({ type: 'chain', data: { text: 'Plan execution', contract_id, amendment_id } })

DB.queues.tasks.push({ fnName: 'amendment', id: amendment_id }) // TODO: sort tasks based on priority (RATIO!)

next_task(log)

const { user } = data

var { status, timestamp, cid } = user.hoster.challenge

user.hoster.challenge.status = 'timed-out'

log({ type: 'storage-challenge', data: { text: 'error: storage challenge timeout', status, cid, perf: performance.now() - timestamp} })

const storageChallenge = getStorageChallengeByID(cid)

const { hoster: hoster_id, attester: attester_id} = storageChallenge

unbook_and_rate({ id: attester_id, role: 'attester', task: cid, type: 'storage', status: 'fail', log })

unbook_and_rate({ id: hoster_id, role: 'hoster', task: cid, type: 'storage', status: 'unknown', log })

await start_new_storage_challenge(user, log)

const { feedID } = data

const feed = getFeedByID(feedID)

const { status, timestamp, cid } = feed.challenge

feed.challenge.status = 'timed-out'

log({ type: 'performance-challenge-timeout', data: { text: 'error: performance challenge timeout', status, cid, perf: performance.now() - timestamp} })

const performanceChallenge = getPerformanceChallengeByID(cid)

const attesterIDs = performanceChallenge.attesters

attesterIDs.forEach(id => unbook_and_rate({ id, role: 'attester', task: cid, type: 'performance', status: 'fail', log }))

await start_new_performance_challenge(feedID, log)

const { id } = data

log({ type: 'chain', data: { text: 'Amendment timed out', id } })

const { providers: { attesters, hosters, encoders } } = getAmendmentByID(id)

const failed = [...attesters, ...hosters, ...encoders]

// TODO: handle (details in retry_amendment, do we need status too?)

// _retry_amendment({ failed, amendmentID: id, log})

const hoster_id = data.hoster_id

const { scheduleAction } = await scheduler

// select an attester

// tell them which hoster to challenge

// tell them which subset of contracts & chunks to challenge

const user = getUserByID(hoster_id)

const amendments = Object.keys(user.hoster.tasks).map(task => getItem(Number(task))).filter(task => task.contract)

const contract_ids = amendments.map(amendment => amendment.contract)

if (!contract_ids.length) return

const selected = get_random_ids({ items: contract_ids, max: 5 })

const checks = {}

const avoid = {}

log({ type: 'storage', data: { text: 'New storage challenge for contracts', contract_ids, selected } })

for (var i = 0, len = selected.length; i < len; i++) {

const contractID = selected[i]

const { plan, ranges } = getContractByID(contractID)

// avoid[plan.sponsor] = true

checks[contractID] = { index: getRandomChunk(ranges) }

}

const storage_challenge = { checks, hoster: hoster_id }

const id = addItem(storage_challenge)

DB.active.storageChallenges[id] = true

// find & book the attester

const type = 'NewStorageChallenge'

avoid[hoster_id] = true

const idleProviders = DB.status.idleAttesters

const selectedProviders = select({ idleProviders, role: 'attester', newTask: id, amount: 1, avoid, plan: {}, log })

const [attester] = selectedProviders

if (!attester) return DB.queues.tasks.push({ fnName: 'NewStorageChallenge', id })

storage_challenge.attester = attester.id

book({ type, selectedProviders, role: 'attester', newTask: id, log })

book({ type, selectedProviders: [{ id: hoster_id }], role: 'hoster', newTask: id, log })

//

log({ type: 'chain', data: { text: 'Making new storage challenge for', items: { type, newTask: id, hoster_id, amendments, cid: id } } })

const sid = scheduleAction({ from: log, data: {user}, delay: 5, type: 'storage_challenge_timeout' })

const timestamp = performance.now()

user.hoster.challenge = { status: 'active', timestamp, sid, cid: id }

// emit event

emitEvent(type, [id], log)

const { feedID } = data

const { scheduleAction } = await scheduler

const feed = getFeedByID(feedID)

const contractIDs = feed.contracts

const performanceChallenge = { feed: feedID }

const id = addItem(performanceChallenge)

performanceChallenge.id = id

DB.active.performanceChallenges[id] = true

var hosterIDs

// find attesters

const avoid = {}

const all_ids = []

for (var i = 0, len = contractIDs.length; i < len; i++) {

const { amendments, plan: planID } = getContractByID(contractIDs[i])

const plan = getPlanByID(planID)

// avoid[plan.sponsor] = true

const active_amendment = getAmendmentByID(amendments[amendments.length-1])

hosterIDs = active_amendment.providers.hosters

log({ type: 'chain', data: { text: 'Hoster IDs from active amendment', hosterIDs, challengeID: id } })

hosterIDs.forEach(id => avoid[id] = true)

all_ids.push(...hosterIDs)

}

performanceChallenge.hosters = [...new Set(all_ids)]

const type = 'NewPerformanceChallenge'

const idleProviders = DB.status.idleAttesters

let attesters = select({ idleProviders, role: 'attester', newTask: id, amount: 1, avoid, plan: {}, log })

if (!attesters.length) return DB.queues.tasks.push({ fnName: 'NewPerformanceChallenge', id })

performanceChallenge.attesters = attesters.map(attester => attester.id)

book({ type, selectedProviders: attesters, role: 'attester', newTask: id, log })

book({ type, selectedProviders: performanceChallenge.hosters.map(id => ({ id, role: 'hoster' })), role: 'hoster', newTask: id, log })

log({ type: 'challenge', data: {text:'Making new performance challenge', performanceChallenge, items: {challenge: type, newTask: id, attesters, cid: id} }})

const sid = scheduleAction({ from: log, data: {feedID}, delay: 2, type: 'performance_challenge_timeout' })

feed.challenge = { status: 'active', timestamp: performance.now(), sid, cid: id }

// emit event

log({ type: 'chain', data: [type, id] })

emitEvent(type, [id], log)

const log = connections[name].log

const pos = DB.lookups.userByAddress[address]

const user = getUserByID(pos)

log({ type: 'chain', data: `Existing user: ${name}, ${user.id}, ${address}` })

return user

if ('id' in item) throw new Error('new items cannot have "id" property')

const id = DB.storage.length

item.id = id

DB.storage.push([item])

return id

if (!Number.isInteger(id)) return

if (id < 0) return

const len = DB.storage.length

if (id >= len) return

const history = DB.storage[id]

if (!Array.isArray(history)) return

const next = history.length

const item = history[next - 1]

return item

if (!Number.isInteger(id)) return

if (id < 0) return

const len = DB.storage.length

if (id >= len) return

const history = DB.storage[id]

if (!Array.isArray(history)) return

return !!history.push(void 0)

if (!Number.isInteger(id)) return

if (id < 0) return

const len = DB.storage.length

if (id >= len) return

const history = DB.storage[id]

if (!Array.isArray(history)) return

return !!history.push(item)

let [data] = args

const { signingPublicKey, noiseKey } = data

const signingKeyBuf = b4a.from(signingPublicKey, 'hex')

const noiseBuf = b4a.from(noiseKey, 'hex')

const user = {

address,

noiseKey,

signingKey: signingPublicKey,

form: {},

idleStorage: 0,

rating: 0,

balance: 0

}

addItem(user)

DB.lookups.userByAddress[address] = user.id

DB.lookups.userIDBySigningKey[signingKeyBuf.toString('hex')] = user.id

DB.lookups.userIDByNoiseKey[noiseBuf.toString('hex')] = user.id

log({ type: 'chain', data: [`New user: ${name}, ${JSON.stringify(user)}`] })

const log = connections[name].log

let [form] = args

const { components } = form

const { resources_ids, performances_ids, timetables_ids, regions_ids } = await publish_form_components(components)

form.timetables = form.timetables.map(ref => { if (ref < 0) return timetables_ids[(Math.abs(ref) - 1)] })

form.regions = form.regions.map(ref => { if (ref < 0) return regions_ids[(Math.abs(ref) - 1)] })

form.performances = form.performances.map(ref => { if (ref < 0) return performances_ids[(Math.abs(ref) - 1)] })

form.resources = form.resources.map(ref => { if (ref < 0) return resources_ids[(Math.abs(ref) - 1)] })

user.form = form

user.idleStorage = getItem(form.resources[0]).storage

log({ type: 'register', data: [`Registering for work`] })

;['encoder', 'hoster', 'attester'].forEach(role => registerRole (user, role, log))

const log = connections[name].log

log({ type: 'chain', data: [`Publishing a plan`] })

let [data] = args

const { plan, components, proofs = {} } = data

const { program } = plan

const feed_ids = await Promise.all(components.feeds.map(async feed => await publish_feed(feed, user.id, log)))

const verified = await verify_and_store(proofs, feed_ids, log)

if (!verified) return log({ type: 'chain', data: [`Error: Proofs could not be verified`] })

const component_ids = await publish_plan_components(log, components, feed_ids)

const updated_program = []

for (var i = 0, len = program.length; i < len; i++) {

const item = program[i]

if (item.plans) updated_program.push(...getPrograms(item.plan))

else updated_program.push(handleNew(item, component_ids))

}

plan.program = updated_program

if (!planValid({ plan })) return log({ type: 'chain', data: [`Error: Plan from and/or until are invalid`] })

plan.sponsor = user.id

plan.contracts = []

const id = addItem(plan)

priority_queue.add({ type: 'plan', id })

next_plan(priority_queue.take(), log) // schedule the plan execution

const [planID] = args

const plan = getPlanByID(planID)

if (!plan.sponsor === user.id) return log({ type: 'chain', data: [`Error: Only a sponsor is allowed to unpublish the plan`] })

cancelContracts(plan) // remove all hosted and draft contracts

const userID = user.id

// registered.push(role)

if (!user[role]) {

user[role] = {

tasks: {},

challenge: {},

capacity: 2, // TODO: calculate capacity for each task based on the form

}

}

const first = role[0].toUpperCase()

const rest = role.substring(1)

DB.status[`idle${first + rest}s`].push(userID)

next_task(log)

const log = connections[name].log

const meta = [user, name, nonce, status]

const [ report ] = args

const { id: amendmentID, failed, signatures } = report // [2,6,8]

log({ type: 'chain', data: { text: 'Amendment report', report: JSON.stringify(report) } })

const amendment = getAmendmentByID(amendmentID)

const { contract: contractID, sid } = amendment

const { hosters, attesters, encoders } = amendment.providers

const contract = getContractByID(contractID)

const feedObj = getFeedByID(contract.feed)

const [attesterID] = attesters

// check if right attester

if (user.id !== attesterID) return log({ type: 'chain', data: { text: `Error: this user can not submit the attestation`, providers: JSON.stringify(amendment.providers), user: user.id } })

// check if right amendment

if (contract.amendments[contract.amendments.length - 1] !== amendmentID) return log({ type: 'chain', data: [`Error: this amendment has expired`] })

// cancel amendment schedule

const { cancelAction } = await scheduler

if (!amendment.sid) log({ type: 'chain', data: { text: 'No scheduler for', contract } })

cancelAction(amendment.sid)

// verify hosters' signatures for hoster that didn't fail

for (var i = 0, len = hosters.length; i < len; i++) {

const hoster_id = hosters[i]

if (failed.includes(hoster_id)) continue

const sig = signatures[hoster_id]

if (!sig) {

failed.push(hoster_id)

continue

}

// log({ type: 'chain', data: { text: 'Getting signature', hoster_id, signatures, one_sig: sig } })

const sig_buf = Buffer.isBuffer(sig) ? sig : b4a.from(sig, 'hex')

const data = b4a.from(`${amendmentID}/${i}`, 'binary')

const signingKey = b4a.from(getUserByID(hoster_id).signingKey)

log({ type: 'chain', data: { text: 'Verifying signatures', sig: sig_buf, data, signingKey: signingKey.toString('hex') } })

if (!datdot_crypto.verify_signature(sig_buf, data, signingKey)) return log({ type: 'chain', data: { text: `Error: unique_el_signature for hoster: ${hoster_id} could not be verified` } })

}

log({ type: 'chain', data: { text: `amendmentReport hoster signatures verified`, amendmentID } })

if (failed.length) return _retry_amendment({ failed, amendmentID, log })

feedObj.contracts.push(contractID)

encoders.forEach(id => unbook_and_rate({ id, role: 'encoder', task: amendmentID, type: 'setup', status: 'done', log }))

attesters.forEach(id => unbook_and_rate({ id, role: 'attester', task: amendmentID, type: 'setup', status: 'done', log }))

for (var i = 0, len = hosters.length; i < len; i++) {

const user = getUserByID(hosters[i])

const tasks = Object.keys(user.hoster.tasks).map(task => Number(task))

log(`Hosting started: hoster: ${hosters[i]}, contract: ${contractID}, amendment: ${amendmentID}, tasks: ${tasks}, challenges: ${JSON.stringify(user.hoster.challenge)}`)

// schedule storage challenges (for each hoster only once)

// TODO: improve, because if one hoster hosts a lot, they won't be challenged enough

if (!user.hoster.challenge.status) {

user.hoster.challenge.status = 'pending'

await start_new_storage_challenge(user, log)

}

}

// schedule performance challenge

if (!feedObj.challenge.status) {

feedObj.challenge.status = 'pending'

await start_new_performance_challenge(feedObj.id, log)

}

// => until HOSTING STARTED event, everyone keeps the data around

emitEvent('HostingStarted', [amendmentID], log)

return

const log = connections[name].log

log({ type: 'storage challenge', data: { text: `Received storage challenge response`, args: JSON.stringify(args) } })

const [ response ] = args

const { storageChallengeID, proof_of_contact, reports } = response

const storageChallenge = getStorageChallengeByID(storageChallengeID)