Updated OrderCreated processor to include new log fields

AugurProject · Nov 28, 2017 · 8a2370f · 8a2370f
1 parent 698c3e6
commit 8a2370f
Show file tree

Hide file tree

Showing 3 changed files with 59 additions and 68 deletions.
diff --git a/src/blockchain/log-processors/order-created.ts b/src/blockchain/log-processors/order-created.ts
@@ -1,29 +1,13 @@
 import Augur from "augur.js";
-import { parallel } from "async";
 import BigNumber from "bignumber.js";
 import * as Knex from "knex";
-import { Address, Bytes32, FormattedLog, OrdersRow, OrderState, ErrorCallback, AsyncCallback } from "../../types";
+import { Address, Bytes32, FormattedLog, MarketsRow, OrdersRow, TokensRow, OrderState, ErrorCallback, AsyncCallback } from "../../types";
 import { processOrderCanceledLog } from "./order-canceled";
 import { augurEmitter } from "../../events";
 import { convertFixedPointToDecimal } from "../../utils/convert-fixed-point-to-decimal";
 import { denormalizePrice } from "../../utils/denormalize-price";
 import { formatOrderAmount, formatOrderPrice } from "../../utils/format-order";
-import { WEI_PER_ETHER } from "../../constants";
-
-interface BlocksRow {
-  timestamp: number;
-}
-
-interface TokensRow {
-  marketID: Address;
-  outcome: number;
-}
-
-interface MarketsRow {
-  minPrice: string|number;
-  maxPrice: string|number;
-  numTicks: string|number;
-}
+import { WEI_PER_ETHER, ZERO } from "../../constants";
 
 interface OrderCreatedOnContractData {
   orderType: string;
@@ -37,55 +21,55 @@ interface OrderCreatedOnContractData {
 }
 
 export function processOrderCreatedLog(db: Knex, augur: Augur, trx: Knex.Transaction, log: FormattedLog, callback: ErrorCallback): void {
-  trx.select(["marketID", "outcome"]).from("tokens").where({ contractAddress: log.shareToken }).asCallback((err: Error|null, tokensRows?: Array<TokensRow>): void => {
+  const amount: string = log.amount;
+  const price: string = log.price;
+  const orderType: string = log.orderType;
+  const moneyEscrowed: string = log.moneyEscrowed;
+  const sharesEscrowed: string = log.sharesEscrowed;
+  const shareToken: Address = log.shareToken;
+  trx.first("marketID", "outcome").from("tokens").where({ contractAddress: shareToken }).asCallback((err: Error|null, tokensRow?: TokensRow): void => {
     if (err) return callback(err);
-    if (!tokensRows || !tokensRows.length) return callback(new Error("market and outcome not found"));
-    const { marketID, outcome } = tokensRows[0];
-    trx.select(["minPrice", "maxPrice", "numTicks"]).from("markets").where({ marketID }).asCallback((err: Error|null, marketsRows?: Array<MarketsRow>): void => {
+    if (!tokensRow) return callback(new Error("market and outcome not found"));
+    const marketID = tokensRow.marketID!;
+    const outcome = tokensRow.outcome!;
+    trx.first("minPrice", "maxPrice", "numTicks").from("markets").where({ marketID }).asCallback((err: Error|null, marketsRow?: MarketsRow): void => {
       if (err) return callback(err);
-      if (!marketsRows || !marketsRows.length) return callback(new Error("market min price, max price, and/or num ticks not found"));
-      const { minPrice, maxPrice, numTicks } = marketsRows[0];
+      if (!marketsRow) return callback(new Error("market min price, max price, and/or num ticks not found"));
+      const minPrice = marketsRow.minPrice!;
+      const maxPrice = marketsRow.maxPrice!;
+      const numTicks = marketsRow.numTicks!;
       const ordersPayload = { _orderId: log.orderId };
-      parallel({
-        orderType: (next: AsyncCallback): void => augur.api.Orders.getOrderType(ordersPayload, next),
-        price: (next: AsyncCallback): void => augur.api.Orders.getPrice(ordersPayload, next),
-        amount: (next: AsyncCallback): void => augur.api.Orders.getAmount(ordersPayload, next),
-        sharesEscrowed: (next: AsyncCallback): void => augur.api.Orders.getOrderSharesEscrowed(ordersPayload, next),
-        moneyEscrowed: (next: AsyncCallback): void => augur.api.Orders.getOrderMoneyEscrowed(ordersPayload, next),
-      }, (err: Error|null, onContractData: OrderCreatedOnContractData): void => {
+      const fullPrecisionAmount = convertFixedPointToDecimal(amount, WEI_PER_ETHER);
+      const fullPrecisionPrice = denormalizePrice(minPrice, maxPrice, convertFixedPointToDecimal(price, numTicks));
+      if (new BigNumber(fullPrecisionPrice, 10).eq(new BigNumber(-10, 10))) process.exit();
+      const orderTypeLabel = orderType === "0" ? "buy" : "sell";
+      const orderData: OrdersRow = {
+        marketID,
+        blockNumber: log.blockNumber,
+        transactionHash: log.transactionHash,
+        logIndex: log.logIndex,
+        outcome,
+        shareToken,
+        orderCreator: log.creator,
+        orderState: OrderState.OPEN,
+        tradeGroupID: log.tradeGroupId,
+        orderType: orderTypeLabel,
+        price: formatOrderPrice(orderTypeLabel, minPrice, maxPrice, fullPrecisionPrice),
+        amount: formatOrderAmount(minPrice, maxPrice, fullPrecisionAmount),
+        fullPrecisionPrice,
+        fullPrecisionAmount,
+        tokensEscrowed: convertFixedPointToDecimal(moneyEscrowed, WEI_PER_ETHER),
+        sharesEscrowed: convertFixedPointToDecimal(sharesEscrowed, WEI_PER_ETHER),
+      };
+      const orderID = { orderID: log.orderId };
+      augurEmitter.emit("OrderCreated", Object.assign(orderData, orderID));
+      trx.select("marketID").from("orders").where(orderID).asCallback((err: Error|null, ordersRows?: Array<Partial<OrdersRow>>): void => {
         if (err) return callback(err);
-        const { price, amount, orderType, moneyEscrowed, sharesEscrowed } = onContractData;
-        const fullPrecisionAmount = convertFixedPointToDecimal(amount, WEI_PER_ETHER);
-        const fullPrecisionPrice = denormalizePrice(minPrice, maxPrice, convertFixedPointToDecimal(price, numTicks));
-        const orderTypeLabel = orderType === "0" ? "buy" : "sell";
-        const orderData: OrdersRow = {
-          marketID,
-          blockNumber: log.blockNumber,
-          transactionHash: log.transactionHash,
-          logIndex: log.logIndex,
-          outcome,
-          shareToken: log.shareToken,
-          orderCreator: log.creator,
-          orderState: OrderState.OPEN,
-          tradeGroupID: log.tradeGroupId,
-          orderType: orderTypeLabel,
-          price: formatOrderPrice(orderTypeLabel, minPrice, maxPrice, fullPrecisionPrice),
-          amount: formatOrderAmount(minPrice, maxPrice, fullPrecisionAmount),
-          fullPrecisionPrice,
-          fullPrecisionAmount,
-          tokensEscrowed: convertFixedPointToDecimal(moneyEscrowed, WEI_PER_ETHER),
-          sharesEscrowed: convertFixedPointToDecimal(sharesEscrowed, WEI_PER_ETHER),
-        };
-        const orderID = { orderID: log.orderId };
-        augurEmitter.emit("OrderCreated", Object.assign(orderData, orderID));
-        trx.select(["marketID"]).from("orders").where(orderID).asCallback((err: Error|null, ordersRows?: any): void => {
-          if (err) return callback(err);
-          if (!ordersRows || !ordersRows.length) {
-            db.transacting(trx).insert(Object.assign(orderData, orderID)).into("orders").asCallback(callback);
-          } else {
-            db.transacting(trx).from("orders").where(orderID).update(orderData).asCallback(callback);
-          }
-        });
+        if (!ordersRows || !ordersRows.length) {
+          db.transacting(trx).insert(Object.assign(orderData, orderID)).into("orders").asCallback(callback);
+        } else {
+          db.transacting(trx).from("orders").where(orderID).update(orderData).asCallback(callback);
+        }
       });
     });
   });

diff --git a/src/constants.ts b/src/constants.ts
@@ -21,3 +21,5 @@ export const PRECISION: Precision = {
 export const MINIMUM_TRADE_SIZE = "0.01";
 
 export const WEI_PER_ETHER: string = new BigNumber(10, 10).toPower(18).toFixed();
+
+export const ZERO = new BigNumber(0);
diff --git a/test/blockchain/log-processors/order-created.js b/test/blockchain/log-processors/order-created.js
@@ -31,7 +31,12 @@ describe("blockchain/log-processors/order-created", () => {
     description: "OrderCreated log and removal",
     params: {
       log: {
+        orderType: "0",
         shareToken: "0x1000000000000000000000000000000000000000",
+        price: "7500",
+        amount: "3000000000000000000",
+        sharesEscrowed: "0",
+        moneyEscrowed: "2250000000000000000",
         creator: "CREATOR_ADDRESS",
         orderId: "ORDER_ID",
         tradeGroupId: "TRADE_GROUP_ID",
@@ -48,7 +53,7 @@ describe("blockchain/log-processors/order-created", () => {
             },
             getPrice: (p, callback) => {
               assert.deepEqual(p, { _orderId: "ORDER_ID" });
-              callback(null, "8064"); // = 0.75 * 10752
+              callback(null, "7500"); // = 0.75 * 10752
             },
             getAmount: (p, callback) => {
               assert.deepEqual(p, { _orderId: "ORDER_ID" });
@@ -80,9 +85,9 @@ describe("blockchain/log-processors/order-created", () => {
           orderType: "buy",
           orderCreator: "CREATOR_ADDRESS",
           orderState: "OPEN",
-          fullPrecisionPrice: 0.8064,
+          fullPrecisionPrice: 0.75,
           fullPrecisionAmount: 3,
-          price: 0.8064,
+          price: 0.75,
           amount: 3,
           tokensEscrowed: 2.25,
           sharesEscrowed: 0,
@@ -103,9 +108,9 @@ describe("blockchain/log-processors/order-created", () => {
           orderCreator: "CREATOR_ADDRESS",
           orderState: "OPEN",
           blockNumber: 1400100,
-          fullPrecisionPrice: 0.8064,
+          fullPrecisionPrice: 0.75,
           fullPrecisionAmount: 3,
-          price: 0.8064,
+          price: 0.75,
           amount: 3,
           tokensEscrowed: 2.25,
           sharesEscrowed: 0,