@d8x/perpetuals-sdk 1.3.7 → 2.0.1-alpha

package/dist/esm/perpetualDataHandler.js

@@ -1,12 +1,7 @@
-import { FormatTypes, Interface } from "@ethersproject/abi";
-import { Signer } from "@ethersproject/abstract-signer";
-import { BigNumber } from "@ethersproject/bignumber";
-import { AddressZero } from "@ethersproject/constants";
-import { Contract } from "@ethersproject/contracts";
-import { StaticJsonRpcProvider } from "@ethersproject/providers";
-import { BUY_SIDE, CLOSED_SIDE, COLLATERAL_CURRENCY_BASE, COLLATERAL_CURRENCY_QUOTE, CollaterlCCY, DEFAULT_CONFIG, ERC20_ABI, MASK_CLOSE_ONLY, MASK_KEEP_POS_LEVERAGE, MASK_LIMIT_ORDER, MASK_MARKET_ORDER, MASK_STOP_ORDER, MAX_64x64, MULTICALL_ADDRESS, ORDER_MAX_DURATION_SEC, ORDER_TYPE_LIMIT, ORDER_TYPE_MARKET, ORDER_TYPE_STOP_LIMIT, ORDER_TYPE_STOP_MARKET, PERP_STATE_STR, SELL_SIDE, SYMBOL_LIST, ZERO_ADDRESS, ZERO_ORDER_ID, } from "./constants";
-import { LimitOrderBookFactory__factory, LimitOrderBook__factory, Multicall3__factory, OracleFactory__factory, } from "./contracts";
-import { ABDK29ToFloat, ABK64x64ToFloat, calculateLiquidationPriceCollateralBase, calculateLiquidationPriceCollateralQuanto, calculateLiquidationPriceCollateralQuote, div64x64, floatToABK64x64, dec18ToFloat, } from "./d8XMath";
+import { Contract, JsonRpcProvider, Network, ZeroAddress, } from "ethers";
+import { BUY_SIDE, CLOSED_SIDE, COLLATERAL_CURRENCY_BASE, COLLATERAL_CURRENCY_QUOTE, CollaterlCCY, DEFAULT_CONFIG, MASK_CLOSE_ONLY, MASK_KEEP_POS_LEVERAGE, MASK_LIMIT_ORDER, MASK_MARKET_ORDER, MASK_PREDICTIVE_MARKET, MASK_STOP_ORDER, MAX_64x64, MULTICALL_ADDRESS, ORDER_MAX_DURATION_SEC, ORDER_TYPE_LIMIT, ORDER_TYPE_MARKET, ORDER_TYPE_STOP_LIMIT, ORDER_TYPE_STOP_MARKET, PERP_STATE_STR, SELL_SIDE, SYMBOL_LIST, ZERO_ADDRESS, ZERO_ORDER_ID, } from "./constants";
+import { ERC20__factory, LimitOrderBookFactory__factory, LimitOrderBook__factory, Multicall3__factory, OracleFactory__factory, } from "./contracts";
+import { ABDK29ToFloat, ABK64x64ToFloat, calculateLiquidationPriceCollateralBase, calculateLiquidationPriceCollateralQuanto, calculateLiquidationPriceCollateralQuote, div64x64, floatToABK64x64, dec18ToFloat, priceToProb, probToPrice, } from "./d8XMath";
 import PriceFeeds from "./priceFeeds";
 import { combineFlags, containsFlag, contractSymbolToSymbol, loadConfigAbis, symbol4BToLongSymbol, fromBytes4, to4Chars, } from "./utils";
 /**
@@ -35,7 +30,8 @@ export default class PerpetualDataHandler {
         this.symbolToTokenAddrMap = new Map();
         this.perpetualIdToSymbol = new Map();
         this.nestedPerpetualIDs = new Array();
-        this.chainId = config.chainId;
+        this.chainId = BigInt(config.chainId);
+        this.network = new Network(config.name || "", this.chainId);
         this.proxyAddr = config.proxyAddr;
         this.nodeURL = config.nodeURL;
         this.proxyABI = config.proxyABI;
@@ -50,11 +46,11 @@ export default class PerpetualDataHandler {
         // check network
         let network;
         try {
-            if (signerOrProvider instanceof Signer) {
+            if (signerOrProvider.provider) {
                 network = await signerOrProvider.provider.getNetwork();
             }
             else {
-                network = await signerOrProvider.getNetwork();
+                throw new Error("Signer has no provider"); // TODO: check
             }
         }
         catch (error) {
@@ -73,14 +69,22 @@ export default class PerpetualDataHandler {
      * @param symbol symbol of the form ETH-USD-MATIC
      * @returns order book contract for the perpetual
      */
