@d8x/perpetuals-sdk 1.3.4 → 1.3.6

package/src/config/priceFeedConfig.json

@@ -148,8 +148,12 @@
       }
     ],
     "endpoints": [
-      { "type": "pyth", "endpoints": ["https://hermes.pyth.network"] },
-      { "type": "onchain", "endpoints": [] }
+      {
+        "type": "pyth",
+        "endpoints": ["https://hermes.pyth.network"],
+        "writeEndpoints": ["https://hermes.pyth.network"]
+      },
+      { "type": "onchain", "endpoints": [], "writeEndpoints": [] }
     ]
   },
   {
@@ -228,6 +232,8 @@
         "origin": "Crypto.USDT/USD"
       }
     ],
-    "endpoints": [{ "type": "odin", "endpoints": ["https://odin.d8x.xyz"] }]
+    "endpoints": [
+      { "type": "odin", "endpoints": ["https://hermes.pyth.network"], "writeEndpoints": ["https://odin.d8x.xyz"] }
+    ]
   }
 ]

package/src/nodeSDKTypes.ts

@@ -20,7 +20,7 @@ export interface NodeSDKConfig {
   lobFactoryABI?: ContractInterface | undefined;
   lobABI?: ContractInterface | undefined;
   shareTokenABI?: ContractInterface | undefined;
-  priceFeedEndpoints?: Array<{ type: string; endpoints: string[] }>;
+  priceFeedEndpoints?: PriceFeedEndpointsOptionalWrite;
   multicall?: string;
 }
 
@@ -287,9 +287,25 @@ export interface TypeSafeOrder {
 export interface PriceFeedConfig {
   network: string;
   ids: Array<{ symbol: string; id: string; type: string; origin: string }>;
-  endpoints: Array<{ type: string; endpoints: string[] }>;
+  endpoints: PriceFeedEndpoints;
 }
 
+export interface PriceFeedEndpointsItem {
+  type: string | "odin" | "pyth" | "onchain";
+  // Read only endpoints. Used by default.
+  endpoints: string[];
+  // Price feed endpoints which are used for fetching prices which will be
+  // submitted for updates on chain.
+  writeEndpoints?: string[];
+}
+
+// For price feeds config
+export type PriceFeedEndpoints = Array<Required<PriceFeedEndpointsItem>>;
+
+// For SDK configuration writeEndpoints are set as optional for backwards
+// compatibility. See NodeSDKConfig interface.
+export type PriceFeedEndpointsOptionalWrite = Array<PriceFeedEndpointsItem>;
+
 export interface PriceFeedSubmission {
   symbols: Map<string, string[]>; //id -> symbols
   ids: string[];

package/src/orderExecutorTool.ts

@@ -1,8 +1,8 @@
 import { Signer } from "@ethersproject/abstract-signer";
-import { BigNumber } from "@ethersproject/bignumber";
+import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
 import { HashZero } from "@ethersproject/constants";
 import type { CallOverrides, ContractTransaction, PayableOverrides } from "@ethersproject/contracts";
-import { BlockTag, StaticJsonRpcProvider } from "@ethersproject/providers";
+import { BlockTag, StaticJsonRpcProvider, TransactionRequest } from "@ethersproject/providers";
 import { BUY_SIDE, MULTICALL_ADDRESS, OrderStatus, SELL_SIDE, ZERO_ADDRESS, ZERO_ORDER_ID } from "./constants";
 import { IPyth__factory, LimitOrderBook, LimitOrderBook__factory, Multicall3, Multicall3__factory } from "./contracts";
 import { ABK64x64ToFloat, floatToABK64x64 } from "./d8XMath";
@@ -88,7 +88,7 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     executorAddr?: string,
     submission?: PriceFeedSubmission,
     overrides?: PayableOverrides
-  ): Promise<ContractTransaction | undefined> {
+  ): Promise<ContractTransaction> {
     return this.executeOrders(symbol, [orderId], executorAddr, submission, overrides);
   }
 
@@ -125,8 +125,8 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     orderIds: string[],
     executorAddr?: string,
     submission?: PriceFeedSubmission,
-    overrides?: PayableOverrides & { rpcURL?: string; splitTx?: boolean }
-  ): Promise<ContractTransaction | undefined> {
+    overrides?: PayableOverrides & { rpcURL?: string; splitTx?: boolean; maxGasLimit?: BigNumberish }
+  ): Promise<ContractTransaction> {
     if (this.proxyContract == null || this.signer == null) {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
     }
@@ -182,11 +182,23 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     }
 
     if (overrides?.nonce !== undefined) {
-      const nonce = await overrides!.nonce;
+      const nonce = await overrides.nonce;
       overrides.nonce = BigNumber.from(nonce).add(nonceInc);
     }
 
