@d8x/perpetuals-sdk 1.3.6 → 2.0.0-alpha

package/src/orderExecutorTool.ts

@@ -1,10 +1,16 @@
-import { Signer } from "@ethersproject/abstract-signer";
-import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
-import { HashZero } from "@ethersproject/constants";
-import type { CallOverrides, ContractTransaction, PayableOverrides } from "@ethersproject/contracts";
-import { BlockTag, StaticJsonRpcProvider, TransactionRequest } from "@ethersproject/providers";
+import {
+  BigNumberish,
+  BlockTag,
+  JsonRpcProvider,
+  Overrides,
+  Signer,
+  TransactionRequest,
+  TransactionResponse,
+  ZeroHash,
+} from "ethers";
 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 { IPyth__factory, LimitOrderBook__factory, Multicall3, Multicall3__factory } from "./contracts";
+import { PayableOverrides } from "./contracts/common";
 import { ABK64x64ToFloat, floatToABK64x64 } from "./d8XMath";
 import {
   type NodeSDKConfig,
@@ -88,7 +94,7 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     executorAddr?: string,
     submission?: PriceFeedSubmission,
     overrides?: PayableOverrides
-  ): Promise<ContractTransaction> {
+  ): Promise<TransactionResponse> {
     return this.executeOrders(symbol, [orderId], executorAddr, submission, overrides);
   }
 
@@ -126,16 +132,17 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     executorAddr?: string,
     submission?: PriceFeedSubmission,
     overrides?: PayableOverrides & { rpcURL?: string; splitTx?: boolean; maxGasLimit?: BigNumberish }