-    getOrderBookContract(symbol, provider) {
+    getOrderBookContract(symbol, signerOrProvider) {
         let orderBookAddr = this.symbolToPerpStaticInfo.get(symbol)?.limitOrderBookAddr;
-        if (orderBookAddr == "" || orderBookAddr == undefined || this.signerOrProvider == null) {
+        if (orderBookAddr == "" || orderBookAddr == undefined) {
             throw Error(`no limit order book found for ${symbol} or no signer`);
         }
-        let lobContract = LimitOrderBook__factory.connect(orderBookAddr, provider ?? this.signerOrProvider);
+        let lobContract = LimitOrderBook__factory.connect(orderBookAddr, signerOrProvider ?? this.signerOrProvider);
         return lobContract;
     }
+    /**
+     * Returns the order-book contract for the symbol if found or fails
+     * @param symbol symbol of the form ETH-USD-MATIC
+     * @returns order book contract for the perpetual
+     */
+    getOrderBookAddress(symbol) {
+        return this.symbolToPerpStaticInfo.get(symbol)?.limitOrderBookAddr;
+    }
     /**
      * Get perpetuals for the given ids from onchain
      * @param ids perpetual ids
@@ -118,7 +122,7 @@ export default class PerpetualDataHandler {
         const tokenOverrides = require("./config/tokenOverrides.json");
         let poolInfo = await PerpetualDataHandler.getPoolStaticInfo(this.proxyContract, overrides);
         this.nestedPerpetualIDs = poolInfo.nestedPerpetualIDs;
-        const IERC20 = new Interface(ERC20_ABI);
+        const IERC20 = ERC20__factory.createInterface();
         const proxyCalls = poolInfo.poolMarginTokenAddr.map((tokenAddr) => ({
             target: tokenAddr,
             allowFailure: false,
@@ -135,7 +139,7 @@ export default class PerpetualDataHandler {
             callData: this.proxyContract.interface.encodeFunctionData("getOracleFactory"),
         });
         // multicall
-        const encodedResults = await this.multicall.callStatic.aggregate3(proxyCalls, overrides || {});
+        const encodedResults = await this.multicall.aggregate3.staticCall(proxyCalls, overrides || {});
         // decimals
         for (let j = 0; j < poolInfo.nestedPerpetualIDs.length; j++) {
             const decimals = IERC20.decodeFunctionResult("decimals", encodedResults[j].returnData)[0];
@@ -143,13 +147,13 @@ export default class PerpetualDataHandler {
                 poolId: j + 1,
                 poolMarginSymbol: "",
                 poolMarginTokenAddr: poolInfo.poolMarginTokenAddr[j],
-                poolMarginTokenDecimals: decimals,
+                poolMarginTokenDecimals: Number(decimals),
                 poolSettleSymbol: "",
                 poolSettleTokenAddr: poolInfo.poolMarginTokenAddr[j],
-                poolSettleTokenDecimals: decimals,
+                poolSettleTokenDecimals: Number(decimals),
                 shareTokenAddr: poolInfo.poolShareTokenAddr[j],
                 oracleFactoryAddr: poolInfo.oracleFactory,
-                isRunning: poolInfo.poolShareTokenAddr[j] != AddressZero,
+                isRunning: poolInfo.poolShareTokenAddr[j] != ZeroAddress,
                 MgnToSettleTriangulation: ["*", "1"], // correct later
             };
             this.poolStaticInfos.push(info);
@@ -245,14 +249,12 @@ export default class PerpetualDataHandler {
             currPoolId = poolId;
             // We only assume the flag to be correct
             // in the first perpetual of the pool
-            const flag = perpStaticInfos[j].perpFlags == undefined
-                ? BigNumber.from(0)
-                : BigNumber.from(perpStaticInfos[j].perpFlags.toString());
+            const flag = perpStaticInfos[j].perpFlags == undefined ? 0n : BigInt(perpStaticInfos[j].perpFlags.toString());
             // find settlement setting for this flag
             let s = undefined;
             for (let j = 0; j < this.settlementConfig.length; j++) {
-                const masked = flag.and(BigNumber.from(this.settlementConfig[j].perpFlags.toString()));
-                if (!masked.isZero()) {
+                const masked = flag & BigInt(this.settlementConfig[j].perpFlags.toString());
+                if (masked != 0n) {
                     s = this.settlementConfig[j];
                     break;
                 }
@@ -451,7 +453,7 @@ export default class PerpetualDataHandler {
         // query blockchain in chunks
         const infoArr = new Array();
         for (let k = 0; k < ids.length; k++) {
-            let perpInfos = await _proxyContract.getPerpetualStaticInfo(ids[k], overrides || {});
+            let perpInfos = (await _proxyContract.getPerpetualStaticInfo(ids[k], overrides || {}));
             for (let j = 0; j < perpInfos.length; j++) {
                 let base = contractSymbolToSymbol(perpInfos[j].S2BaseCCY, symbolList);
                 let quote = contractSymbolToSymbol(perpInfos[j].S2QuoteCCY, symbolList);
@@ -460,19 +462,19 @@ export default class PerpetualDataHandler {
                 let sym2 = base + "-" + quote;
                 let sym3 = base3 == "" ? "" : base3 + "-" + quote3;
                 let info = {
-                    id: perpInfos[j].id,
-                    poolId: Math.floor(perpInfos[j].id / 100000),
+                    id: Number(perpInfos[j].id),
+                    poolId: Math.floor(Number(perpInfos[j].id) / 100000),
                     limitOrderBookAddr: perpInfos[j].limitOrderBookAddr,
                     initialMarginRate: ABDK29ToFloat(perpInfos[j].fInitialMarginRate),
                     maintenanceMarginRate: ABDK29ToFloat(perpInfos[j].fMaintenanceMarginRate),
-                    collateralCurrencyType: perpInfos[j].collCurrencyType,
+                    collateralCurrencyType: Number(perpInfos[j].collCurrencyType),
                     S2Symbol: sym2,
                     S3Symbol: sym3,
                     lotSizeBC: ABK64x64ToFloat(perpInfos[j].fLotSizeBC),
                     referralRebate: ABK64x64ToFloat(perpInfos[j].fReferralRebateCC),
                     priceIds: perpInfos[j].priceIds,
                     isPyth: perpInfos[j].isPyth,
-                    perpFlags: perpInfos[j].perpFlags,
+                    perpFlags: BigInt(perpInfos[j].perpFlags.toString()),
                 };
                 infoArr.push(info);
             }
@@ -523,22 +525,22 @@ export default class PerpetualDataHandler {
                 isRunning: orig.isRunning,
                 iPerpetualCount: Number(orig.iPerpetualCount),
                 id: Number(orig.id),
-                fCeilPnLShare: ABK64x64ToFloat(BigNumber.from(orig.fCeilPnLShare)),
+                fCeilPnLShare: ABK64x64ToFloat(BigInt(orig.fCeilPnLShare)),
                 marginTokenDecimals: Number(orig.marginTokenDecimals),
                 iTargetPoolSizeUpdateTime: Number(orig.iTargetPoolSizeUpdateTime),
                 marginTokenAddress: orig.marginTokenAddress,
                 prevAnchor: Number(orig.prevAnchor),
-                fRedemptionRate: ABK64x64ToFloat(BigNumber.from(orig.fRedemptionRate)),
+                fRedemptionRate: ABK64x64ToFloat(BigInt(orig.fRedemptionRate)),
                 shareTokenAddress: orig.shareTokenAddress,
-                fPnLparticipantsCashCC: ABK64x64ToFloat(BigNumber.from(orig.fPnLparticipantsCashCC)),
-                fTargetAMMFundSize: ABK64x64ToFloat(BigNumber.from(orig.fTargetAMMFundSize)),
-                fDefaultFundCashCC: ABK64x64ToFloat(BigNumber.from(orig.fDefaultFundCashCC)),
-                fTargetDFSize: ABK64x64ToFloat(BigNumber.from(orig.fTargetDFSize)),
-                fBrokerCollateralLotSize: ABK64x64ToFloat(BigNumber.from(orig.fBrokerCollateralLotSize)),
-                prevTokenAmount: dec18ToFloat(BigNumber.from(orig.prevTokenAmount)),
-                nextTokenAmount: dec18ToFloat(BigNumber.from(orig.nextTokenAmount)),
-                totalSupplyShareToken: dec18ToFloat(BigNumber.from(orig.totalSupplyShareToken)),
-                fBrokerFundCashCC: ABK64x64ToFloat(BigNumber.from(orig.fBrokerFundCashCC)), // state: amount of cash in broker fund
+                fPnLparticipantsCashCC: ABK64x64ToFloat(BigInt(orig.fPnLparticipantsCashCC)),
+                fTargetAMMFundSize: ABK64x64ToFloat(BigInt(orig.fTargetAMMFundSize)),
+                fDefaultFundCashCC: ABK64x64ToFloat(BigInt(orig.fDefaultFundCashCC)),
+                fTargetDFSize: ABK64x64ToFloat(BigInt(orig.fTargetDFSize)),
+                fBrokerCollateralLotSize: ABK64x64ToFloat(BigInt(orig.fBrokerCollateralLotSize)),
+                prevTokenAmount: dec18ToFloat(BigInt(orig.prevTokenAmount)),
+                nextTokenAmount: dec18ToFloat(BigInt(orig.nextTokenAmount)),
+                totalSupplyShareToken: dec18ToFloat(BigInt(orig.totalSupplyShareToken)),
+                fBrokerFundCashCC: ABK64x64ToFloat(BigInt(orig.fBrokerFundCashCC)), // state: amount of cash in broker fund
             };
             p.push(v);
         }
@@ -553,6 +555,7 @@ export default class PerpetualDataHandler {
      * @returns array of PerpetualData converted into decimals
      */
     static async _getPerpetuals(ids, _proxyContract, _symbolList, overrides) {
+        // TODO: can't be type safe here because proxyContract's abi is not static across chains (zkevm is the exception)
         const rawPerps = await _proxyContract.getPerpetuals(ids, overrides || {});
         let p = new Array();
         for (let k = 0; k < rawPerps.length; k++) {
@@ -576,44 +579,41 @@ export default class PerpetualDataHandler {
                 fSigma3: ABDK29ToFloat(Number(orig.fSigma3)),
                 fRho23: ABDK29ToFloat(Number(orig.fRho23)),
                 liquidationPenaltyRateBps: Number(orig.liquidationPenaltyRateTbps) / 10,
-                currentMarkPremiumRatePrice: ABK64x64ToFloat(BigNumber.from(orig.currentMarkPremiumRate.fPrice)),
+                currentMarkPremiumRatePrice: ABK64x64ToFloat(BigInt(orig.currentMarkPremiumRate.fPrice)),
                 currentMarkPremiumRateTime: Number(orig.currentMarkPremiumRate.time),
-                premiumRatesEMA: ABK64x64ToFloat(BigNumber.from(orig.premiumRatesEMA)),
-                fUnitAccumulatedFunding: ABK64x64ToFloat(BigNumber.from(orig.fUnitAccumulatedFunding)),
-                fOpenInterest: ABK64x64ToFloat(BigNumber.from(orig.fOpenInterest)),
-                fTargetAMMFundSize: ABK64x64ToFloat(BigNumber.from(orig.fTargetAMMFundSize)),
-                fCurrentTraderExposureEMA: ABK64x64ToFloat(BigNumber.from(orig.fCurrentTraderExposureEMA)),
-                fCurrentFundingRate: ABK64x64ToFloat(BigNumber.from(orig.fCurrentFundingRate)),
-                fLotSizeBC: ABK64x64ToFloat(BigNumber.from(orig.fLotSizeBC)),
-                fReferralRebateCC: ABK64x64ToFloat(BigNumber.from(orig.fReferralRebateCC)),
-                fTargetDFSize: ABK64x64ToFloat(BigNumber.from(orig.fTargetDFSize)),
-                fkStar: ABK64x64ToFloat(BigNumber.from(orig.fkStar)),
-                fAMMTargetDD: ABK64x64ToFloat(BigNumber.from(orig.fAMMTargetDD)),
+                premiumRatesEMA: ABK64x64ToFloat(BigInt(orig.premiumRatesEMA)),
+                fUnitAccumulatedFunding: ABK64x64ToFloat(BigInt(orig.fUnitAccumulatedFunding)),
+                fOpenInterest: ABK64x64ToFloat(BigInt(orig.fOpenInterest)),
+                fTargetAMMFundSize: ABK64x64ToFloat(BigInt(orig.fTargetAMMFundSize)),
+                fCurrentTraderExposureEMA: ABK64x64ToFloat(BigInt(orig.fCurrentTraderExposureEMA)),
+                fCurrentFundingRate: ABK64x64ToFloat(BigInt(orig.fCurrentFundingRate)),
+                fLotSizeBC: ABK64x64ToFloat(BigInt(orig.fLotSizeBC)),
+                fReferralRebateCC: ABK64x64ToFloat(BigInt(orig.fReferralRebateCC)),
+                fTargetDFSize: ABK64x64ToFloat(BigInt(orig.fTargetDFSize)),
+                fkStar: ABK64x64ToFloat(BigInt(orig.fkStar)),
+                fAMMTargetDD: ABK64x64ToFloat(BigInt(orig.fAMMTargetDD)),
                 perpFlags: Number(orig.perpFlags?.toString()),
-                fMinimalTraderExposureEMA: ABK64x64ToFloat(BigNumber.from(orig.fMinimalTraderExposureEMA)),
-                fMinimalAMMExposureEMA: ABK64x64ToFloat(BigNumber.from(orig.fMinimalAMMExposureEMA)),
-                fSettlementS3PriceData: ABK64x64ToFloat(BigNumber.from(orig.fSettlementS3PriceData)),
-                fSettlementS2PriceData: ABK64x64ToFloat(BigNumber.from(orig.fSettlementS2PriceData)),
-                fTotalMarginBalance: ABK64x64ToFloat(BigNumber.from(orig.fTotalMarginBalance)),
+                fMinimalTraderExposureEMA: ABK64x64ToFloat(BigInt(orig.fMinimalTraderExposureEMA)),
+                fMinimalAMMExposureEMA: ABK64x64ToFloat(BigInt(orig.fMinimalAMMExposureEMA)),
+                fSettlementS3PriceData: ABK64x64ToFloat(BigInt(orig.fSettlementS3PriceData)),
+                fSettlementS2PriceData: ABK64x64ToFloat(BigInt(orig.fSettlementS2PriceData)),
+                fTotalMarginBalance: ABK64x64ToFloat(BigInt(orig.fTotalMarginBalance)),
                 fMarkPriceEMALambda: ABK64x64ToFloat(Number(orig.fMarkPriceEMALambda)),
                 fFundingRateClamp: ABK64x64ToFloat(Number(orig.fFundingRateClamp)),
                 fMaximalTradeSizeBumpUp: ABK64x64ToFloat(Number(orig.fMaximalTradeSizeBumpUp)),
                 iLastTargetPoolSizeTime: Number(orig.iLastTargetPoolSizeTime),
                 fStressReturnS3: [
-                    ABK64x64ToFloat(BigNumber.from(orig.fStressReturnS3[0])),
-                    ABK64x64ToFloat(BigNumber.from(orig.fStressReturnS3[1])),
-                ],
-                fDFLambda: [
-                    ABK64x64ToFloat(BigNumber.from(orig.fDFLambda[0])),
-                    ABK64x64ToFloat(BigNumber.from(orig.fDFLambda[1])),
+                    ABK64x64ToFloat(BigInt(orig.fStressReturnS3[0])),
+                    ABK64x64ToFloat(BigInt(orig.fStressReturnS3[1])),
                 ],
+                fDFLambda: [ABK64x64ToFloat(BigInt(orig.fDFLambda[0])), ABK64x64ToFloat(BigInt(orig.fDFLambda[1]))],
                 fCurrentAMMExposureEMA: [
-                    ABK64x64ToFloat(BigNumber.from(orig.fCurrentAMMExposureEMA[0])),
-                    ABK64x64ToFloat(BigNumber.from(orig.fCurrentAMMExposureEMA[1])),
+                    ABK64x64ToFloat(BigInt(orig.fCurrentAMMExposureEMA[0])),
+                    ABK64x64ToFloat(BigInt(orig.fCurrentAMMExposureEMA[1])),
                 ],
                 fStressReturnS2: [
-                    ABK64x64ToFloat(BigNumber.from(orig.fStressReturnS2[0])),
-                    ABK64x64ToFloat(BigNumber.from(orig.fStressReturnS2[1])),
+                    ABK64x64ToFloat(BigInt(orig.fStressReturnS2[0])),
+                    ABK64x64ToFloat(BigInt(orig.fStressReturnS2[1])),
                 ], // parameter: negative and positive stress returns for base-quote asset
             };
             p.push(v);
@@ -629,9 +629,11 @@ export default class PerpetualDataHandler {
         let poolMarginTokenAddr = [];
         let oracleFactory = "";
         while (lenReceived == len) {
-            let res = await _proxyContract.getPoolStaticInfo(idxFrom, idxFrom + len - 1, overrides || {});
+            const res = (await _proxyContract.getPoolStaticInfo(idxFrom, idxFrom + len - 1, overrides || {}));
             lenReceived = res.length;
-            nestedPerpetualIDs = nestedPerpetualIDs.concat(res[0]);
+            const nestedIds = res[0].map((ids) => ids.map((id) => Number(id)));
+            nestedPerpetualIDs = nestedPerpetualIDs.concat(nestedIds);
+            // TODO: this looks like a bug if num pools > 10 --- concat?
             poolShareTokenAddr = res[1];
             poolMarginTokenAddr = res[2];
             oracleFactory = res[3];
@@ -651,22 +653,22 @@ export default class PerpetualDataHandler {
         const idx_mark_price = 8;
         const idx_lvg = 7;
         const idx_s3 = 9;
-        let isEmpty = traderState[idx_notional].eq(0);
+        let isEmpty = traderState[idx_notional] == 0n;
         let cash = ABK64x64ToFloat(traderState[idx_cash]);
-        let S2Liq = 0, S3Liq = 0, tau = Infinity, pnl = 0, unpaidFundingCC = 0, fLockedIn = BigNumber.from(0), side = CLOSED_SIDE, entryPrice = 0;
+        let S2Liq = 0, S3Liq = 0, tau = Infinity, pnl = 0, unpaidFundingCC = 0, fLockedIn = BigInt(0), side = CLOSED_SIDE, entryPrice = 0;
         if (!isEmpty) {
             [S2Liq, S3Liq, tau, pnl, unpaidFundingCC] = PerpetualDataHandler._calculateLiquidationPrice(symbol, traderState, _pxS2S3[0], symbolToPerpStaticInfo);
             fLockedIn = traderState[idx_locked_in];
-            side = traderState[idx_notional].gt(0) ? BUY_SIDE : SELL_SIDE;
-            entryPrice = ABK64x64ToFloat(div64x64(fLockedIn, traderState[idx_notional]).abs());
+            side = traderState[idx_notional] > 0n ? BUY_SIDE : SELL_SIDE;
+            entryPrice = Math.abs(ABK64x64ToFloat(div64x64(fLockedIn, traderState[idx_notional])));
         }
         let mgn = {
             symbol: symbol,
-            positionNotionalBaseCCY: isEmpty ? 0 : ABK64x64ToFloat(traderState[idx_notional].abs()),
+            positionNotionalBaseCCY: isEmpty ? 0 : Math.abs(ABK64x64ToFloat(traderState[idx_notional])),
             side: isEmpty ? CLOSED_SIDE : side,
             entryPrice: isEmpty ? 0 : entryPrice,
             leverage: isEmpty ? 0 : ABK64x64ToFloat(traderState[idx_lvg]),
-            markPrice: ABK64x64ToFloat(traderState[idx_mark_price].abs()),
+            markPrice: Math.abs(ABK64x64ToFloat(traderState[idx_mark_price])),
             unrealizedPnlQuoteCCY: isEmpty ? 0 : pnl,
             unrealizedFundingCollateralCCY: isEmpty ? 0 : unpaidFundingCC,
             collateralCC: cash,
@@ -766,7 +768,7 @@ export default class PerpetualDataHandler {
         if (overrides) {
             ({ rpcURL, ...overrides } = overrides);
         }
-        const provider = new StaticJsonRpcProvider(rpcURL ?? this.nodeURL);
+        const provider = new JsonRpcProvider(rpcURL ?? this.nodeURL, this.network, {});
         const orderBookSC = this.getOrderBookContract(symbol).connect(provider);
         let numOrders = await orderBookSC.orderCount(overrides || {});
         return Number(numOrders);
@@ -802,17 +804,17 @@ export default class PerpetualDataHandler {
         if (overrides) {
             ({ rpcURL, ...overrides } = overrides);
         }
-        const provider = new StaticJsonRpcProvider(rpcURL ?? this.nodeURL);
+        const provider = new JsonRpcProvider(rpcURL ?? this.nodeURL, this.network, { staticNetwork: true });
         const orderBookSC = this.getOrderBookContract(symbol).connect(provider);
         const multicall = Multicall3__factory.connect(this.config.multicall ?? MULTICALL_ADDRESS, provider);
-        if (typeof startAfter === "undefined") {
+        if (startAfter == undefined) {
             startAfter = ZERO_ORDER_ID;
         }
         else if (typeof startAfter === "string") {
             startAfter = 0; // TODO: fix
         }
         // first get client orders (incl. dependency info)
-        let [orders, orderIds] = await orderBookSC.pollRange(startAfter, BigNumber.from(numElements), overrides || {});
+        let [orders, orderIds] = await orderBookSC.pollRange(startAfter, numElements, overrides || {});
         let userFriendlyOrders = new Array();
         let traderAddr = [];
         let orderIdsOut = [];
@@ -825,11 +827,11 @@ export default class PerpetualDataHandler {
         }
         // then get perp orders (incl. submitted ts info)
         const multicalls = orderIdsOut.map((id) => ({
-            target: orderBookSC.address,
+            target: orderBookSC.target,
             allowFailure: true,
             callData: orderBookSC.interface.encodeFunctionData("orderOfDigest", [id]),
         }));
-        const encodedResults = await multicall.callStatic.aggregate3(multicalls, overrides || {});
+        const encodedResults = await multicall.aggregate3.staticCall(multicalls, overrides || {});
         // order status
         encodedResults.map((res, k) => {
             if (res.success) {
@@ -857,7 +859,7 @@ export default class PerpetualDataHandler {
             throw new Error("traderAddr, symbol and pxS2S3 should all have the same length");
         }
         const proxyCalls = traderAddrs.map((_addr, i) => ({
-            target: _proxyContract.address,
+            target: _proxyContract.target,
             allowFailure: true,
             callData: _proxyContract.interface.encodeFunctionData("getTraderState", [
                 PerpetualDataHandler.symbolToPerpetualId(symbols[i], symbolToPerpStaticInfo),
@@ -865,7 +867,7 @@ export default class PerpetualDataHandler {
                 _pxS2S3s[i].map((x) => floatToABK64x64(x)),
             ]),
         }));
-        const encodedResults = await _multicall.callStatic.aggregate3(proxyCalls, overrides || {});
+        const encodedResults = await _multicall.aggregate3.staticCall(proxyCalls, overrides || {});
         const traderStates = encodedResults.map(({ success, returnData }, i) => {
             if (!success)
                 throw new Error(`Failed to get perp info for ${symbols[i]}`);
@@ -916,7 +918,7 @@ export default class PerpetualDataHandler {
         let markPrice = S2 * (1 + ABK64x64ToFloat(ammState[8]));
         let state = {
             id: perpId,
-            state: PERP_STATE_STR[ammState[13].toNumber()],
+            state: PERP_STATE_STR[Number(ammState[13])],
             baseCurrency: ccy[0],
             quoteCurrency: ccy[1],
             indexPrice: S2,
@@ -956,7 +958,7 @@ export default class PerpetualDataHandler {
         let position = ABK64x64ToFloat(traderState[idx_notional]);
         let cashCC = ABK64x64ToFloat(traderState[idx_availableCashCC]);
         let Sm = ABK64x64ToFloat(traderState[idx_mark_price]);
-        let unpaidFundingCC = ABK64x64ToFloat(traderState[idx_availableCashCC].sub(traderState[idx_cash]));
+        let unpaidFundingCC = ABK64x64ToFloat(traderState[idx_availableCashCC] - traderState[idx_cash]);
         let unpaidFunding = unpaidFundingCC;
         if (perpInfo.collateralCurrencyType == CollaterlCCY.BASE) {
             S2Liq = calculateLiquidationPriceCollateralBase(lockedInValueQC, position, cashCC, tau);
@@ -1020,39 +1022,45 @@ export default class PerpetualDataHandler {
     }
     static fromSmartContractOrder(order, symbolToPerpInfoMap) {
         // find symbol of perpetual id
-        let symbol = PerpetualDataHandler._getByValue(symbolToPerpInfoMap, order.iPerpetualId, "id");
+        const symbol = PerpetualDataHandler._getByValue(symbolToPerpInfoMap, Number(order.iPerpetualId), "id");
         if (symbol == undefined) {
-            throw Error(`Perpetual id ${order.iPerpetualId} not found. Check with marketData.exchangeInfo().`);
+            throw new Error(`Perpetual id ${order.iPerpetualId} not found. Check with marketData.exchangeInfo().`);
         }
-        let side = order.fAmount > BigNumber.from(0) ? BUY_SIDE : SELL_SIDE;
+        const side = BigInt(order.fAmount.toString()) > BigInt(0) ? BUY_SIDE : SELL_SIDE;
         let limitPrice, stopPrice;
-        let fLimitPrice = BigNumber.from(order.fLimitPrice);
-        if (fLimitPrice.eq(0)) {
+        const fLimitPrice = BigInt(order.fLimitPrice);
+        if (fLimitPrice == 0n) {
             limitPrice = side == BUY_SIDE ? undefined : 0;
         }
-        else if (fLimitPrice.eq(MAX_64x64)) {
+        else if (fLimitPrice == MAX_64x64) {
             limitPrice = side == BUY_SIDE ? Infinity : undefined;
         }
         else {
             limitPrice = ABK64x64ToFloat(fLimitPrice);
         }
-        let fStopPrice = BigNumber.from(order.fTriggerPrice);
-        if (fStopPrice.eq(0) || fStopPrice.eq(MAX_64x64)) {
+        const fStopPrice = BigInt(order.fTriggerPrice);
+        if (fStopPrice == 0n || fStopPrice == MAX_64x64) {
             stopPrice = undefined;
         }
         else {
             stopPrice = ABK64x64ToFloat(fStopPrice);
         }
+        // adjust prices for market type
+        const sInfo = symbolToPerpInfoMap.get(symbol);
+        if (PerpetualDataHandler.isPredictiveMarket(sInfo)) {
+            limitPrice = limitPrice !== undefined && limitPrice !== 0 ? priceToProb(limitPrice) : limitPrice;
+            stopPrice = stopPrice !== undefined && stopPrice !== 0 ? priceToProb(stopPrice) : stopPrice;
+        }
         let userOrder = {
             symbol: symbol,
             side: side,
-            type: PerpetualDataHandler._flagToOrderType(BigNumber.from(order.flags), BigNumber.from(order.fLimitPrice)),
-            quantity: Math.abs(ABK64x64ToFloat(BigNumber.from(order.fAmount))),
-            reduceOnly: containsFlag(BigNumber.from(order.flags), MASK_CLOSE_ONLY),
+            type: PerpetualDataHandler._flagToOrderType(BigInt(order.flags), BigInt(order.fLimitPrice)),
+            quantity: Math.abs(ABK64x64ToFloat(BigInt(order.fAmount))),
+            reduceOnly: containsFlag(BigInt(order.flags), MASK_CLOSE_ONLY),
             limitPrice: limitPrice,
-            keepPositionLvg: containsFlag(BigNumber.from(order.flags), MASK_KEEP_POS_LEVERAGE),
+            keepPositionLvg: containsFlag(BigInt(order.flags), MASK_KEEP_POS_LEVERAGE),
             brokerFeeTbps: order.brokerFeeTbps == 0 ? undefined : Number(order.brokerFeeTbps),
-            brokerAddr: order.brokerAddr == ZERO_ADDRESS ? undefined : order.brokerAddr,
+            brokerAddr: order.brokerAddr == ZERO_ADDRESS ? undefined : order.brokerAddr.toString(),
             brokerSignature: order.brokerSignature == "0x" ? undefined : order.brokerSignature,
             stopPrice: stopPrice,
             leverage: Number(order.leverageTDR) / 100,
@@ -1077,7 +1085,7 @@ export default class PerpetualDataHandler {
         PerpetualDataHandler.checkOrder(order, perpStaticInfo);
         // translate order
         let flags = PerpetualDataHandler._orderTypeToFlag(order);
-        let brokerSig = order.brokerSignature == undefined ? [] : order.brokerSignature;
+        let brokerSig = order.brokerSignature == undefined ? "0x" : order.brokerSignature;
         let perpetualId = PerpetualDataHandler.symbolToPerpetualId(order.symbol, perpStaticInfo);
         let fAmount;
         if (order.side == BUY_SIDE) {
@@ -1089,20 +1097,23 @@ export default class PerpetualDataHandler {
         else {
             throw Error(`invalid side in order spec, use ${BUY_SIDE} or ${SELL_SIDE}`);
         }
+        const isPred = PerpetualDataHandler.isPredictiveMarket(perpStaticInfo.get(order.symbol));
         let fLimitPrice;
         if (order.limitPrice == undefined) {
             // we need to set the limit price to infinity or zero for
             // the trade to go through
             // Also: stop orders always have limits set, so even  for this case
             // we set the limit to 0 or infinity
-            fLimitPrice = order.side == BUY_SIDE ? MAX_64x64 : BigNumber.from(0);
+            fLimitPrice = order.side == BUY_SIDE ? MAX_64x64 : BigInt(0);
         }
         else {
-            fLimitPrice = floatToABK64x64(order.limitPrice);
+            fLimitPrice = floatToABK64x64(isPred ? probToPrice(order.limitPrice) : order.limitPrice);
         }
-        let iDeadline = order.deadline == undefined ? Date.now() / 1000 + ORDER_MAX_DURATION_SEC : order.deadline;
-        let fTriggerPrice = order.stopPrice == undefined ? BigNumber.from(0) : floatToABK64x64(order.stopPrice);
-        let smOrder = {
+        const iDeadline = order.deadline == undefined ? Date.now() / 1000 + ORDER_MAX_DURATION_SEC : order.deadline;
+        const fTriggerPrice = order.stopPrice == undefined
+            ? BigInt(0)
+            : floatToABK64x64(isPred ? probToPrice(order.stopPrice) : order.stopPrice);
+        const smOrder = {
             flags: flags,
             iPerpetualId: perpetualId,
             brokerFeeTbps: order.brokerFeeTbps == undefined ? 0 : order.brokerFeeTbps,
@@ -1184,9 +1195,10 @@ export default class PerpetualDataHandler {
         return order;
     }
     static _flagToOrderType(orderFlags, orderLimitPrice) {
-        let flag = BigNumber.from(orderFlags);
+        // TODO: check
+        let flag = BigInt(orderFlags);
         let isLimit = containsFlag(flag, MASK_LIMIT_ORDER);
-        let hasLimit = !BigNumber.from(orderLimitPrice).eq(0) || !BigNumber.from(orderLimitPrice).eq(MAX_64x64);
+        let hasLimit = BigInt(orderLimitPrice) != 0n || BigInt(orderLimitPrice) != MAX_64x64;
         let isStop = containsFlag(flag, MASK_STOP_ORDER);
         if (isStop && hasLimit) {
             return ORDER_TYPE_STOP_LIMIT;
@@ -1374,13 +1386,13 @@ export default class PerpetualDataHandler {
         return ids;
     }
     /**
-     * Get the ABI of a function in a given contract
+     * Get the ABI of a function in a given contract. Undefined if it doesn't exist.
      * @param contract A contract instance, e.g. this.proxyContract
      * @param functionName Name of the function whose ABI we want
      * @returns Function ABI as a single JSON string
      */
     static _getABIFromContract(contract, functionName) {
-        return contract.interface.getFunction(functionName).format(FormatTypes.full);
+        return contract.interface.getFunction(functionName)?.format("full");
     }
     /**
      * Gets the pool index (starting at 0 in exchangeInfo, not ID!) corresponding to a given symbol.
@@ -1498,6 +1510,9 @@ export default class PerpetualDataHandler {
     static checkOrder(order, 
     // traderAccount: MarginAccount,
     perpStaticInfo) {
+        if (!perpStaticInfo.has(order.symbol)) {
+            throw new Error(`Perpetual not found for symbol ${order.symbol}`);
+        }
         // check side
         if (order.side != BUY_SIDE && order.side != SELL_SIDE) {
             throw Error(`order side must be ${BUY_SIDE} or ${SELL_SIDE}`);
@@ -1534,14 +1549,14 @@ export default class PerpetualDataHandler {
     static fromClientOrderToTypeSafeOrder(order) {
         return {
             iPerpetualId: +order.iPerpetualId.toString(),
-            fLimitPrice: BigInt(BigNumber.from(order.fLimitPrice).toString()),
+            fLimitPrice: order.fLimitPrice,
             leverageTDR: +order.leverageTDR.toString(),
             executionTimestamp: +order.executionTimestamp.toString(),
-            flags: BigInt(BigNumber.from(order.flags).toString()),
+            flags: BigInt(order.flags),
             iDeadline: +order.iDeadline.toString(),
             brokerAddr: order.brokerAddr,
-            fTriggerPrice: BigInt(BigNumber.from(order.fTriggerPrice).toString()),
-            fAmount: BigInt(BigNumber.from(order.fAmount).toString()),
+            fTriggerPrice: order.fTriggerPrice,
+            fAmount: order.fAmount,
             parentChildDigest1: order.parentChildDigest1,
             traderAddr: order.traderAddr,
             parentChildDigest2: order.parentChildDigest2,
@@ -1550,5 +1565,14 @@ export default class PerpetualDataHandler {
             callbackTarget: order.callbackTarget,
         };
     }
+    /**
+     * Determines whether a given perpetual represents a predictive market
+     * @param staticInfo Perpetual static info
+     * @returns True if this is a predictive market
+     */
+    static isPredictiveMarket(staticInfo) {
+        // return true; // for testing
+        return containsFlag(staticInfo.perpFlags, MASK_PREDICTIVE_MARKET);
+    }
 }
 //# sourceMappingURL=perpetualDataHandler.js.map