dev/SenShaMart
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

smarter store update after replacing chains

Browse source 
concurrent mining
validity checks for new transactions/blocks/metadata
rdf store stores quads
smarter clearing of transactions from pool when a new block is mined
change querying to be readonly and generic
moved some things around
This commit is contained in:
Josip Milovac 2022-12-20 11:26:06 +11:00
parent ea81105df6
commit b4c2a0c88d
7 changed files with 373 additions and 177 deletions
Download patch file Download diff file Expand all files Collapse all files

146
app/index.js
View file

@ -33,8 +33,8 @@ const Blockchain = require('../blockchain');
const P2pServer = require('./p2p-server');
const Wallet = require('../wallet');
const TransactionPool = require('../wallet/transaction-pool');
const Miner = require('./miner');
const QueryEngine = require('@comunica/query-sparql').QueryEngine;
const ChainUtil = require('../chain-util');
const N3 = require('n3');
const jsonld = require('jsonld');
@ -51,10 +51,10 @@ const multer = require('multer');/* Multer is a node.js middleware for
const app = express();
const bc = new Blockchain();
const wallet = new Wallet();
//currently gen a new keypair per run, we probably want to load this from something else in the future
const wallet = new Wallet(ChainUtil.genKeyPair());
const tp = new TransactionPool();
const p2pServer = new P2pServer(bc, tp,'./persist_block_chain.json');
const miner = new Miner(bc, tp, wallet, p2pServer);
const p2pServer = new P2pServer(bc, tp, wallet, './persist_block_chain.json');
const parser = new N3.Parser(); //({format: 'application/n-quads'});
const myEngine = new QueryEngine();
@ -119,12 +119,12 @@ app.get('/Transactions', (req, res) => {
res.json(tp);
});
///////////////
app.get('/mine-transactions', (req, res) => {
const block = miner.mine();
console.log(`New block added: ${block.toString()}`);
res.redirect('/blocks');
// res.json("Block mined");
});
//app.get('/mine-transactions', (req, res) => {
// const block = miner.mine();
// console.log(`New block added: ${block.toString()}`);
// res.redirect('/blocks');
// // res.json("Block mined");
//});
///////////////
app.get('/public-key', (req, res) => {
res.json({ publicKey: wallet.publicKey });
@ -137,60 +137,66 @@ app.get('/Balance', (req, res) => {
///////////////
//this API prints all the quads stored in the RDF store and returns the entire store
app.get('/quads', (req, res) => {
for (const quad of store)
console.log(quad);
//for (const quad of store)
//console.log(quad);
res.json(store);
});
app.get('/IoTdeviceRegistration', (req, res)=> {
fs.readdir('./uploads', function(err, files) {
console.log(files[files.length-2]);
var FileName = files[files.length-2];
let rawdata = fs.readFileSync(`./uploads/${FileName}`);
let SenShaMartDesc = JSON.parse(rawdata);
/* the following piece of code is used to genrate JSON object out of name-value pairs submitted
let SenShaMartExtNames = ['Name','Geo' ,'IP_URL' , 'Topic_Token', 'Permission', 'RequestDetail',
'OrgOwner', 'DepOwner','PrsnOwner', 'PaymentPerKbyte',
'PaymentPerMinute','Protocol', 'MessageAttributes', 'Interval',
'FurtherDetails']
let SenShaMartExtValues = [Name,Geo ,IP_URL , Topic_Token, Permission, RequestDetail,
OrgOwner, DepOwner,PrsnOwner, PaymentPerKbyte,
PaymentPerMinute,Protocol, MessageAttributes, Interval,
FurtherDetails]
let SenSHaMArtExt = {};
for (let i =0; i <SenShaMartExtNames.length; i++){
SenSHaMArtExt[`${SenShaMartExtNames[i]}`]= SenShaMartExtValues[i]
//console.log(files[files.length-2]);
var FileName = files[files.length-2];
let rawdata = fs.readFileSync(`./uploads/${FileName}`);
let SenShaMartDesc = JSON.parse(rawdata);
/* the following piece of code is used to genrate JSON object out of name-value pairs submitted
let SenShaMartExtNames = ['Name','Geo' ,'IP_URL' , 'Topic_Token', 'Permission', 'RequestDetail',
'OrgOwner', 'DepOwner','PrsnOwner', 'PaymentPerKbyte',
'PaymentPerMinute','Protocol', 'MessageAttributes', 'Interval',
'FurtherDetails']
let SenShaMartExtValues = [Name,Geo ,IP_URL , Topic_Token, Permission, RequestDetail,
OrgOwner, DepOwner,PrsnOwner, PaymentPerKbyte,
PaymentPerMinute,Protocol, MessageAttributes, Interval,
FurtherDetails]
let SenSHaMArtExt = {};
for (let i =0; i <SenShaMartExtNames.length; i++){
SenSHaMArtExt[`${SenShaMartExtNames[i]}`]= SenShaMartExtValues[i]
}
//let SenShaMartOnt = SSNmetadata;
//SenShaMartOnt.push(SenSHaMArtExt); */
console.log(SenShaMartDesc)
jsonld.toRDF(SenShaMartDesc, {format: 'application/n-quads'},
(err, nquads) => {
console.log(nquads)
var metaDataTransaction = wallet.createMetadata(
nquads, tp);
}
//let SenShaMartOnt = SSNmetadata;
//SenShaMartOnt.push(SenSHaMArtExt); */
//console.log(SenShaMartDesc);
jsonld.toRDF(SenShaMartDesc, {format: 'application/n-quads'},
(err, nquads) => {
//console.log(nquads)
var metadata = wallet.createMetadata(
nquads, tp);
p2pServer.newMetadata(metadata);
});
});
res.json("MetadataTransactionCreated");
});
res.json("MetadataTransactionCreated");
});
//////////////////////////////////////////////////
// POST APIs
app.post('/mine', (req, res) => {
const block = bc.addBlock(req.body.data);
console.log(`New block added: ${block.toString()}`);
//this doesn't work well with the continious miner
//app.post('/mine', (req, res) => {
// const block = bc.addBlock(req.body.data);
// console.log(`New block added: ${block.toString()}`);
p2pServer.newBlock(block);
// p2pServer.newBlock(block);
res.redirect('/blocks');
});
// res.redirect('/blocks');
//});
///////////////
app.post('/PaymentTransaction', (req, res) => {
const { recipient, amount } = req.body;
const transaction = wallet.createTransaction(recipient, amount, bc, tp);
//p2pServer.broadcastTransaction(transaction);
if (transaction === null) {
res.json("Couldn't create transaction");
return;
}
p2pServer.newTransaction(transaction);
res.redirect('/transactions');
});
@ -198,11 +204,12 @@ app.post('/PaymentTransaction', (req, res) => {
app.post('/IoTdevicePaymentTransaction', (req, res) => {
const { Recipient_payment_address, Amount_of_money, Payment_method,
Further_details} = req.body;
if (Payment_method == "SensorCoin"){
const PaymentTransaction = wallet.createCoinTransaction(
Recipient_payment_address, Amount_of_money, bc, tp);
p2pServer.broadcastCoinTransaction(PaymentTransaction);
res.json("PaymentTransactionCreated");
if (Payment_method == "SensorCoin") {
//create coin transaction doesn't exist yet
const PaymentTransaction = wallet.createCoinTransaction(
Recipient_payment_address, Amount_of_money, bc, tp);
p2pServer.broadcastCoinTransaction(PaymentTransaction);
res.json("PaymentTransactionCreated");
}
else if (Payment_method == "Bitcoin") {
res.redirect('/BitcoinTransaction')
@ -233,21 +240,30 @@ app.post("/UploadMetafile", upload.single('file'), (req, res) => {
//Start of comunica sparql query code
app.post('/sparql', (req, res) => {
console.log(req.body);
const {Select,subject,predicate,object,Limit}= req.body;
const start = async function (a,b){
const bindingsStream = await myEngine.queryBindings(`SELECT ${Select} WHERE
{${subject} ${predicate} ${object}} LIMIT
${Limit}`, { sources: [{ type: 'rdfjsSource',
value: p2pServer.store}]
});
bindingsStream.on('data', (binding) => {
console.log(binding.toString());
queryResult= binding;
const start = async function () {
let result = [];
const bindingsStream = await myEngine.queryBindings(
req.body,
{
readOnly: true,
sources: [{
type: 'rdfjsSource',
value: p2pServer.store
}]
});
};
start()
res.json("Query succsessful");
});
bindingsStream.on('data', (binding) => {
console.log(binding.toString());
result.push(binding);
});
bindingsStream.on('end', () => {
res.json(JSON.stringify(result));
});
bindingsStream.on('error', (err) => {
console.error(err);
});
};
start()
});
///////////////////////////////////////////////////////////Integration///////////////////////////////////////////////////////////
DistributedBrokers = ["mqtt.eclipse.org", "test.mosquitto.org","broker.hivemq.com"];

84
app/miner.js
View file

@ -1,34 +1,88 @@
const Wallet = require('../wallet');
const Transaction = require('../wallet/transaction');
const Block = require('../blockchain/block');
class Miner {
static STATE_WAITING = 0;
static STATE_RUNNING = 1;
static STATE_INTERRUPTED = 2;
static STATE_RESTARTING = 3;
constructor(blockchain, transactionPool, wallet, p2pServer) {
this.blockchain = blockchain;
this.transactionPool = transactionPool;
this.wallet = wallet;
this.p2pServer = p2pServer;
}
this.state = Miner.STATE_WAITING;
this.mining = [[], []];
this.lastBlock = null;
}
interrupt() {
if (this.state === Miner.STATE_RUNNING) {
this.state = Miner.STATE_INTERRUPTED;
}
}
interruptIfContainsTransaction(transaction) {
if (this.state === Miner.STATE_RUNNING && this.mining[0].find(t => t.id === transaction.id)) {
this.state = Miner.STATE_INTERRUPTED;
}
}
interruptIfContainsMetadata(metadata) {
if (this.state === Miner.STATE_RUNNING && this.mining[1].find(t => t.id === metadata.id)) {
this.state = Miner.STATE_INTERRUPTED;
}
}
startMine() {
//only continue if state is waiting or restarting
if (this.state !== Miner.STATE_WAITING && this.state !== Miner.STATE_RESTARTING) {
return;
}
mine() {
const validTransactions = this.transactionPool.validTransactions();
const validMetadataS = this.transactionPool.validMetadataS();
if (validTransactions.length === 0 && validMetadataS.length === 0) {
this.state = Miner.STATE_WAITING;
return;
}
validTransactions.push(
Transaction.rewardTransaction(this.wallet, Wallet.blockchainWallet())
);
console.log(validTransactions);
console.log("//////");
const validMetadataS = this.transactionPool.validMetadataS();
// for (let i =0; i <validMetadataS.length; i++){
// validTransactions.push(validMetadataS[i]);
// }
console.log(validTransactions);
// const validMetadataS = this.transactionPool.metadataS;
const block = this.blockchain.addBlock([validTransactions, validMetadataS]);
this.p2pServer.newBlock(block);
this.transactionPool.clear();
return block;
this.lastBlock = this.blockchain.chain[this.blockchain.chain.length - 1];
this.state = Miner.STATE_RUNNING;
this.mining = [validTransactions, validMetadataS];
this.nonce = 0;
this.mine();
}
mine() {
if (this.state !== Miner.STATE_RUNNING) {
this.state = Miner.STATE_RESTARTING;
startMine();
return;
}
const timestamp = Date.now();
const difficulty = Block.adjustDifficulty(this.lastBlock, timestamp);
const hash = Block.hash(timestamp, this.lastBlock.hash, this.mining, this.nonce, difficulty);
if (hash.substring(0, difficulty) === '0'.repeat(difficulty)) {
//success
this.p2pServer.newBlock(new Block(timestamp, this.lastBlock.hash, hash, this.mining, this.nonce, difficulty));
this.state = Miner.STATE_RESTARTING;
setImmediate(() => { this.startMine() });
} else {
//failure
this.nonce++;
setImmediate(() => { this.mine() });
}
}
}

126
app/p2p-server.js
View file

@ -1,9 +1,12 @@
const Websocket = require('ws');
const N3 = require('n3');
const parser = new N3.Parser(); //({format: 'application/n-quads'});
const DataFactory = require('n3').DataFactory;
const fs = require('fs');
const process = require('process');
const Miner = require('./miner');
const Transaction = require('../wallet/transaction');
const TransactionPool = require('../wallet/transaction-pool');
const Metadata = require('../wallet/metadata');
const P2P_PORT = process.env.P2P_PORT || 5000;
const peers = process.env.PEERS ? process.env.PEERS.split(',') : [];
@ -15,12 +18,13 @@ const MESSAGE_TYPES = {
};
class P2pServer {
constructor(blockchain, transactionPool,chainStorageLocation) {
constructor(blockchain, transactionPool, wallet, chainStorageLocation) {
this.blockchain = blockchain;
this.transactionPool = transactionPool;
this.sockets = [];
this.store = new N3.Store();
this.chainStorageLocation = chainStorageLocation;
this.miner = new Miner(this.blockchain, this.transactionPool, wallet, this);
//possible race if deleted after check, but we live with it I guess
if (fs.existsSync(this.chainStorageLocation)) {
@ -63,39 +67,93 @@ class P2pServer {
const data = JSON.parse(message);
switch(data.type) {
case MESSAGE_TYPES.chain:
newChain(data.chain);
this.newChain(data.chain);
break;
case MESSAGE_TYPES.transaction:
this.transactionPool.updateOrAddTransaction(data.transaction);
this.newTransaction(data.transaction, false);
break;
case MESSAGE_TYPES.metadata:
this.transactionPool.updateOrAddMetadata(data.metadata);
break;
case MESSAGE_TYPES.clear_transactions:
this.transactionPool.clear();
this.newMetadata(data.metadata, false);
break;
//case MESSAGE_TYPES.clear_transactions:
// this.transactionPool.clear();
// break;
}
});
}
newBlock(block) {
this.onNewBlock(block.data);
this.syncChains();
this.persistChain(this.blockchain.chain);
newMetadata(metadata, broadcast) {
if (!Metadata.verifyMetadata(metadata)) {
console.log("Couldn't add metadata to p2pServer, couldn't verify");
return;
}
switch (this.transactionPool.updateOrAddMetadata(metadata)) {
case TransactionPool.Return.add:
this.miner.startMine();
break;
case TransactionPool.Return.update:
this.miner.interruptIfContainsMetadata(metadata);
break;
case TransactionPool.Return.error:
console.log("Couldn't add metadata to p2pServer, couldn't updateOrAdd");
return;
}
if (broadcast === undefined || broadcast) {
this.broadcastMetadata(metadata);
}
}
newChain(chain,persist) {
if (!this.blockchain.replaceChain(chain)) {
newTransaction(transaction, broadcast) {
if (!Transaction.verifyTransaction(transaction)) {
console.log("Couldn't add transaction to p2pServer, couldn't verify");
return false;
}
switch (this.transactionPool.updateOrAddTransaction(transaction)) {
case TransactionPool.Return.add:
this.miner.startMine();
break;
case TransactionPool.Return.update:
this.miner.interruptIfContainsTransaction(transaction);
break;
case TransactionPool.Return.error:
console.log("Couldn't add transaction to p2pServer, couldn't updateOrAdd");
return;
}
if (broadcast === undefined || broadcast) {
this.broadcastTransaction(transaction);
}
}
newBlock(block) {
if (!this.blockchain.addBlock(block)) {
//invalid block, return
return;
}
this.onNewBlock(block);
this.persistChain(this.blockchain.chain);
this.syncChains();
}
newChain(chain, persist) {
const oldChain = this.blockchain.chain;
const divergence = this.blockchain.replaceChain(chain);
if (divergence === null) {
//failed to replace
return;
}
if (typeof persist === "undefined" || persist) {
this.persistChain(chain);
}
//dirty clear
this.store = new N3.Store();
for (var block in this.blockchain.chain) {
this.onNewBlock(block);
for (let i = divergence; i < oldChain.length; i++) {
this.store.deleteGraph(oldChain[i].hash);
}
for (let i = divergence; i < this.blockchain.chain.length; i++) {
this.onNewBlock(this.blockchain.chain[i]);
}
}
@ -112,28 +170,36 @@ class P2pServer {
onNewBlock(block) {
//block data is of form [transactions,metadatas]
if (block.length != 2) {
if (block.data.length != 2) {
//assert?
return;
}
const metadatas = block[1];
for (var metadata in metadatas) {
if (!(SSNmetadata in metadata)) {
this.transactionPool.clearFromBlock(block);
this.miner.interrupt();
const metadatas = block.data[1];
for (const metadata of metadatas) {
if (!("SSNmetadata" in metadata)) {
//assert?
return;
}
var ssn = metadata.SSNmetadata;
const parser = new N3.Parser();
parser.parse(
ssn,
(error, quadN, prefixes) => {
if (quadN) {
store.addQuad(DataFactory.quad(
this.store.addQuad(DataFactory.quad(
DataFactory.namedNode(quadN.subject.id),
DataFactory.namedNode(quadN.predicate.id),
DataFactory.namedNode(quadN.object.id)));
DataFactory.namedNode(quadN.object.id),
DataFactory.namedNode(block.hash)));
}
});
}
@ -163,13 +229,13 @@ class P2pServer {
this.sockets.forEach(socket => this.sendChain(socket));
}
//broadcastTransaction(transaction) {
// this.sockets.forEach(socket => this.sendTransaction(socket, transaction));
//}
broadcastTransaction(transaction) {
this.sockets.forEach(socket => this.sendTransaction(socket, transaction));
}
//broadcastMetadata(metadata) {
// this.sockets.forEach(socket => this.sendMetadata(socket, metadata));
//}
broadcastMetadata(metadata) {
this.sockets.forEach(socket => this.sendMetadata(socket, metadata));
}
//broadcastClearTransactions() {
// this.sockets.forEach(socket => socket.send(JSON.stringify({