feat: import, commit, and cancel offer as a taker

src/controllers/offer.controller.js

@@ -6,8 +6,13 @@ import {
   assertWalletIsSynced,
   assertIfReadOnlyMode,
   assertStagingTableNotEmpty,
+  assertStagingTableIsEmpty,
+  assertNoActiveOfferFile,
+  assertActiveOfferFile,
 } from '../utils/data-assertions';
 
+// import { deserializeMaker, deserializeTaker } from '../utils/datalayer-utils';
+
 import * as datalayer from '../datalayer/persistance';
 
 export const generateOfferFile = async (req, res) => {
@@ -52,3 +57,78 @@ export const cancelActiveOffer = async (req, res) => {
     });
   }
 };
+
+export const importOfferFile = async (req, res) => {
+  try {
+    await assertIfReadOnlyMode();
+    await assertStagingTableIsEmpty();
+    await assertHomeOrgExists();
+    await assertWalletIsSynced();
+    await assertNoPendingCommits();
+    await assertNoActiveOfferFile();
+
+    const offerFile = req.body;
+
+    await datalayer.verifyOffer(offerFile);
+
+    await Meta.upsert({
+      metaKey: 'activeOffer',
+      metaValue: JSON.stringify(offerFile),
+    });
+
+    //  const makerChanges = deserializeMaker(offerFile.maker);
+    //  const takerChanges = deserializeTaker(offerFile.taker);
+
+    res.json({
+      message: 'Offer has been imported for review.',
+    });
+  } catch (error) {
+    console.trace(error);
+    res.status(400).json({
+      message: 'Can not import offer file.',
+      error: error.message,
+    });
+  }
+};
+
+export const commitImportedOfferFile = async (req, res) => {
+  try {
+    await assertActiveOfferFile();
+
+    const offerFile = Meta.findOne({ where: { metaKey: 'activeOffer' } });
+    const response = await datalayer.takeOffer(offerFile);
+
+    res.json({
+      message: 'Offer Accepted.',
+      tradeId: response.trade_id,
+    });
+
+    await Meta.destroy({
+      where: {
+        meteKey: 'activeOffer',
+      },
+    });
+  } catch (error) {
+    res.status(400).json({
+      message: 'Can not commit offer.',
+      error: error.message,
+    });
+  }
+};
+
+export const cancelImportedOfferFile = async (req, res) => {
+  try {
+    await assertActiveOfferFile();
+
+    await Meta.destroy({
+      where: {
+        meteKey: 'activeOffer',
+      },
+    });
+  } catch (error) {
+    res.status(400).json({
+      message: 'Can not cancel offer.',
+      error: error.message,
+    });
+  }
+};

src/datalayer/persistance.js

@@ -514,6 +514,54 @@ const makeOffer = async (offer) => {
   }
 };
 
+const takeOffer = async (offer) => {
+  const options = {
+    url: `${CONFIG.DATALAYER_URL}/take_offer `,
+    body: JSON.stringify(offer),
+  };
+
+  try {
+    const response = await request(
+      Object.assign({}, getBaseOptions(), options),
+    );
+
+    const data = JSON.parse(response);
+
+    if (data.success) {
+      return data;
+    }
+
+    throw new Error(data.error);
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+};
+
+const verifyOffer = async (offer) => {
+  const options = {
+    url: `${CONFIG.DATALAYER_URL}/verify_offer `,
+    body: JSON.stringify(offer),
+  };
+
+  try {
+    const response = await request(
+      Object.assign({}, getBaseOptions(), options),
+    );
+
+    const data = JSON.parse(response);
+
+    if (data.success) {
+      return true;
+    }
+
+    throw new Error(data.error);
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+};
+
 const cancelOffer = async (tradeId) => {
   const options = {
     url: `${CONFIG.DATALAYER_URL}/cancel_offer `,
@@ -559,4 +607,6 @@ export {
   createDataLayerStore,
   getSubscriptions,
   cancelOffer,
+  verifyOffer,
+  takeOffer,
 };

src/models/staging/staging.model.js

@@ -213,6 +213,7 @@ class Staging extends Model {
 
       const offerInfo = generateOffer(maker, taker);
       const offerResponse = await makeOffer(offerInfo);
+
       if (!offerResponse.success) {
         throw new Error(offerResponse.error);
       }

src/routes/v1/resources/offer.js

@@ -13,4 +13,16 @@ OfferRouter.delete('/', (req, res) => {
   return OfferController.cancelActiveOffer(req, res);
 });
 
+OfferRouter.post('/accept/import', (req, res) => {
+  return OfferController.importOfferFile(req, res);
+});
+
+OfferRouter.post('/accept/commit', (req, res) => {
+  return OfferController.commitImportedOfferFile(req, res);
+});
+
+OfferRouter.delete('/accept/cancel', (req, res) => {
+  return OfferController.cancelImportedOfferFile(req, res);
+});
+
 export { OfferRouter };

src/utils/data-assertions.js

@@ -231,3 +231,23 @@ export const assertStagingTableIsEmpty = async (customMessage) => {
     throw new Error(customMessage || `Staging table is not empty.`);
   }
 };
+
+export const assertActiveOfferFile = async () => {
+  const activeOfferFile = await Meta.findOne({
+    where: { metaKey: 'activeOffer' },
+  });
+
+  if (!activeOfferFile) {
+    throw new Error(`There is no active offer pending`);
+  }
+};
+
+export const assertNoActiveOfferFile = async () => {
+  const activeOfferFile = await Meta.findOne({
+    where: { metaKey: 'activeOffer' },
+  });
+
+  if (activeOfferFile) {
+    throw new Error(`There is an active offer pending`);
+  }
+};

src/utils/datalayer-utils.js

@@ -49,3 +49,25 @@ export const generateOffer = (maker, taker) => {
     fee: 0,
   };
 };
+
+export const deserializeTaker = (taker) => {
+  const changes = taker[0].inclusions.map((inclusion) => {
+    const tableKey = decodeHex(inclusion.key);
+    const table = tableKey.split('|')[0];
+    const value = JSON.parse(decodeHex(inclusion.value));
+    return { table, value };
+  });
+
+  return changes;
+};
+
+export const deserializeMaker = (maker) => {
+  const changes = maker[0].proofs.map((inclusion) => {
+    const tableKey = decodeHex(inclusion.key);
+    const table = tableKey.split('|')[0];
+    const value = JSON.parse(decodeHex(inclusion.value));
+    return { table, value };
+  });
+
+  return changes;
+};