-  ): Promise<ContractTransaction> {
+  ): Promise<TransactionResponse> {
     if (this.proxyContract == null || this.signer == null) {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
     }
     let rpcURL: string | undefined;
     let splitTx: boolean | undefined;
+    let maxGasLimit: BigNumberish | undefined;
     if (overrides) {
-      ({ rpcURL, splitTx, ...overrides } = overrides);
+      ({ rpcURL, splitTx, maxGasLimit, ...overrides } = overrides);
     }
-    const provider = new StaticJsonRpcProvider(rpcURL ?? this.nodeURL);
+    const provider = new JsonRpcProvider(rpcURL ?? this.nodeURL);
 
     if (typeof executorAddr == "undefined") {
       executorAddr = this.traderAddr;
@@ -181,9 +188,8 @@ export default class OrderExecutorTool extends WriteAccessHandler {
       value = this.PRICE_UPDATE_FEE_GWEI * submission.timestamps.length;
     }
 
-    if (overrides?.nonce !== undefined) {
-      const nonce = await overrides.nonce;
-      overrides.nonce = BigNumber.from(nonce).add(nonceInc);
+    if (overrides?.nonce != undefined) {
+      overrides.nonce = overrides.nonce + nonceInc;
     }
 
     if (overrides?.gasLimit !== undefined) {
@@ -199,7 +205,7 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     }
 
     const unsignedTx: TransactionRequest = {
-      to: this.getOrderBookContract(symbol).address,
+      to: this.getOrderBookContract(symbol).target,
       from: this.traderAddr,
       nonce: overrides?.nonce,
       data: txData,
@@ -211,29 +217,21 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     };
     // no gas limit was specified, explicitly estimate
     if (!overrides?.gasLimit) {
-      // 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))
+        .then((gas) => (gas * 1500n) / 1000n)
         .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(
+        overrides = { gasLimit: maxGasLimit ?? this.gasLimit, value: unsignedTx.value, ...overrides };
+        await this.getOrderBookContract(symbol).executeOrders.staticCall(
           orderIds,
           executorAddr,
           submission.priceFeedVaas,
           submission.timestamps,
           overrides
         );
-        // it worked - use fallback
-        gasLimit = BigNumber.from(overrides?.maxGasLimit ?? this.gasLimit);
+        gasLimit = BigInt(maxGasLimit ?? this.gasLimit);
       }
       unsignedTx.gasLimit = gasLimit;
     }
@@ -265,7 +263,7 @@ export default class OrderExecutorTool extends WriteAccessHandler {
   public async getOrderById(
     symbol: string,
     id: string,
-    overrides?: CallOverrides & { rpcURL?: string }
+    overrides?: Overrides & { rpcURL?: string }
   ): Promise<Order | undefined> {
     let ob = this.getOrderBookContract(symbol);
     // multicall
@@ -273,63 +271,65 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     if (overrides) {
       ({ rpcURL, ...overrides } = overrides);
     }
-    const provider = new StaticJsonRpcProvider(rpcURL ?? this.nodeURL);
+    const provider = new JsonRpcProvider(rpcURL ?? this.nodeURL, this.network, { staticNetwork: true });
     const multicall = Multicall3__factory.connect(this.config.multicall ?? MULTICALL_ADDRESS, provider);
     const calls: Multicall3.Call3Struct[] = [
       // 0: orderOfDigest
       {
-        target: ob.address,
+        target: ob.target,
         allowFailure: false,
         callData: ob.interface.encodeFunctionData("orderOfDigest", [id]),
       },
       // 1: orderDependency
       {
-        target: ob.address,
+        target: ob.target,
         allowFailure: false,
         callData: ob.interface.encodeFunctionData("orderDependency", [id]),
       },
     ];
-    const encodedResults = await multicall.callStatic.aggregate3(calls, overrides || {});
+    const encodedResults = await multicall.aggregate3.staticCall(calls, overrides || {});
     if (encodedResults.some(({ success }) => !success)) {
       return undefined;
     }
 
-    const smartContractOrder = ob.interface.decodeFunctionResult("orderOfDigest", encodedResults[0].returnData) as [
-      number,
-      number,
-      number,
+    const smartContractOrder = ob.interface.decodeFunctionResult(
+      "orderOfDigest",
+      encodedResults[0].returnData
+    ) as unknown as [
+      bigint,
+      bigint,
+      bigint,
       string,
-      number,
+      bigint,
       string,
-      number,
-      number,
-      number,
+      bigint,
+      bigint,
+      bigint,
       string,
-      BigNumber,
-      BigNumber,
-      BigNumber,
+      bigint,
+      bigint,
+      bigint,
       string
     ] & {
-      leverageTDR: number;
-      brokerFeeTbps: number;
-      iPerpetualId: number;
+      leverageTDR: bigint;
+      brokerFeeTbps: bigint;
+      iPerpetualId: bigint;
       traderAddr: string;
-      executionTimestamp: number;
+      executionTimestamp: bigint;
       brokerAddr: string;
-      submittedTimestamp: number;
-      flags: number;
-      iDeadline: number;
+      submittedTimestamp: bigint;
+      flags: bigint;
+      iDeadline: bigint;
       executorAddr: string;
-      fAmount: BigNumber;
-      fLimitPrice: BigNumber;
-      fTriggerPrice: BigNumber;
+      fAmount: bigint;
+      fLimitPrice: bigint;
+      fTriggerPrice: bigint;
       brokerSignature: string;
     };
-
-    const orderDependency = ob.interface.decodeFunctionResult("orderDependency", encodedResults[1].returnData) as [
-      string,
-      string
-    ] & {
+    const orderDependency = ob.interface.decodeFunctionResult(
+      "orderDependency",
+      encodedResults[1].returnData
+    ) as unknown as [string, string] & {
       parentChildDigest1: string;
       parentChildDigest2: string;
     };
@@ -368,7 +368,7 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     orderId: string,
     blockTimestamp?: number,
     indexPrices?: [number, number],
-    overrides?: CallOverrides & { rpcURL?: string }
+    overrides?: Overrides & { rpcURL?: string }
   ): Promise<boolean> {
     if (this.proxyContract == null || this.multicall == null) {
       throw Error("no proxy contract initialized. Use createProxyInstance().");
@@ -381,11 +381,11 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     if (overrides) {
       ({ rpcURL, ...overrides } = overrides);
     }
-    const provider = new StaticJsonRpcProvider(rpcURL ?? this.nodeURL);
+    const provider = new JsonRpcProvider(rpcURL ?? this.nodeURL, this.network, { staticNetwork: true });
 
     const fS2S3 = indexPrices.map((x) => floatToABK64x64(x == undefined || Number.isNaN(x) ? 0 : x)) as [
-      BigNumber,
-      BigNumber
+      bigint,
+      bigint
     ];
     const perpId = this.getPerpIdFromSymbol(order.symbol);
     const fAmount = floatToABK64x64(order.quantity * (order.side == BUY_SIDE ? 1 : -1));
@@ -394,25 +394,25 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     const proxyCalls: Multicall3.Call3Struct[] = [
       // 0: trade amount price
       {
-        target: this.proxyContract.address,
+        target: this.proxyContract.target,
         allowFailure: true,
         callData: this.proxyContract.interface.encodeFunctionData("queryPerpetualPrice", [perpId, fAmount, fS2S3]),
       },
       // 1: amm state to get the mark price
       {
-        target: this.proxyContract.address,
+        target: this.proxyContract.target,
         allowFailure: true,
         callData: this.proxyContract.interface.encodeFunctionData("getAMMState", [perpId, fS2S3]),
       },
       // 2: order status to see if it's still open
       {
-        target: orderBook.address,
+        target: orderBook.target,
         allowFailure: true,
         callData: orderBook.interface.encodeFunctionData("getOrderStatus", [orderId]),
       },
       // 3: block timestamp
       {
-        target: this.multicall.address,
+        target: this.multicall.target,
         allowFailure: false,
         callData: this.multicall.interface.encodeFunctionData("getCurrentBlockTimestamp"),
       },
@@ -420,23 +420,23 @@ export default class OrderExecutorTool extends WriteAccessHandler {
 
     const hasParent =
       order.parentChildOrderIds != undefined &&
-      order.parentChildOrderIds[0] == HashZero &&
-      order.parentChildOrderIds[1] != HashZero;
+      order.parentChildOrderIds[0] == ZeroHash &&
+      order.parentChildOrderIds[1] != ZeroHash;
 
     if (hasParent) {
       // 4: order has a parent, one more call needed:
       proxyCalls.push({
-        target: orderBook.address,
+        target: orderBook.target,
         allowFailure: true,
         callData: orderBook.interface.encodeFunctionData("getOrderStatus", [order.parentChildOrderIds![1]]),
       });
     }
     // multicall
     const multicall = Multicall3__factory.connect(this.config.multicall ?? MULTICALL_ADDRESS, provider);
-    const encodedResults = await multicall.callStatic.aggregate3(proxyCalls, overrides || {});
+    const encodedResults = await multicall.aggregate3.staticCall(proxyCalls, overrides || {});
 
     // order status
-    let iOrderStatus: number;
+    let iOrderStatus: BigNumberish;
     if (encodedResults[2].success) {
       iOrderStatus = orderBook.interface.decodeFunctionResult("getOrderStatus", encodedResults[2].returnData)[0];
     } else {
@@ -449,7 +449,7 @@ export default class OrderExecutorTool extends WriteAccessHandler {
 
     // parent status
     if (hasParent) {
-      let iParentOrderStatus: number;
+      let iParentOrderStatus: BigNumberish;
       if (encodedResults[4].success) {
         iParentOrderStatus = orderBook.interface.decodeFunctionResult(
           "getOrderStatus",
@@ -465,37 +465,35 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     }
 
     // mark price
-    let ammState: BigNumber[];
+    let ammState: bigint[];
     if (encodedResults[1].success) {
       ammState = this.proxyContract.interface.decodeFunctionResult(
         "getAMMState",
         encodedResults[1].returnData
-      )[0] as BigNumber[];
+      )[0] as bigint[];
     } else {
       ammState = await this.proxyContract.getAMMState(perpId, fS2S3);
     }
     const markPrice = indexPrices[0] * (1 + ABK64x64ToFloat(ammState[8]));
 
     // price
-    let fOrderPrice: BigNumber;
+    let fOrderPrice: bigint;
     if (encodedResults[0].success) {
       fOrderPrice = this.proxyContract.interface.decodeFunctionResult(
         "queryPerpetualPrice",
         encodedResults[0].returnData
-      )[0] as BigNumber;
+      )[0] as bigint;
     } else {
       fOrderPrice = await this.proxyContract.queryPerpetualPrice(perpId, fAmount, fS2S3);
     }
     const orderPrice = ABK64x64ToFloat(fOrderPrice);
 
     // block timestamp
-    const ts = (
-      this.multicall.interface.decodeFunctionResult(
-        "getCurrentBlockTimestamp",
-        encodedResults[3].returnData
-      )[0] as BigNumber
-    ).toNumber();
-    blockTimestamp = Math.max(ts + 1, blockTimestamp ?? 0);
+    const ts = this.multicall.interface.decodeFunctionResult(
+      "getCurrentBlockTimestamp",
+      encodedResults[3].returnData
+    )[0] as bigint;
+    blockTimestamp = Math.max(Number(ts) + 1, blockTimestamp ?? 0);
     return this._isTradeable(order, orderPrice, markPrice, blockTimestamp, this.symbolToPerpStaticInfo);
   }
 
@@ -529,7 +527,7 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     orderIds: string[],
     blockTimestamp?: number,
     indexPrices?: [number, number, boolean, boolean],
-    overrides?: CallOverrides & { rpcURL?: string }
+    overrides?: Overrides & { rpcURL?: string }
   ): Promise<boolean[]> {
     const MAX_ORDERS_CHECKED = 10;
     let totalOrders = orders.length;
@@ -564,7 +562,7 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     orderIds: string[],
     blockTimestamp?: number,
     indexPrices?: [number, number, boolean, boolean],
-    overrides?: CallOverrides & { rpcURL?: string }
+    overrides?: Overrides & { rpcURL?: string }
   ): Promise<boolean[]> {
     if (orders.length == 0) {
       return [];
@@ -587,11 +585,11 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     if (overrides) {
       ({ rpcURL, ...overrides } = overrides);
     }
-    const provider = new StaticJsonRpcProvider(rpcURL ?? this.nodeURL);
+    const provider = new JsonRpcProvider(rpcURL ?? this.nodeURL, this.network, { staticNetwork: true });
 
     const fS2S3 = [indexPrices[0], indexPrices[1]].map((x) =>
       floatToABK64x64(x == undefined || Number.isNaN(x) ? 0 : x)
-    ) as [BigNumber, BigNumber];
+    ) as [bigint, bigint];
     const perpId = this.getPerpIdFromSymbol(orders[0].symbol);
     const fAmounts = orders.map((order) => floatToABK64x64(order.quantity * (order.side == BUY_SIDE ? 1 : -1)));
     const orderBook = this.getOrderBookContract(orders[0].symbol).connect(provider);
@@ -601,13 +599,13 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     let proxyCalls: Multicall3.Call3Struct[] = [
       // 0: amm state to get the mark price
       {
-        target: this.proxyContract.address,
+        target: this.proxyContract.target,
         allowFailure: false,
         callData: this.proxyContract.interface.encodeFunctionData("getAMMState", [perpId, fS2S3]),
       },
       // 1: block timestamp
       {
-        target: this.multicall.address,
+        target: this.multicall.target,
         allowFailure: false,
         callData: this.multicall.interface.encodeFunctionData("getCurrentBlockTimestamp"),
       },
@@ -615,7 +613,7 @@ export default class OrderExecutorTool extends WriteAccessHandler {
 
     // status calls
     const statusCalls: Multicall3.Call3Struct[] = orderIds.map((orderId) => ({
-      target: orderBook.address,
+      target: orderBook.target,
       allowFailure: false,
       callData: orderBook.interface.encodeFunctionData("getOrderStatus", [orderId]),
     }));
@@ -623,7 +621,7 @@ export default class OrderExecutorTool extends WriteAccessHandler {
 
     // price calls
     const priceCalls: Multicall3.Call3Struct[] = fAmounts.map((fAmount) => ({
-      target: this.proxyContract!.address,
+      target: this.proxyContract!.target,
       allowFailure: false,
       callData: this.proxyContract!.interface.encodeFunctionData("queryPerpetualPrice", [perpId, fAmount, fS2S3]),
     }));
@@ -634,12 +632,12 @@ export default class OrderExecutorTool extends WriteAccessHandler {
       .filter(
         (order) =>
           order.parentChildOrderIds != undefined &&
-          order.parentChildOrderIds[0] == HashZero &&
-          order.parentChildOrderIds[1] != HashZero
+          order.parentChildOrderIds[0] == ZeroHash &&
+          order.parentChildOrderIds[1] != ZeroHash
       )
       .map((order) => {
         return {
-          target: orderBook.address,
+          target: orderBook.target,
           allowFailure: false,
           callData: orderBook.interface.encodeFunctionData("getOrderStatus", [order.parentChildOrderIds![1]]),
         };
@@ -647,23 +645,21 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     proxyCalls = proxyCalls.concat(parentStatusCalls);
 
     // --- multicall ---
-    const encodedResults = await multicall.callStatic.aggregate3(proxyCalls, overrides || {});
+    const encodedResults = await multicall.aggregate3.staticCall(proxyCalls, overrides || {});
 
     // mark price
     const ammState = this.proxyContract.interface.decodeFunctionResult(
       "getAMMState",
       encodedResults[0].returnData
-    )[0] as BigNumber[];
+    )[0] as bigint[];
     const markPrice = indexPrices[0] * (1 + ABK64x64ToFloat(ammState[8]));
 
     // block timestamp
-    const ts = (
-      this.multicall.interface.decodeFunctionResult(
-        "getCurrentBlockTimestamp",
-        encodedResults[1].returnData
-      )[0] as BigNumber
-    ).toNumber();
-    blockTimestamp = Math.max(ts, blockTimestamp ?? 0);
+    const ts = this.multicall.interface.decodeFunctionResult(
+      "getCurrentBlockTimestamp",
+      encodedResults[1].returnData
+    )[0] as bigint;
+    blockTimestamp = Math.max(Number(ts), blockTimestamp ?? 0);
 
     // order status
     const isOrderOpen = encodedResults.slice(2, 2 + orders.length).map((encodedResult) => {
@@ -674,10 +670,7 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     // order prices
     const orderPrices = encodedResults.slice(2 + orders.length, 2 + 2 * orders.length).map((encodedResult) => {
       const orderPrice = ABK64x64ToFloat(
-        this.proxyContract!.interface.decodeFunctionResult(
-          "queryPerpetualPrice",
-          encodedResult.returnData
-        )[0] as BigNumber
+        this.proxyContract!.interface.decodeFunctionResult("queryPerpetualPrice", encodedResult.returnData)[0] as bigint
       );
       return orderPrice;
     });
@@ -689,8 +682,8 @@ export default class OrderExecutorTool extends WriteAccessHandler {
       const order = orders[i];
       const hasParent =
         order.parentChildOrderIds != undefined &&
-        order.parentChildOrderIds[0] == HashZero &&
-        order.parentChildOrderIds[1] != HashZero;
+        order.parentChildOrderIds[0] == ZeroHash &&
+        order.parentChildOrderIds[1] != ZeroHash;
       if (hasParent) {
         const iParentStatus = orderBook.interface.decodeFunctionResult(
           "getOrderStatus",
@@ -790,6 +783,6 @@ export default class OrderExecutorTool extends WriteAccessHandler {
     if (this.signer == null) {
       throw Error("no wallet initialized. Use createProxyInstance().");
     }
-    return await this.signer.getTransactionCount(blockTag);
+    return await this.signer.getNonce(blockTag);
   }
 }