Implement routes with db backend

Author: Joonmo Yang

package.json

@@ -14,7 +14,8 @@
  },
  "dependencies": {
  "@types/config": "^0.0.34",
- "codechain-keystore": "~0.4.0",
+ "codechain-keystore": "^0.6.1",
+ "codechain-primitives": "^1.0.1",
  "config": "^3.1.0",
  "debug": "~2.6.9",
  "express": "~4.16.0",

src/models/key.ts

@@ -1,3 +1,4 @@
+import { SecretStorage } from "codechain-keystore";
 import { Model, snakeCaseMappers } from "objection";
 
 export default class KeyModel extends Model {
@@ -18,4 +19,21 @@ export default class KeyModel extends Model {
  public readonly ciphertext!: string;
 
  public readonly meta!: any;
+
+ public toJSON(): SecretStorage {
+ return {
+ crypto: {
+ ciphertext: this.ciphertext,
+ cipherparams: this.cipherparams,
+ cipher: this.cipher,
+ kdf: this.kdf,
+ kdfparams: this.kdfparams,
+ mac: this.mac
+ },
+ id: this.address,
+ version: this.version,
+ address: this.address,
+ meta: this.meta
+ };
+ }
 }

src/routes/api.ts

@@ -1,97 +1,194 @@
+import * as storage from "codechain-keystore/lib/logic/storage";
+import { KeyType as KeyTypeId } from "codechain-keystore/lib/model/keytypes";
+import {
+ generatePrivateKey,
+ getAccountIdFromPublic,
+ getPublicFromPrivate,
+ signEcdsa
+} from "codechain-primitives";
 import * as express from "express";
 import { Context } from "../context";
+import KeyModel from "../models/key";
 
 type KeyType = "asset" | "platform";
 
+function findKey(
+ type: KeyType,
+ address: string
+): Promise<KeyModel | undefined> {
+ return KeyModel.query().findById([type, address]) as any;
+}
+
 export function createRouter(context: Context) {
  const router = express.Router();
 
  router.get("/keys", async (req, res) => {
  const keyType: KeyType = req.body.keyType;
- const keys = await context.cckey[keyType].getKeys();
-
  res.json({
  success: true,
- result: keys
+ result: await KeyModel.query().where({ type: keyType })
  });
  });
 
  router.get("/keys/:key/publicKey", async (req, res) => {
  const { key } = req.params;
  const keyType: KeyType = req.body.keyType;
- const publicKey = await context.cckey[keyType].getPublicKey({ key });
-
- res.json({
- success: true,
- result: publicKey
- });
- });
 
- router.get("/keys/:key/rawKey", async (req, res) => {
- try {
- const { key } = req.params;
- const { passphrase } = req.body;
- const keyType: KeyType = req.body.keyType;
- const rawKey = await context.cckey[keyType].exportRawKey({
- key,
- passphrase
+ const row = await findKey(keyType, key);
+ if (row == null) {
+ res.json({
+ success: false,
+ error: "Not found"
  });
-
+ } else {
+ const priv = await storage.decode(row.toJSON(), "");
+ const pub = getPublicFromPrivate(priv);
  res.json({
  success: true,
- result: rawKey
+ result: pub
  });
- } catch (e) {
+ }
+ });
+
+ router.get("/keys/:key/rawKey", async (req, res) => {
+ const { key } = req.params;
+ const { passphrase } = req.body;
+ const keyType: KeyType = req.body.keyType;
+
+ const row = await findKey(keyType, key);
+ if (row == null) {
  res.json({
  success: false,
- error: e
+ error: "Not found"
  });
+ } else {
+ try {
+ const priv = await storage.decode(row.toJSON(), passphrase);
+ res.json({
+ success: true,
+ result: priv
+ });
+ } catch (e) {
+ res.json({
+ success: false,
+ error: "Invalid passphrase"
+ });
+ }
  }
  });
 
  router.post("/keys", async (req, res) => {
  const { passphrase } = req.body;
  const keyType: KeyType = req.body.keyType;
- const key = await context.cckey[keyType].createKey({
- passphrase
- });
- res.json({
- success: true,
- result: key
- });
+
+ while (true) {
+ const priv = generatePrivateKey();
+ const pub = getPublicFromPrivate(priv);
+ const address = getAccountIdFromPublic(pub);
+
+ // Check duplication
+ if ((await findKey(keyType, address)) != null) {
+ continue;
+ }
+
+ let typeId: KeyTypeId | undefined;
+ switch (keyType) {
+ case "asset": {
+ typeId = KeyTypeId.Asset;
+ break;
+ }
+ case "platform": {
+ typeId = KeyTypeId.Platform;
+ break;
+ }
+ }
+
+ const secret = await storage.encode(
+ priv,
+ typeId!,
+ passphrase,
+ JSON.stringify({})
+ );
+ await KeyModel.query().insert({
+ type: keyType,
+ address: secret.address,
+ version: secret.version,
+
+ kdf: secret.crypto.kdf,
+ kdfparams: secret.crypto.kdfparams,
+ mac: secret.crypto.mac,
+
+ cipher: secret.crypto.cipher,
+ cipherparams: secret.crypto.cipherparams,
+ ciphertext: secret.crypto.ciphertext,
+
+ meta: secret.meta
+ });
+
+ res.json({
+ success: true,
+ result: secret.address
+ });
+ return;
+ }
  });
 
  router.delete("/keys/:key", async (req, res) => {
  const { key } = req.params;
  const keyType: KeyType = req.body.keyType;
- const result = await context.cckey[keyType].deleteKey({
- key
- });
- res.json({
- success: true,
- result
- });
- });
 
- router.post("/keys/:key/sign", async (req, res) => {
- try {
- const { key } = req.params;
- const { message, passphrase = "" } = req.body;
- const keyType: KeyType = req.body.keyType;
- const result = await context.cckey[keyType].sign({
- key,
- passphrase,
- message
- });
+ const row = await findKey(keyType, key);
+
+ if (row == null) {
  res.json({
- success: true,
- result
+ success: false,
+ error: "Not found"
  });
- } catch (e) {
+ } else {
+ try {
+ // Check if the passphrase is correct
+ await storage.decode(row.toJSON(), "");
+ await KeyModel.query()
+ .del()
+ .findById([keyType, key]);
+ res.json({
+ success: true,
+ result: true
+ });
+ } catch (e) {
+ res.json({
+ success: true,
+ result: false
+ });
+ }
+ }
+ });
+
+ router.post("/keys/:key/sign", async (req, res) => {
+ const { key } = req.params;
+ const { message, passphrase = "" } = req.body;
+ const keyType: KeyType = req.body.keyType;
+
+ const row = await findKey(keyType, key);
+
+ if (row == null) {
  res.json({
  success: false,
- error: e
+ error: "Not found"
  });
+ } else {
+ try {
+ const priv = await storage.decode(row.toJSON(), passphrase);
+ res.json({
+ success: true,
+ result: signEcdsa(message, priv)
+ });
+ } catch (e) {
+ res.json({
+ success: false,
+ error: e
+ });
+ }
  }
  });