Loc-Chain
/
loc-chain-backend
mirror of https://github.com/hackku21/loc-chain-backend
3
0
Fork 0
Code Issues Projects Releases Wiki Activity

Add proof-of-elapsed-time based consensus algorithm

Browse Source
working-state
Garrett Mills 3 years ago
parent fbc3711560
commit 9e4164632c
Signed by: garrettmills
GPG Key ID: D2BF5FBA8298F246
7 changed files with 1070 additions and 766 deletions
Show Stats Download Patch File Download Diff File

1
package.json
Unescape View File

@ -12,6 +12,7 @@
"@extollo/di": "^0.4.5",
"@extollo/lib": "^0.1.5",
"@extollo/util": "^0.3.3",
"axios": "^0.21.1",
"bcrypt": "^5.0.1",
"copyfiles": "^2.4.1",
"firebase-admin": "^9.6.0",

1594
pnpm-lock.yaml
View File

File diff suppressed because it is too large Load Diff

12
src/app/http/controllers/api/Blockchain.controller.ts
Unescape View File

@ -33,6 +33,18 @@ export class Blockchain extends Controller {
}))
}
/**
* Read the version of the blockchain held by this host, including the host's
* most recent submission, that has NOT been accepted yet.
*/
public async readBlockchainSubmission() {
return many((await this.blockchain.getSubmitChain()).map(x => {
// @ts-ignore
delete x.firebaseID
return x
}))
}
/**
* Determine whether the current blockchain is valid.
*/

4
src/app/http/routes/app.routes.ts
Unescape View File

@ -13,8 +13,12 @@ Route.group('/api/v1', () => {
.pre('DebugOnly')
Route.get('/chain', 'api:Blockchain.readBlockchain')
Route.get('/check', 'api:Blockchain.check')
.pre('api:FirebaseUserOnly')
Route.get('/check-debug', 'api:Blockchain.check')
.pre('DebugOnly')
Route.get('/chain/submit', 'api:Blockchain.readBlockchainSubmission')
})

17
src/app/rtdb/BlockResource.ts
Unescape View File

@ -57,6 +57,23 @@ export interface BlockResourceItem extends FirebaseResourceItem {
lastBlockUUID: string; // the UUID of the previous block
proof: string; // the generated proof-of-work string
timestamp: number; // millisecond unix timestamp when this block was created
waitTime: number; // number of milliseconds between last block and this one
}
/**
* Returns true if the given item is a valid BlockResourceItem.
* @param what
*/
export function isBlockResourceItem(what: any): what is BlockResourceItem {
return (
typeof what?.uuid === 'string'
&& Array.isArray(what?.transactions)
&& typeof what?.lastBlockHash === 'string'
&& typeof what?.lastBlockUUID === 'string'
&& typeof what?.proof === 'string'
&& typeof what?.timestamp === 'number'
&& typeof what?.waitTime === 'number'
)
}
/**

24
src/app/rtdb/PeerResource.ts
Unescape View File

@ -0,0 +1,24 @@
import {FirebaseResource, FirebaseResourceItem} from "../FirebaseResource"
import {Injectable} from "@extollo/di"
import {RTDBRef} from "../units/FirebaseUnit"
import {AsyncCollection} from "@extollo/util"
/**
* Interface representing a peer of this node.
*/
export interface PeerResourceItem extends FirebaseResourceItem {
host: string,
name?: string,
}
/**
* A Firebase realtime-database resource for managing blockchain peers.
*/
@Injectable()
export class PeerResource extends FirebaseResource<PeerResourceItem> {
public static collect(): AsyncCollection<PeerResourceItem> {
return new AsyncCollection<PeerResourceItem>(new PeerResource())
}
protected refName: RTDBRef = 'peers'
}

184
src/app/units/Blockchain.ts
Unescape View File

