@velocity-exchange/sdk 0.0.5 → 0.2.0

package/lib/node/dlob/DLOB.js

@@ -31,6 +31,18 @@ const SUPPORTED_ORDER_TYPES = [
     'triggerLimit',
     'oracle',
 ];
+function getOrderOrThrow(node) {
+    if (!node.order) {
+        throw new Error('DLOBNode must have an order');
+    }
+    return node.order;
+}
+function getUserAccountOrThrow(node) {
+    if (node.userAccount === undefined) {
+        throw new Error('DLOBNode must have a userAccount');
+    }
+    return node.userAccount;
+}
 class DLOB {
     constructor() {
         this.openOrders = new Map();
@@ -45,19 +57,41 @@ class DLOB {
         this.orderLists.set('perp', new Map());
         this.orderLists.set('spot', new Map());
     }
+    getOpenOrdersForMarketType(marketTypeStr) {
+        const openOrders = this.openOrders.get(marketTypeStr);
+        if (!openOrders) {
+            throw new Error(`DLOB has no open orders set for market type ${marketTypeStr}`);
+        }
+        return openOrders;
+    }
+    getOrderListsForMarketType(marketTypeStr) {
+        const orderLists = this.orderLists.get(marketTypeStr);
+        if (!orderLists) {
+            throw new Error(`DLOB has no order lists for market type ${marketTypeStr}`);
+        }
+        return orderLists;
+    }
+    tryGetMarketNodeLists(marketTypeStr, marketIndex) {
+        var _a;
+        return (_a = this.orderLists.get(marketTypeStr)) === null || _a === void 0 ? void 0 : _a.get(marketIndex);
+    }
+    getMarketNodeLists(marketTypeStr, marketIndex) {
+        const marketNodeLists = this.tryGetMarketNodeLists(marketTypeStr, marketIndex);
+        if (!marketNodeLists) {
+            throw new Error(`DLOB has no order lists for market type ${marketTypeStr} and market index ${marketIndex}`);
+        }
+        return marketNodeLists;
+    }
     clear() {
-        for (const marketType of this.openOrders.keys()) {
-            this.openOrders.get(marketType).clear();
+        for (const openOrders of this.openOrders.values()) {
+            openOrders.clear();
         }
         this.openOrders.clear();
-        for (const marketType of this.orderLists.keys()) {
-            for (const marketIndex of this.orderLists.get(marketType).keys()) {
-                const marketNodeLists = this.orderLists
-                    .get(marketType)
-                    .get(marketIndex);
-                for (const side of Object.keys(marketNodeLists)) {
-                    for (const orderType of Object.keys(marketNodeLists[side])) {
-                        marketNodeLists[side][orderType].clear();
+        for (const marketNodeListsMap of this.orderLists.values()) {
+            for (const marketNodeLists of marketNodeListsMap.values()) {
+                for (const side of Object.values(marketNodeLists)) {
+                    for (const nodeList of Object.values(side)) {
+                        nodeList.clear();
                     }
                 }
             }
@@ -78,7 +112,7 @@ class DLOB {
         }
         // initialize the dlob with the user map
         for (const user of userMap.values()) {
-            const userAccount = user.getUserAccount();
+            const userAccount = user.getUserAccountOrThrow();
             const userAccountPubkey = user.getUserAccountPublicKey();
             const userAccountPubkeyString = userAccountPubkey.toString();
             for (const order of userAccount.orders) {
@@ -102,13 +136,11 @@ class DLOB {
             return;
         }
         const marketType = (0, types_1.getVariant)(order.marketType);
-        if (!this.orderLists.get(marketType).has(order.marketIndex)) {
+        if (!this.getOrderListsForMarketType(marketType).has(order.marketIndex)) {
             this.addOrderList(marketType, order.marketIndex);
         }
         if ((0, types_1.isVariant)(order.status, 'open')) {
-            this.openOrders
-                .get(marketType)
-                .add((0, NodeList_1.getOrderSignature)(order.orderId, userAccount));
+            this.getOpenOrdersForMarketType(marketType).add((0, NodeList_1.getOrderSignature)(order.orderId, userAccount));
         }
         (_a = this.getListForOnChainOrder(order, slot)) === null || _a === void 0 ? void 0 : _a.insert(order, marketType, userAccount, baseAssetAmount);
         if (onInsert) {
@@ -119,22 +151,17 @@ class DLOB {
         const marketType = (0, types_1.getVariant)(order.marketType);
         const marketIndex = order.marketIndex;
         const bidOrAsk = (0, types_1.isVariant)(order.direction, 'long') ? 'bid' : 'ask';
-        if (!this.orderLists.get(marketType).has(order.marketIndex)) {
+        if (!this.getOrderListsForMarketType(marketType).has(order.marketIndex)) {
             this.addOrderList(marketType, order.marketIndex);
         }
-        this.openOrders
-            .get(marketType)
-            .add((0, NodeList_1.getOrderSignature)(order.orderId, userAccount));
-        this.orderLists
-            .get(marketType)
-            .get(marketIndex)
-            .signedMsg[bidOrAsk].insert(order, marketType, userAccount, baseAssetAmount);
+        this.getOpenOrdersForMarketType(marketType).add((0, NodeList_1.getOrderSignature)(order.orderId, userAccount));
+        this.getMarketNodeLists(marketType, marketIndex).signedMsg[bidOrAsk].insert(order, marketType, userAccount, baseAssetAmount);
         if (onInsert) {
             onInsert();
         }
     }
     addOrderList(marketType, marketIndex) {
-        this.orderLists.get(marketType).set(marketIndex, {
+        this.getOrderListsForMarketType(marketType).set(marketIndex, {
             restingLimit: {
                 ask: new NodeList_1.NodeList('restingLimit', 'asc'),
                 bid: new NodeList_1.NodeList('restingLimit', 'desc'),
@@ -174,32 +201,37 @@ class DLOB {
     }
     getListForOnChainOrder(order, slot) {
         const isInactiveTriggerOrder = (0, orders_1.mustBeTriggered)(order) && !(0, orders_1.isTriggered)(order);
-        let type;
+        const marketType = (0, types_1.getVariant)(order.marketType);
+        const marketNodeLists = this.tryGetMarketNodeLists(marketType, order.marketIndex);
+        if (!marketNodeLists) {
+            return undefined;
+        }
         if (isInactiveTriggerOrder) {
-            type = 'trigger';
+            const subType = (0, types_1.isVariant)(order.triggerCondition, 'above')
+                ? 'above'
+                : 'below';
+            return marketNodeLists.trigger[subType];
         }
-        else if ((0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket', 'oracle'])) {
-            type = 'market';
+        const subType = (0, types_1.isVariant)(order.direction, 'long') ? 'bid' : 'ask';
+        if ((0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket', 'oracle'])) {
+            return marketNodeLists.market[subType];
         }
         else if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
-            type = 'floatingLimit';
+            return marketNodeLists.floatingLimit[subType];
         }
         else {
             const isResting = (0, orders_1.isRestingLimitOrder)(order, slot);
-            type = isResting ? 'restingLimit' : 'takingLimit';
+            return isResting
+                ? marketNodeLists.restingLimit[subType]
+                : marketNodeLists.takingLimit[subType];
         }
-        let subType;
-        if (isInactiveTriggerOrder) {
-            subType = (0, types_1.isVariant)(order.triggerCondition, 'above') ? 'above' : 'below';
-        }
-        else {
-            subType = (0, types_1.isVariant)(order.direction, 'long') ? 'bid' : 'ask';
-        }
-        const marketType = (0, types_1.getVariant)(order.marketType);
-        if (!this.orderLists.has(marketType)) {
-            return undefined;
+    }
+    getListForOnChainOrderOrThrow(order, slot) {
+        const list = this.getListForOnChainOrder(order, slot);
+        if (!list) {
+            throw new Error(`No order list found for order ${order.orderId} in market ${order.marketIndex}`);
         }
-        return this.orderLists.get(marketType).get(order.marketIndex)[type][subType];
+        return list;
     }
     updateRestingLimitOrders(slot) {
         if (slot <= this.maxSlotForRestingLimitOrders) {
@@ -210,10 +242,10 @@ class DLOB {
         this.updateRestingLimitOrdersForMarketType(slot, 'spot');
     }
     updateRestingLimitOrdersForMarketType(slot, marketTypeStr) {
-        for (const [_, nodeLists] of this.orderLists.get(marketTypeStr)) {
+        for (const [_, nodeLists] of this.getOrderListsForMarketType(marketTypeStr)) {
             const nodesToUpdate = [];
             for (const node of nodeLists.takingLimit.ask.getGenerator()) {
-                if (!(0, orders_1.isRestingLimitOrder)(node.order, slot)) {
+                if (!(0, orders_1.isRestingLimitOrder)(getOrderOrThrow(node), slot)) {
                     continue;
                 }
                 nodesToUpdate.push({
@@ -222,7 +254,7 @@ class DLOB {
                 });
             }
             for (const node of nodeLists.takingLimit.bid.getGenerator()) {
-                if (!(0, orders_1.isRestingLimitOrder)(node.order, slot)) {
+                if (!(0, orders_1.isRestingLimitOrder)(getOrderOrThrow(node), slot)) {
                     continue;
                 }
                 nodesToUpdate.push({
@@ -232,8 +264,10 @@ class DLOB {
             }
             for (const nodeToUpdate of nodesToUpdate) {
                 const { side, node } = nodeToUpdate;
-                nodeLists.takingLimit[side].remove(node.order, node.userAccount);
-                nodeLists.restingLimit[side].insert(node.order, marketTypeStr, node.userAccount);
+                const order = getOrderOrThrow(node);
+                const userAccount = getUserAccountOrThrow(node);
+                nodeLists.takingLimit[side].remove(order, userAccount);
+                nodeLists.restingLimit[side].insert(order, marketTypeStr, userAccount);
             }
         }
     }
@@ -258,7 +292,7 @@ class DLOB {
         // get expired market nodes
         const expiredNodesToFill = this.findExpiredNodesToFill(marketIndex, ts, marketType, new anchor_1.BN(slot));
         const stepSize = (0, types_1.isVariant)(marketType, 'perp')
-            ? marketAccount.amm.orderStepSize
+            ? marketAccount.orderStepSize
             : marketAccount.orderStepSize;
         const cancelReduceOnlyNodesToFill = this.findUnfillableReduceOnlyOrdersToCancel(marketIndex, marketType, stepSize);
         return this.mergeNodesToFill(restingLimitOrderNodesToFill, takingOrderNodesToFill)
@@ -291,17 +325,17 @@ class DLOB {
         const mergedNodesToFill = new Map();
         const mergeNodesToFillHelper = (nodesToFillArray) => {
             nodesToFillArray.forEach((nodeToFill) => {
-                const nodeSignature = (0, NodeList_1.getOrderSignature)(nodeToFill.node.order.orderId, nodeToFill.node.userAccount);
-                if (!mergedNodesToFill.has(nodeSignature)) {
-                    mergedNodesToFill.set(nodeSignature, {
+                const nodeSignature = (0, NodeList_1.getOrderSignature)(getOrderOrThrow(nodeToFill.node).orderId, getUserAccountOrThrow(nodeToFill.node));
+                let mergedNodeToFill = mergedNodesToFill.get(nodeSignature);
+                if (!mergedNodeToFill) {
+                    mergedNodeToFill = {
                         node: nodeToFill.node,
                         makerNodes: [],
-                    });
+                    };
+                    mergedNodesToFill.set(nodeSignature, mergedNodeToFill);
                 }
                 if (nodeToFill.makerNodes) {
-                    mergedNodesToFill
-                        .get(nodeSignature)
-                        .makerNodes.push(...nodeToFill.makerNodes);
+                    mergedNodeToFill.makerNodes.push(...nodeToFill.makerNodes);
                 }
             });
         };
@@ -319,6 +353,9 @@ class DLOB {
             const askGenerator = this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData);
             const fallbackBidWithBuffer = fallbackBid.sub(fallbackBid.muln(makerRebateNumerator).divn(makerRebateDenominator));
             const asksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, askGenerator, (askPrice) => {
+                if (askPrice === undefined) {
+                    throw new Error('Resting limit ask must have a limit price');
+                }
                 return askPrice.lte(fallbackBidWithBuffer);
             }, stateAccount, marketAccount);
             for (const askCrossingFallback of asksCrossingFallback) {
@@ -329,6 +366,9 @@ class DLOB {
             const bidGenerator = this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData);
             const fallbackAskWithBuffer = fallbackAsk.add(fallbackAsk.muln(makerRebateNumerator).divn(makerRebateDenominator));
             const bidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, bidGenerator, (bidPrice) => {
+                if (bidPrice === undefined) {
+                    throw new Error('Resting limit bid must have a limit price');
+                }
                 return bidPrice.gte(fallbackAskWithBuffer);
             }, stateAccount, marketAccount);
             for (const bidCrossingFallback of bidsCrossingFallback) {
@@ -399,7 +439,7 @@ class DLOB {
                 if (sameUser) {
                     continue;
                 }
-                const makerPrice = makerNode.getPrice(oraclePriceData, slot);
+                const makerPrice = makerNode.getPriceOrThrow(oraclePriceData, slot);
                 const takerPrice = takerNode.getPrice(oraclePriceData, slot);
                 const ordersCross = doesCross(takerPrice, makerPrice);
                 if (!ordersCross) {
@@ -411,27 +451,28 @@ class DLOB {
                     node: takerNode,
                     makerNodes: [makerNode],
                 });
-                const makerOrder = makerNode.order;
-                const takerOrder = takerNode.order;
+                const makerOrder = getOrderOrThrow(makerNode);
+                const takerOrder = getOrderOrThrow(takerNode);
                 const makerBaseRemaining = makerOrder.baseAssetAmount.sub(makerOrder.baseAssetAmountFilled);
                 const takerBaseRemaining = takerOrder.baseAssetAmount.sub(takerOrder.baseAssetAmountFilled);
                 const baseFilled = anchor_1.BN.min(makerBaseRemaining, takerBaseRemaining);
                 const newMakerOrder = { ...makerOrder };
                 newMakerOrder.baseAssetAmountFilled =
                     makerOrder.baseAssetAmountFilled.add(baseFilled);
-                this.getListForOnChainOrder(newMakerOrder, slot).update(newMakerOrder, makerNode.userAccount);
+                this.getListForOnChainOrderOrThrow(newMakerOrder, slot).update(newMakerOrder, getUserAccountOrThrow(makerNode));
                 const newTakerOrder = { ...takerOrder };
                 newTakerOrder.baseAssetAmountFilled =
                     takerOrder.baseAssetAmountFilled.add(baseFilled);
                 if (takerNode.isSignedMsg) {
                     const marketTypeStr = (0, types_1.getVariant)(marketType);
+                    const marketNodeLists = this.getMarketNodeLists(marketTypeStr, marketIndex);
                     const orderList = (0, types_1.isVariant)(takerOrder.direction, 'long')
-                        ? this.orderLists.get(marketTypeStr).get(marketIndex).signedMsg.bid
-                        : this.orderLists.get(marketTypeStr).get(marketIndex).signedMsg.ask;
-                    orderList.update(newTakerOrder, takerNode.userAccount);
+                        ? marketNodeLists.signedMsg.bid
+                        : marketNodeLists.signedMsg.ask;
+                    orderList.update(newTakerOrder, getUserAccountOrThrow(takerNode));
                 }
                 else {
-                    this.getListForOnChainOrder(newTakerOrder, slot).update(newTakerOrder, takerNode.userAccount);
+                    this.getListForOnChainOrderOrThrow(newTakerOrder, slot).update(newTakerOrder, getUserAccountOrThrow(takerNode));
                 }
                 if (newTakerOrder.baseAssetAmountFilled.eq(takerOrder.baseAssetAmount)) {
                     break;
@@ -450,12 +491,13 @@ class DLOB {
                 nextNode = nodeGenerator.next();
                 continue;
             }
-            const nodePrice = (0, orders_1.getLimitPrice)(node.order, oraclePriceData, slot);
+            const nodeOrder = getOrderOrThrow(node);
+            const nodePrice = (0, orders_1.getLimitPrice)(nodeOrder, oraclePriceData, slot);
             // order crosses if there is no limit price or it crosses fallback price
             const crosses = doesCross(nodePrice);
             // fallback is available if auction is complete or it's a spot order
             const fallbackAvailable = (0, types_1.isVariant)(marketType, 'spot') ||
-                (0, auction_1.isFallbackAvailableLiquiditySource)(node.order, oraclePriceData, slot, state, marketAccount);
+                (0, auction_1.isFallbackAvailableLiquiditySource)(nodeOrder, oraclePriceData, slot, state, marketAccount);
             if (crosses && fallbackAvailable) {
                 nodesToFill.push({
                     node: node,
@@ -469,7 +511,7 @@ class DLOB {
     findExpiredNodesToFill(marketIndex, ts, marketType, slot) {
         const nodesToFill = new Array();
         const marketTypeStr = (0, types_1.getVariant)(marketType);
-        const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        const nodeLists = this.tryGetMarketNodeLists(marketTypeStr, marketIndex);
         if (!nodeLists) {
             return nodesToFill;
         }
@@ -491,14 +533,17 @@ class DLOB {
         ];
         for (const bidGenerator of bidGenerators) {
             for (const bid of bidGenerator) {
-                if (bid.isSignedMsg &&
-                    slot.gt(bid.order.slot.addn(bid.order.auctionDuration))) {
-                    this.orderLists
-                        .get(marketTypeStr)
-                        .get(marketIndex)
-                        .signedMsg.bid.remove(bid.order, bid.userAccount);
+                const bidOrder = getOrderOrThrow(bid);
+                if (bid.isSignedMsg) {
+                    if (slot === undefined) {
+                        throw new Error('Must provide slot to findExpiredNodesToFill to expire signedMsg orders');
+                    }
+                    if (slot.gt(bidOrder.slot.addn(bidOrder.auctionDuration))) {
+                        nodeLists.signedMsg.bid.remove(bidOrder, getUserAccountOrThrow(bid));
+                        continue;
+                    }
                 }
-                else if ((0, orders_1.isOrderExpired)(bid.order, ts, true, 25)) {
+                if ((0, orders_1.isOrderExpired)(bidOrder, ts, true, 25)) {
                     nodesToFill.push({
                         node: bid,
                         makerNodes: [],
@@ -508,14 +553,17 @@ class DLOB {
         }
         for (const askGenerator of askGenerators) {
             for (const ask of askGenerator) {
-                if (ask.isSignedMsg &&
-                    slot.gt(ask.order.slot.addn(ask.order.auctionDuration))) {
-                    this.orderLists
-                        .get(marketTypeStr)
-                        .get(marketIndex)
-                        .signedMsg.ask.remove(ask.order, ask.userAccount);
+                const askOrder = getOrderOrThrow(ask);
+                if (ask.isSignedMsg) {
+                    if (slot === undefined) {
+                        throw new Error('Must provide slot to findExpiredNodesToFill to expire signedMsg orders');
+                    }
+                    if (slot.gt(askOrder.slot.addn(askOrder.auctionDuration))) {
+                        nodeLists.signedMsg.ask.remove(askOrder, getUserAccountOrThrow(ask));
+                        continue;
+                    }
                 }
-                else if ((0, orders_1.isOrderExpired)(ask.order, ts, true, 25)) {
+                if ((0, orders_1.isOrderExpired)(askOrder, ts, true, 25)) {
                     nodesToFill.push({
                         node: ask,
                         makerNodes: [],
@@ -528,7 +576,7 @@ class DLOB {
     findUnfillableReduceOnlyOrdersToCancel(marketIndex, marketType, stepSize) {
         const nodesToFill = new Array();
         const marketTypeStr = (0, types_1.getVariant)(marketType);
-        const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        const nodeLists = this.tryGetMarketNodeLists(marketTypeStr, marketIndex);
         if (!nodeLists) {
             return nodesToFill;
         }
@@ -548,7 +596,7 @@ class DLOB {
         ];
         for (const generator of generators) {
             for (const node of generator) {
-                if (!node.order.reduceOnly) {
+                if (!getOrderOrThrow(node).reduceOnly) {
                     continue;
                 }
                 if (node.baseAssetAmount.lt(stepSize)) {
@@ -563,7 +611,7 @@ class DLOB {
     }
     *getTakingBids(marketIndex, marketType, slot, oraclePriceData, filterFcn) {
         const marketTypeStr = (0, types_1.getVariant)(marketType);
-        const orderLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        const orderLists = this.tryGetMarketNodeLists(marketTypeStr, marketIndex);
         if (!orderLists) {
             return;
         }
@@ -571,15 +619,15 @@ class DLOB {
         const generatorList = [
             orderLists.market.bid.getGenerator(),
             orderLists.takingLimit.bid.getGenerator(),
-            this.signedMsgGenerator(orderLists.signedMsg.bid, (x) => !(0, orders_1.isRestingLimitOrder)(x.order, slot)),
+            this.signedMsgGenerator(orderLists.signedMsg.bid, (x) => !(0, orders_1.isRestingLimitOrder)(getOrderOrThrow(x), slot)),
         ];
         yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestNode, currentNode) => {
-            return bestNode.order.slot.lt(currentNode.order.slot);
+            return getOrderOrThrow(bestNode).slot.lt(getOrderOrThrow(currentNode).slot);
         }, filterFcn);
     }
     *getTakingAsks(marketIndex, marketType, slot, oraclePriceData, filterFcn) {
         const marketTypeStr = (0, types_1.getVariant)(marketType);
-        const orderLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        const orderLists = this.tryGetMarketNodeLists(marketTypeStr, marketIndex);
         if (!orderLists) {
             return;
         }
@@ -587,10 +635,10 @@ class DLOB {
         const generatorList = [
             orderLists.market.ask.getGenerator(),
             orderLists.takingLimit.ask.getGenerator(),
-            this.signedMsgGenerator(orderLists.signedMsg.ask, (x) => !(0, orders_1.isRestingLimitOrder)(x.order, slot)),
+            this.signedMsgGenerator(orderLists.signedMsg.ask, (x) => !(0, orders_1.isRestingLimitOrder)(getOrderOrThrow(x), slot)),
         ];
         yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestNode, currentNode) => {
-            return bestNode.order.slot.lt(currentNode.order.slot);
+            return getOrderOrThrow(bestNode).slot.lt(getOrderOrThrow(currentNode).slot);
         }, filterFcn);
     }
     *signedMsgGenerator(signedMsgOrderList, filter) {
@@ -646,19 +694,19 @@ class DLOB {
         }
         this.updateRestingLimitOrders(slot);
         const marketTypeStr = (0, types_1.getVariant)(marketType);
-        const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        const nodeLists = this.tryGetMarketNodeLists(marketTypeStr, marketIndex);
         if (!nodeLists) {
             return;
         }
         const generatorList = [
             nodeLists.restingLimit.ask.getGenerator(),
             nodeLists.floatingLimit.ask.getGenerator(),
-            this.signedMsgGenerator(nodeLists.signedMsg.ask, (x) => (0, orders_1.isRestingLimitOrder)(x.order, slot)),
+            this.signedMsgGenerator(nodeLists.signedMsg.ask, (x) => (0, orders_1.isRestingLimitOrder)(getOrderOrThrow(x), slot)),
         ];
         yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestNode, currentNode, slot, oraclePriceData) => {
             return bestNode
-                .getPrice(oraclePriceData, slot)
-                .lt(currentNode.getPrice(oraclePriceData, slot));
+                .getPriceOrThrow(oraclePriceData, slot)
+                .lt(currentNode.getPriceOrThrow(oraclePriceData, slot));
         }, filterFcn);
     }
     *getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData, filterFcn) {
@@ -667,19 +715,19 @@ class DLOB {
         }
         this.updateRestingLimitOrders(slot);
         const marketTypeStr = (0, types_1.getVariant)(marketType);
-        const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        const nodeLists = this.tryGetMarketNodeLists(marketTypeStr, marketIndex);
         if (!nodeLists) {
             return;
         }
         const generatorList = [
             nodeLists.restingLimit.bid.getGenerator(),
             nodeLists.floatingLimit.bid.getGenerator(),
-            this.signedMsgGenerator(nodeLists.signedMsg.bid, (x) => (0, orders_1.isRestingLimitOrder)(x.order, slot)),
+            this.signedMsgGenerator(nodeLists.signedMsg.bid, (x) => (0, orders_1.isRestingLimitOrder)(getOrderOrThrow(x), slot)),
         ];
         yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestNode, currentNode, slot, oraclePriceData) => {
             return bestNode
-                .getPrice(oraclePriceData, slot)
-                .gt(currentNode.getPrice(oraclePriceData, slot));
+                .getPriceOrThrow(oraclePriceData, slot)
+                .gt(currentNode.getPriceOrThrow(oraclePriceData, slot));
         }, filterFcn);
     }
     /**
@@ -704,7 +752,7 @@ class DLOB {
             const bestNodePrice = (_a = bestNode.getPrice(oraclePriceData, slot)) !== null && _a !== void 0 ? _a : numericConstants_1.ZERO;
             const currentNodePrice = (_b = currentNode.getPrice(oraclePriceData, slot)) !== null && _b !== void 0 ? _b : numericConstants_1.ZERO;
             if (bestNodePrice.eq(currentNodePrice)) {
-                return bestNode.order.slot.lt(currentNode.order.slot);
+                return getOrderOrThrow(bestNode).slot.lt(getOrderOrThrow(currentNode).slot);
             }
             return bestNodePrice.lt(currentNodePrice);
         }, filterFcn);
@@ -731,7 +779,7 @@ class DLOB {
             const bestNodePrice = (_a = bestNode.getPrice(oraclePriceData, slot)) !== null && _a !== void 0 ? _a : numericConstants_1.BN_MAX;
             const currentNodePrice = (_b = currentNode.getPrice(oraclePriceData, slot)) !== null && _b !== void 0 ? _b : numericConstants_1.BN_MAX;
             if (bestNodePrice.eq(currentNodePrice)) {
-                return bestNode.order.slot.lt(currentNode.order.slot);
+                return getOrderOrThrow(bestNode).slot.lt(getOrderOrThrow(currentNode).slot);
             }
             return bestNodePrice.gt(currentNodePrice);
         }, filterFcn);
@@ -741,14 +789,14 @@ class DLOB {
         for (const askNode of this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData)) {
             const bidGenerator = this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData);
             for (const bidNode of bidGenerator) {
-                const bidPrice = bidNode.getPrice(oraclePriceData, slot);
-                const askPrice = askNode.getPrice(oraclePriceData, slot);
+                const bidPrice = bidNode.getPriceOrThrow(oraclePriceData, slot);
+                const askPrice = askNode.getPriceOrThrow(oraclePriceData, slot);
                 // orders don't cross
                 if (bidPrice.lt(askPrice)) {
                     break;
                 }
-                const bidOrder = bidNode.order;
-                const askOrder = askNode.order;
+                const bidOrder = getOrderOrThrow(bidNode);
+                const askOrder = getOrderOrThrow(askNode);
                 // Can't match orders from the same user
                 const sameUser = bidNode.userAccount === askNode.userAccount;
                 if (sameUser) {
@@ -766,12 +814,12 @@ class DLOB {
                 const newBidOrder = { ...bidOrder };
                 newBidOrder.baseAssetAmountFilled =
                     bidOrder.baseAssetAmountFilled.add(baseFilled);
-                this.getListForOnChainOrder(newBidOrder, slot).update(newBidOrder, bidNode.userAccount);
+                this.getListForOnChainOrderOrThrow(newBidOrder, slot).update(newBidOrder, getUserAccountOrThrow(bidNode));
                 // ask completely filled
                 const newAskOrder = { ...askOrder };
                 newAskOrder.baseAssetAmountFilled =
                     askOrder.baseAssetAmountFilled.add(baseFilled);
-                this.getListForOnChainOrder(newAskOrder, slot).update(newAskOrder, askNode.userAccount);
+                this.getListForOnChainOrderOrThrow(newAskOrder, slot).update(newAskOrder, getUserAccountOrThrow(askNode));
                 nodesToFill.push({
                     node: takerNode,
                     makerNodes: [makerNode],
@@ -784,18 +832,20 @@ class DLOB {
         return nodesToFill;
     }
     determineMakerAndTaker(askNode, bidNode) {
-        const askSlot = askNode.order.slot.add(new anchor_1.BN(askNode.order.auctionDuration));
-        const bidSlot = bidNode.order.slot.add(new anchor_1.BN(bidNode.order.auctionDuration));
-        if (bidNode.order.postOnly && askNode.order.postOnly) {
+        const askOrder = getOrderOrThrow(askNode);
+        const bidOrder = getOrderOrThrow(bidNode);
+        const askSlot = askOrder.slot.add(new anchor_1.BN(askOrder.auctionDuration));
+        const bidSlot = bidOrder.slot.add(new anchor_1.BN(bidOrder.auctionDuration));
+        if (bidOrder.postOnly && askOrder.postOnly) {
             return undefined;
         }
-        else if (bidNode.order.postOnly) {
+        else if (bidOrder.postOnly) {
             return {
                 takerNode: askNode,
                 makerNode: bidNode,
             };
         }
-        else if (askNode.order.postOnly) {
+        else if (askOrder.postOnly) {
             return {
                 takerNode: bidNode,
                 makerNode: askNode,
@@ -830,17 +880,17 @@ class DLOB {
     }
     *getStopLosses(marketIndex, marketType, direction) {
         const marketTypeStr = (0, types_1.getVariant)(marketType);
-        const marketNodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        const marketNodeLists = this.getMarketNodeLists(marketTypeStr, marketIndex);
         if ((0, types_1.isVariant)(direction, 'long') && marketNodeLists.trigger.below) {
             for (const node of marketNodeLists.trigger.below.getGenerator()) {
-                if ((0, types_1.isVariant)(node.order.direction, 'short')) {
+                if ((0, types_1.isVariant)(getOrderOrThrow(node).direction, 'short')) {
                     yield node;
                 }
             }
         }
         else if ((0, types_1.isVariant)(direction, 'short') && marketNodeLists.trigger.above) {
             for (const node of marketNodeLists.trigger.above.getGenerator()) {
-                if ((0, types_1.isVariant)(node.order.direction, 'long')) {
+                if ((0, types_1.isVariant)(getOrderOrThrow(node).direction, 'long')) {
                     yield node;
                 }
             }
@@ -848,31 +898,31 @@ class DLOB {
     }
     *getStopLossMarkets(marketIndex, marketType, direction) {
         for (const node of this.getStopLosses(marketIndex, marketType, direction)) {
-            if ((0, types_1.isVariant)(node.order.orderType, 'triggerMarket')) {
+            if ((0, types_1.isVariant)(getOrderOrThrow(node).orderType, 'triggerMarket')) {
                 yield node;
             }
         }
     }
     *getStopLossLimits(marketIndex, marketType, direction) {
         for (const node of this.getStopLosses(marketIndex, marketType, direction)) {
-            if ((0, types_1.isVariant)(node.order.orderType, 'triggerLimit')) {
+            if ((0, types_1.isVariant)(getOrderOrThrow(node).orderType, 'triggerLimit')) {
                 yield node;
             }
         }
     }
     *getTakeProfits(marketIndex, marketType, direction) {
         const marketTypeStr = (0, types_1.getVariant)(marketType);
-        const marketNodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        const marketNodeLists = this.getMarketNodeLists(marketTypeStr, marketIndex);
         if ((0, types_1.isVariant)(direction, 'long') && marketNodeLists.trigger.above) {
             for (const node of marketNodeLists.trigger.above.getGenerator()) {
-                if ((0, types_1.isVariant)(node.order.direction, 'short')) {
+                if ((0, types_1.isVariant)(getOrderOrThrow(node).direction, 'short')) {
                     yield node;
                 }
             }
         }
         else if ((0, types_1.isVariant)(direction, 'short') && marketNodeLists.trigger.below) {
             for (const node of marketNodeLists.trigger.below.getGenerator()) {
-                if ((0, types_1.isVariant)(node.order.direction, 'long')) {
+                if ((0, types_1.isVariant)(getOrderOrThrow(node).direction, 'long')) {
                     yield node;
                 }
             }
@@ -880,30 +930,32 @@ class DLOB {
     }
     *getTakeProfitMarkets(marketIndex, marketType, direction) {
         for (const node of this.getTakeProfits(marketIndex, marketType, direction)) {
-            if ((0, types_1.isVariant)(node.order.orderType, 'triggerMarket')) {
+            if ((0, types_1.isVariant)(getOrderOrThrow(node).orderType, 'triggerMarket')) {
                 yield node;
             }
         }
     }
     *getTakeProfitLimits(marketIndex, marketType, direction) {
         for (const node of this.getTakeProfits(marketIndex, marketType, direction)) {
-            if ((0, types_1.isVariant)(node.order.orderType, 'triggerLimit')) {
+            if ((0, types_1.isVariant)(getOrderOrThrow(node).orderType, 'triggerLimit')) {
                 yield node;
             }
         }
     }
     findNodesToTrigger(marketIndex, slot, triggerPrice, marketType, stateAccount) {
+        var _a;
         if ((0, exchangeStatus_1.exchangePaused)(stateAccount)) {
             return [];
         }
         const nodesToTrigger = [];
         const marketTypeStr = (0, types_1.getVariant)(marketType);
-        const marketNodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        const marketNodeLists = (_a = this.orderLists
+            .get(marketTypeStr)) === null || _a === void 0 ? void 0 : _a.get(marketIndex);
         const triggerAboveList = marketNodeLists
             ? marketNodeLists.trigger.above
             : undefined;
         if (triggerAboveList) {
-            for (const node of triggerAboveList.getGenerator()) {
+            for (let node = triggerAboveList.head; node !== undefined; node = node.next) {
                 if (triggerPrice.gt(node.order.triggerPrice)) {
                     nodesToTrigger.push({
                         node: node,
@@ -918,7 +970,7 @@ class DLOB {
             ? marketNodeLists.trigger.below
             : undefined;
         if (triggerBelowList) {
-            for (const node of triggerBelowList.getGenerator()) {
+            for (let node = triggerBelowList.head; node !== undefined; node = node.next) {
                 if (triggerPrice.lt(node.order.triggerPrice)) {
                     nodesToTrigger.push({
                         node: node,
@@ -931,12 +983,15 @@ class DLOB {
         }
         return nodesToTrigger;
     }
-    printTop(driftClient, slotSubscriber, marketIndex, marketType) {
+    printTop(velocityClient, slotSubscriber, marketIndex, marketType) {
         if ((0, types_1.isVariant)(marketType, 'perp')) {
             const slot = slotSubscriber.getSlot();
-            const oraclePriceData = driftClient.getMMOracleDataForPerpMarket(marketIndex);
+            const oraclePriceData = velocityClient.getMMOracleDataForPerpMarket(marketIndex);
             const bestAsk = this.getBestAsk(marketIndex, slot, marketType, oraclePriceData);
             const bestBid = this.getBestBid(marketIndex, slot, marketType, oraclePriceData);
+            if (bestAsk === undefined || bestBid === undefined) {
+                throw new Error(`printTop requires both a best ask and best bid for market ${marketIndex}`);
+            }
             const mid = bestAsk.add(bestBid).div(new anchor_1.BN(2));
             const bidSpread = ((0, conversion_1.convertToNumber)(bestBid, numericConstants_1.PRICE_PRECISION) /
                 (0, conversion_1.convertToNumber)(oraclePriceData.price, numericConstants_1.PRICE_PRECISION) -
@@ -946,7 +1001,7 @@ class DLOB {
                 (0, conversion_1.convertToNumber)(oraclePriceData.price, numericConstants_1.PRICE_PRECISION) -
                 1) *
                 100.0;
-            const name = (0, userName_1.decodeName)(driftClient.getPerpMarketAccount(marketIndex).name);
+            const name = (0, userName_1.decodeName)(velocityClient.getPerpMarketAccountOrThrow(marketIndex).name);
             console.log(`Market ${name} Orders`);
             console.log(`  Ask`, (0, conversion_1.convertToNumber)(bestAsk, numericConstants_1.PRICE_PRECISION).toFixed(3), `(${askSpread.toFixed(4)}%)`);
             console.log(`  Mid`, (0, conversion_1.convertToNumber)(mid, numericConstants_1.PRICE_PRECISION).toFixed(3));
@@ -954,9 +1009,12 @@ class DLOB {
         }
         else if ((0, types_1.isVariant)(marketType, 'spot')) {
             const slot = slotSubscriber.getSlot();
-            const oraclePriceData = driftClient.getOracleDataForSpotMarket(marketIndex);
+            const oraclePriceData = velocityClient.getOracleDataForSpotMarket(marketIndex);
             const bestAsk = this.getBestAsk(marketIndex, slot, types_1.MarketType.SPOT, oraclePriceData);
             const bestBid = this.getBestBid(marketIndex, slot, types_1.MarketType.SPOT, oraclePriceData);
+            if (bestAsk === undefined || bestBid === undefined) {
+                throw new Error(`printTop requires both a best ask and best bid for market ${marketIndex}`);
+            }
             const mid = bestAsk.add(bestBid).div(new anchor_1.BN(2));
             const bidSpread = ((0, conversion_1.convertToNumber)(bestBid, numericConstants_1.PRICE_PRECISION) /
                 (0, conversion_1.convertToNumber)(oraclePriceData.price, numericConstants_1.PRICE_PRECISION) -
@@ -966,7 +1024,7 @@ class DLOB {
                 (0, conversion_1.convertToNumber)(oraclePriceData.price, numericConstants_1.PRICE_PRECISION) -
                 1) *
                 100.0;
-            const name = (0, userName_1.decodeName)(driftClient.getSpotMarketAccount(marketIndex).name);
+            const name = (0, userName_1.decodeName)(velocityClient.getSpotMarketAccountOrThrow(marketIndex).name);
             console.log(`Market ${name} Orders`);
             console.log(`  Ask`, (0, conversion_1.convertToNumber)(bestAsk, numericConstants_1.PRICE_PRECISION).toFixed(3), `(${askSpread.toFixed(4)}%)`);
             console.log(`  Mid`, (0, conversion_1.convertToNumber)(mid, numericConstants_1.PRICE_PRECISION).toFixed(3));
@@ -978,15 +1036,15 @@ class DLOB {
         for (const nodeList of this.getNodeLists()) {
             for (const node of nodeList.getGenerator()) {
                 dlobOrders.push({
-                    user: new web3_js_1.PublicKey(node.userAccount),
-                    order: node.order,
+                    user: new web3_js_1.PublicKey(getUserAccountOrThrow(node)),
+                    order: getOrderOrThrow(node),
                 });
             }
         }
         return dlobOrders;
     }
     *getNodeLists() {
-        for (const [_, nodeLists] of this.orderLists.get('perp')) {
+        for (const [_, nodeLists] of this.getOrderListsForMarketType('perp')) {
             yield nodeLists.restingLimit.bid;
             yield nodeLists.restingLimit.ask;
             yield nodeLists.takingLimit.bid;
@@ -998,7 +1056,7 @@ class DLOB {
             yield nodeLists.trigger.above;
             yield nodeLists.trigger.below;
         }
-        for (const [_, nodeLists] of this.orderLists.get('spot')) {
+        for (const [_, nodeLists] of this.getOrderListsForMarketType('spot')) {
             yield nodeLists.restingLimit.bid;
             yield nodeLists.restingLimit.ask;
             yield nodeLists.takingLimit.bid;
@@ -1057,20 +1115,22 @@ class DLOB {
         const asks = [];
         const restingAsks = this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData);
         for (const ask of restingAsks) {
+            const askOrder = getOrderOrThrow(ask);
             asks.push({
-                price: ask.getPrice(oraclePriceData, slot),
-                size: ask.order.baseAssetAmount.sub(ask.order.baseAssetAmountFilled),
-                maker: new web3_js_1.PublicKey(ask.userAccount),
-                orderId: ask.order.orderId,
+                price: ask.getPriceOrThrow(oraclePriceData, slot),
+                size: askOrder.baseAssetAmount.sub(askOrder.baseAssetAmountFilled),
+                maker: new web3_js_1.PublicKey(getUserAccountOrThrow(ask)),
+                orderId: askOrder.orderId,
             });
         }
         const restingBids = this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData);
         for (const bid of restingBids) {
+            const bidOrder = getOrderOrThrow(bid);
             bids.push({
-                price: bid.getPrice(oraclePriceData, slot),
-                size: bid.order.baseAssetAmount.sub(bid.order.baseAssetAmountFilled),
-                maker: new web3_js_1.PublicKey(bid.userAccount),
-                orderId: bid.order.orderId,
+                price: bid.getPriceOrThrow(oraclePriceData, slot),
+                size: bidOrder.baseAssetAmount.sub(bidOrder.baseAssetAmountFilled),
+                maker: new web3_js_1.PublicKey(getUserAccountOrThrow(bid)),
+                orderId: bidOrder.orderId,
             });
         }
         return {
@@ -1083,8 +1143,9 @@ class DLOB {
         let runningSumQuote = numericConstants_1.ZERO;
         let runningSumBase = numericConstants_1.ZERO;
         for (const side of dlobSide) {
-            const price = side.getPrice(oraclePriceData, slot); //side.order.quoteAssetAmount.div(side.order.baseAssetAmount);
-            const baseAmountRemaining = side.order.baseAssetAmount.sub(side.order.baseAssetAmountFilled);
+            const price = side.getPriceOrThrow(oraclePriceData, slot); //side.order.quoteAssetAmount.div(side.order.baseAssetAmount);
+            const sideOrder = getOrderOrThrow(side);
+            const baseAmountRemaining = sideOrder.baseAssetAmount.sub(sideOrder.baseAssetAmountFilled);
             if (runningSumBase.add(baseAmountRemaining).gt(baseAmountIn)) {
                 const remainingBase = baseAmountIn.sub(runningSumBase);
                 runningSumBase = runningSumBase.add(remainingBase);
@@ -1117,6 +1178,7 @@ class DLOB {
         else if ((0, types_1.isVariant)(orderDirection, 'short')) {
             return this.estimateFillExactBaseAmountInForSide(baseAmount, oraclePriceData, slot, this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData));
         }
+        throw new Error(`Invalid order direction ${(0, types_1.getVariant)(orderDirection)}: must be long or short`);
     }
     getBestMakers({ marketIndex, marketType, direction, slot, oraclePriceData, numMakers, }) {
         const makers = new Map();
@@ -1124,8 +1186,9 @@ class DLOB {
             ? this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData)
             : this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData);
         for (const node of generator) {
-            if (!makers.has(node.userAccount.toString())) {
-                makers.set(node.userAccount.toString(), new web3_js_1.PublicKey(node.userAccount));
+            const userAccount = getUserAccountOrThrow(node);
+            if (!makers.has(userAccount)) {
+                makers.set(userAccount, new web3_js_1.PublicKey(userAccount));
             }
             if (makers.size === numMakers) {
                 break;