Merged WIP Message Endpoint

Merge branch 'feature/message-send-receive' into develop

api-result.js

@@ -14,6 +14,39 @@ class APIResult {
         this.data = data;
         this.error = error;
     }
+
+    /**
+     * @return {APIResult} APIResult with status 202
+     */
+    static accepted() {
+        return accepted;
+    }
+
+    /**
+     * @return {APIResult} APIResult with status 204
+     */
+    static noContent() {
+        return noContent;
+    }
+
+    /**
+     * @return {APIResult} APIResult with status 400
+     */
+    static badRequest() {
+        return badRequest;
+    }
+
+    /**
+     * @return {APIResult} APIResult with status 404
+     */
+    static notFound() {
+        return notFound;
+    }
 }
 
+const accepted = new APIResult(202);
+const noContent = new APIResult(204);
+const badRequest = new APIResult(400);
+const notFound = new APIResult(404);
+
 module.exports = APIResult;

app.js

@@ -13,11 +13,14 @@ const log = require('./log').log;
 const pool = require('./pool');
 const middleware = require('./middleware');
 const routes = require('./routes');
+const message = require('./controllers/message');
 
 const app = express();
 
 app.use(middleware.before);
 
+app.use('/indy', message.receiveMessage);
+
 app.use('/api/docs', swaggerUi.serve, swaggerUi.setup(swaggerDoc));
 
 app.use('/api/', routes);
@@ -42,5 +45,4 @@ const server = app.listen(process.env.APP_PORT, process.env.APP_HOST, async () =
     }
 });
 
-// for testing purposes
 module.exports = app;

controllers/connection.js

@@ -7,10 +7,12 @@ const indy = require('indy-sdk');
 const agent = require('superagent');
 
 const wrap = require('../asyncwrap').wrap;
+const lib = require('../lib');
 const log = require('../log').log;
 const pool = require('../pool');
 const APIResult = require('../api-result');
 const ConnectionOffer = require('../models/connectionoffer');
+const Message = require('../models/message');
 
 const ENDPOINT = `${process.env.APP_HOST}:${process.env.APP_PORT}`;
 
@@ -49,6 +51,7 @@ module.exports = {
         const [signature, anonCryptConnRes] = await req.wallet.signAndAnonCrypt(toFromKey, fromToKey, {
             did: toFromDid,
             verkey: toFromKey,
+            endpoint: req.body.endpoint || ENDPOINT,
             nonce: connOffer.nonce
         });
         const [recipient] = await indy.getEndpointForDid(req.wallet.handle, pool.handle, connOffer.did);
@@ -72,20 +75,106 @@ module.exports = {
         // ToDo The following line creates indy error with new version of indy-sdk
         //  await indy.storeTheirDid(req.wallet.handle, {did: connOffer.did, verkey: fromToKey});
         await indy.setEndpointForDid(req.wallet.handle, connOffer.did, recipient, fromToKey);
-        await pool.attribRequest(
+        /* await pool.attribRequest(
             req.wallet.handle,
             toFromDid,
             toFromDid,
             null,
             { endpoint: { ha: req.body.endpoint || ENDPOINT } },
             null
-        );
+        ); */
         await indy.createPairwise(req.wallet.handle, connOffer.did, toFromDid);
         next(
             new APIResult(200, {
                 myDid: toFromDid,
                 theirDid: connOffer.did
             })
         );
-    })
+    }),
+
+    async offer(wallet, message) {
+        await Message.store(wallet.id, message.id, message.type, message.message);
+        return APIResult.accepted();
+    },
+
+    async request(wallet, message) {
+        const connOffer = await Message.findOne({
+            messageId: message.id,
+            wallet: wallet.id
+        }).exec();
+
+        // previous offer exists
+        if (connOffer) {
+            return await module.exports.acceptRequest(wallet, message.message);
+        }
+
+        // no previous offer, so just store the request
+        await Message.store(wallet.id, message.message.nonce, message.type, message.message);
+        return APIResult.accepted();
+    },
+
+    async response(wallet, message) {
+        // TODO
+        return new APIResult(501, { message: 'not implemented' });
+    },
+
+    async acknowledgement(wallet, message) {
+        // TODO
+        return new APIResult(501, { message: 'not implemented' });
+    },
+
+    async acceptRequest(wallet, connReq, connOffer) {
+        const theirDid = connReq.did;
+        let theirVk = connReq.verkey;
+        const theirEndpointDid = connReq.endpointDid;
+        let theirEndpoint = connReq.theirEndpoint;
+        let theirEndpointVk;
+        try {
+            if (!theirEndpoint) {
+                [theirEndpoint, theirEndpointVk] = await indy.getEndpointForDid(
+                    wallet.handle,
+                    pool.handle,
+                    theirEndpointDid
+                );
+            }
+            if (!theirEndpointVk) {
+                theirEndpointVk = await indy.keyForDid(pool.handle, wallet.handle, theirEndpointDid);
+            }
+            if (!theirVk) {
+                theirVk = await indy.keyForDid(pool.handle, wallet.handle, theirDid);
+            }
+        } catch (err) {
+            log.warn('failed to retrieve endpoint details', err);
+            return new APIResult(400, { message: 'endpoint details missing from request and not found on ledger' });
+        }
+
+        const [myDid, myVk] = await indy.createAndStoreMyDid(wallet.handle, {});
+        await indy.storeTheirDid(wallet.handle, {
+            did: theirDid,
+            verkey: theirVk
+        });
+        await indy.createPairwise(
+            wallet.handle,
+            theirDid,
+            myDid,
+            JSON.stringify({
+                theirEndpointDid: theirEndpointDid,
+                verified: false
+            })
+        );
+        await indy.setEndpointForDid(wallet.handle, theirEndpointDid, theirEndpoint, theirEndpointVk);
+
+        const connRes = lib.connection.createConnectionResponse(
+            wallet,
+            myDid,
+            myVk,
+            theirDid,
+            theirVk,
+            connReq.request_nonce
+        );
+        // TODO store unencrypted message somewhere?
+
+        connRes.message = await lib.crypto.anonCrypt(theirVk, connRes.message);
+        return lib.message.sendAnoncryptMessage(pool.handle, wallet.handle, theirEndpointDid, connRes);
+    }
 };

