@d8x/perpetuals-sdk 1.3.7 → 2.0.1-alpha

package/src/perpetualEventHandler.ts

@@ -1,4 +1,3 @@
-import { BigNumber } from "@ethersproject/bignumber";
 import { ONE_64x64 } from "./constants";
 import { ABK64x64ToFloat, mul64x64 } from "./d8XMath";
 import MarketData from "./marketData";
@@ -194,9 +193,9 @@ export default class PerpetualEventHandler {
    */
   public onUpdateMarkPrice(
     perpetualId: number,
-    fMidPricePremium: BigNumber,
-    fMarkPricePremium: BigNumber,
-    fSpotIndexPrice: BigNumber
+    fMidPricePremium: bigint,
+    fMarkPricePremium: bigint,
+    fSpotIndexPrice: bigint
   ): void {
     let [newMidPrice, newMarkPrice, newIndexPrice] = PerpetualEventHandler.ConvertUpdateMarkPrice(
       fMidPricePremium,
@@ -218,7 +217,7 @@ export default class PerpetualEventHandler {
    * UpdateFundingRate(uint24 indexed perpetualId, int128 fFundingRate)
    * @param fFundingRate funding rate in ABDK format
    */
-  public onUpdateUpdateFundingRate(perpetualId: number, fFundingRate: BigNumber): void {
+  public onUpdateUpdateFundingRate(perpetualId: number, fFundingRate: bigint): void {
     let newRate = ABK64x64ToFloat(fFundingRate);
     let perpetual = this.getPerpetualData(perpetualId.toString());
     if (perpetual == undefined) {
@@ -332,11 +331,11 @@ export default class PerpetualEventHandler {
     perpetualId: number,
     trader: string,
     _positionId: string,
-    _fPositionBC: BigNumber,
-    _fCashCC: BigNumber,
-    _fLockedInValueQC: BigNumber,
-    _fFundingPaymentCC: BigNumber,
-    fOpenInterestBC: BigNumber
+    _fPositionBC: bigint,
+    _fCashCC: bigint,
+    _fLockedInValueQC: bigint,
+    _fFundingPaymentCC: bigint,
+    fOpenInterestBC: bigint
   ): Promise<void> {
     let perpetual = this.getPerpetualData(perpetualId.toString());
     if (perpetual == undefined) {
@@ -369,8 +368,8 @@ export default class PerpetualEventHandler {
     positionId: string,
     _order: SmartContractOrder,
     orderDigest: string,
-    newPositionSizeBC: BigNumber,
-    _price: BigNumber
+    newPositionSizeBC: bigint,
+    _price: bigint
   ): TradeEvent {
     // remove order digest from open orders
     let orderStructs = this.ordersInPerpetual.get(perpetualId);
@@ -440,12 +439,12 @@ export default class PerpetualEventHandler {
    * @returns mark price and spot index in float
    */
   private static ConvertUpdateMarkPrice(
-    fMidPricePremium: BigNumber,
-    fMarkPricePremium: BigNumber,
-    fSpotIndexPrice: BigNumber
+    fMidPricePremium: bigint,
+    fMarkPricePremium: bigint,
+    fSpotIndexPrice: bigint
   ): [number, number, number] {
-    let fMarkPrice = mul64x64(fSpotIndexPrice, ONE_64x64.add(fMarkPricePremium));
-    let fMidPrice = mul64x64(fSpotIndexPrice, ONE_64x64.add(fMidPricePremium));
+    let fMarkPrice = mul64x64(fSpotIndexPrice, ONE_64x64 + fMarkPricePremium);
+    let fMidPrice = mul64x64(fSpotIndexPrice, ONE_64x64 + fMidPricePremium);
     let midPrice = ABK64x64ToFloat(fMidPrice);
     let markPrice = ABK64x64ToFloat(fMarkPrice);
     let indexPrice = ABK64x64ToFloat(fSpotIndexPrice);

package/src/polyMktsPxFeed.ts

@@ -0,0 +1,71 @@
+import type { PriceFeedConfig } from "./nodeSDKTypes";
+
+interface PolyConfig {
+  sym: string;
+  idDec: string;
+  id: string;
+}
+
+/**
+ * PolyMktsPxFeed gets prices from the official polymarket api
+ * and applies the exp(px) transformation
+ *
+ */
+export default class PolyMktsPxFeed {
+  private ids: Map<string, PolyConfig>;
+
+  constructor(config: PriceFeedConfig) {
+    this.ids = new Map<string, PolyConfig>();
+    for (let k = 0; k < config.ids.length; k++) {
+      if (config.ids[k].type == "polymarket") {
+        const sym = config.ids[k].symbol;
+        const idDec = PolyMktsPxFeed.hexToDecimalString(config.ids[k].id);
+        const el: PolyConfig = {
+          sym: sym,
+          id: config.ids[k].id,
+          idDec: idDec,
+        };
+        this.ids.set(sym, el);
+      }
+    }
+  }
+
+  public isPolyMktsSym(sym: string) {
+    return this.ids.get(sym) == undefined;
+  }
+
+  public async fetchPriceForSym(sym: string): Promise<number> {
+    const mkt = this.ids.get(sym);
+    if (mkt == undefined) {
+      throw new Error(`symbol not in polymarket universe: ${sym}`);
+    }
+    return this.fetchPrice(mkt.idDec);
+  }
+
+  public async fetchPrice(tokenIdDec: string): Promise<number> {
+    const query = "https://clob.polymarket.com/midpoint?token_id=" + tokenIdDec;
+    let response = await fetch(query);
+    if (response.status !== 200) {
+      throw new Error(`unexpected status code: ${response.status}`);
+    }
+    if (!response.ok) {
+      throw new Error(`failed to fetch posts (${response.status}): ${response.statusText} ${query}`);
+    }
+    const data = await response.json();
+    const px = Number(data.mid);
+    return Math.exp(px);
+  }
+
+  static hexToDecimalString(hexString: string): string {
+    // Remove the "0x" prefix if it exists
+    if (hexString.startsWith("0x")) {
+      hexString = hexString.slice(2);
+    }
+
+    // Convert the hex string to a BigInt
+    const bigIntValue = BigInt("0x" + hexString);
+
+    // Convert the BigInt to a decimal string
+    return bigIntValue.toString(10);
+  }
+}

package/src/priceFeeds.ts

@@ -1,4 +1,3 @@
-import { BigNumber } from "@ethersproject/bignumber";
 import { Buffer } from "buffer";
 import { decNToFloat, floatToDec18 } from "./d8XMath";
 import type {
@@ -13,6 +12,8 @@ import PerpetualDataHandler from "./perpetualDataHandler";
 import Triangulator from "./triangulator";
 import OnChainPxFeed from "./onChainPxFeed";
 import OnChainPxFactory from "./onChainPxFactory";
+import PolyMktsPxFeed from "./polyMktsPxFeed";
+import { sleep } from "./utils";
 /**
  * This class communicates with the REST API that provides price-data that is
  * to be submitted to the smart contracts for certain functions such as
@@ -35,10 +36,12 @@ export default class PriceFeeds {
   // api formatting constants
   private PYTH = { endpoint: "/v2/updates/price/latest?encoding=base64&ids[]=", separator: "&ids[]=", suffix: "" };
 
+  private polyMktsPxFeed: PolyMktsPxFeed;
+
   constructor(dataHandler: PerpetualDataHandler, priceFeedConfigNetwork: string) {
     let configs = require("./config/priceFeedConfig.json") as PriceFeedConfig[];
     this.config = PriceFeeds._selectConfig(configs, priceFeedConfigNetwork);
-
+    this.polyMktsPxFeed = new PolyMktsPxFeed(this.config);
     // if SDK config contains custom price feed endpoints, these override the
     // public/default ones
     if (dataHandler.config.priceFeedEndpoints && dataHandler.config.priceFeedEndpoints.length > 0) {
@@ -52,7 +55,7 @@ export default class PriceFeeds {
     for (let k = 0; k < this.config.ids.length; k++) {
       if (this.config.ids[k].type == "onchain") {
         let sym = this.config.ids[k].symbol;
-        this.onChainPxFeeds[sym] = OnChainPxFactory.createFeed(sym);
+        this.onChainPxFeeds.set(sym, OnChainPxFactory.createFeed(sym)!);
       }
     }
     [this.feedInfo, this.feedEndpoints, this.writeFeedEndpoints] = PriceFeeds._constructFeedInfo(this.config, false);
@@ -245,6 +248,7 @@ export default class PriceFeeds {
       symbolsOfEndpoint.push([]);
     }
     let onChainSyms: string[] = [];
+    let polyMktSyms: string[] = [];
     for (let k = 0; k < this.config.ids.length; k++) {
       let currFeed = this.config.ids[k];
       if (symbols != undefined && !symbols.includes(currFeed.symbol)) {
@@ -254,6 +258,10 @@ export default class PriceFeeds {
         onChainSyms.push(currFeed.symbol);
         continue;
       }
+      if (currFeed.type == "polymarket") {
+        polyMktSyms.push(currFeed.symbol);
+        continue;
+      }
       const apiFormat = { pyth: this.PYTH, odin: this.PYTH }[currFeed.type];
       if (apiFormat === undefined) {
         throw new Error(`API format for ${currFeed} unknown.`);
@@ -271,6 +279,7 @@ export default class PriceFeeds {
       }
     }
     let onChainPromise = this.queryOnChainPxFeeds(onChainSyms);
+    let polyMktsPromise = this.queryPolyMktsPxFeeds(polyMktSyms);
     let resultPrices = new Map<string, [number, boolean]>();
     for (let k = 0; k < queries.length; k++) {
       if (queries[k] == undefined) {
@@ -279,7 +288,7 @@ export default class PriceFeeds {
       let [, pxInfo]: [string[], PriceFeedFormat[]] = await this.fetchPriceQuery(queries[k] + suffixes[k]);
       let tsSecNow = Math.round(Date.now() / 1000);
       for (let j = 0; j < pxInfo.length; j++) {
-        let price = decNToFloat(BigNumber.from(pxInfo[j].price), -pxInfo[j].expo);
+        let price = decNToFloat(BigInt(pxInfo[j].price), -pxInfo[j].expo);
         let isMarketClosed = tsSecNow - pxInfo[j].publish_time > this.THRESHOLD_MARKET_CLOSED_SEC;
         resultPrices.set(symbolsOfEndpoint[k][j], [price, isMarketClosed]);
       }
@@ -289,6 +298,14 @@ export default class PriceFeeds {
       let sym = onChainSyms[k];
       resultPrices.set(sym, [onChPxs[k], false]);
     }
+    let polyPxs = await polyMktsPromise;
+    for (let k = 0; k < polyPxs.length; k++) {
+      let sym = polyMktSyms[k];
+      if (polyPxs[k] == -1) {
+        continue;
+      }
+      resultPrices.set(sym, [polyPxs[k], false]);
+    }
     return resultPrices;
   }
 
@@ -296,12 +313,30 @@ export default class PriceFeeds {
     let prices: number[] = new Array<number>();
     for (let k = 0; k < symbols.length; k++) {
       let sym = symbols[k];
-      let price = await this.onChainPxFeeds[sym].getPrice();
+      const feed = this.onChainPxFeeds.get(sym);
+      let price = await feed!.getPrice();
       prices.push(price);
     }
     return prices;
   }
 
+  private async queryPolyMktsPxFeeds(symbols: string[]) {
+    let prices: number[] = new Array<number>();
+    for (let k = 0; k < symbols.length; k++) {
+      try {
+        let price = await this.polyMktsPxFeed.fetchPriceForSym(symbols[k]);
+        prices.push(price);
+      } catch (error) {
+        console.log("fetchPriceForSym failed for " + symbols[k]);
+        prices.push(-1);
+      }
+      if (k > 0) {
+        await sleep(0.25);
+      }
+    }
+    return prices;
+  }
+
   /**
    * Get all configured feed prices via "latest_price_feeds".
    * @returns map of feed-price symbol to price/isMarketClosed
@@ -328,16 +363,17 @@ export default class PriceFeeds {
         throw new Error(`priceFeeds: config for symbol ${symbol} insufficient`);
       }
       // we use the first endpoint for a given symbol even if there is another symbol with the same id
-      // and another
       let idx = info[0].endpointId;
       let feedId = feedIds[k];
       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);
+          let v = symbols.get(feedId);
+          v!.push(info[j].symbol);
+          symbols.set(feedId, v!);
         } else {
-          symbols[feedId] = [info[j].symbol];
+          symbols.set(feedId, [info[j].symbol]);
         }
       }
     }
@@ -376,7 +412,7 @@ export default class PriceFeeds {
     const tsSecNow = Math.round(Date.now() / 1000);
     for (let k = 0; k < feedIds.length; k++) {
       let pxInfo: PriceFeedFormat = data[k].prices[0];
-      let price = decNToFloat(BigNumber.from(pxInfo.price), -pxInfo.expo);
+      let price = decNToFloat(BigInt(pxInfo.price), -pxInfo.expo);
       prices.push(price);
       priceFeedUpdates.push(data[k].vaas[0]);
       let isMarketClosed = tsSecNow - pxInfo.publish_time > this.THRESHOLD_MARKET_CLOSED_SEC;
@@ -404,7 +440,7 @@ export default class PriceFeeds {
   public calculateTriangulatedPricesFromFeedInfo(symbols: string[], feeds: PriceFeedSubmission): [number[], boolean[]] {
     let priceMap = new Map<string, [number, boolean]>();
     for (let j = 0; j < feeds.prices.length; j++) {
-      const syms = feeds.symbols[feeds.ids[j]];
+      const syms = feeds.symbols.get(feeds.ids[j]);
       if (syms == undefined) {
         console.log("calculateTriangulatedPricesFromFeedInfo: could not find symbol for id ", feeds.ids[j]);
         continue;

package/src/referralCodeSigner.ts

@@ -1,8 +1,4 @@
-import { defaultAbiCoder } from "@ethersproject/abi";
-import { Signer } from "@ethersproject/abstract-signer";
-import { keccak256 } from "@ethersproject/keccak256";
-import { Provider, StaticJsonRpcProvider } from "@ethersproject/providers";
-import { Wallet, verifyMessage } from "@ethersproject/wallet";
+import { AbiCoder, JsonRpcProvider, keccak256, Provider, Signer, verifyMessage, Wallet } from "ethers";
 import type { APIReferPayload, APIReferralCodePayload, APIReferralCodeSelectionPayload } from "./nodeSDKTypes";
 
 /**
@@ -31,7 +27,7 @@ export default class ReferralCodeSigner {
     if (typeof signer == "string") {
       const wallet = this.createSignerInstance(signer);
       this.signingFun = (x: string | Uint8Array) => wallet.signMessage(x);
-    } else if (Signer.isSigner(signer)) {
+    } else if ("signMessage" in signer) {
       this.signingFun = (x: string | Uint8Array) => signer.signMessage(x);
     } else {
       this.signingFun = signer;
@@ -39,7 +35,7 @@ export default class ReferralCodeSigner {
   }
 
   public createSignerInstance(_privateKey: string): Signer {
-    this.provider = new StaticJsonRpcProvider(this.rpcURL);
+    this.provider = new JsonRpcProvider(this.rpcURL);
     const wallet = new Wallet(_privateKey);
     return wallet.connect(this.provider);
   }
@@ -120,7 +116,7 @@ export default class ReferralCodeSigner {
   }
 
   private static _referralNewToMessage(rc: APIReferPayload): string {
-    let abiCoder = defaultAbiCoder;
+    let abiCoder = new AbiCoder();
     const passOnPercTwoDigitsFormat = Math.round(rc.passOnPercTDF);
     let digest = keccak256(
       abiCoder.encode(
@@ -137,7 +133,7 @@ export default class ReferralCodeSigner {
    * @returns the hex-string to be signed
    */
   private static _referralCodeNewCodePayloadToMessage(rc: APIReferralCodePayload): string {
-    let abiCoder = defaultAbiCoder;
+    let abiCoder = new AbiCoder();
     const passOnPercTwoDigitsFormat = Math.round(rc.passOnPercTDF);
     let digest = keccak256(
       abiCoder.encode(
@@ -154,7 +150,7 @@ export default class ReferralCodeSigner {
    * @returns the hex-string to be signed
    */
   private static _codeSelectionPayloadToMessage(rc: APIReferralCodeSelectionPayload): string {
-    let abiCoder = defaultAbiCoder;
+    let abiCoder = new AbiCoder();
     let digest = keccak256(
       abiCoder.encode(["string", "address", "uint256"], [rc.code, rc.traderAddr, Math.round(rc.createdOn)])
     );

package/src/traderDigests.ts

@@ -1,8 +1,5 @@
-import { defaultAbiCoder } from "@ethersproject/abi";
-import { concat } from "@ethersproject/bytes";
-import { keccak256 } from "@ethersproject/keccak256";
-import { toUtf8Bytes } from "@ethersproject/strings";
 import { Buffer } from "buffer";
+import { AbiCoder, BigNumberish, concat, keccak256, toUtf8Bytes } from "ethers";
 import { type SmartContractOrder } from "./nodeSDKTypes";
 
 export default class TraderDigests {
@@ -30,11 +27,17 @@ export default class TraderDigests {
    * @returns digest
    * @ignore
    */
-  public createDigest(order: SmartContractOrder, chainId: number, isNewOrder: boolean, proxyAddress: string): string {
+  public createDigest(
+    order: SmartContractOrder,
+    chainId: BigNumberish,
+    isNewOrder: boolean,
+    proxyAddress: string
+  ): string {
     const NAME = "Perpetual Trade Manager";
     const DOMAIN_TYPEHASH = keccak256(
       Buffer.from("EIP712Domain(string name,uint256 chainId,address verifyingContract)")
     );
+    const defaultAbiCoder = new AbiCoder();
     let domainSeparator = keccak256(
       defaultAbiCoder.encode(
         ["bytes32", "bytes32", "uint256", "address"],

package/src/traderInterface.ts

@@ -1,11 +1,11 @@
-import { Signer } from "@ethersproject/abstract-signer";
-import type { CallOverrides, ContractTransaction, Overrides } from "@ethersproject/contracts";
-import { ZERO_ORDER_ID } from "./constants";
-import { ABK64x64ToFloat, floatToDec18, floatToDecN } from "./d8XMath";
+import { Contract, ContractTransactionResponse, Overrides, Signer } from "ethers";
+import { MASK_PREDICTIVE_MARKET, ZERO_ORDER_ID } from "./constants";
+import { ABK64x64ToFloat, floatToDec18, floatToDecN, priceToProb, probToPrice } from "./d8XMath";
 import MarketData from "./marketData";
 import type { ClientOrder, NodeSDKConfig, Order, SmartContractOrder } from "./nodeSDKTypes";
 import PerpetualDataHandler from "./perpetualDataHandler";
 import TraderDigests from "./traderDigests";
+import { containsFlag } from "./utils";
 /**
  * Interface that can be used by front-end that wraps all private functions
  * so that signatures can be handled in frontend via wallet
@@ -50,14 +50,19 @@ export default class TraderInterface extends MarketData {
     poolSymbolName: string,
     traderAddr: string,
     brokerAddr: string,
-    overrides?: CallOverrides
+    overrides?: Overrides
   ): Promise<number> {
     if (this.proxyContract == null) {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
     }
     let poolId = PerpetualDataHandler._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
-    let feeTbps = await this.proxyContract.queryExchangeFee(poolId, traderAddr, brokerAddr, overrides || {});
-    return feeTbps / 100_000;
+    let feeTbps = (await this.proxyContract.queryExchangeFee(
+      poolId,
+      traderAddr,
+      brokerAddr,
+      overrides || {}
+    )) as bigint;
+    return Number(feeTbps) / 100_000;
   }
 
   /**
@@ -82,7 +87,7 @@ export default class TraderInterface extends MarketData {
   public async getCurrentTraderVolume(
     poolSymbolName: string,
     traderAddr: string,
-    overrides?: CallOverrides
+    overrides?: Overrides
   ): Promise<number> {
     if (this.proxyContract == null) {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
@@ -117,7 +122,7 @@ export default class TraderInterface extends MarketData {
   public async cancelOrderDigest(
     symbol: string,
     orderId: string,
-    overrides?: CallOverrides
+    overrides?: Overrides
   ): Promise<{ digest: string; OBContractAddr: string }> {
     if (this.proxyContract == null) {
       throw Error("no proxy contract initialized. Use createProxyInstance().");
@@ -125,7 +130,7 @@ export default class TraderInterface extends MarketData {
     let orderBookContract = this.getOrderBookContract(symbol);
     let scOrder: SmartContractOrder = await orderBookContract.orderOfDigest(orderId, overrides || {});
     let digest = this.digestTool.createDigest(scOrder, this.chainId, false, this.proxyAddr);
-    return { digest: digest, OBContractAddr: orderBookContract.address };
+    return { digest: digest, OBContractAddr: orderBookContract.target.toString() };
   }
 
   /**
@@ -147,7 +152,7 @@ export default class TraderInterface extends MarketData {
    */
   public getOrderBookAddress(symbol: string): string {
     let orderBookContract = this.getOrderBookContract(symbol);
-    return orderBookContract.address;
+    return orderBookContract.target.toString();
   }
 
   /**
@@ -157,6 +162,19 @@ export default class TraderInterface extends MarketData {
    * @returns Smart contract type order struct
    */
   public createSmartContractOrder(order: Order, traderAddr: string): SmartContractOrder {
+    const sInfo = this.symbolToPerpStaticInfo.get(order.symbol);
+    if (!sInfo) {
+      throw new Error(`No perpetual static info found for symbol ${order.symbol}`);
+    }
+    if (containsFlag(BigInt(sInfo.perpFlags), MASK_PREDICTIVE_MARKET)) {
+      // convert prob to actual price
+      if (order.limitPrice !== undefined) {
+        order.limitPrice = probToPrice(order.limitPrice);
+      }
+      if (order.stopPrice !== undefined) {
+        order.stopPrice = probToPrice(order.stopPrice);
+      }
+    }
     let scOrder = TraderInterface.toSmartContractOrder(order, traderAddr, this.symbolToPerpStaticInfo);
     return scOrder;
   }
@@ -172,20 +190,24 @@ export default class TraderInterface extends MarketData {
     if (this.proxyContract == null) {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
     }
-    let digest = this.digestTool.createDigest(scOrder, this.chainId, true, this.proxyContract.address);
+    let digest = this.digestTool.createDigest(scOrder, this.chainId, true, this.proxyContract.target.toString());
     return digest;
   }
 
   /**
-   * Get the ABI of a method in the proxy contract
+   * Get the ABI of a method in the proxy contract. Throws if non-existent
    * @param method Name of the method
    * @returns ABI as a single string
    */
   public getProxyABI(method: string): string {
     if (this.proxyContract == null) {
-      throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+      throw new Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+    }
+    const res = PerpetualDataHandler._getABIFromContract(this.proxyContract, method);
+    if (!res) {
+      throw new Error(`no proxy method found with name ${method}`);
     }
-    return PerpetualDataHandler._getABIFromContract(this.proxyContract, method);
+    return res;
   }
 
   /**
@@ -199,7 +221,11 @@ export default class TraderInterface extends MarketData {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
     }
     let orderBookContract = this.getOrderBookContract(symbol);
-    return PerpetualDataHandler._getABIFromContract(orderBookContract, method);
+    const res = PerpetualDataHandler._getABIFromContract(orderBookContract, method);
+    if (!res) {
+      throw new Error(`no proxy method found with name ${method}`);
+    }
+    return res;
   }
 
   /**
@@ -254,16 +280,14 @@ export default class TraderInterface extends MarketData {
     poolSymbolName: string,
     amountCC: number,
     overrides?: Overrides
-  ): Promise<ContractTransaction> {
+  ): Promise<ContractTransactionResponse> {
     if (this.proxyContract == null) {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
     }
-    let poolId = PerpetualDataHandler._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
-    let decimals = this.getMarginTokenDecimalsFromSymbol(poolSymbolName);
-    let tx = await this.proxyContract
-      .connect(signer)
-      .addLiquidity(poolId, floatToDecN(amountCC, decimals!), overrides || { gasLimit: this.gasLimit });
-    return tx;
+    const poolId = PerpetualDataHandler._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
+    const decimals = this.getSettlementTokenDecimalsFromSymbol(poolSymbolName);
+    const proxy = new Contract(this.proxyAddr, this.proxyABI, signer);
+    return await proxy.addLiquidity(poolId, floatToDecN(amountCC, decimals!), overrides || { gasLimit: this.gasLimit });
   }
 
   /**
@@ -295,15 +319,17 @@ export default class TraderInterface extends MarketData {
     poolSymbolName: string,
     amountPoolShares: number,
     overrides?: Overrides
-  ): Promise<ContractTransaction> {
+  ): Promise<ContractTransactionResponse> {
     if (this.proxyContract == null) {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
     }
     let poolId = PerpetualDataHandler._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
-    let tx = await this.proxyContract
-      .connect(signer)
-      .withdrawLiquidity(poolId, floatToDec18(amountPoolShares), overrides || { gasLimit: this.gasLimit });
-    return tx;
+    const proxy = new Contract(this.proxyAddr, this.proxyABI, signer);
+    return await proxy.withdrawLiquidity(
+      poolId,
+      floatToDec18(amountPoolShares),
+      overrides || { gasLimit: this.gasLimit }
+    );
   }
 
   /**
@@ -332,14 +358,16 @@ export default class TraderInterface extends MarketData {
     signer: Signer,
     poolSymbolName: string,
     overrides?: Overrides
-  ): Promise<ContractTransaction> {
+  ): Promise<ContractTransactionResponse> {
     if (this.proxyContract == null) {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
     }
     let poolId = PerpetualDataHandler._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
-    let tx = await this.proxyContract
-      .connect(signer)
-      .executeLiquidityWithdrawal(poolId, await signer.getAddress(), overrides || { gasLimit: this.gasLimit });
-    return tx;
+    const proxy = new Contract(this.proxyAddr, this.proxyABI, signer);
+    return await proxy.executeLiquidityWithdrawal(
+      poolId,
+      await signer.getAddress(),
+      overrides || { gasLimit: this.gasLimit }
+    );
   }
 }

package/src/utils.ts

@@ -1,4 +1,3 @@
-import { BigNumber } from "@ethersproject/bignumber";
 import { Buffer } from "buffer";
 import { NodeSDKConfig } from "./nodeSDKTypes";
 
@@ -126,11 +125,11 @@ export function symbol4BToLongSymbol(s: string, mapping: Map<string, string>): s
   return longCCY.substring(1);
 }
 
-export function combineFlags(f1: BigNumber, f2: BigNumber): BigNumber {
-  return BigNumber.from((parseInt(f1.toString()) | parseInt(f2.toString())) >>> 0);
+export function combineFlags(f1: bigint, f2: bigint): bigint {
+  return BigInt((parseInt(f1.toString()) | parseInt(f2.toString())) >>> 0);
 }
 
-export function containsFlag(f1: BigNumber, f2: BigNumber): boolean {
+export function containsFlag(f1: bigint, f2: bigint): boolean {
   return (BigInt(f1.toString()) & BigInt(f2.toString())) > 0;
 }
 

package/src/version.ts

@@ -1 +1 @@
-export const D8X_SDK_VERSION = "1.3.7";
+export const D8X_SDK_VERSION = "2.0.1-alpha";