@alcorexchange/alcor-swap-sdk 1.0.18 → 1.0.19

package/build/entities/fractions/currencyAmount.d.ts

@@ -28,4 +28,5 @@ export declare class CurrencyAmount<T extends Currency> extends Fraction {
     toExact(format?: object): string;
     toAsset(...args: any[]): string;
     toExtendedAsset(...args: any[]): string;
+    toExtendedAssetObject(...args: any[]): object;
 }

package/build/entities/fractions/currencyAmount.js

@@ -76,5 +76,8 @@ class CurrencyAmount extends fraction_1.Fraction {
     toExtendedAsset(...args) {
         return `${this.toFixed(...args)} ${this.currency.symbol}@${this.currency.contract}`;
     }
+    toExtendedAssetObject(...args) {
+        return { quantity: `${this.toFixed(...args)} ${this.currency.symbol}`, contract: this.currency.contract };
+    }
 }
 exports.CurrencyAmount = CurrencyAmount;

package/build/entities/trade.d.ts

@@ -116,6 +116,7 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
      * @returns The route
      */
     static fromRoute<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(route: Route<TInput, TOutput>, amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>, tradeType: TTradeType): Promise<Trade<TInput, TOutput, TTradeType>>;
+    static fromRouteReadOnly<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(nodes: string[], route: Route<TInput, TOutput>, amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>, tradeType: TTradeType): Promise<Trade<TInput, TOutput, TTradeType>>;
     /**
      * Constructs a trade from routes by simulating swaps
      *
@@ -221,4 +222,6 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
     static bestTradeExactOut<TInput extends Currency, TOutput extends Currency>(pools: Pool[], currencyIn: TInput, currencyAmountOut: CurrencyAmount<TOutput>, { maxNumResults, maxHops }?: BestTradeOptions, currentPools?: Pool[], nextAmountOut?: CurrencyAmount<Currency>, bestTrades?: Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[]): Promise<Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[]>;
     static bestTradeExactIn2<TInput extends Currency, TOutput extends Currency>(routes: Route<TInput, TOutput>[], pools: Pool[], currencyAmountIn: CurrencyAmount<TInput>, maxNumResults?: number): Promise<Trade<TInput, TOutput, TradeType.EXACT_INPUT>[]>;
     static bestTradeExactOut2<TInput extends Currency, TOutput extends Currency>(routes: Route<TInput, TOutput>[], pools: Pool[], currencyAmountOut: CurrencyAmount<TOutput>, maxNumResults?: number): Promise<Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[]>;
+    static bestTradeExactInReadOnly<TInput extends Currency, TOutput extends Currency>(nodes: string[], routes: Route<TInput, TOutput>[], currencyAmountIn: CurrencyAmount<TInput>, maxNumResults?: number): Promise<Trade<TInput, TOutput, TradeType.EXACT_INPUT>[]>;
+    static bestTradeExactOutReadOnly<TInput extends Currency, TOutput extends Currency>(nodes: string[], routes: Route<TInput, TOutput>[], currencyAmountOut: CurrencyAmount<TOutput>, maxNumResults?: number): Promise<Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[]>;
 }

package/build/entities/trade.js

@@ -18,6 +18,7 @@ const fractions_1 = require("./fractions");
 const utils_1 = require("../utils");
 const internalConstants_1 = require("../internalConstants");
 const route_1 = require("./route");
+const computeAllRoutes_1 = require("../utils/computeAllRoutes");
 /**
  * Trades comparator, an extension of the input output comparator that also considers other dimensions of the trade in ranking them
  * @template TInput The input token, either Ether or an ERC-20
@@ -201,6 +202,28 @@ class Trade {
             });
         });
     }
+    static fromRouteReadOnly(nodes, route, amount, tradeType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let inputAmount;
+            let outputAmount;
+            if (tradeType === internalConstants_1.TradeType.EXACT_INPUT) {
+                (0, tiny_invariant_1.default)(amount.currency.equals(route.input), 'INPUT');
+                inputAmount = fractions_1.CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
+                const value = yield (0, computeAllRoutes_1.callReadOnlySwapCalculation)(nodes, tradeType, inputAmount, fractions_1.CurrencyAmount.fromRawAmount(route.output, 0), route.pools.map(p => p.id));
+                outputAmount = fractions_1.CurrencyAmount.fromRawAmount(route.output, value);
+            }
+            else {
+                (0, tiny_invariant_1.default)(amount.currency.equals(route.output), 'OUTPUT');
+                outputAmount = fractions_1.CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
+                const value = yield (0, computeAllRoutes_1.callReadOnlySwapCalculation)(nodes, tradeType, fractions_1.CurrencyAmount.fromRawAmount(route.input, 0), outputAmount, route.pools.map(p => p.id));
+                inputAmount = fractions_1.CurrencyAmount.fromRawAmount(route.input, value);
+            }
+            return new Trade({
+                routes: [{ inputAmount, outputAmount, route }],
+                tradeType
+            });
+        });
+    }
     /**
      * Constructs a trade from routes by simulating swaps
      *
@@ -494,5 +517,36 @@ class Trade {
             return bestTrades;
         });
     }
+    static bestTradeExactInReadOnly(nodes, routes, currencyAmountIn, maxNumResults = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bestTrades = [];
+            const requests = routes.map(r => {
+                return Trade.fromRouteReadOnly(nodes, r, currencyAmountIn, internalConstants_1.TradeType.EXACT_INPUT);
+            });
+            const trades = yield Promise.all(requests);
+            for (const trade of trades) {
+                if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0)) {
+                    continue;
+                }
+                (0, utils_1.sortedInsert)(bestTrades, trade, maxNumResults, tradeComparator);
+            }
+            return bestTrades;
+        });
+    }
+    static bestTradeExactOutReadOnly(nodes, routes, currencyAmountOut, maxNumResults = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bestTrades = [];
+            const requests = routes.map(r => {
+                return Trade.fromRouteReadOnly(nodes, r, currencyAmountOut, internalConstants_1.TradeType.EXACT_OUTPUT);
+            });
+            const trades = yield Promise.all(requests);
+            for (const trade of trades) {
+                if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0))
+                    continue;
+                (0, utils_1.sortedInsert)(bestTrades, trade, maxNumResults, tradeComparator);
+            }
+            return bestTrades;
+        });
+    }
 }
 exports.Trade = Trade;

package/build/utils/computeAllRoutes.d.ts

@@ -1,2 +1,4 @@
-import { Token, Pool, Route } from '../entities';
+import { TradeType } from '../internalConstants';
+import { Token, Pool, Route, Currency, CurrencyAmount } from '../entities';
 export declare function computeAllRoutes(tokenIn: Token, tokenOut: Token, pools: Pool[], maxHops: number): Route<Token, Token>[];
+export declare function callReadOnlySwapCalculation<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(nodes: string[], tradeType: TTradeType, inToken: CurrencyAmount<TInput>, outToken: CurrencyAmount<TOutput>, poolIds: number[]): Promise<any>;

package/build/utils/computeAllRoutes.js

@@ -1,6 +1,21 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeAllRoutes = void 0;
+exports.callReadOnlySwapCalculation = exports.computeAllRoutes = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const antelope_1 = require("@wharfkit/antelope");
+const internalConstants_1 = require("../internalConstants");
 const entities_1 = require("../entities");
 function computeAllRoutes(tokenIn, tokenOut, pools, maxHops) {
     const poolsUsed = Array(pools.length).fill(false);
@@ -37,3 +52,38 @@ function computeAllRoutes(tokenIn, tokenOut, pools, maxHops) {
     return routes;
 }
 exports.computeAllRoutes = computeAllRoutes;
+const abiCache = {};
+function callReadOnlySwapCalculation(nodes, tradeType, inToken, outToken, poolIds) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const name = tradeType == internalConstants_1.TradeType.EXACT_INPUT ? 'swapexactin' : 'swapexactout';
+        // TODO add failover
+        const node = nodes[0];
+        // TODO Retry logic
+        const rpc = new antelope_1.APIClient({ url: node, fetch: node_fetch_1.default });
+        const info = yield rpc.v1.chain.get_info();
+        const header = info.getTransactionHeader();
+        if (!abiCache[node])
+            abiCache[node] = (yield rpc.v1.chain.get_abi('amminterface')).abi;
+        const abi = abiCache[node];
+        const action = antelope_1.Action.from({
+            authorization: [],
+            account: 'amminterface',
+            name,
+            data: {
+                inToken: inToken.toExtendedAssetObject(),
+                outToken: outToken.toExtendedAssetObject(),
+                poolIds,
+            }
+        }, abi);
+        const transaction = antelope_1.Transaction.from(Object.assign(Object.assign({}, header), { actions: [action] }));
+        try {
+            const res = yield rpc.v1.chain.send_read_only_transaction(transaction);
+            const outQuantity = res.processed.action_traces[0].return_value_data.quantity;
+            return outQuantity.split(' ')[0].replace('.', '');
+        }
+        catch (e) {
+            return '0';
+        }
+    });
+}
+exports.callReadOnlySwapCalculation = callReadOnlySwapCalculation;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alcorexchange/alcor-swap-sdk",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "description": "",
   "main": "build/index.js",
   "scripts": {

package/src/entities/fractions/currencyAmount.ts

@@ -126,4 +126,8 @@ export class CurrencyAmount<T extends Currency> extends Fraction {
   public toExtendedAsset(...args): string {
     return `${this.toFixed(...args)} ${this.currency.symbol}@${this.currency.contract}`
   }
+
+  public toExtendedAssetObject(...args): object {
+    return { quantity: `${this.toFixed(...args)} ${this.currency.symbol}`, contract: this.currency.contract }
+  }
 }

package/src/entities/trade.ts

@@ -7,6 +7,7 @@ import { Token } from './token'
 import { ONE, ZERO, TradeType } from '../internalConstants'
 import { Pool } from './pool'
 import { Route } from './route'
+import { callReadOnlySwapCalculation } from '../utils/computeAllRoutes'
 
 /**
  * Trades comparator, an extension of the input output comparator that also considers other dimensions of the trade in ranking them
@@ -267,6 +268,51 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
     })
   }
 
+  public static async fromRouteReadOnly<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(
+    nodes: string[],
+    route: Route<TInput, TOutput>,
+    amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>,
+    tradeType: TTradeType
+  ): Promise<Trade<TInput, TOutput, TTradeType>> {
+    let inputAmount: CurrencyAmount<TInput>
+    let outputAmount: CurrencyAmount<TOutput>
+
+    if (tradeType === TradeType.EXACT_INPUT) {
+      invariant(amount.currency.equals(route.input), 'INPUT')
+
+      inputAmount = CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator)
+
+      const value = await callReadOnlySwapCalculation(
+        nodes,
+        tradeType,
+        inputAmount,
+        CurrencyAmount.fromRawAmount(route.output, 0),
+        route.pools.map(p => p.id),
+      )
+
+      outputAmount = CurrencyAmount.fromRawAmount(route.output, value)
+    } else {
+      invariant(amount.currency.equals(route.output), 'OUTPUT')
+
+      outputAmount = CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator)
+
+      const value = await callReadOnlySwapCalculation(
+        nodes,
+        tradeType,
+        CurrencyAmount.fromRawAmount(route.input, 0),
+        outputAmount,
+        route.pools.map(p => p.id),
+      )
+
+      inputAmount = CurrencyAmount.fromRawAmount(route.input, value)
+    }
+
+    return new Trade({
+      routes: [{ inputAmount, outputAmount, route }],
+      tradeType
+    })
+  }
+
   /**
    * Constructs a trade from routes by simulating swaps
    *
@@ -716,4 +762,72 @@ export class Trade<TInput extends Currency, TOutput extends Currency, TTradeType
 
     return bestTrades
   }
+
+  public static async bestTradeExactInReadOnly<TInput extends Currency, TOutput extends Currency>(
+    nodes: string[],
+    routes: Route<TInput, TOutput>[],
+    currencyAmountIn: CurrencyAmount<TInput>,
+    maxNumResults = 1,
+  ): Promise<Trade<TInput, TOutput, TradeType.EXACT_INPUT>[]> {
+    const bestTrades: Trade<TInput, TOutput, TradeType.EXACT_INPUT>[] = []
+
+    const requests = routes.map(r => {
+      return Trade.fromRouteReadOnly(
+        nodes,
+        r,
+        currencyAmountIn,
+        TradeType.EXACT_INPUT
+      )
+    })
+
+    const trades = await Promise.all(requests)
+
+    for (const trade of trades) {
+      if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0)) {
+        continue
+      }
+
+      sortedInsert(
+        bestTrades,
+        trade,
+        maxNumResults,
+        tradeComparator
+      )
+    }
+
+    return bestTrades
+  }
+
+  public static async bestTradeExactOutReadOnly<TInput extends Currency, TOutput extends Currency>(
+    nodes: string[],
+    routes: Route<TInput, TOutput>[],
+    currencyAmountOut: CurrencyAmount<TOutput>,
+    maxNumResults = 1,
+  ): Promise<Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[]> {
+    const bestTrades: Trade<TInput, TOutput, TradeType.EXACT_OUTPUT>[] = []
+
+    const requests = routes.map(r => {
+      return Trade.fromRouteReadOnly(
+        nodes,
+        r,
+        currencyAmountOut,
+        TradeType.EXACT_OUTPUT
+      )
+    })
+
+    const trades = await Promise.all(requests)
+
+    for (const trade of trades) {
+      if (!trade.inputAmount.greaterThan(0) || !trade.priceImpact.greaterThan(0)) continue
+
+      sortedInsert(
+        bestTrades,
+        trade,
+        maxNumResults,
+        tradeComparator
+      )
+    }
+
+    return bestTrades
+  }
 }

package/src/utils/computeAllRoutes.ts

@@ -1,4 +1,8 @@
-import { Token, Pool, Route } from '../entities';
+import fetch from 'node-fetch'
+import { APIClient, Action, Transaction } from '@wharfkit/antelope'
+
+import { TradeType } from '../internalConstants'
+import { Token, Pool, Route, Currency, CurrencyAmount } from '../entities';
 
 export function computeAllRoutes(
   tokenIn: Token,
@@ -62,3 +66,52 @@ export function computeAllRoutes(
 
   return routes;
 }
+
+const abiCache = {}
+export async function callReadOnlySwapCalculation<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(
+  nodes: string[],
+  tradeType: TTradeType,
+  inToken: CurrencyAmount<TInput>,
+  outToken: CurrencyAmount<TOutput>,
+  poolIds: number[],
+) {
+
+  const name = tradeType == TradeType.EXACT_INPUT ? 'swapexactin' : 'swapexactout'
+
+  // TODO add failover
+  const node = nodes[0]
+
+  // TODO Retry logic
+  const rpc = new APIClient({ url: node, fetch })
+  const info = await rpc.v1.chain.get_info()
+  const header = info.getTransactionHeader()
+
+  if (!abiCache[node]) abiCache[node] = (await rpc.v1.chain.get_abi('amminterface')).abi
+
+  const abi = abiCache[node]
+
+  const action = Action.from({
+      authorization: [], // No authorizations
+      account: 'amminterface',
+      name,
+      data: {
+        inToken: inToken.toExtendedAssetObject(),
+        outToken: outToken.toExtendedAssetObject(),
+        poolIds,
+      }
+  }, abi)
+
+  const transaction = Transaction.from({
+      ...header,
+      actions: [action],
+  })
+
+  try {
+    const res: any = await rpc.v1.chain.send_read_only_transaction(transaction)
+    const outQuantity = res.processed.action_traces[0].return_value_data.quantity
+
+    return outQuantity.split(' ')[0].replace('.', '')
+  } catch (e) {
+    return '0'
+  }
+}