controllers/credential.js

@@ -127,5 +127,20 @@ module.exports = {
         } else {
             next(new APIResult(200, cred));
         }
-    })
+    }),
+
+    async offer(wallet, message) {
+        // TODO
+        return new APIResult(501, { message: 'not implemented' });
+    },
+
+    async request(wallet, message) {
+        // TODO
+        return new APIResult(501, { message: 'not implemented' });
+    },
+
+    async credential(wallet, message) {
+        // TODO
+        return new APIResult(501, { message: 'not implemented' });
+    }
 };

controllers/endpoint.js

@@ -8,6 +8,7 @@ const indy = require('indy-sdk');
 const pool = require('../pool');
 const Wallet = require('../models/wallet');
 const ConnectionOffer = require('../models/connectionoffer');
+const WalletProvider = require('../middleware/walletProvider');
 const wrap = require('../asyncwrap').wrap;
 const APIResult = require('../api-result');
 
@@ -25,14 +26,14 @@ module.exports = {
         if (!connOffer) {
             return next(new APIResult(404, { message: 'Unknown nonce' }));
         }
-        // TODO interface with walletProvider here
         req.wallet = await Wallet.findOne({ _id: connOffer.issuerWallet }).exec();
-        await req.wallet.open();
+        await WalletProvider.provideHandle(req.wallet);
         const fromToKey = await indy.keyForDid(pool.handle, req.wallet.handle, connOffer.ownDid);
         const connRes = await req.wallet.anonDecryptAndVerify(fromToKey, message, signature);
         const role = connOffer.role === 'NONE' ? null : connOffer.role;
         await pool.nymRequest(req.wallet.handle, req.wallet.ownDid, connRes.did, connRes.verkey, null, role);
         await indy.storeTheirDid(req.wallet.handle, { did: connRes.did, verkey: connRes.verkey });
+        await indy.setEndpointForDid(req.wallet.handle, connRes.did, connRes.endpoint, connRes.verkey);
         await indy.createPairwise(req.wallet.handle, connRes.did, connOffer.ownDid);
         await connOffer.remove();
         next(new APIResult(200, { message: 'Success' }));