-    let unsignedTx = {
+    if (overrides?.gasLimit !== undefined) {
+      overrides.gasLimit = await overrides.gasLimit;
+    }
+
+    if (overrides?.gasPrice !== undefined) {
+      overrides.gasPrice = await overrides.gasPrice;
+    }
+
+    if (value !== undefined) {
+      value = await value;
+    }
+
+    const unsignedTx: TransactionRequest = {
       to: this.getOrderBookContract(symbol).address,
       from: this.traderAddr,
       nonce: overrides?.nonce,
@@ -199,31 +211,33 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     };
     // no gas limit was specified, explicitly estimate
     if (!overrides?.gasLimit) {
-      overrides = {
-        gasLimit: await this.signer
-          .estimateGas(unsignedTx)
-          .then((gas) => gas.mul(1100).div(1000))
-          .catch((_e) => undefined),
-        ...overrides,
-      };
-      if (!overrides.gasLimit) {
-        // gas estimate failed - txn would probably revert, double check:
-        overrides = { gasLimit: this.gasLimit, value: unsignedTx.value, ...overrides };
-        try {
-          await this.getOrderBookContract(symbol).callStatic.executeOrders(
-            orderIds,
-            executorAddr,
-            submission.priceFeedVaas,
-            submission.timestamps,
-            overrides
-          );
-        } catch (e) {
-          console.log("Order cannot be executed:", e);
-          return undefined;
-        }
+      // given gas price might be conservative, which leads to a lower a gas estimate
+      //-> compensate with larger buffer
+      let gasLimit = await this.signer
+        .estimateGas(unsignedTx)
+        .then((gas) => gas.mul(1500).div(1000))
+        .catch((_e) => undefined);
+
+      if (!gasLimit) {
+        // gas estimate failed - txn would probably revert, double check (and possibly re-throw):
+        overrides = {
+          ...overrides,
+          gasLimit: overrides?.maxGasLimit ?? this.gasLimit,
+          value: unsignedTx.value,
+        };
+        await this.getOrderBookContract(symbol, provider).callStatic.executeOrders(
+          orderIds,
+          executorAddr,
+          submission.priceFeedVaas,
+          submission.timestamps,
+          overrides
+        );
+        // it worked - use fallback
+        gasLimit = BigNumber.from(overrides?.maxGasLimit ?? this.gasLimit);
       }
+      unsignedTx.gasLimit = gasLimit;
     }
-    return await this.signer.sendTransaction(unsignedTx);
+    return await this.signer.connect(provider).sendTransaction(unsignedTx);
   }
 
   /**

package/src/perpetualDataHandler.ts

@@ -179,12 +179,12 @@ export default class PerpetualDataHandler {
    * @param symbol symbol of the form ETH-USD-MATIC
    * @returns order book contract for the perpetual
    */
-  public getOrderBookContract(symbol: string): Contract & LimitOrderBook {
+  public getOrderBookContract(symbol: string, provider?: Provider): Contract & LimitOrderBook {
     let orderBookAddr = this.symbolToPerpStaticInfo.get(symbol)?.limitOrderBookAddr;
     if (orderBookAddr == "" || orderBookAddr == undefined || this.signerOrProvider == null) {
       throw Error(`no limit order book found for ${symbol} or no signer`);
     }
-    let lobContract = LimitOrderBook__factory.connect(orderBookAddr, this.signerOrProvider);
+    let lobContract = LimitOrderBook__factory.connect(orderBookAddr, provider ?? this.signerOrProvider);
     return lobContract;
   }
 

package/src/priceFeeds.ts

@@ -1,7 +1,14 @@
 import { BigNumber } from "@ethersproject/bignumber";
 import { Buffer } from "buffer";
 import { decNToFloat, floatToDec18 } from "./d8XMath";
-import type { PriceFeedConfig, PriceFeedFormat, PriceFeedSubmission, PythV2LatestPriceFeed } from "./nodeSDKTypes";
+import type {
+  PriceFeedConfig,
+  PriceFeedEndpoints,
+  PriceFeedEndpointsOptionalWrite,
+  PriceFeedFormat,
+  PriceFeedSubmission,
+  PythV2LatestPriceFeed,
+} from "./nodeSDKTypes";
 import PerpetualDataHandler from "./perpetualDataHandler";
 import Triangulator from "./triangulator";
 import OnChainPxFeed from "./onChainPxFeed";
@@ -13,7 +20,11 @@ import OnChainPxFactory from "./onChainPxFactory";
  */
 export default class PriceFeeds {
   private config: PriceFeedConfig;
-  private feedEndpoints: Array<string>; //feedEndpoints[endpointId] = endpointstring
+  // Read only price info endpoints. Used by default. feedEndpoints[endpointId]
+  // = endpointstring
+  public feedEndpoints: Array<string>;
+  // Endpoints which are used to fetch prices for submissions
+  public writeFeedEndpoints: Array<string> = [];
   private feedInfo: Map<string, { symbol: string; endpointId: number }[]>; // priceFeedId -> [symbol, endpointId]
   private dataHandler: PerpetualDataHandler;
   // store triangulation paths given the price feeds
@@ -27,21 +38,16 @@ export default class PriceFeeds {
   constructor(dataHandler: PerpetualDataHandler, priceFeedConfigNetwork: string) {
     let configs = require("./config/priceFeedConfig.json") as PriceFeedConfig[];
     this.config = PriceFeeds._selectConfig(configs, priceFeedConfigNetwork);
-    // if SDK config contains custom price feed endpoints, these override the public/default ones
+
+    // if SDK config contains custom price feed endpoints, these override the
+    // public/default ones
     if (dataHandler.config.priceFeedEndpoints && dataHandler.config.priceFeedEndpoints.length > 0) {
-      // override price feed endpoints of same type
-      for (let k = 0; k < dataHandler.config.priceFeedEndpoints.length; k++) {
-        for (let j = 0; j < this.config.endpoints.length; j++) {
-          if (this.config.endpoints[j].type == dataHandler.config.priceFeedEndpoints[k].type) {
-            this.config.endpoints[j] = dataHandler.config.priceFeedEndpoints[k];
-            for (let i = 0; i < this.config.endpoints[j].endpoints.length; i++) {
-              this.config.endpoints[j].endpoints[i] = PriceFeeds.trimEndpoint(this.config.endpoints[j].endpoints[i]);
-            }
-            break;
-          }
-        }
-      }
+      this.config.endpoints = PriceFeeds.overridePriceEndpointsOfSameType(
+        this.config.endpoints,
+        dataHandler.config.priceFeedEndpoints
+      );
     }
+
     this.onChainPxFeeds = new Map<string, OnChainPxFeed>();
     for (let k = 0; k < this.config.ids.length; k++) {
       if (this.config.ids[k].type == "onchain") {
@@ -49,11 +55,56 @@ export default class PriceFeeds {
         this.onChainPxFeeds[sym] = OnChainPxFactory.createFeed(sym);
       }
     }
-    [this.feedInfo, this.feedEndpoints] = PriceFeeds._constructFeedInfo(this.config, false);
+    [this.feedInfo, this.feedEndpoints, this.writeFeedEndpoints] = PriceFeeds._constructFeedInfo(this.config, false);
+    // Deny providing no endpoints
+    if (this.feedEndpoints.length == 0) {
+      throw new Error("PriceFeeds: no endpoints provided in config");
+    }
+    if (this.writeFeedEndpoints.length == 0) {
+      throw new Error("PriceFeeds: no writeEndpoints provided in config");
+    }
+
     this.dataHandler = dataHandler;
     this.triangulations = new Map<string, [string[], boolean[]]>();
   }
 
+  // overridePriceEndpointsOfSameType overrides endpoints of config with same
+  // type endpoints provided by user and returns the updated price feed
+  // endpoints list.
+  public static overridePriceEndpointsOfSameType(
+    configEndpoints: PriceFeedEndpoints,
+    userProvidedEndpoints: PriceFeedEndpointsOptionalWrite
+  ): PriceFeedEndpoints {
+    let result = configEndpoints;
+    for (let k = 0; k < userProvidedEndpoints.length; k++) {
+      for (let j = 0; j < result.length; j++) {
+        if (result[j].type == userProvidedEndpoints[k].type) {
+          // read only endpoints
+          if (userProvidedEndpoints[k].endpoints.length > 0) {
+            result[j].endpoints = userProvidedEndpoints[k].endpoints;
+            for (let i = 0; i < result[j].endpoints.length; i++) {
+              result[j].endpoints[i] = PriceFeeds.trimEndpoint(result[j].endpoints[i]);
+            }
+          }
+
+          // write endpoints
+          if (
+            userProvidedEndpoints[k].writeEndpoints !== undefined &&
+            userProvidedEndpoints[k].writeEndpoints!.length > 0
+          ) {
+            result[j].writeEndpoints = userProvidedEndpoints[k].writeEndpoints!;
+            for (let i = 0; i < result[j].writeEndpoints.length; i++) {
+              result[j].writeEndpoints[i] = PriceFeeds.trimEndpoint(result[j].writeEndpoints[i]);
+            }
+          }
+
+          break;
+        }
+      }
+    }
+    return result;
+  }
+
   /**
    * We cut last / or legacy url format /api/ if any
    * @param endp endpoint string
@@ -101,8 +152,8 @@ export default class PriceFeeds {
   }
 
   /**
-   * Get required information to be able to submit a blockchain transaction with price-update
-   * such as trade execution, liquidation
+   * Get required information to be able to submit a blockchain transaction with
+   * price-update such as trade execution, liquidation. Uses write price feed endpoints.
    * @param symbol symbol of perpetual, e.g., BTC-USD-MATIC
    * @returns PriceFeedSubmission, index prices, market closed information
    */
@@ -128,8 +179,9 @@ export default class PriceFeeds {
 
   /**
    * Get all prices/isMarketClosed for the provided symbols via
-   * "latest_price_feeds" and triangulation. Triangulation must be defined in config, unless
-   * it is a direct price feed.
+   * "latest_price_feeds" and triangulation. Triangulation must be defined in
+   * config, unless it is a direct price feed. Uses read endpoints.
+   * @param symbol perpetual symbol of the form BTC-USD-MATIC
    * @returns map of feed-price symbol to price/isMarketClosed
    */
   public async fetchPrices(symbols: string[]): Promise<Map<string, [number, boolean]>> {
@@ -179,8 +231,10 @@ export default class PriceFeeds {
    * Fetch the provided feed prices and bool whether market is closed or open
    * - requires the feeds to be defined in priceFeedConfig.json
    * - if symbols undefined, all feeds are queried
-   * - vaas are not of interest here
-   * @param symbols array of feed-price symbols (e.g., [btc-usd, eth-usd]) or undefined
+   * - vaas are not of interest here, therefore only readonly price feed
+   *   endpoints are used
+   * @param symbols array of feed-price symbols (e.g., [btc-usd, eth-usd]) or
+   * undefined
    * @returns mapping symbol-> [price, isMarketClosed]
    */
   public async fetchFeedPrices(symbols?: string[]): Promise<Map<string, [number, boolean]>> {
@@ -249,7 +303,7 @@ export default class PriceFeeds {
   }
 
   /**
-   * Get all configured feed prices via "latest_price_feeds"
+   * Get all configured feed prices via "latest_price_feeds".
    * @returns map of feed-price symbol to price/isMarketClosed
    */
   public async fetchAllFeedPrices(): Promise<Map<string, [number, boolean]>> {
@@ -258,10 +312,10 @@ export default class PriceFeeds {
 
   /**
    * Get the latest prices for a given perpetual from the offchain oracle
-   * networks
+   * networks. Uses write price feed endpoints.
    * @param symbol perpetual symbol of the form BTC-USD-MATIC
-   * @returns array of price feed updates that can be submitted to the smart contract
-   * and corresponding price information
+   * @returns array of price feed updates that can be submitted to the smart
+   * contract and corresponding price information
    */
   public async fetchLatestFeedPriceInfoForPerpetual(symbol: string): Promise<PriceFeedSubmission> {
     // get the feedIds that the contract uses
@@ -277,7 +331,8 @@ export default class PriceFeeds {
       // and another
       let idx = info[0].endpointId;
       let feedId = feedIds[k];
-      queries.push(this.feedEndpoints[idx] + "/v2/updates/price/latest?encoding=base64&ids[]=" + feedId);
+      queries.push(this.writeFeedEndpoints[idx] + "/v2/updates/price/latest?encoding=base64&ids[]=" + feedId);
+
       for (let j = 0; j < info.length; j++) {
         if (symbols.has(feedId)) {
           symbols[feedId].append(info[j].symbol);
@@ -481,11 +536,12 @@ export default class PriceFeeds {
   static _constructFeedInfo(
     config: PriceFeedConfig,
     shuffleEndpoints: boolean
-  ): [Map<string, { symbol: string; endpointId: number }[]>, string[]] {
+  ): [Map<string, { symbol: string; endpointId: number }[]>, string[], string[]] {
     let feed = new Map<string, [{ symbol: string; endpointId: number }]>();
     let endpointId = -1;
     let type = "";
     let feedEndpoints = new Array<string>();
+    let writeFeedEndpoints = new Array<string>();
 
     for (let k = 0; k < config.endpoints.length; k++) {
       const L = config.endpoints[k].endpoints.length;
@@ -493,7 +549,13 @@ export default class PriceFeeds {
       // if config has only one endpoint:
       endpointNr = Math.min(endpointNr, L - 1);
       feedEndpoints.push(config.endpoints[k].endpoints[endpointNr]);
+
+      // write endpoints
+      const n = config.endpoints[k].writeEndpoints.length;
+      const useEndpoint = Math.min(!shuffleEndpoints ? 0 : 1 + Math.floor(Math.random() * (n - 1)), n - 1);
+      writeFeedEndpoints.push(config.endpoints[k].writeEndpoints[useEndpoint]);
     }
+
     for (let k = 0; k < config.ids.length; k++) {
       if (type != config.ids[k].type) {
         type = config.ids[k].type;
@@ -518,6 +580,6 @@ export default class PriceFeeds {
         feed.set(id, [item]);
       }
     }
-    return [feed, feedEndpoints];
+    return [feed, feedEndpoints, writeFeedEndpoints];
   }
 }

package/src/version.ts

@@ -1 +1 @@
-export const D8X_SDK_VERSION = "1.3.4";
+export const D8X_SDK_VERSION = "1.3.6";

package/src/contracts/BeaconProxy.ts

@@ -1,108 +0,0 @@
-/* Autogenerated file. Do not edit manually. */
-/* tslint:disable */
-/* eslint-disable */
-import type { BaseContract, Signer, utils } from "ethers";
-import type { EventFragment } from "@ethersproject/abi";
-import type { Listener, Provider } from "@ethersproject/providers";
-import type {
-  TypedEventFilter,
-  TypedEvent,
-  TypedListener,
-  OnEvent,
-} from "./common";
-
-export interface BeaconProxyInterface extends utils.Interface {
-  functions: {};
-
-  events: {
-    "AdminChanged(address,address)": EventFragment;
-    "BeaconUpgraded(address)": EventFragment;
-    "Upgraded(address)": EventFragment;
-  };
-
-  getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
-}
-
-export interface AdminChangedEventObject {
-  previousAdmin: string;
-  newAdmin: string;
-}
-export type AdminChangedEvent = TypedEvent<
-  [string, string],
-  AdminChangedEventObject
->;
-
-export type AdminChangedEventFilter = TypedEventFilter<AdminChangedEvent>;
-
-export interface BeaconUpgradedEventObject {
-  beacon: string;
-}
-export type BeaconUpgradedEvent = TypedEvent<
-  [string],
-  BeaconUpgradedEventObject
->;
-
-export type BeaconUpgradedEventFilter = TypedEventFilter<BeaconUpgradedEvent>;
-
-export interface UpgradedEventObject {
-  implementation: string;
-}
-export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>;
-
-export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;
-
-export interface BeaconProxy extends BaseContract {
-  connect(signerOrProvider: Signer | Provider | string): this;
-  attach(addressOrName: string): this;
-  deployed(): Promise<this>;
-
-  interface: BeaconProxyInterface;
-
-  queryFilter<TEvent extends TypedEvent>(
-    event: TypedEventFilter<TEvent>,
-    fromBlockOrBlockhash?: string | number | undefined,
-    toBlock?: string | number | undefined
-  ): Promise<Array<TEvent>>;
-
-  listeners<TEvent extends TypedEvent>(
-    eventFilter?: TypedEventFilter<TEvent>
-  ): Array<TypedListener<TEvent>>;
-  listeners(eventName?: string): Array<Listener>;
-  removeAllListeners<TEvent extends TypedEvent>(
-    eventFilter: TypedEventFilter<TEvent>
-  ): this;
-  removeAllListeners(eventName?: string): this;
-  off: OnEvent<this>;
-  on: OnEvent<this>;
-  once: OnEvent<this>;
-  removeListener: OnEvent<this>;
-
-  functions: {};
-
-  callStatic: {};
-
-  filters: {
-    "AdminChanged(address,address)"(
-      previousAdmin?: null,
-      newAdmin?: null
-    ): AdminChangedEventFilter;
-    AdminChanged(
-      previousAdmin?: null,
-      newAdmin?: null
-    ): AdminChangedEventFilter;
-
-    "BeaconUpgraded(address)"(
-      beacon?: string | null
-    ): BeaconUpgradedEventFilter;
-    BeaconUpgraded(beacon?: string | null): BeaconUpgradedEventFilter;
-
-    "Upgraded(address)"(implementation?: string | null): UpgradedEventFilter;
-    Upgraded(implementation?: string | null): UpgradedEventFilter;
-  };
-
-  estimateGas: {};
-
-  populateTransaction: {};
-}