lib/order/structure/getTakerOrders.js 

  1. // const withExecuteTxns = require('./taker/withExecuteTxns');
  2. const getTakerOrderInformation = require('./taker/getTakerOrderInformation');
  3. const getCutTakerOrders = require('./taker/getCutTakerOrders');
  4. // const fromBaseUnits = require('../../utils/units/fromBaseUnits');
  5. const logger = require('../../logger');
  7. /**
  8.  *
  9.  * @param {string} takerWalletAddr
  10.  * @param {boolean} isSellingAssetAsTakerOrder
  11.  * @param {Object[]}  allOrderBookOrders
  12.  * @return {Array}
  13.  * @ignore
  14.  */
  15. function getQueuedTakerOrders(
  16.     takerWalletAddr,
  17.     isSellingAssetAsTakerOrder,
  18.     allOrderBookOrders,
  19. ) {
  20.   const queuedOrders = [];
  21.   // getAllOrderBookEscrowOrders is UI dependant and needs to be customized for the React version
  23.   if (allOrderBookOrders == null || allOrderBookOrders.length === 0) {
  24.     return [];
  25.   }
  27.   // FIXME: don't allow executions against own orders! check wallet address doesn't match
  28.   // takerWalletAddr
  30.   for (let i = 0; i < allOrderBookOrders.length; i++) {
  31.     const orderBookEntry = allOrderBookOrders[i];
  33.     if (orderBookEntry['escrowOrderType'] === 'buy' && !isSellingAssetAsTakerOrder) {
  34.       // only look for sell orders in this case
  35.       continue;
  36.     }
  37.     if (orderBookEntry['escrowOrderType'] === 'sell' && isSellingAssetAsTakerOrder) {
  38.       // only look for buy orders in this case
  39.       continue;
  40.     }
  41.     orderBookEntry.price = parseFloat(orderBookEntry.price);
  43.     queuedOrders.push(orderBookEntry);
  44.   }
  46.   if (isSellingAssetAsTakerOrder) {
  47.     // sort highest first (index 0) to lowest (last index)
  48.     // these are buy orders, so we want to sell to the highest first
  49.     queuedOrders.sort((a, b) => (a.price < b.price) ? 1 : (a.price === b.price) ? ((a.price < b.price) ? 1 : -1) : -1);
  50.   } else {
  51.     // sort lowest first (index 0) to highest (last index)
  52.     // these are sell orders, so we want to buy the lowest first
  53.     queuedOrders.sort((a, b) => (a.price > b.price) ? 1 : (a.price === b.price) ? ((a.price > b.price) ? 1 : -1) : -1);
  54.   }
  56.   return queuedOrders;
  57. }
  59. /**
  60.  * @deprecated
  61.  * @param {number} assetId
  62.  * @param {AlgodexApi} api
  63.  * @return {Promise<*>}
  64.  * @ignore
  65.  */
  66. async function getOrderbook(assetId, api) {
  67.   logger.warn(`Fetching Orderbook for ${assetId}`);
  68.   const res = await api.http.dexd.fetchAssetOrders(assetId);
  70.   return api.http.dexd.mapToAllEscrowOrders({
  71.     buy: res.buyASAOrdersInEscrow,
  72.     sell: res.sellASAOrdersInEscrow,
  73.   });
  74. }
  77. /**
  78.  *
  79.  * * # 🏃 getTakerOrders
  80.  *
  81.  * Accepts an {@link Order} with execution of [Taker]{@tutorial Taker} and matches the criteria with [Executable]{@tutorial Executable} orders in the [Orderbook]{@tutorial Orderbook}.
  82.  *
  83.  * If executable orders exist then the relevant transactions are generated.
  84.  *
  85.  * The generated transactions fall into one of the two categories below:
  86.  * ### SingleOrderExecution
  87.  * **Condition:** For when the desired user "total" amount is less than the available escrow amount
  88.  *  * Example: There is an order in the orderbook at the user's desired price and desired amount
  89.  *
  90.  * **Return value:** An array of length=1 containing {@link Order} object with an txnArr attached to the contract
  91.  *
  92.  *
  93.  * ### MultiOrderExececution
  94.  * **Condition:** For when the desired user total amount is greater than the available escrow amount
  95.  *  * Example: There are multiple orders in the orderbook at the user's desired price, but no entry contains the user's desired amount.
  96.  *
  97.  * **Return value:** An array of variable length.  Each item represents a group of transactions.
  98.  *
  99.  * ### When is it used?
  100.  * This method and the corresponding factories are used anytime a user is executing upon an existing [Algodex Orderbook]{@tutorial Orderbook} [Order]{@link Order}.
  101.  *
  102.  * This method is used to generate the taker transactions in [getMakerTakerTxns]{@link module/structure.getMakerTakerTxns}
  103.  *
  104.  * This method would be ideal for use in algorithmic trading strategies.
  105.  *
  106.  * @example
  107.  * const [AlgodexAPI]{@link AlgodexApi} = require(@algodex/algodex-sdk)
  108.  * const api = new [AlgodexAPI]{@link AlgodexApi}(require('../config.json'))
  109.  * const order = {
  110.  *   "client": api.algod,
  111.  *   "indexer": api.indexer,
  112.  *   "asset": {
  113.  *     "id": 15322902,
  114.  *     "decimals": 6,
  115.  *   },
  116.  *   "address": "TJFFNUYWHPPIYDE4DGGYPGHWKGAPJEWP3DGE5THZS3B2M2XIAPQ2WY3X4I",
  117.  *   "price": 2.22,
  118.  *   "amount": 1,
  119.  *   "total": 2,
  120.  *   "execution": "taker",
  121.  *   "type": "buy",
  122.  *   "appId": 22045503,
  123.  *   "version": 6
  124.  * }
  125.  *
  126.  * // Scenario: singleOrder
  127.  * //order.execution === 'taker'
  128.  * let res = await getTakerOrders(api, order)
  129.  * console.log(res.contract.txns)
  130.  * //Outputs an array with structure of:
  131.  * [makeExecuteAssetTxns]{@link module:txns/sell.makeExecuteAssetTxns} || [makeExecuteAlgoTxns]{@link module:txns/buy.makeExecuteAlgoTxns}
  132.  *
  133.  *
  134.  *
  135.  * @example
  136.  * const [AlgodexAPI]{@link AlgodexApi} = require(@algodex/algodex-sdk)
  137.  * const api = new [AlgodexAPI]{@link AlgodexApi}(require('../config.json'))
  138.  * const order = {
  139.  *   "client": api.algod,
  140.  *   "indexer": api.indexer,
  141.  *   "asset": {
  142.  *     "id": 15322902,
  143.  *     "decimals": 6,
  144.  *   },
  145.  *   "address": "TJFFNUYWHPPIYDE4DGGYPGHWKGAPJEWP3DGE5THZS3B2M2XIAPQ2WY3X4I",
  146.  *   "price": 2.22,
  147.  *   "amount": 1,
  148.  *   "total": 2,
  149.  *   "execution": "taker",
  150.  *   "type": "buy",
  151.  *   "appId": 22045503,
  152.  *   "version": 6
  153.  * }
  154.  * // Scenario: multiOrder
  155.  * //order.execution === 'taker'
  156.  * let res = await getTakerOrders(api, order)
  157.  * console.log(res)
  158.  * //Outputs an array with each item being:
  159.  * [withExecuteAssetTxns]{@link module:txns/sell.withExecuteAssetTxns} || [withExecuteAlgoTxns]{@link module:txns/buy.withExecuteAlgoTxns}
  160.  *
  161.  * @param {AlgodexApi} api The Algodex API
  162.  * @param {Order} order The User's Order
  163.  * @return {Promise<Structure[]>}
  164.  * @throws ValidationError
  165.  * @see [makeExecuteAssetTxns]{@link module:txns/sell.makeExecuteAssetTxns} || [makeExecuteAlgoTxns]{@link module:txns/buy.makeExecuteAlgoTxns} ||  [withExecuteAssetTxns]{@link module:txns/sell.withExecuteAssetTxns} || [withExecuteAlgoTxns]{@link module:txns/buy.withExecuteAlgoTxns}
  166.  * @memberOf module:order/structure
  167.  */
  168. async function getTakerOrders(api, order) {
  169.   if (order.execution !== 'taker' && order.execution !== 'market' && order.execution !== 'both') {
  170.     throw new TypeError(`Unsupported execution of ${order.execution}, use [taker, market, both] for automated orderbook matching`);
  171.   }
  173.   // Fetch Orderbook if it doesn't exist
  174.   const _orderbook = !order.asset?.orderbook ?
  175.         // TODO: Move to new Orderbook Shape
  176.         await getOrderbook(order.asset.id, api) :
  177.         order.asset.orderbook;
  179.   // Clone Object for mutations
  180.   const _order = {...order, asset: {...order.asset, orderbook: _orderbook}};
  182.   /**
  183.      * @todo Move to new Orderbook Shape, send User's Order instance as the first parameter
  184.      * @type {Array}
  185.      */
  186.   const _queuedOrders = getQueuedTakerOrders(_order.address, _order.type === 'sell', _orderbook);
  188.   // Exit if no taker orders
  189.   if (_queuedOrders.length === 0) {
  190.     logger.warn({address: order.address, type: _order.type},
  191.         'No orders exist for user to execute',
  192.     );
  193.     // Exit early
  194.     return [];
  195.   }
  197.   /**
  198.      * First Order
  199.      * @type {Order}
  200.      */
  201.   const _firstOrder = _queuedOrders[0]; // rough implementation will change name/ placement later
  203.   /**
  204.      * Balance of the First Order
  205.      * @type {Number}
  206.      */
  207.   // const firstOrderBalance = fromBaseUnits(
  208.   //       _order.type === 'buy' ?
  209.   //           _firstOrder.asaBalance :
  210.   //           _firstOrder.algoBalance/ _firstOrder.price, // to get assetAmount
  211.   // );
  212.   //   We want to see if the escrow amount is larger than order amount because comparing by order total can lead to unexpected results
  213.   // If user is selling below market price we want to make sure they get the best deal possible for their "amount" sold so we should ignore their total.
  216.   /**
  217.      * Check to see if the order fits
  218.      * @type {boolean}
  219.      */
  220.   // const isMultiOrderExecution = _order.amount > firstOrderBalance;
  221.   //   We should always check by amounts, totals can be misleading when users input prices that over/under
  224.   /**
  225.      * Flag for if the User's order has Executable Orders
  226.      * @type {boolean}
  227.      */
  228.   const isExecutable = _order.
  229.       type === 'buy' ?
  230.         _order.price >= _firstOrder.price :
  231.         _order.price <= _firstOrder.price;
  234.   // No Taker Orders Found
  235.   if (!isExecutable) {
  236.     logger.warn({
  237.       userPrice: _order.price, totalOrders: _queuedOrders.length, spreadPrice: _firstOrder.price,
  238.     }, 'No orders exist at the price.');
  239.     // Exit early
  240.     return [];
  241.   }
  243.   // User's order "fits" into the top order. Execute against that order
  244.   // if (!isMultiOrderExecution) {
  245.   //   // Closeout if the order matches the balance
  246.   //   const withCloseout = firstOrderBalance === _order.total;
  247.   //
  248.   //   const _price = parseFloat(_firstOrder.price);
  249.   //   /**
  250.   //        * Mapped Order from API
  251.   //        *
  252.   //        * @todo This should come from the API and we should only need to set amount/total
  253.   //        * @type {Order}
  254.   //        * @private
  255.   //        */
  256.   //   const _mappedOrder = {
  257.   //     execution: 'execute',
  258.   //     client: _order.client,
  259.   //     indexer: api.indexer,
  260.   //     address: _firstOrder.orderCreatorAddr,
  261.   //     type: _firstOrder.escrowOrderType,
  262.   //     price: _price,
  263.   //     amount: _order.amount,
  264.   //     total: _price * _order.amount,
  265.   //     appId: parseInt(_firstOrder.appId),
  266.   //     asset: {
  267.   //       id: _firstOrder.assetId,
  268.   //     },
  269.   //     contract: {
  270.   //       N: _firstOrder.n,
  271.   //       D: _firstOrder.d,
  272.   //       min: _firstOrder.min,
  273.   //       entry: _firstOrder.orderEntry,
  274.   //       escrow: _firstOrder.escrowAddr,
  275.   //       creator: _firstOrder.orderCreatorAddr,
  276.   //     },
  277.   //     version: _firstOrder.version,
  278.   //     wallet: _order.wallet,
  279.   //   };
  280.   //
  281.   //   // Return an Array with the compiled order
  282.   //   return [await withExecuteTxns(_mappedOrder, withCloseout)];
  283.   // }
  284.   //
  285.   // // Order is overflowing, split it and generate TakerTxns
  286.   // if (isMultiOrderExecution) {
  287.   // TODO: Handle Market Orders
  288.   return await getCutTakerOrders(
  289.       api,
  290.       {..._order, indexer: api.indexer},
  291.       _queuedOrders,
  292.       await getTakerOrderInformation({..._order, indexer: api.indexer}, _queuedOrders));
  293.   // }
  294. }
  296. module.exports = getTakerOrders;
  297. JAVASCRIPT
    Copied!