blockchain tmp

README.md

@@ -43,7 +43,7 @@ Being a decentralized application, we try to let the community choose how this p
 ``` bash
 # install dependencies
 $ npm install
-
+$ npm run database
 # serve with hot reload at localhost:3000
 $ npm run dev
 

backend/README.md

@@ -2,7 +2,13 @@
 
 ```
 nodenv install
-npm install -g @uniqys/cli
+npm install -g @uniqys/cli@0.3.3
+```
+
+# resolve dependencies
+
+```
+npm install
 ```
 
 # start backend server

backend/dapp.json

@@ -8,5 +8,5 @@
     }
   ],
   "initApp": "",
-  "startApp": "node src/index.js"
+  "startApp": "node src/uniqys.js"
 }

backend/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "backend",
+  "version": "1.0.0",
+  "description": "``` nodenv install npm install -g @uniqys/cli ```",
+  "main": "index.js",
+  "dependencies": {
+    "axios": "^0.19.0",
+    "body-parser": "^1.19.0",
+    "express": "^4.17.1",
+    "memcached": "^2.2.2"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC"
+}

backend/src/uniqys.js

@@ -0,0 +1,240 @@
+const express = require("express")
+const bodyParser = require("body-parser")
+const Memcached = require("memcached")
+
+const APP_HOST = '0.0.0.0'
+const APP_PORT = 5650
+const DB_HOST = 'localhost'
+const DB_PORT = 5652
+const INNER_API_HOST = 'localhost'
+const INNER_API_PORT = 5651
+
+const OPERATOR_ADDRESS = 'b8e6493bf64cae685095b162c4a4ee0645cde586'
+
+const DEFAULT_GARI = 10000
+
+const app = express()
+const memcached = new Memcached(`${DB_HOST}:${DB_PORT}`)
+
+app.use(bodyParser())
+
+app.get('/api/hello', async (req, res) => {
+  res.send('Hello, world!')
+})
+
+function getPost (hash) {
+  return new Promise((resolve, reject) => {
+    memcached.get(`post:${hash}`, (err, result) => {
+      if (err) return reject(err)
+      if (typeof result === 'object') return resolve(result)
+      resolve([])
+    })
+  })
+}
+
+function getPosts () {
+  return new Promise((resolve, reject) => {
+    memcached.get(`posts`, (err, result) => {
+      if (err) return reject(err)
+      if (typeof result === 'object') return resolve(result)
+      resolve([])
+    })
+  })
+}
+
+async function removePost(hash) {
+  const posts = await getPosts()
+  const newPosts = posts.filter(post => post.hash !== hash)
+
+  return new Promise((resolve, reject) => {
+    memcached.set(`posts`, newPosts, 0, (err) => {
+      if (err) reject(err)
+      else resolve(newPosts)
+    })
+  })
+}
+
+async function addBalance(address, amount) {
+  await new Promise((resolve, reject) => {
+    memcached.incr(`balance:${address}`, amount, (err, result) => {
+      if (err) return reject(err)
+      if (typeof result === 'number') return resolve(result)
+      memcached.set(`balance:${address}`, amount, 0, (err) => {
+        if (err) return reject(err)
+        resolve(amount)
+      })
+    })
+  })
+}
+
+app.get('/api/message', async (req, res) => {
+  const message = await new Promise((resolve, reject) => {
+    memcached.get('message', (err, result) => {
+      if (err) return reject(err)
+      if (typeof result === 'string') return resolve(result)
+      resolve('')
+    })
+  })
+  res.send(message)
+})
+
+app.post('/api/message', async (req, res) => {
+  const { message } = req.body
+
+  memcached.set('message', message, 0, (err) => {
+    if (err) {
+      res.status(400).send(err)
+    }
+    else {
+      res.sendStatus(200)
+    }
+  })
+})
+
+app.get('/api/posts', async (req, res) => {
+  const posts = await getPosts()
+  res.send({ posts })
+})
+
+app.get('/api/post', async (req, res) => {
+  const { hash } = req.query
+  const post = await getPost(hash)
+  res.send(post)
+})
+
+app.post('/api/post', async (req, res) => {
+  const { post } = req.body
+  const sender = req.header('uniqys-sender')
+  const hash = post.hash
+  const data = {
+    reviewer: sender,
+    post,
+    hash
+  }
+
+  await addBalance(`0x${sender}`, 100)
+
+  await new Promise((resolve, reject) => {
+    memcached.set(`post:${hash}`, data, 0, (err) => {
+      if (err) reject(err)
+      else resolve(data)
+    })
+  })
+
+  const posts = await getPosts()
+  const newPosts = [...posts, data]
+
+  await new Promise((resolve, reject) => {
+    memcached.set(`posts`, newPosts, 0, (err) => {
+      if (err) reject(err)
+      else resolve(newPosts)
+    })
+  })
+
+  res.send(newPosts)
+})
+
+app.get('/api/upvote', async (req, res) => {
+  const { hash } = req.query
+
+  const upvote = await new Promise((resolve, reject) => {
+    memcached.get(`post:${hash}:upvote`, (err, result) => {
+      if (err) return reject(err)
+      if (typeof result === 'number') return resolve(result)
+      resolve(0)
+    })
+  })
+
+  res.send({ upvote })
+})
+
+app.post('/api/upvote', async (req, res) => {
+  const { hash } = req.body
+
+  // token code here
+
+  await new Promise((resolve, reject) => {
+    memcached.incr(`post:${hash}:upvote`, 1, (err, result) => {
+      if (err) return reject(err)
+      if (typeof result === 'number') return resolve(result)
+      memcached.set(`post:${hash}:upvote`, 1, 0, (err) => {
+        if (err) return reject(err)
+        resolve(1)
+      })
+    })
+  })
+
+  res.sendStatus(200)
+})
+
+app.get('/api/downvote', async (req, res) => {
+  const { hash } = req.query
+
+  const downvote = await new Promise((resolve, reject) => {
+    memcached.get(`post:${hash}:downvote`, (err, result) => {
+      if (err) return reject(err)
+      if (typeof result === 'number') return resolve(result)
+      resolve(0)
+    })
+  })
+
+  res.send({ downvote })
+})
+
+app.post('/api/downvote', async (req, res) => {
+  const { hash } = req.body
+
+  // token code here
+
+  const downvote = await new Promise((resolve, reject) => {
+    memcached.get(`post:${hash}:downvote`, (err, result) => {
+      if (err) return reject(err)
+      if (typeof result === 'number') return resolve(result)
+      resolve(0)
+    })
+  })
+
+  if (downvote > 1) {
+    const { reviewer } = await getPost(hash)
+    await addBalance(`0x${reviewer}`, -100)
+    await removePost(hash)
+    return res.send({ hash })
+  } 
+
+  await new Promise((resolve, reject) => {
+    memcached.incr(`post:${hash}:downvote`, 1, (err, result) => {
+      if (err) return reject(err)
+      if (typeof result === 'number') return resolve(result)
+      memcached.set(`post:${hash}:downvote`, 1, 0, (err) => {
+        if (err) return reject(err)
+        resolve(1)
+      })
+    })
+  })
+
+  res.send({ hash })
+})
+
+app.get('/api/balance', async (req, res) => {
+  const { address } = req.query
+
+  const balance = await new Promise((resolve, reject) => {
+    memcached.get(`balance:${address}`, (err, result) => {
+      if (err) return reject(err)
+      if (typeof result === 'number') return resolve(result)
+      resolve(0)
+    })
+  })
+
+  res.send({ balance })
+})
+
+app.post('/api/tap', async (req, res) => {
+  const sender = req.header('uniqys-sender')
+
+  const balance = await addBalance(`0x${sender}`, 1000)
+
+  res.send({ balance })
+})
+
+app.listen(APP_PORT, APP_HOST)

backend/uniqys.json

@@ -4,7 +4,7 @@
   "validatorKey": "validatorKey.json",
   "easy": {
     "gateway": {
-      "port": 8080,
+      "port": 8081,
       "host": "0.0.0.0"
     },
     "app": {