@ -1,12 +1,20 @@
import { Singleton, Inject } from "@extollo/di"
import { Unit, Logging, Config, Application } from "@extollo/lib"
import { FirebaseUnit } from "./FirebaseUnit"
import { BlockEncounterTransaction, BlockResource, BlockResourceItem, BlockTransaction } from "../rtdb/BlockResource"
import {
BlockEncounterTransaction,
BlockResource,
BlockResourceItem,
BlockTransaction,
isBlockResourceItem
} from "../rtdb/BlockResource"
import { TransactionResourceItem } from "../rtdb/TransactionResource"
import * as openpgp from "openpgp"
import * as crypto from "crypto"
import axios from "axios"
import { collect, uuid_v4 } from "@extollo/util"
import {ExposureResourceItem} from "../rtdb/ExposureResource";
import {ExposureResourceItem} from "../rtdb/ExposureResource"
import {PeerResource} from "../rtdb/PeerResource"
/**
* Utility wrapper class for a block in the chain.
@ -20,6 +28,7 @@ export class Block implements BlockResourceItem {
lastBlockHash: string
lastBlockUUID: string
proof: string
waitTime: number
get config(): Config {
return Application.getApplication().make(Config)
@ -34,6 +43,7 @@ export class Block implements BlockResourceItem {
this.lastBlockUUID = rec.lastBlockUUID
this.proof = rec.proof
this.timestamp = rec.timestamp
this.waitTime = rec.waitTime
}
/** Returns true if this is the genesis block. */
@ -75,6 +85,7 @@ export class Block implements BlockResourceItem {
lastBlockUUID: this.lastBlockUUID,
proof: this.proof,
timestamp: this.timestamp,
waitTime: this.waitTime,
}
}
@ -82,6 +93,7 @@ export class Block implements BlockResourceItem {
toString() {
return [
this.uuid,
this.waitTime,
JSON.stringify(this.transactions || [], undefined, 0),
this.lastBlockHash,
this.lastBlockUUID,
@ -113,6 +125,17 @@ export class Blockchain extends Unit {
@Inject()
protected readonly config!: Config
/**
* Block transactions that will be attempted as part of this host's
* next block submission.
* @protected
*/
protected pendingTransactions: BlockTransaction[] = []
protected pendingSubmit?: Block
protected isSubmitting: boolean = false
/**
* Returns true if the given host is registered as a peer.
* @param host
@ -126,8 +149,23 @@ export class Blockchain extends Unit {
* Get a list of all registered peers.
*/
public async getPeers(): Promise<Peer[]> {
const data = await this.firebase.ref('peers').once('value')
return (data.val() as Peer[]) || []
return PeerResource.collect().all()
}
/**
* From a peer, fetch the submission blockchain, if it is valid.
* @param peer
*/
public async getPeerSubmit(peer: Peer): Promise<Block[] | undefined> {
try {
const result = await axios.get(peer.host)
const blocks: unknown = result.data?.data?.records
if ( Array.isArray(blocks) && blocks.every(isBlockResourceItem) ) {
return blocks.map(x => new Block(x))
}
} catch (e) {
return undefined
}
}
/**
@ -136,7 +174,14 @@ export class Blockchain extends Unit {
*/
public async registerPeer(peer: Peer) {
if (!(await this.hasPeer(peer.host))) {
await this.firebase.ref('peers').push().set(peer)
await (<PeerResource> this.make(PeerResource)).push({
firebaseID: '',
seqID: -1,
name: peer.name,
host: peer.host,
})
this.refresh()
}
}
@ -164,8 +209,6 @@ export class Blockchain extends Unit {
return false;
}
const pass = (
block.lastBlockUUID === previous.uuid
&& block.lastBlockHash === previous.hash()
@ -187,7 +230,88 @@ export class Blockchain extends Unit {
}
public async refresh() {
if ( this.isSubmitting ) {
return
} else {
this.isSubmitting = true
}
const validSeqID = (await this.read()).reverse()[0]?.seqID
const peers = await this.getPeers()
const time_x_block: {[key: string]: Block} = {}
const time_x_peer: {[key: string]: Peer | true} = {}
for ( const peer of peers ) {
const blocks: Block[] | undefined = await this.getPeerSubmit(peer)
if ( blocks && await this.validate(blocks) ) {
const block = blocks.reverse()[0]
if ( !block || block.seqID === validSeqID || !block.seqID ) continue
time_x_block[block.waitTime] = block
time_x_peer[block.waitTime] = peer
}
}
if ( this.pendingTransactions.length && !this.pendingSubmit ) {
await this.attemptSubmit()
}
if ( this.pendingSubmit ) {
time_x_block[this.pendingSubmit.waitTime] = this.pendingSubmit
time_x_peer[this.pendingSubmit.waitTime] = true
}
const min = Math.min(...Object.keys(time_x_block).map(parseFloat))
const block = time_x_block[min]
const peer = time_x_peer[min]
await (<BlockResource>this.app().make(BlockResource)).push(block)
if ( peer === true ) {
this.pendingSubmit = undefined
this.pendingTransactions = []
} else {
this.pendingSubmit = undefined
await this.attemptSubmit()
}
this.isSubmitting = false
}
public async getSubmitChain(): Promise<BlockResourceItem[]> {
const blocks = await this.read()
const submit = await this.attemptSubmit()
if ( submit ) {
submit.seqID = blocks.length > 0 ? collect<BlockResourceItem>(blocks).max('seqID') + 1 : 0
blocks.push(submit.toItem())
}
return blocks
}
public async attemptSubmit() {
if ( !this.pendingSubmit && this.pendingTransactions.length ) {
const lastBlock = await this.getLastBlock()
const waitTime = this.random(3000, 5000)
const proof = await this.generateProofOfWork(lastBlock, waitTime)
const block: BlockResourceItem = {
timestamp: (new Date).getTime(),
uuid: uuid_v4(),
transactions: this.pendingTransactions,
lastBlockHash: lastBlock!.hash(),
lastBlockUUID: lastBlock!.uuid,
proof,
waitTime,
firebaseID: '',
seqID: -1,
}
this.pendingSubmit = new Block(block)
}
return this.pendingSubmit
}
/**
@ -195,7 +319,16 @@ export class Blockchain extends Unit {
* @param group
*/
public async submitTransactions(group: [TransactionResourceItem, TransactionResourceItem]) {
const lastBlock = await this.getLastBlock()
const txes = group.map(item => this.getEncounterTransaction(item))
if ( this.pendingSubmit ) {
this.pendingSubmit.transactions.push(...txes)
}
this.pendingTransactions.push(...txes)
this.refresh()
/*const lastBlock = await this.getLastBlock()
this.logging.verbose('Last block:')
this.logging.verbose(lastBlock)
@ -213,7 +346,7 @@ export class Blockchain extends Unit {
}
await (<BlockResource>this.app().make(BlockResource)).push(block)
return new Block(block)
return new Block(block)*/
}
/**
@ -221,7 +354,14 @@ export class Blockchain extends Unit {
* @param exposures
*/
public async submitExposures(...exposures: ExposureResourceItem[]) {
const lastBlock = await this.getLastBlock()
if ( this.pendingSubmit ) {
this.pendingSubmit.transactions.push(...exposures)
}
this.pendingTransactions.push(...exposures)
this.refresh()
/*const lastBlock = await this.getLastBlock()
this.logging.verbose('Last block:')
this.logging.verbose(lastBlock)
@ -239,7 +379,7 @@ export class Blockchain extends Unit {
}
await (<BlockResource>this.app().make(BlockResource)).push(block)
return new Block(block)
return new Block(block)*/
}
/**
@ -263,6 +403,7 @@ export class Blockchain extends Unit {
})),
firebaseID: '',
seqID: -1,
waitTime: 0,
})
}
@ -301,13 +442,16 @@ export class Blockchain extends Unit {
/**
* Generate a proof of work string for the block that follows lastBlock.
* @param lastBlock
* @param waitTime
* @protected
*/
protected async generateProofOfWork(lastBlock: Block): Promise<string> {
protected async generateProofOfWork(lastBlock: Block, waitTime: number): Promise<string> {
const hashString = lastBlock.hash()
const privateKey = this.config.get("app.gpg.key.private")
const message = openpgp.Message.fromText(hashString)
await this.sleep(waitTime)
// Sign the hash using the server's private key
return (await openpgp.sign({
message,
@ -338,4 +482,20 @@ export class Blockchain extends Unit {
return !!(await result.signatures?.[0]?.verified)
}
/** Sleep for (roughly) the given number of milliseconds. */
async sleep(ms: number) {
await new Promise<void>(res => {
setTimeout(res, ms)
})
}
/**
* Get a random number between two values.
* @param min
* @param max
*/
random(min: number, max: number): number {
return Math.floor(Math.random() * (Math.floor(max) - Math.ceil(min) + 1)) + Math.ceil(min);
}
}

Write Preview
Loading…
Cancel
Save