WriteAccessHandlerFunctions to create, submit and cancel orders on the exchange. This class requires a private key and executes smart-contract interactions that require gas-payments.
WriteAccessHandlerFunctions for white-label partners to determine fees, deposit lots, and sign-up traders. This class requires a private key and executes smart-contract interactions that require gas-payments.
WriteAccessHandlerFunctions to liquidate traders. This class requires a private key and executes smart-contract interactions that require gas-payments.
WriteAccessHandlerFunctions to provide liquidity. This class requires a private key and executes smart-contract interactions that require gas-payments.
PerpetualDataHandlerFunctions to access market data (e.g., information on open orders, information on products that can be traded). This class requires no private key and is blockchain read-only. No gas required for the queries here.
OnChainPxFeed: get a price from a chainlink-style oracle
OnChainPxFeedAngle: get STUSD-USDC exchange rate
OnChainPxFeedRedStone: get a price from a chainlink-style oracle
WriteAccessHandlerFunctions to execute existing conditional orders from the limit order book. This class requires a private key and executes smart-contract interactions that require gas-payments.
Parent class for MarketData and WriteAccessHandler that handles common data and chain operations.
This class handles events and stores relevant variables as member variables. The events change the state of the member variables: mktData : MarketData relevant market data with current state (e.g. index price) ordersInPerpetual: Map<number, OrderStruct> all open orders for the given trader positionInPerpetual: Map<number, MarginAccount> all open positions for the given trader
Get data:
Construct with a trader address and a marketData object
Initialize to gather all the relevant data.
Send event variables to event handler "on
PolyMktsPxFeed gets prices from the official polymarket api and applies the 1+px transformation
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 trader liquidations, trade executions, change of trader margin amount.
This is a 'standalone' class that deals with signatures required for referral codes:
Note that since the back-end is chain specific, the referral code is typically bound to one chain, unless the backend employs code transferrals
MarketDataInterface that can be used by front-end that wraps all private functions so that signatures can be handled in frontend via wallet
PerpetualDataHandlerThis is a parent class for the classes that require write access to the contracts. This class requires a private key and executes smart-contract interaction that require gas-payments.
Gets the price of one Angle stUSD in USDC from on-chain
LiquidityPoolData corresponding to the data in the smart contract
ObjectObjectObjectObjectnumber
* [~ABK64x64ToFloat(x)](#module_d8xMath..ABK64x64ToFloat) ⇒ number
* [~decNToFloat(x)](#module_d8xMath..decNToFloat) ⇒ number
* [~dec18ToFloat(x)](#module_d8xMath..dec18ToFloat) ⇒ number
* [~floatToABK64x64(x)](#module_d8xMath..floatToABK64x64) ⇒ bigint
* [~floatToDec18(x)](#module_d8xMath..floatToDec18) ⇒ BigNumber
* [~floatToDecN(x, decimals)](#module_d8xMath..floatToDecN) ⇒ BigNumber
* [~countDecimalsOf(x, precision)](#module_d8xMath..countDecimalsOf) ⇒
* [~roundToLotString(x, lot, precision)](#module_d8xMath..roundToLotString) ⇒
* [~mul64x64(x, y)](#module_d8xMath..mul64x64) ⇒ bigint
* [~div64x64(x, y)](#module_d8xMath..div64x64) ⇒ bigint
* [~calculateLiquidationPriceCollateralBase(LockedInValueQC, position, cash_cc, maintenance_margin_rate, S3)](#module_d8xMath..calculateLiquidationPriceCollateralBase) ⇒ number
* [~calculateLiquidationPriceCollateralQuantoConservative(LockedInValueQC, position, cash_cc, maintenance_margin_rate, S3, Sm)](#module_d8xMath..calculateLiquidationPriceCollateralQuantoConservative) ⇒ number
* [~calculateLiquidationPriceCollateralQuanto(LockedInValueQC, position, cash_cc, maintenance_margin_rate, S3, Sm)](#module_d8xMath..calculateLiquidationPriceCollateralQuanto) ⇒ number
* [~calculateLiquidationPriceCollateralQuote(LockedInValueQC, position, cash_cc, maintenance_margin_rate, S3)](#module_d8xMath..calculateLiquidationPriceCollateralQuote) ⇒ number
* [~getMarginRequiredForLeveragedTrade(targetLeverage, currentPosition, currentLockedInValue, tradeAmount, markPrice, indexPriceS2, indexPriceS3, tradePrice, feeRate)](#module_d8xMath..getMarginRequiredForLeveragedTrade) ⇒ number
* [~getNewPositionLeverage(tradeAmount, marginCollateral, currentPosition, currentLockedInValue, price, indexPriceS3, markPrice)](#module_d8xMath..getNewPositionLeverage) ⇒
* [~getDepositAmountForLvgTrade(pos0, b0, tradeAmnt, targetLvg, price, S3, S2Mark, cmin)](#module_d8xMath..getDepositAmountForLvgTrade) ⇒ number
* [~getDepositAmountForPredMktLvgTrade(pos0, b0, c0, tradeAmnt, targetLvg, prob, S3, markProb, imr)](#module_d8xMath..getDepositAmountForPredMktLvgTrade) ⇒ number
* [~newPos](#module_d8xMath..getDepositAmountForPredMktLvgTrade..newPos)
* [~priceToProb(px)](#module_d8xMath..priceToProb) ⇒
* [~probToPrice(prob)](#module_d8xMath..probToPrice) ⇒
* [~pmMarginThresh(pos, lockedInQC, s2, s3, m)](#module_d8xMath..pmMarginThresh) ⇒
* [~pmInitialMarginRate(posSign, s0, sm, cmin)](#module_d8xMath..pmInitialMarginRate) ⇒ number
* [~pmExchangeFee(prob, m, tradeAmt, tradeMgnRate)](#module_d8xMath..pmExchangeFee) ⇒
* [~pmMarginBalance(pos, s2, s3, ell, mc)](#module_d8xMath..pmMarginBalance) ⇒
* [~pmFindLiquidationPrice(pos, s3, ell, mc, baseMarginRate, sm)](#module_d8xMath..pmFindLiquidationPrice) ⇒ number
* [~excessMargin(tradeAmt, currentCashCC, currentPos, currentLockedInQC, limitPrice, Sm, S3)](#module_d8xMath..excessMargin) ⇒
* [~pmGetDepositAmtForLvgTrade(tradeAmt, targetLvg, price, S3, S2Mark)](#module_d8xMath..pmGetDepositAmtForLvgTrade) ⇒
* [~pmExcessCashAtLvg(tradeAmt, lvg, walletBalCC, currentCashCC, currentPosition, currentLockedInValue, slippage, S2, Sm, S3, totLong, totShort)](#module_d8xMath..pmExcessCashAtLvg) ⇒
* [~pmFindMaxPersonalTradeSizeAtLeverage(dir, lvg, walletBalCC, slippage, currentPosition, currentCashCC, currentLockedInValue, S2, Sm, S3, glblMaxTrade)](#module_d8xMath..pmFindMaxPersonalTradeSizeAtLeverage) ⇒
* [~pmMaxSignedOpenTradeSize(long, short, sm, isBuy, mr)](#module_d8xMath..pmMaxSignedOpenTradeSize)
### d8xMath~ABDK29ToFloat(x) ⇒ number
Convert ABK64x64/2^35 bigint-format to float. Divide by 2^64 to get a float, but it's already "divided" by 2^35, so there's only 2^29 left
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: number - x/2^64 in number-format (float)
| Param | Type | Description | | --- | --- | --- | | x |BigNumber \| number | number in ABDK-format/2^35
| ### d8xMath~ABK64x64ToFloat(x) ⇒number
Convert ABK64x64 bigint-format to float. Result = x/2^64 if big number, x/2^29 if number
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: number - x/2^64 in number-format (float)
| Param | Type | Description | | --- | --- | --- | | x |BigNumberish \| number | number in ABDK-format or 2^29
| ### d8xMath~decNToFloat(x) ⇒number
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: number - x as a float (number)
| Param | Type | Description | | --- | --- | --- | | x |BigNumberish | BigNumber in Dec-N format
| ### d8xMath~dec18ToFloat(x) ⇒number
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: number - x as a float (number)
| Param | Type | Description | | --- | --- | --- | | x |BigNumberish | BigNumber in Dec18 format
| ### d8xMath~floatToABK64x64(x) ⇒bigint
Converts x into ABDK64x64 format
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: bigint - x^64 in big number format
| Param | Type | Description | | --- | --- | --- | | x |number | number (float)
| ### d8xMath~floatToDec18(x) ⇒BigNumber
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: BigNumber - x as a BigNumber in Dec18 format
| Param | Type | Description | | --- | --- | --- | | x |number | number (float)
| ### d8xMath~floatToDecN(x, decimals) ⇒BigNumber
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: BigNumber - x as a BigNumber in Dec18 format
| Param | Type | Description | | --- | --- | --- | | x |number | number (float)
| | decimals |number | number of decimals
| ### d8xMath~countDecimalsOf(x, precision) ⇒9 are rounded up regardless of precision, e.g, 0.1899000 at precision 6 results in 3
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: number of decimals
| Param | Type | | --- | --- | | x |number |
| precision | number |
### d8xMath~roundToLotString(x, lot, precision) ⇒
Round a number to a given lot size and return a string formated to for this lot-size
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: formated number string
| Param | Type | Default | Description | | --- | --- | --- | --- | | x |number | | number to round
| | lot |number | | lot size (could be 'uneven' such as 0.019999999 instead of 0.02)
| | precision |number | 7 | optional lot size precision (e.g. if 0.01999 should be 0.02 then precision could be 5)
| ### d8xMath~mul64x64(x, y) ⇒bigint
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: bigint - x * y
| Param | Type | | --- | --- | | x |bigint |
| y | bigint |
### d8xMath~div64x64(x, y) ⇒ bigint
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: bigint - x / y
| Param | Type | | --- | --- | | x |bigint |
| y | bigint |
### d8xMath~calculateLiquidationPriceCollateralBase(LockedInValueQC, position, cash_cc, maintenance_margin_rate, S3) ⇒ number
Determine the liquidation price
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: number - Amount to be deposited to have the given leverage when trading into position pos
| Param | Type | Description | | --- | --- | --- | | LockedInValueQC |number | trader locked in value in quote currency
| | position |number | trader position in base currency
| | cash_cc |number | trader available margin cash in collateral currency
| | maintenance_margin_rate |number | maintenance margin ratio
| | S3 |number | collateral to quote conversion (=S2 if base-collateral, =1 if quuote collateral, = index S3 if quanto)
| ### d8xMath~calculateLiquidationPriceCollateralQuantoConservative(LockedInValueQC, position, cash_cc, maintenance_margin_rate, S3, Sm) ⇒number
Determine the liquidation price
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: number - Amount to be deposited to have the given leverage when trading into position pos
| Param | Type | Description | | --- | --- | --- | | LockedInValueQC |number | trader locked in value in quote currency
| | position |number | trader position in base currency
| | cash_cc |number | trader available margin cash in collateral currency
| | maintenance_margin_rate |number | maintenance margin ratio
| | S3 |number | collateral to quote conversion (=S2 if base-collateral, =1 if quuote collateral, = index S3 if quanto)
| | Sm |number | mark price
| ### d8xMath~calculateLiquidationPriceCollateralQuanto(LockedInValueQC, position, cash_cc, maintenance_margin_rate, S3, Sm) ⇒number
Determine the liquidation price for quanto -- assuming quanto currency value remains constant See calculateLiquidationPriceCollateralQuantoConservative for a more conservative version
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: number - Amount to be deposited to have the given leverage when trading into position pos
| Param | Type | Description | | --- | --- | --- | | LockedInValueQC |number | trader locked in value in quote currency
| | position |number | trader position in base currency
| | cash_cc |number | trader available margin cash in collateral currency
| | maintenance_margin_rate |number | maintenance margin ratio
| | S3 |number | collateral to quote conversion (=S2 if base-collateral, =1 if quuote collateral, = index S3 if quanto)
| | Sm |number | mark price
| ### d8xMath~calculateLiquidationPriceCollateralQuote(LockedInValueQC, position, cash_cc, maintenance_margin_rate, S3) ⇒number
Determine the liquidation price
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: number - Amount to be deposited to have the given leverage when trading into position pos
| Param | Type | Description | | --- | --- | --- | | LockedInValueQC |number | trader locked in value in quote currency
| | position |number | trader position in base currency
| | cash_cc |number | trader available margin cash in collateral currency
| | maintenance_margin_rate |number | maintenance margin ratio
| | S3 |number | collateral to quote conversion (=S2 if base-collateral, =1 if quuote collateral, = index S3 if quanto)
| ### d8xMath~getMarginRequiredForLeveragedTrade(targetLeverage, currentPosition, currentLockedInValue, tradeAmount, markPrice, indexPriceS2, indexPriceS3, tradePrice, feeRate) ⇒number
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: number - Total collateral amount needed for the new position to have he desired leverage.
| Param | Description | | --- | --- | | targetLeverage |Leverage of the resulting position. It must be positive unless the resulting position is closed.
| | currentPosition |Current position size, in base currency, signed.
| | currentLockedInValue |Current locked in value, average entry price times position size, in quote currency.
| | tradeAmount |Trade amount, in base currency, signed.
| | markPrice |Mark price, positive.
| | indexPriceS2 |Index price, positive.
| | indexPriceS3 |Collateral index price, positive.
| | tradePrice |Expected price to trade tradeAmount.
| | feeRate | | ### d8xMath~getNewPositionLeverage(tradeAmount, marginCollateral, currentPosition, currentLockedInValue, price, indexPriceS3, markPrice) ⇒Compute the leverage resulting from a trade
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: Leverage of the resulting position
| Param | Description | | --- | --- | | tradeAmount |Amount to trade, in base currency, signed
| | marginCollateral |Amount of cash in the margin account, in collateral currency
| | currentPosition |Position size before the trade
| | currentLockedInValue |Locked-in value before the trade
| | price |Price charged to trade tradeAmount
| | indexPriceS3 |Spot price of the collateral currency when the trade happens
| | markPrice |Mark price of the index when the trade happens
| ### d8xMath~getDepositAmountForLvgTrade(pos0, b0, tradeAmnt, targetLvg, price, S3, S2Mark, cmin) ⇒number
Determine amount to be deposited into margin account so that the given leverage is obtained when trading a position pos (trade amount = position) Does NOT include fees Smart contract equivalent: calcMarginForTargetLeverage(..., _ignorePosBalance = false & balance = b0)
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: number - Amount to be deposited to have the given leverage when trading into position pos before fees
| Param | Type | Description | | --- | --- | --- | | pos0 |number | current position
| | b0 |number | current balance
| | tradeAmnt |number | amount to trade
| | targetLvg |number | target leverage
| | price |number | price to trade amount 'tradeAmnt'
| | S3 |number | collateral to quote conversion (=S2 if base-collateral, =1 if quote collateral, = index S3 if quanto)
| | S2Mark |number | mark price
| | cmin |number | Absolute minimum margin per contract, only for pred markets
| ### d8xMath~getDepositAmountForPredMktLvgTrade(pos0, b0, c0, tradeAmnt, targetLvg, prob, S3, markProb, imr) ⇒number
Determine amount to be deposited into margin account so that the given leverage is obtained when opening a prediction market position Does NOT include fees, but accounts for a possible non-zero current position Smart contract equivalent: getDepositAmountForPredMktLvgPosition
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: number - Amount to be deposited to have the given leverage when trading into position pos before fees
| Param | Type | Description | | --- | --- | --- | | pos0 |number | current position
| | b0 |number | current balance
| | c0 |number | current available cash
| | tradeAmnt |number | amount to trade
| | targetLvg |number | target leverage
| | prob |number | prob to trade amount 'tradeAmnt'
| | S3 |number | collateral to quote conversion (=S2 if base-collateral, =1 if quote collateral, = index S3 if quanto)
| | markProb |number | mark prob
| | imr |number | minimum absolute margin per contract (fInitialMarginRate)
| #### getDepositAmountForPredMktLvgTrade~newPosSmart contract implementation: // find smallest x such that: // bal * s3 >= pos value / lvg // where: // pos value / lvg = |pos| * R(pm, sign(pos)) * margin rate // pos = pos0 + k // cash = cash0 + x // ell = ell0 + px * k // bal * s3 = cash * s3 + pos * sm - ell // = bal0 * s3 + x * s3 + k * (sm - px) // subject to: // x >= 0 // cash * s3 >= |pos| * min(cmin, prob(sign(pos))) // k * (sm - px) <= 0 a.s. // (positive pnl does not contribute, i.e. ignore px better than mark) // solution: // bal0 * s3 + x * s3 >= pos value / lvg + (k * (px - sm))+ = v * s3 // --> // x >= v + (cash0 - bal0)+ - cash0 = v - min(bal0, cash0) // = pos value / lvg/ s3 + (k * (px - sm))_+ / s3 - min (bal0, cash0) // = A + B - C // x >= |pos| * min(cmin, prob(sign(pos))) / s3 - cash0 // x >= 0 // init x = A = pos value / lvg / s3 int128 fNewPos = _fPosition0.add(_fTradeAmount); int128 v = ( fNewPos > 0 ? fNewPos.mul(_fMarkProb) : fNewPos.neg().mul(ONE_64x64.sub(_fMarkProb)) ).mul(_fMarginRate).div(_fS3); // + B = max(0,k * (px - sm)) / s3 { int128 fPnL = _fTradeAmount.mul(_fMarkProb.sub(_fTradeProb)); if (fPnL < 0) { v = v.sub(fPnL.div(_fS3)); // pnl < 0 -> increase v } } // - C = - min(bal0, cash0) = - Equity { int128 equity = _fCash0CC < _fBalance0 ? _fCash0CC : _fBalance0; v = v.sub(equity); // equity can be used / must be covered if negative } return v > 0 ? v : int128(0);
**Kind**: inner constant of [getDepositAmountForPredMktLvgTrade](#module_d8xMath..getDepositAmountForPredMktLvgTrade)
### d8xMath~priceToProb(px) ⇒
Convert a perpetual price to probability (predtictive markets)
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: Probability in [0,1]
| Param | Description | | --- | --- | | px |Perpetual price
| ### d8xMath~probToPrice(prob) ⇒Convert a probability to a predictive market price
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: Perpetual price
| Param | Description | | --- | --- | | prob |Probability in [0,1]
| ### d8xMath~pmMarginThresh(pos, lockedInQC, s2, s3, m) ⇒Maintenance margin requirement for prediction markets
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: required margin balance
| Param | Description | | --- | --- | | pos |signed position
| | lockedInQC |locked in value
| | s2 |mark price
| | s3 |collateral to quote conversion
| | m |base margin rate
| ### d8xMath~pmInitialMarginRate(posSign, s0, sm, cmin) ⇒number
Initial margin rate for prediction markets.
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: number - The margin rate to be applied: (Math.abs(pos) * p * tau) / s3
sign of position in base currency (can be signed position or -1, 1)
| | s0 |trade price
| | sm |mark-price (=1+p)
| | cmin |Absolute min margin saved as fInitialMarginRate
Exchange fee as a rate for prediction markets For opening trades only
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: dollar fee relative to tradeAmt
| Param | Description | | --- | --- | | prob |long probability
| | m |max maintenance margin rate (0.18)
| | tradeAmt |trade amount in base currency
| | tradeMgnRate |margin rate for this trade
| ### d8xMath~pmMarginBalance(pos, s2, s3, ell, mc) ⇒Margin balance for prediction markets
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: current margin balance
| Param | Description | | --- | --- | | pos |signed position
| | s2 |mark price
| | s3 |collateral to quote conversion
| | ell |locked in value
| | mc |margin cash in collateral currency
| ### d8xMath~pmFindLiquidationPrice(pos, s3, ell, mc, baseMarginRate, sm) ⇒number
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: number - Liquidation price as a probability in the range [0, 1]
| Param | Description | | --- | --- | | pos |Signed position size
| | s3 |Collateral to quote conversion at spot
| | ell |Locked-in value
| | mc |Margin collateral
| | baseMarginRate |Maintenance margin per contract (mu_m)
| | sm |Mark price at entry
| ### d8xMath~excessMargin(tradeAmt, currentCashCC, currentPos, currentLockedInQC, limitPrice, Sm, S3) ⇒Calculate the excess margin defined as excess := margin balance - trading fee - initial margin threshold for the given trade and position
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: excess margin as defined above
| Param | | --- | | tradeAmt | | currentCashCC | | currentPos | | currentLockedInQC | | limitPrice | | Sm | | S3 | ### d8xMath~pmGetDepositAmtForLvgTrade(tradeAmt, targetLvg, price, S3, S2Mark) ⇒Internal function to find the deposit amount required for a given trade amount and target leverage
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: deposit amount
| Param | | --- | | tradeAmt | | targetLvg | | price | | S3 | | S2Mark | ### d8xMath~pmExcessCashAtLvg(tradeAmt, lvg, walletBalCC, currentCashCC, currentPosition, currentLockedInValue, slippage, S2, Sm, S3, totLong, totShort) ⇒Internal function to calculate cash over initial margin rate after a trade of size tradeAmt in prediction markets
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: excess cash
| Param | | --- | | tradeAmt | | lvg | | walletBalCC | | currentCashCC | | currentPosition | | currentLockedInValue | | slippage | | S2 | | Sm | | S3 | | totLong | | totShort | ### d8xMath~pmFindMaxPersonalTradeSizeAtLeverage(dir, lvg, walletBalCC, slippage, currentPosition, currentCashCC, currentLockedInValue, S2, Sm, S3, glblMaxTrade) ⇒Find maximal affordable trade size (short dir=-1 or long dir=1) for prediction markets at provided leverage and incorporating the current position and wallet balance. Factors in lot size and global max short/long, factors in opening/closing position
**Kind**: inner method of [d8xMath](#module_d8xMath)
**Returns**: max signed trade size
| Param | Description | | --- | --- | | dir |direction of trade (-1 sell, 1 buy)
| | lvg |leverage of the trade
| | walletBalCC |wallet balance of the trader (collateral currency)
| | slippage |slippage percent used to estimate a traded price
| | currentPosition |position in base currency of the trader
| | currentCashCC |this is the cash available net of unpaid funding (often called available cash)
| | currentLockedInValue |average entry price * signed position size in base currency, in margin account
| | S2 |current index price of the form 1+p (regardless whether short or long)
| | Sm |current mark price (not just the mark price index but including the ema-premium from the contract)
| | S3 |current collateral to quote index price
| | glblMaxTrade |global max short or long order size that we retreive, e.g., from position risk (sign irrelevant) based on long: (ℓ+n) * (1-p) - m (1-p) s = F → n = (F+m(1-p)s)/(1-p)-ℓ short: (s+n)p - m p ℓ = F →n = (F+mp**ℓ*)/p-s
| ### d8xMath~pmMaxSignedOpenTradeSize(long, short, sm, isBuy, mr)See PerpetualTradeLogic::_getMaxSignedOpenPredMktTradeSize
**Kind**: inner method of [d8xMath](#module_d8xMath)
| Param | Description |
| --- | --- |
| long | Long open OI
| | short |Short open OI
| | sm |Mark price (>1)
| | isBuy |True if trade is long
| | mr |Margin threshold per contract for liquidation (mu_m)
| ## utils * [utils](#module_utils) * [~to4Chars(s)](#module_utils..to4Chars) ⇒string
* [~toBytes4(s)](#module_utils..toBytes4) ⇒ Buffer
* [~fromBytes4(b)](#module_utils..fromBytes4) ⇒ string
* [~fromBytes4HexString(s)](#module_utils..fromBytes4HexString) ⇒ string
* [~contractSymbolToSymbol(s, mapping)](#module_utils..contractSymbolToSymbol) ⇒ string
* [~symbolToContractSymbol(s, mapping)](#module_utils..symbolToContractSymbol) ⇒ Buffer
* [~symbol4BToLongSymbol(s, mapping)](#module_utils..symbol4BToLongSymbol) ⇒ string
### utils~to4Chars(s) ⇒ string
**Kind**: inner method of [utils](#module_utils)
**Returns**: string - String with 4 characters (or characters + null chars)
| Param | Type | Description | | --- | --- | --- | | s |string | String to shorten/extend to 4 characters
| ### utils~toBytes4(s) ⇒Buffer
Converts string into 4-character bytes4 uses to4Chars to first convert the string into 4 characters. Resulting buffer can be used with smart contract to identify tokens (BTC, USDC, MATIC etc.)
**Kind**: inner method of [utils](#module_utils)
**Returns**: Buffer - 4-character bytes4.
| Param | Type | Description | | --- | --- | --- | | s |string | String to encode into bytes4
| ### utils~fromBytes4(b) ⇒string
Decodes a buffer encoded with toBytes4 into a string. The string is the result of to4Chars of the originally encoded string stripped from null-chars
**Kind**: inner method of [utils](#module_utils)
**Returns**: string - String decoded into to4Chars-type string without null characters
| Param | Type | Description | | --- | --- | --- | | b |Buffer | Correctly encoded bytes4 buffer using toBytes4
| ### utils~fromBytes4HexString(s) ⇒string
Decodes the bytes4 encoded string received from the smart contract as a hex-number in string-format
**Kind**: inner method of [utils](#module_utils)
**Returns**: string - x of to4Chars(x) stripped from null-chars, where x was originally encoded and returned by the smart contract as bytes4
| Param | Type | Description | | --- | --- | --- | | s |string | string representing a hex-number ("0x...")
| ### utils~contractSymbolToSymbol(s, mapping) ⇒string
**Kind**: inner method of [utils](#module_utils)
**Returns**: string - User friendly currency symbol, e.g. "MATIC"
| Param | Type | Description | | --- | --- | --- | | s |string | String representing a hex-number ("0x...")
| | mapping |Object | List of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
| ### utils~symbolToContractSymbol(s, mapping) ⇒Buffer
**Kind**: inner method of [utils](#module_utils)
**Returns**: Buffer - Buffer that can be used with smart contract to identify tokens
| Param | Type | Description | | --- | --- | --- | | s |string | User friendly currency symbol, e.g. "MATIC"
| | mapping |Object | List of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
| ### utils~symbol4BToLongSymbol(s, mapping) ⇒string
Converts symbol or symbol combination into long format
**Kind**: inner method of [utils](#module_utils)
**Returns**: string - long format e.g. MATIC. if not found the element is ""
| Param | Type | Description | | --- | --- | --- | | s |string | symbol, e.g., USDC-MATC-USDC, MATC, USDC, ...
| | mapping |Object | list of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
| ## AccountTrade ⇐ [WriteAccessHandler](#WriteAccessHandler)
Functions to create, submit and cancel orders on the exchange. This class requires a private key and executes smart-contract interactions that require gas-payments.
**Kind**: global class **Extends**: [WriteAccessHandler](#WriteAccessHandler)
* [AccountTrade](#AccountTrade) ⇐ [WriteAccessHandler](#WriteAccessHandler)
* [new AccountTrade(config, signer)](#new_AccountTrade_new)
* [.cancelOrder(symbol, orderId)](#AccountTrade+cancelOrder) ⇒ ContractTransaction
* [.order(order)](#AccountTrade+order) ⇒ ContractTransaction
* [.queryExchangeFee(poolSymbolName, [brokerAddr])](#AccountTrade+queryExchangeFee) ⇒
* [.getCurrentTraderVolume(poolSymbolName)](#AccountTrade+getCurrentTraderVolume) ⇒ number
* [.getOrderIds(symbol)](#AccountTrade+getOrderIds) ⇒ Array.<string>
* [.addCollateral(symbol, amount)](#AccountTrade+addCollateral)
* [.removeCollateral(symbol, amount)](#AccountTrade+removeCollateral)
* [.createProxyInstance(provider)](#WriteAccessHandler+createProxyInstance)
* [.setAllowance(symbol, amount)](#WriteAccessHandler+setAllowance) ⇒
* [.getAddress()](#WriteAccessHandler+getAddress) ⇒ string
* [.swapForMockToken(symbol, amountToPay)](#WriteAccessHandler+swapForMockToken) ⇒
* [.fetchSymbolList()](#PerpetualDataHandler+fetchSymbolList)
* [.getOrderBookContract(symbol)](#PerpetualDataHandler+getOrderBookContract) ⇒
* [.getOrderBookAddress(symbol)](#PerpetualDataHandler+getOrderBookAddress) ⇒
* [.getPerpetuals(ids, overrides)](#PerpetualDataHandler+getPerpetuals) ⇒
* [.getLiquidityPools(fromIdx, toIdx, overrides)](#PerpetualDataHandler+getLiquidityPools) ⇒
* [._fillSymbolMaps()](#PerpetualDataHandler+_fillSymbolMaps)
* [.initSettlementToken(perpStaticInfos)](#PerpetualDataHandler+initSettlementToken)
* [.getSymbolFromPoolId(poolId)](#PerpetualDataHandler+getSymbolFromPoolId) ⇒ symbol
* [.getPoolIdFromSymbol(symbol)](#PerpetualDataHandler+getPoolIdFromSymbol) ⇒ number
* [.getPerpIdFromSymbol(symbol)](#PerpetualDataHandler+getPerpIdFromSymbol) ⇒ number
* [.getSymbolFromPerpId(perpId)](#PerpetualDataHandler+getSymbolFromPerpId) ⇒ string
* [.symbol4BToLongSymbol(sym)](#PerpetualDataHandler+symbol4BToLongSymbol) ⇒ string
* [.fetchPriceSubmissionInfoForPerpetual(symbol)](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual) ⇒
* [.getIndexSymbols(symbol)](#PerpetualDataHandler+getIndexSymbols) ⇒
* [.fetchLatestFeedPriceInfo(symbol)](#PerpetualDataHandler+fetchLatestFeedPriceInfo) ⇒
* [.fetchCollateralToSettlementConversion(symbol)](#PerpetualDataHandler+fetchCollateralToSettlementConversion)
* [.getPriceIds(symbol)](#PerpetualDataHandler+getPriceIds) ⇒
* [.getPerpetualSymbolsInPool(poolSymbol)](#PerpetualDataHandler+getPerpetualSymbolsInPool) ⇒
* [.getAllOpenOrders(symbol)](#PerpetualDataHandler+getAllOpenOrders) ⇒
* [.numberOfOpenOrders(symbol)](#PerpetualDataHandler+numberOfOpenOrders) ⇒ number
* [.pollLimitOrders(symbol, numElements, [startAfter])](#PerpetualDataHandler+pollLimitOrders) ⇒
* [.getPoolStaticInfoIndexFromSymbol(symbol)](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol) ⇒
* [.getMarginTokenFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenFromSymbol) ⇒
* [.getSettlementTokenFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenFromSymbol) ⇒
* [.getMarginTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol) ⇒
* [.getSettlementTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol) ⇒
* [.getABI(contract)](#PerpetualDataHandler+getABI) ⇒
* [.isPredictionMarket(symbol)](#PerpetualDataHandler+isPredictionMarket) ⇒
* [.isLowLiquidityMarket(symbol)](#PerpetualDataHandler+isLowLiquidityMarket) ⇒
* [.isTradFiMarket(symbol)](#PerpetualDataHandler+isTradFiMarket) ⇒
* [.getMarketDayTradingOpenCloseSec(symbol)](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec) ⇒
* [.getInitialMarginRate(symbol)](#PerpetualDataHandler+getInitialMarginRate) ⇒
* [.getMaintenanceMarginRate(symbol)](#PerpetualDataHandler+getMaintenanceMarginRate) ⇒
* [.getShortSymbol(symbol)](#PerpetualDataHandler+getShortSymbol) ⇒
* [.refreshSymbols()](#PerpetualDataHandler+refreshSymbols)
* [.getLocalPerpetualStates()](#PerpetualDataHandler+getLocalPerpetualStates) ⇒
* [.fetchOnChainPerpetualStates()](#PerpetualDataHandler+fetchOnChainPerpetualStates) ⇒
* [.checkHeartbeat()](#PerpetualDataHandler+checkHeartbeat) ⇒
### new AccountTrade(config, signer)
Constructor
| Param | Type | Description | | --- | --- | --- | | config |NodeSDKConfig | Configuration object, see PerpetualDataHandler. readSDKConfig.
| | signer |string \| Signer | Private key or ethers Signer of the account
| **Example** ```js import { AccountTrade, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(AccountTrade); // load configuration for Polygon zkEVM Tesnet const config = PerpetualDataHandler.readSDKConfig("cardona"); // AccountTrade (authentication required, PK is an environment variable with a private key) const pk: string =ContractTransaction
Cancels an existing order on the exchange.
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Returns**: ContractTransaction - Contract Transaction (containing events).
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| | orderId |string | ID of the order to be cancelled.
| **Example** ```js import { AccountTrade, PerpetualDataHandler, Order } from '@d8x/perpetuals-sdk'; async function main() { console.log(AccountTrade); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =ContractTransaction
Submits an order to the exchange.
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Returns**: ContractTransaction - Contract Transaction (containing events).
| Param | Type | Description | | --- | --- | --- | | order |Order | Order structure. As a minimum the structure needs to specify symbol, side, type and quantity.
| **Example** ```js import { AccountTrade, PerpetualDataHandler, Order } from '@d8x/perpetuals-sdk'; async function main() { console.log(AccountTrade); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Fee charged by the exchange for trading any perpetual on a given pool. It accounts for the current trader's fee tier (based on the trader's D8X balance and trading volume). If trading with a broker, it also accounts for the selected broker's fee tier. Note that this result only includes exchange fees, additional broker fees are not included.
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Returns**: Exchange fee, in decimals (i.e. 0.1% is 0.001).
| Param | Type | Description | | --- | --- | --- | | poolSymbolName |string | Pool symbol name (e.g. MATIC, USDC, etc).
| | [brokerAddr] |string | Optional address of a broker this trader may use to trade under.
| **Example** ```js import { AccountTrade, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(AccountTrade); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Exponentially weighted EMA of the total USD trading volume of all trades performed by this trader. The weights are chosen so that in average this coincides with the 30 day volume.
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Returns**: number - Current trading volume for this trader, in USD.
| Param | Type | Description | | --- | --- | --- | | poolSymbolName |string | Pool symbol name (e.g. MATIC, USDC, etc).
| **Example** ```js import { AccountTrade, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(AccountTrade); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Array.<string>
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Returns**: Array.<string> - Array of Ids for all the orders currently open by this trader.
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { AccountTrade, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(AccountTrade); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =AccountTrade](#AccountTrade)
| Param | Type | Description |
| --- | --- | --- |
| symbol | string | Symbol of the form ETH-USD-MATIC.
| | amount |number | How much collateral to add, in units of collateral currency, e.g. MATIC
| **Example** ```js import { AccountTrade, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =AccountTrade](#AccountTrade)
| Param | Type | Description |
| --- | --- | --- |
| symbol | string | Symbol of the form ETH-USD-MATIC.
| | amount |number | How much collateral to remove, in units of collateral currency, e.g. MATIC
| **Example** ```js import { AccountTrade, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Initialize the writeAccessHandler-Class with this function to create instance of D8X perpetual contract and gather information about perpetual currencies
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [createProxyInstance](#WriteAccessHandler+createProxyInstance)
| Param | Description |
| --- | --- |
| provider | optional provider
| ### accountTrade.setAllowance(symbol, amount) ⇒Set allowance for ar margin token (e.g., MATIC, ETH, USDC)
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [setAllowance](#WriteAccessHandler+setAllowance)
**Returns**: Contract Transaction
| Param | Description | | --- | --- | | symbol |token in 'long-form' such as MATIC, symbol also fine (ETH-USD-MATIC)
| | amount |optional, amount to approve if not 'infinity'
| ### accountTrade.getAddress() ⇒string
Address corresponding to the private key used to instantiate this class.
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getAddress](#WriteAccessHandler+getAddress)
**Returns**: string - Address of this wallet.
### accountTrade.swapForMockToken(symbol, amountToPay) ⇒Converts a given amount of chain native currency (test MATIC) into a mock token used for trading on testnet, with a rate of 1:100_000
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [swapForMockToken](#WriteAccessHandler+swapForMockToken)
**Returns**: Transaction object
| Param | Description | | --- | --- | | symbol |Pool margin token e.g. MATIC
| | amountToPay |Amount in chain currency, e.g. "0.1" for 0.1 MATIC
| ### accountTrade.fetchSymbolList()sets the symbollist if a remote config url is specified
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [fetchSymbolList](#PerpetualDataHandler+fetchSymbolList)
### accountTrade.getOrderBookContract(symbol) ⇒
Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getOrderBookContract](#PerpetualDataHandler+getOrderBookContract)
**Returns**: order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### accountTrade.getOrderBookAddress(symbol) ⇒Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getOrderBookAddress](#PerpetualDataHandler+getOrderBookAddress)
**Returns**: order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### accountTrade.getPerpetuals(ids, overrides) ⇒Get perpetuals for the given ids from onchain
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getPerpetuals](#PerpetualDataHandler+getPerpetuals)
**Returns**: array of PerpetualData converted into decimals
| Param | Description | | --- | --- | | ids |perpetual ids
| | overrides |optional
| ### accountTrade.getLiquidityPools(fromIdx, toIdx, overrides) ⇒Get liquidity pools data
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getLiquidityPools](#PerpetualDataHandler+getLiquidityPools)
**Returns**: array of LiquidityPoolData converted into decimals
| Param | Description | | --- | --- | | fromIdx |starting index (>=1)
| | toIdx |to index (inclusive)
| | overrides |optional
| ### accountTrade.\_fillSymbolMaps()Called when initializing. This function fills this.symbolToTokenAddrMap, and this.nestedPerpetualIDs and this.symbolToPerpStaticInfo
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [\_fillSymbolMaps](#PerpetualDataHandler+_fillSymbolMaps)
### accountTrade.initSettlementToken(perpStaticInfos)
Initializes settlement currency for all pools by completing this.poolStaticInfos with settlement currency info
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [initSettlementToken](#PerpetualDataHandler+initSettlementToken)
| Param | Description |
| --- | --- |
| perpStaticInfos | PerpetualStaticInfo array from contract call
| ### accountTrade.getSymbolFromPoolId(poolId) ⇒symbol
Get pool symbol given a pool Id.
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getSymbolFromPoolId](#PerpetualDataHandler+getSymbolFromPoolId)
**Returns**: symbol - Pool symbol, e.g. "USDC".
| Param | Type | Description | | --- | --- | --- | | poolId |number | Pool Id.
| ### accountTrade.getPoolIdFromSymbol(symbol) ⇒number
Get pool Id given a pool symbol. Pool IDs start at 1.
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getPoolIdFromSymbol](#PerpetualDataHandler+getPoolIdFromSymbol)
**Returns**: number - Pool Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Pool symbol.
| ### accountTrade.getPerpIdFromSymbol(symbol) ⇒number
Get perpetual Id given a perpetual symbol.
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getPerpIdFromSymbol](#PerpetualDataHandler+getPerpIdFromSymbol)
**Returns**: number - Perpetual Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Perpetual symbol, e.g. "BTC-USD-MATIC".
| ### accountTrade.getSymbolFromPerpId(perpId) ⇒string
Get the symbol in long format of the perpetual id
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getSymbolFromPerpId](#PerpetualDataHandler+getSymbolFromPerpId)
**Returns**: string - Symbol
| Param | Type | Description | | --- | --- | --- | | perpId |number | perpetual id
| ### accountTrade.symbol4BToLongSymbol(sym) ⇒string
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [symbol4BToLongSymbol](#PerpetualDataHandler+symbol4BToLongSymbol)
**Returns**: string - Long symbol
| Param | Type | Description | | --- | --- | --- | | sym |string | Short symbol
| ### accountTrade.fetchPriceSubmissionInfoForPerpetual(symbol) ⇒Get PriceFeedSubmission data required for blockchain queries that involve price data, and the corresponding triangulated prices for the indices S2 and S3
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [fetchPriceSubmissionInfoForPerpetual](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual)
**Returns**: PriceFeedSubmission and prices for S2 and S3. [S2price, 0] if S3 not defined.
| Param | Description | | --- | --- | | symbol |pool symbol of the form "ETH-USD-MATIC"
| ### accountTrade.getIndexSymbols(symbol) ⇒Get the symbols required as indices for the given perpetual
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getIndexSymbols](#PerpetualDataHandler+getIndexSymbols)
**Returns**: name of underlying index prices, e.g. ["MATIC-USD", ""]
| Param | Description | | --- | --- | | symbol |of the form ETH-USD-MATIC, specifying the perpetual
| ### accountTrade.fetchLatestFeedPriceInfo(symbol) ⇒Get the latest prices for a given perpetual from the offchain oracle networks
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [fetchLatestFeedPriceInfo](#PerpetualDataHandler+fetchLatestFeedPriceInfo)
**Returns**: array of price feed updates that can be submitted to the smart contract and corresponding price information
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form BTC-USD-MATIC
| ### accountTrade.fetchCollateralToSettlementConversion(symbol)fetchCollateralToSettlementConversion returns the price which converts the collateral currency into settlement currency. For example if BTC-USD-STUSD has settlement currency USDC, we get let px = fetchCollateralToSettlementConversion("BTC-USD-STUSD") valueInUSDC = collateralInSTUSD * px
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [fetchCollateralToSettlementConversion](#PerpetualDataHandler+fetchCollateralToSettlementConversion)
| Param | Description |
| --- | --- |
| symbol | either perpetual symbol of the form BTC-USD-MATIC or just collateral token
| ### accountTrade.getPriceIds(symbol) ⇒Get list of required pyth price source IDs for given perpetual
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getPriceIds](#PerpetualDataHandler+getPriceIds)
**Returns**: list of required pyth price sources for this perpetual
| Param | Description | | --- | --- | | symbol |perpetual symbol, e.g., BTC-USD-MATIC
| ### accountTrade.getPerpetualSymbolsInPool(poolSymbol) ⇒Get ('normal'-state) perpetual symbols for a given pool
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getPerpetualSymbolsInPool](#PerpetualDataHandler+getPerpetualSymbolsInPool)
**Returns**: array of perpetual symbols in this pool
| Param | Description | | --- | --- | | poolSymbol |pool symbol such as "MATIC"
| ### accountTrade.getAllOpenOrders(symbol) ⇒All the orders in the order book for a given symbol that are currently open.
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getAllOpenOrders](#PerpetualDataHandler+getAllOpenOrders)
**Returns**: Array with all open orders and their IDs.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Total number of limit orders for this symbol, excluding those that have been cancelled/removed.
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [numberOfOpenOrders](#PerpetualDataHandler+numberOfOpenOrders)
**Returns**: number - Number of open orders.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Get a list of active conditional orders in the order book. This a read-only action and does not incur in gas costs.
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [pollLimitOrders](#PerpetualDataHandler+pollLimitOrders)
**Returns**: Array of orders and corresponding order IDs
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| | numElements |number | Maximum number of orders to poll.
| | [startAfter] |string | Optional order ID from where to start polling. Defaults to the first order.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Gets the pool index (starting at 0 in exchangeInfo, not ID!) corresponding to a given symbol.
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getPoolStaticInfoIndexFromSymbol](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol)
**Returns**: Pool index
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-MATIC
| ### accountTrade.getMarginTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getMarginTokenFromSymbol](#PerpetualDataHandler+getMarginTokenFromSymbol)
**Returns**: Address of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### accountTrade.getSettlementTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getSettlementTokenFromSymbol](#PerpetualDataHandler+getSettlementTokenFromSymbol)
**Returns**: Address of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### accountTrade.getMarginTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getMarginTokenDecimalsFromSymbol](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol)
**Returns**: Decimals of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### accountTrade.getSettlementTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getSettlementTokenDecimalsFromSymbol](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol)
**Returns**: Decimals of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### accountTrade.getABI(contract) ⇒Get ABI for LimitOrderBook, Proxy, or Share Pool Token
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getABI](#PerpetualDataHandler+getABI)
**Returns**: ABI for the requested contract
| Param | Description | | --- | --- | | contract |name of contract: proxy|lob|sharetoken
| ### accountTrade.isPredictionMarket(symbol) ⇒Determines whether a given perpetual represents a prediction market
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [isPredictionMarket](#PerpetualDataHandler+isPredictionMarket)
**Returns**: True if this is a prediction market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form TRUMP24-USD-USDC
| ### accountTrade.isLowLiquidityMarket(symbol) ⇒Determines whether a given perpetual represents a low-liquidity market
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [isLowLiquidityMarket](#PerpetualDataHandler+isLowLiquidityMarket)
**Returns**: True if this is a low-liquidity market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form DIRAC-HONEY-USDC
| ### accountTrade.isTradFiMarket(symbol) ⇒Determines whether a given perpetual represents a tradfi market
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [isTradFiMarket](#PerpetualDataHandler+isTradFiMarket)
**Returns**: True if this is a tradfi market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### accountTrade.getMarketDayTradingOpenCloseSec(symbol) ⇒Returns day trading times for tradfi markets
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getMarketDayTradingOpenCloseSec](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec)
**Returns**: open time in seconds within day, close time in seconds within day
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### accountTrade.getInitialMarginRate(symbol) ⇒getInitialMarginRate
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getInitialMarginRate](#PerpetualDataHandler+getInitialMarginRate)
**Returns**: initial margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### accountTrade.getMaintenanceMarginRate(symbol) ⇒getMaintenanceMarginRate
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getMaintenanceMarginRate](#PerpetualDataHandler+getMaintenanceMarginRate)
**Returns**: maintenance margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### accountTrade.getShortSymbol(symbol) ⇒Short symbol corresponding to a given long symbol.
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getShortSymbol](#PerpetualDataHandler+getShortSymbol)
**Returns**: Short symbol (e.g. NHL0)
| Param | Description | | --- | --- | | symbol |Long symbol (e.g. NHL_TOR_DAL_251015)
| ### accountTrade.refreshSymbols()Refreshes symbol mappings if at least one prediction market is expired
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [refreshSymbols](#PerpetualDataHandler+refreshSymbols)
### accountTrade.getLocalPerpetualStates() ⇒
Get state of perpetuals as currently known locally
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [getLocalPerpetualStates](#PerpetualDataHandler+getLocalPerpetualStates)
**Returns**: Array of [perpetual Id, perpetual state (string)]
### accountTrade.fetchOnChainPerpetualStates() ⇒Fetches on-chain state of local perpetual ids. Does not run if SDK is not ready.
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [fetchOnChainPerpetualStates](#PerpetualDataHandler+fetchOnChainPerpetualStates)
**Returns**: Array of [perpetual Id, perpetual state (string)]
### accountTrade.checkHeartbeat() ⇒Check that states of all perps known locally match on-chain states
**Kind**: instance method of [AccountTrade](#AccountTrade)
**Overrides**: [checkHeartbeat](#PerpetualDataHandler+checkHeartbeat)
**Returns**: True if all perp states are correct
## BrokerTool ⇐ [WriteAccessHandler](#WriteAccessHandler)
Functions for white-label partners to determine fees, deposit lots, and sign-up traders. This class requires a private key and executes smart-contract interactions that require gas-payments.
**Kind**: global class **Extends**: [WriteAccessHandler](#WriteAccessHandler)
* [BrokerTool](#BrokerTool) ⇐ [WriteAccessHandler](#WriteAccessHandler)
* [new BrokerTool(config, privateKey, signer)](#new_BrokerTool_new)
* [.getBrokerInducedFee(poolSymbolName)](#BrokerTool+getBrokerInducedFee) ⇒ number
* [.getFeeForBrokerDesignation(poolSymbolName, [lots])](#BrokerTool+getFeeForBrokerDesignation) ⇒ number
* [.getFeeForBrokerVolume(poolSymbolName)](#BrokerTool+getFeeForBrokerVolume) ⇒ number
* [.getFeeForBrokerStake([brokerAddr])](#BrokerTool+getFeeForBrokerStake) ⇒ number
* [.determineExchangeFee(order, traderAddr)](#BrokerTool+determineExchangeFee) ⇒ number
* [.getCurrentBrokerVolume(poolSymbolName)](#BrokerTool+getCurrentBrokerVolume) ⇒ number
* [.getLotSize(poolSymbolName)](#BrokerTool+getLotSize) ⇒ number
* [.getBrokerDesignation(poolSymbolName)](#BrokerTool+getBrokerDesignation) ⇒ number
* [.depositBrokerLots(poolSymbolName, lots)](#BrokerTool+depositBrokerLots) ⇒ ContractTransaction
* [.signOrder(order, traderAddr)](#BrokerTool+signOrder) ⇒ Order
* [.signSCOrder(scOrder, traderAddr)](#BrokerTool+signSCOrder) ⇒ string
* [.transferOwnership(poolSymbolName, newAddress)](#BrokerTool+transferOwnership) ⇒ ContractTransaction
* [.createProxyInstance(provider)](#WriteAccessHandler+createProxyInstance)
* [.setAllowance(symbol, amount)](#WriteAccessHandler+setAllowance) ⇒
* [.getAddress()](#WriteAccessHandler+getAddress) ⇒ string
* [.swapForMockToken(symbol, amountToPay)](#WriteAccessHandler+swapForMockToken) ⇒
* [.fetchSymbolList()](#PerpetualDataHandler+fetchSymbolList)
* [.getOrderBookContract(symbol)](#PerpetualDataHandler+getOrderBookContract) ⇒
* [.getOrderBookAddress(symbol)](#PerpetualDataHandler+getOrderBookAddress) ⇒
* [.getPerpetuals(ids, overrides)](#PerpetualDataHandler+getPerpetuals) ⇒
* [.getLiquidityPools(fromIdx, toIdx, overrides)](#PerpetualDataHandler+getLiquidityPools) ⇒
* [._fillSymbolMaps()](#PerpetualDataHandler+_fillSymbolMaps)
* [.initSettlementToken(perpStaticInfos)](#PerpetualDataHandler+initSettlementToken)
* [.getSymbolFromPoolId(poolId)](#PerpetualDataHandler+getSymbolFromPoolId) ⇒ symbol
* [.getPoolIdFromSymbol(symbol)](#PerpetualDataHandler+getPoolIdFromSymbol) ⇒ number
* [.getPerpIdFromSymbol(symbol)](#PerpetualDataHandler+getPerpIdFromSymbol) ⇒ number
* [.getSymbolFromPerpId(perpId)](#PerpetualDataHandler+getSymbolFromPerpId) ⇒ string
* [.symbol4BToLongSymbol(sym)](#PerpetualDataHandler+symbol4BToLongSymbol) ⇒ string
* [.fetchPriceSubmissionInfoForPerpetual(symbol)](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual) ⇒
* [.getIndexSymbols(symbol)](#PerpetualDataHandler+getIndexSymbols) ⇒
* [.fetchLatestFeedPriceInfo(symbol)](#PerpetualDataHandler+fetchLatestFeedPriceInfo) ⇒
* [.fetchCollateralToSettlementConversion(symbol)](#PerpetualDataHandler+fetchCollateralToSettlementConversion)
* [.getPriceIds(symbol)](#PerpetualDataHandler+getPriceIds) ⇒
* [.getPerpetualSymbolsInPool(poolSymbol)](#PerpetualDataHandler+getPerpetualSymbolsInPool) ⇒
* [.getAllOpenOrders(symbol)](#PerpetualDataHandler+getAllOpenOrders) ⇒
* [.numberOfOpenOrders(symbol)](#PerpetualDataHandler+numberOfOpenOrders) ⇒ number
* [.pollLimitOrders(symbol, numElements, [startAfter])](#PerpetualDataHandler+pollLimitOrders) ⇒
* [.getPoolStaticInfoIndexFromSymbol(symbol)](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol) ⇒
* [.getMarginTokenFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenFromSymbol) ⇒
* [.getSettlementTokenFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenFromSymbol) ⇒
* [.getMarginTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol) ⇒
* [.getSettlementTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol) ⇒
* [.getABI(contract)](#PerpetualDataHandler+getABI) ⇒
* [.isPredictionMarket(symbol)](#PerpetualDataHandler+isPredictionMarket) ⇒
* [.isLowLiquidityMarket(symbol)](#PerpetualDataHandler+isLowLiquidityMarket) ⇒
* [.isTradFiMarket(symbol)](#PerpetualDataHandler+isTradFiMarket) ⇒
* [.getMarketDayTradingOpenCloseSec(symbol)](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec) ⇒
* [.getInitialMarginRate(symbol)](#PerpetualDataHandler+getInitialMarginRate) ⇒
* [.getMaintenanceMarginRate(symbol)](#PerpetualDataHandler+getMaintenanceMarginRate) ⇒
* [.getShortSymbol(symbol)](#PerpetualDataHandler+getShortSymbol) ⇒
* [.refreshSymbols()](#PerpetualDataHandler+refreshSymbols)
* [.getLocalPerpetualStates()](#PerpetualDataHandler+getLocalPerpetualStates) ⇒
* [.fetchOnChainPerpetualStates()](#PerpetualDataHandler+fetchOnChainPerpetualStates) ⇒
* [.checkHeartbeat()](#PerpetualDataHandler+checkHeartbeat) ⇒
### new BrokerTool(config, privateKey, signer)
Constructor
| Param | Type | Description | | --- | --- | --- | | config |NodeSDKConfig | Configuration object, see PerpetualDataHandler. readSDKConfig.
| | privateKey |string | Private key of a white-label partner.
| | signer |Signer | Signer (ignored if a private key is provided)
| **Example** ```js import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(BrokerTool); // load configuration for Polygon zkEVM (testnet) const config = PerpetualDataHandler.readSDKConfig("cardona"); // BrokerTool (authentication required, PK is an environment variable with a private key) const pk: string =number
Determine the exchange fee based on lots, traded volume, and D8X balance of this white-label partner. This is the final exchange fee that this white-label partner can offer to traders that trade through him.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Returns**: number - Exchange fee for this white-label partner, in decimals (i.e. 0.1% is 0.001)
| Param | Type | Description | | --- | --- | --- | | poolSymbolName |string | Pool symbol name (e.g. MATIC, USDC, etc).
| **Example** ```js import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(BrokerTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Determine the exchange fee based on lots purchased by this white-label partner. The final exchange fee that this white-label partner can offer to traders that trade through him is equal to maximum(brokerTool.getFeeForBrokerDesignation(poolSymbolName), brokerTool.getFeeForBrokerVolume(poolSymbolName), brokerTool.getFeeForBrokerStake())
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Returns**: number - Fee based solely on this white-label partner's designation, in decimals (i.e. 0.1% is 0.001).
| Param | Type | Description | | --- | --- | --- | | poolSymbolName |string | Pool symbol name (e.g. MATIC, USDC, etc).
| | [lots] |number | Optional, designation to use if different from this white-label partner's.
| **Example** ```js import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(BrokerTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Determine the exchange fee based on volume traded under this white-label partner. The final exchange fee that this white-label partner can offer to traders that trade through him is equal to maximum(brokerTool.getFeeForBrokerDesignation(poolSymbolName), brokerTool.getFeeForBrokerVolume(poolSymbolName), brokerTool.getFeeForBrokerStake())
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Returns**: number - Fee based solely on a white-label partner's traded volume in the corresponding pool, in decimals (i.e. 0.1% is 0.001).
| Param | Type | Description | | --- | --- | --- | | poolSymbolName |string | Pool symbol name (e.g. MATIC, USDC, etc).
| **Example** ```js import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(BrokerTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Determine the exchange fee based on the current D8X balance in a white-label partner's wallet. The final exchange fee that this white-label partner can offer to traders that trade through him is equal to maximum(brokerTool.getFeeForBrokerDesignation(symbol, lots), brokerTool.getFeeForBrokerVolume(symbol), brokerTool.getFeeForBrokerStake)
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Returns**: number - Fee based solely on a white-label partner's D8X balance, in decimals (i.e. 0.1% is 0.001).
| Param | Type | Description | | --- | --- | --- | | [brokerAddr] |string | Address of the white-label partner in question, if different from the one calling this function.
| **Example** ```js import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(BrokerTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Determine exchange fee based on an order and a trader. This is the fee charged by the exchange only, excluding the white-label partner fee, For regular perpetuals, the result takes into account whether the order given here has been signed by a white-label partner or not. Use this, for instance, to verify that the fee to be charged for a given order is as expected, before and after signing it with brokerTool.signOrder. This fee is equal or lower than the white-label partner induced fee, provided the order is properly signed.
For prediction markets, the correct fee is to be applied as tradeamt * fee/s3.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Returns**: number - Fee in decimals (i.e. 0.1% is 0.001).
| Param | Type | Description | | --- | --- | --- | | order |Order | Order structure. As a minimum the structure needs to specify symbol, side, type and quantity.
| | traderAddr |string | Address of the trader for whom to determine the fee.
| **Example** ```js import { BrokerTool, PerpetualDataHandler, Order } from '@d8x/perpetuals-sdk'; async function main() { console.log(BrokerTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Exponentially weighted EMA of the total trading volume of all trades performed under this white-label partner. The weights are chosen so that in average this coincides with the 30 day volume.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Returns**: number - Current trading volume for this white-label partner, in USD.
| Param | Type | Description | | --- | --- | --- | | poolSymbolName |string | Pool symbol name (e.g. MATIC, USDC, etc).
| **Example** ```js import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(BrokerTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Total amount of collateral currency a white-label partner has to deposit into the default fund to purchase one lot. This is equivalent to the price of a lot expressed in a given pool's currency (e.g. MATIC, USDC, etc).
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Returns**: number - White-label partner lot size in a given pool's currency, e.g. in MATIC for poolSymbolName MATIC.
| Param | Type | Description | | --- | --- | --- | | poolSymbolName |string | Pool symbol name (e.g. MATIC, USDC, etc).
| **Example** ```js import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(BrokerTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Provides information on how many lots a white-label partner purchased for a given pool. This is relevant to determine the white-label partner's fee tier.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Returns**: number - Number of lots purchased by this white-label partner.
| Param | Type | Description | | --- | --- | --- | | poolSymbolName |string | Pool symbol name (e.g. MATIC, USDC, etc).
| **Example** ```js import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(BrokerTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =ContractTransaction
Deposit lots to the default fund of a given pool.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Returns**: ContractTransaction - ContractTransaction object.
| Param | Type | Description | | --- | --- | --- | | poolSymbolName |string | Pool symbol name (e.g. MATIC, USDC, etc).
| | lots |number | Number of lots to deposit into this pool.
| **Example** ```js import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(BrokerTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Order
Adds this white-label partner's signature to a user-friendly order. An order signed by a white-label partner is considered to be routed through this white-label partner and benefits from the white-label partner's fee conditions.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Returns**: Order - An order signed by this white-label partner, which can be submitted directly with AccountTrade.order.
| Param | Type | Description | | --- | --- | --- | | order |Order | Order to sign. It must contain valid white-label partner fee, white-label partner address, and order deadline.
| | traderAddr |string | Address of trader submitting the order.
| **Example** ```js import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(BrokerTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =string
Generates a white-label partner's signature of a smart-contract ready order. An order signed by a white-label partner is considered to be routed through this white-label partner and benefits from the white-label partner's fee conditions.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Returns**: string - Signature of order.
| Param | Type | Description | | --- | --- | --- | | scOrder | [SmartContractOrder](#SmartContractOrder) | Order to sign. It must contain valid white-label partner fee, white-label partner address, and order deadline.
| | traderAddr |string | Address of trader submitting the order.
| **Example** ```js import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(BrokerTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =ContractTransaction
Transfer ownership of a white-label partner's status to a new wallet. This function transfers the values related to (i) trading volume and (ii) deposited lots to newAddress. The white-label partner needs in addition to manually transfer his D8X holdings to newAddress. Until this transfer is completed, the white-label partner will not have his current designation reflected at newAddress.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Returns**: ContractTransaction - ethers transaction object
| Param | Type | Description | | --- | --- | --- | | poolSymbolName |string | Pool symbol name (e.g. MATIC, USDC, etc).
| | newAddress |string | The address this white-label partner wants to use from now on.
| **Example** ```js import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(BrokerTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Initialize the writeAccessHandler-Class with this function to create instance of D8X perpetual contract and gather information about perpetual currencies
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [createProxyInstance](#WriteAccessHandler+createProxyInstance)
| Param | Description |
| --- | --- |
| provider | optional provider
| ### brokerTool.setAllowance(symbol, amount) ⇒Set allowance for ar margin token (e.g., MATIC, ETH, USDC)
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [setAllowance](#WriteAccessHandler+setAllowance)
**Returns**: Contract Transaction
| Param | Description | | --- | --- | | symbol |token in 'long-form' such as MATIC, symbol also fine (ETH-USD-MATIC)
| | amount |optional, amount to approve if not 'infinity'
| ### brokerTool.getAddress() ⇒string
Address corresponding to the private key used to instantiate this class.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getAddress](#WriteAccessHandler+getAddress)
**Returns**: string - Address of this wallet.
### brokerTool.swapForMockToken(symbol, amountToPay) ⇒Converts a given amount of chain native currency (test MATIC) into a mock token used for trading on testnet, with a rate of 1:100_000
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [swapForMockToken](#WriteAccessHandler+swapForMockToken)
**Returns**: Transaction object
| Param | Description | | --- | --- | | symbol |Pool margin token e.g. MATIC
| | amountToPay |Amount in chain currency, e.g. "0.1" for 0.1 MATIC
| ### brokerTool.fetchSymbolList()sets the symbollist if a remote config url is specified
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [fetchSymbolList](#PerpetualDataHandler+fetchSymbolList)
### brokerTool.getOrderBookContract(symbol) ⇒
Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getOrderBookContract](#PerpetualDataHandler+getOrderBookContract)
**Returns**: order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### brokerTool.getOrderBookAddress(symbol) ⇒Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getOrderBookAddress](#PerpetualDataHandler+getOrderBookAddress)
**Returns**: order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### brokerTool.getPerpetuals(ids, overrides) ⇒Get perpetuals for the given ids from onchain
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getPerpetuals](#PerpetualDataHandler+getPerpetuals)
**Returns**: array of PerpetualData converted into decimals
| Param | Description | | --- | --- | | ids |perpetual ids
| | overrides |optional
| ### brokerTool.getLiquidityPools(fromIdx, toIdx, overrides) ⇒Get liquidity pools data
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getLiquidityPools](#PerpetualDataHandler+getLiquidityPools)
**Returns**: array of LiquidityPoolData converted into decimals
| Param | Description | | --- | --- | | fromIdx |starting index (>=1)
| | toIdx |to index (inclusive)
| | overrides |optional
| ### brokerTool.\_fillSymbolMaps()Called when initializing. This function fills this.symbolToTokenAddrMap, and this.nestedPerpetualIDs and this.symbolToPerpStaticInfo
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [\_fillSymbolMaps](#PerpetualDataHandler+_fillSymbolMaps)
### brokerTool.initSettlementToken(perpStaticInfos)
Initializes settlement currency for all pools by completing this.poolStaticInfos with settlement currency info
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [initSettlementToken](#PerpetualDataHandler+initSettlementToken)
| Param | Description |
| --- | --- |
| perpStaticInfos | PerpetualStaticInfo array from contract call
| ### brokerTool.getSymbolFromPoolId(poolId) ⇒symbol
Get pool symbol given a pool Id.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getSymbolFromPoolId](#PerpetualDataHandler+getSymbolFromPoolId)
**Returns**: symbol - Pool symbol, e.g. "USDC".
| Param | Type | Description | | --- | --- | --- | | poolId |number | Pool Id.
| ### brokerTool.getPoolIdFromSymbol(symbol) ⇒number
Get pool Id given a pool symbol. Pool IDs start at 1.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getPoolIdFromSymbol](#PerpetualDataHandler+getPoolIdFromSymbol)
**Returns**: number - Pool Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Pool symbol.
| ### brokerTool.getPerpIdFromSymbol(symbol) ⇒number
Get perpetual Id given a perpetual symbol.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getPerpIdFromSymbol](#PerpetualDataHandler+getPerpIdFromSymbol)
**Returns**: number - Perpetual Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Perpetual symbol, e.g. "BTC-USD-MATIC".
| ### brokerTool.getSymbolFromPerpId(perpId) ⇒string
Get the symbol in long format of the perpetual id
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getSymbolFromPerpId](#PerpetualDataHandler+getSymbolFromPerpId)
**Returns**: string - Symbol
| Param | Type | Description | | --- | --- | --- | | perpId |number | perpetual id
| ### brokerTool.symbol4BToLongSymbol(sym) ⇒string
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [symbol4BToLongSymbol](#PerpetualDataHandler+symbol4BToLongSymbol)
**Returns**: string - Long symbol
| Param | Type | Description | | --- | --- | --- | | sym |string | Short symbol
| ### brokerTool.fetchPriceSubmissionInfoForPerpetual(symbol) ⇒Get PriceFeedSubmission data required for blockchain queries that involve price data, and the corresponding triangulated prices for the indices S2 and S3
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [fetchPriceSubmissionInfoForPerpetual](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual)
**Returns**: PriceFeedSubmission and prices for S2 and S3. [S2price, 0] if S3 not defined.
| Param | Description | | --- | --- | | symbol |pool symbol of the form "ETH-USD-MATIC"
| ### brokerTool.getIndexSymbols(symbol) ⇒Get the symbols required as indices for the given perpetual
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getIndexSymbols](#PerpetualDataHandler+getIndexSymbols)
**Returns**: name of underlying index prices, e.g. ["MATIC-USD", ""]
| Param | Description | | --- | --- | | symbol |of the form ETH-USD-MATIC, specifying the perpetual
| ### brokerTool.fetchLatestFeedPriceInfo(symbol) ⇒Get the latest prices for a given perpetual from the offchain oracle networks
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [fetchLatestFeedPriceInfo](#PerpetualDataHandler+fetchLatestFeedPriceInfo)
**Returns**: array of price feed updates that can be submitted to the smart contract and corresponding price information
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form BTC-USD-MATIC
| ### brokerTool.fetchCollateralToSettlementConversion(symbol)fetchCollateralToSettlementConversion returns the price which converts the collateral currency into settlement currency. For example if BTC-USD-STUSD has settlement currency USDC, we get let px = fetchCollateralToSettlementConversion("BTC-USD-STUSD") valueInUSDC = collateralInSTUSD * px
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [fetchCollateralToSettlementConversion](#PerpetualDataHandler+fetchCollateralToSettlementConversion)
| Param | Description |
| --- | --- |
| symbol | either perpetual symbol of the form BTC-USD-MATIC or just collateral token
| ### brokerTool.getPriceIds(symbol) ⇒Get list of required pyth price source IDs for given perpetual
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getPriceIds](#PerpetualDataHandler+getPriceIds)
**Returns**: list of required pyth price sources for this perpetual
| Param | Description | | --- | --- | | symbol |perpetual symbol, e.g., BTC-USD-MATIC
| ### brokerTool.getPerpetualSymbolsInPool(poolSymbol) ⇒Get ('normal'-state) perpetual symbols for a given pool
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getPerpetualSymbolsInPool](#PerpetualDataHandler+getPerpetualSymbolsInPool)
**Returns**: array of perpetual symbols in this pool
| Param | Description | | --- | --- | | poolSymbol |pool symbol such as "MATIC"
| ### brokerTool.getAllOpenOrders(symbol) ⇒All the orders in the order book for a given symbol that are currently open.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getAllOpenOrders](#PerpetualDataHandler+getAllOpenOrders)
**Returns**: Array with all open orders and their IDs.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Total number of limit orders for this symbol, excluding those that have been cancelled/removed.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [numberOfOpenOrders](#PerpetualDataHandler+numberOfOpenOrders)
**Returns**: number - Number of open orders.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Get a list of active conditional orders in the order book. This a read-only action and does not incur in gas costs.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [pollLimitOrders](#PerpetualDataHandler+pollLimitOrders)
**Returns**: Array of orders and corresponding order IDs
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| | numElements |number | Maximum number of orders to poll.
| | [startAfter] |string | Optional order ID from where to start polling. Defaults to the first order.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Gets the pool index (starting at 0 in exchangeInfo, not ID!) corresponding to a given symbol.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getPoolStaticInfoIndexFromSymbol](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol)
**Returns**: Pool index
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-MATIC
| ### brokerTool.getMarginTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getMarginTokenFromSymbol](#PerpetualDataHandler+getMarginTokenFromSymbol)
**Returns**: Address of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### brokerTool.getSettlementTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getSettlementTokenFromSymbol](#PerpetualDataHandler+getSettlementTokenFromSymbol)
**Returns**: Address of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### brokerTool.getMarginTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getMarginTokenDecimalsFromSymbol](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol)
**Returns**: Decimals of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### brokerTool.getSettlementTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getSettlementTokenDecimalsFromSymbol](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol)
**Returns**: Decimals of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### brokerTool.getABI(contract) ⇒Get ABI for LimitOrderBook, Proxy, or Share Pool Token
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getABI](#PerpetualDataHandler+getABI)
**Returns**: ABI for the requested contract
| Param | Description | | --- | --- | | contract |name of contract: proxy|lob|sharetoken
| ### brokerTool.isPredictionMarket(symbol) ⇒Determines whether a given perpetual represents a prediction market
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [isPredictionMarket](#PerpetualDataHandler+isPredictionMarket)
**Returns**: True if this is a prediction market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form TRUMP24-USD-USDC
| ### brokerTool.isLowLiquidityMarket(symbol) ⇒Determines whether a given perpetual represents a low-liquidity market
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [isLowLiquidityMarket](#PerpetualDataHandler+isLowLiquidityMarket)
**Returns**: True if this is a low-liquidity market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form DIRAC-HONEY-USDC
| ### brokerTool.isTradFiMarket(symbol) ⇒Determines whether a given perpetual represents a tradfi market
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [isTradFiMarket](#PerpetualDataHandler+isTradFiMarket)
**Returns**: True if this is a tradfi market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### brokerTool.getMarketDayTradingOpenCloseSec(symbol) ⇒Returns day trading times for tradfi markets
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getMarketDayTradingOpenCloseSec](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec)
**Returns**: open time in seconds within day, close time in seconds within day
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### brokerTool.getInitialMarginRate(symbol) ⇒getInitialMarginRate
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getInitialMarginRate](#PerpetualDataHandler+getInitialMarginRate)
**Returns**: initial margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### brokerTool.getMaintenanceMarginRate(symbol) ⇒getMaintenanceMarginRate
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getMaintenanceMarginRate](#PerpetualDataHandler+getMaintenanceMarginRate)
**Returns**: maintenance margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### brokerTool.getShortSymbol(symbol) ⇒Short symbol corresponding to a given long symbol.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getShortSymbol](#PerpetualDataHandler+getShortSymbol)
**Returns**: Short symbol (e.g. NHL0)
| Param | Description | | --- | --- | | symbol |Long symbol (e.g. NHL_TOR_DAL_251015)
| ### brokerTool.refreshSymbols()Refreshes symbol mappings if at least one prediction market is expired
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [refreshSymbols](#PerpetualDataHandler+refreshSymbols)
### brokerTool.getLocalPerpetualStates() ⇒
Get state of perpetuals as currently known locally
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [getLocalPerpetualStates](#PerpetualDataHandler+getLocalPerpetualStates)
**Returns**: Array of [perpetual Id, perpetual state (string)]
### brokerTool.fetchOnChainPerpetualStates() ⇒Fetches on-chain state of local perpetual ids. Does not run if SDK is not ready.
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [fetchOnChainPerpetualStates](#PerpetualDataHandler+fetchOnChainPerpetualStates)
**Returns**: Array of [perpetual Id, perpetual state (string)]
### brokerTool.checkHeartbeat() ⇒Check that states of all perps known locally match on-chain states
**Kind**: instance method of [BrokerTool](#BrokerTool)
**Overrides**: [checkHeartbeat](#PerpetualDataHandler+checkHeartbeat)
**Returns**: True if all perp states are correct
## LiquidatorTool ⇐ [WriteAccessHandler](#WriteAccessHandler)
Functions to liquidate traders. This class requires a private key and executes smart-contract interactions that require gas-payments.
**Kind**: global class **Extends**: [WriteAccessHandler](#WriteAccessHandler)
* [LiquidatorTool](#LiquidatorTool) ⇐ [WriteAccessHandler](#WriteAccessHandler)
* [new LiquidatorTool(config, signer)](#new_LiquidatorTool_new)
* [.liquidateTrader(symbol, traderAddr, [liquidatorAddr], priceFeedData)](#LiquidatorTool+liquidateTrader) ⇒
* [.isMaintenanceMarginSafe(symbol, traderAddr, indexPrices)](#LiquidatorTool+isMaintenanceMarginSafe) ⇒ boolean
* [.countActivePerpAccounts(symbol)](#LiquidatorTool+countActivePerpAccounts) ⇒ number
* [.getActiveAccountsByChunks(symbol, from, to)](#LiquidatorTool+getActiveAccountsByChunks) ⇒ Array.<string>
* [.getAllActiveAccounts(symbol)](#LiquidatorTool+getAllActiveAccounts) ⇒ Array.<string>
* [.createProxyInstance(provider)](#WriteAccessHandler+createProxyInstance)
* [.setAllowance(symbol, amount)](#WriteAccessHandler+setAllowance) ⇒
* [.getAddress()](#WriteAccessHandler+getAddress) ⇒ string
* [.swapForMockToken(symbol, amountToPay)](#WriteAccessHandler+swapForMockToken) ⇒
* [.fetchSymbolList()](#PerpetualDataHandler+fetchSymbolList)
* [.getOrderBookContract(symbol)](#PerpetualDataHandler+getOrderBookContract) ⇒
* [.getOrderBookAddress(symbol)](#PerpetualDataHandler+getOrderBookAddress) ⇒
* [.getPerpetuals(ids, overrides)](#PerpetualDataHandler+getPerpetuals) ⇒
* [.getLiquidityPools(fromIdx, toIdx, overrides)](#PerpetualDataHandler+getLiquidityPools) ⇒
* [._fillSymbolMaps()](#PerpetualDataHandler+_fillSymbolMaps)
* [.initSettlementToken(perpStaticInfos)](#PerpetualDataHandler+initSettlementToken)
* [.getSymbolFromPoolId(poolId)](#PerpetualDataHandler+getSymbolFromPoolId) ⇒ symbol
* [.getPoolIdFromSymbol(symbol)](#PerpetualDataHandler+getPoolIdFromSymbol) ⇒ number
* [.getPerpIdFromSymbol(symbol)](#PerpetualDataHandler+getPerpIdFromSymbol) ⇒ number
* [.getSymbolFromPerpId(perpId)](#PerpetualDataHandler+getSymbolFromPerpId) ⇒ string
* [.symbol4BToLongSymbol(sym)](#PerpetualDataHandler+symbol4BToLongSymbol) ⇒ string
* [.fetchPriceSubmissionInfoForPerpetual(symbol)](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual) ⇒
* [.getIndexSymbols(symbol)](#PerpetualDataHandler+getIndexSymbols) ⇒
* [.fetchLatestFeedPriceInfo(symbol)](#PerpetualDataHandler+fetchLatestFeedPriceInfo) ⇒
* [.fetchCollateralToSettlementConversion(symbol)](#PerpetualDataHandler+fetchCollateralToSettlementConversion)
* [.getPriceIds(symbol)](#PerpetualDataHandler+getPriceIds) ⇒
* [.getPerpetualSymbolsInPool(poolSymbol)](#PerpetualDataHandler+getPerpetualSymbolsInPool) ⇒
* [.getAllOpenOrders(symbol)](#PerpetualDataHandler+getAllOpenOrders) ⇒
* [.numberOfOpenOrders(symbol)](#PerpetualDataHandler+numberOfOpenOrders) ⇒ number
* [.pollLimitOrders(symbol, numElements, [startAfter])](#PerpetualDataHandler+pollLimitOrders) ⇒
* [.getPoolStaticInfoIndexFromSymbol(symbol)](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol) ⇒
* [.getMarginTokenFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenFromSymbol) ⇒
* [.getSettlementTokenFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenFromSymbol) ⇒
* [.getMarginTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol) ⇒
* [.getSettlementTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol) ⇒
* [.getABI(contract)](#PerpetualDataHandler+getABI) ⇒
* [.isPredictionMarket(symbol)](#PerpetualDataHandler+isPredictionMarket) ⇒
* [.isLowLiquidityMarket(symbol)](#PerpetualDataHandler+isLowLiquidityMarket) ⇒
* [.isTradFiMarket(symbol)](#PerpetualDataHandler+isTradFiMarket) ⇒
* [.getMarketDayTradingOpenCloseSec(symbol)](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec) ⇒
* [.getInitialMarginRate(symbol)](#PerpetualDataHandler+getInitialMarginRate) ⇒
* [.getMaintenanceMarginRate(symbol)](#PerpetualDataHandler+getMaintenanceMarginRate) ⇒
* [.getShortSymbol(symbol)](#PerpetualDataHandler+getShortSymbol) ⇒
* [.refreshSymbols()](#PerpetualDataHandler+refreshSymbols)
* [.getLocalPerpetualStates()](#PerpetualDataHandler+getLocalPerpetualStates) ⇒
* [.fetchOnChainPerpetualStates()](#PerpetualDataHandler+fetchOnChainPerpetualStates) ⇒
* [.checkHeartbeat()](#PerpetualDataHandler+checkHeartbeat) ⇒
### new LiquidatorTool(config, signer)
Constructs a LiquidatorTool instance for a given configuration and private key.
| Param | Type | Description | | --- | --- | --- | | config |NodeSDKConfig | Configuration object, see PerpetualDataHandler. readSDKConfig.
| | signer |string \| Signer | Private key or ethers Signer of the account
| **Example** ```js import { LiquidatorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(LiquidatorTool); // load configuration for Polygon zkEVM (tesnet) const config = PerpetualDataHandler.readSDKConfig("cardona"); // LiquidatorTool (authentication required, PK is an environment variable with a private key) const pk: string =Liquidate a trader.
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Returns**: Transaction object.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| | traderAddr |string | Address of the trader to be liquidated.
| | [liquidatorAddr] |string | Address to be credited if the liquidation succeeds.
| | priceFeedData |PriceFeedSubmission | optional. VAA and timestamps for oracle. If not provided will query from REST API. Defaults to the wallet used to execute the liquidation.
| **Example** ```js import { LiquidatorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(LiquidatorTool); // Setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =boolean
Check if the collateral of a trader is above the maintenance margin ("maintenance margin safe"). If not, the position can be liquidated.
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Returns**: boolean - True if the trader is maintenance margin safe in the perpetual. False means that the trader's position can be liquidated.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| | traderAddr |string | Address of the trader whose position you want to assess.
| | indexPrices |Array.<number> | optional, index price S2/S3 for which we test
| **Example** ```js import { LiquidatorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(LiquidatorTool); // Setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Total number of active accounts for this symbol, i.e. accounts with positions that are currently open.
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Returns**: number - Number of active accounts.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { LiquidatorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(LiquidatorTool); // Setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Array.<string>
Get addresses of active accounts by chunks.
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Returns**: Array.<string> - Array of addresses at locations 'from', 'from'+1 ,..., 'to'-1.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| | from |number | From which account we start counting (0-indexed).
| | to |number | Until which account we count, non inclusive.
| **Example** ```js import { LiquidatorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(LiquidatorTool); // Setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Array.<string>
Addresses for all the active accounts in this perpetual symbol.
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Returns**: Array.<string> - Array of addresses.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { LiquidatorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(LiquidatorTool); // Setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Initialize the writeAccessHandler-Class with this function to create instance of D8X perpetual contract and gather information about perpetual currencies
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [createProxyInstance](#WriteAccessHandler+createProxyInstance)
| Param | Description |
| --- | --- |
| provider | optional provider
| ### liquidatorTool.setAllowance(symbol, amount) ⇒Set allowance for ar margin token (e.g., MATIC, ETH, USDC)
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [setAllowance](#WriteAccessHandler+setAllowance)
**Returns**: Contract Transaction
| Param | Description | | --- | --- | | symbol |token in 'long-form' such as MATIC, symbol also fine (ETH-USD-MATIC)
| | amount |optional, amount to approve if not 'infinity'
| ### liquidatorTool.getAddress() ⇒string
Address corresponding to the private key used to instantiate this class.
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getAddress](#WriteAccessHandler+getAddress)
**Returns**: string - Address of this wallet.
### liquidatorTool.swapForMockToken(symbol, amountToPay) ⇒Converts a given amount of chain native currency (test MATIC) into a mock token used for trading on testnet, with a rate of 1:100_000
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [swapForMockToken](#WriteAccessHandler+swapForMockToken)
**Returns**: Transaction object
| Param | Description | | --- | --- | | symbol |Pool margin token e.g. MATIC
| | amountToPay |Amount in chain currency, e.g. "0.1" for 0.1 MATIC
| ### liquidatorTool.fetchSymbolList()sets the symbollist if a remote config url is specified
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [fetchSymbolList](#PerpetualDataHandler+fetchSymbolList)
### liquidatorTool.getOrderBookContract(symbol) ⇒
Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getOrderBookContract](#PerpetualDataHandler+getOrderBookContract)
**Returns**: order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### liquidatorTool.getOrderBookAddress(symbol) ⇒Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getOrderBookAddress](#PerpetualDataHandler+getOrderBookAddress)
**Returns**: order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### liquidatorTool.getPerpetuals(ids, overrides) ⇒Get perpetuals for the given ids from onchain
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getPerpetuals](#PerpetualDataHandler+getPerpetuals)
**Returns**: array of PerpetualData converted into decimals
| Param | Description | | --- | --- | | ids |perpetual ids
| | overrides |optional
| ### liquidatorTool.getLiquidityPools(fromIdx, toIdx, overrides) ⇒Get liquidity pools data
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getLiquidityPools](#PerpetualDataHandler+getLiquidityPools)
**Returns**: array of LiquidityPoolData converted into decimals
| Param | Description | | --- | --- | | fromIdx |starting index (>=1)
| | toIdx |to index (inclusive)
| | overrides |optional
| ### liquidatorTool.\_fillSymbolMaps()Called when initializing. This function fills this.symbolToTokenAddrMap, and this.nestedPerpetualIDs and this.symbolToPerpStaticInfo
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [\_fillSymbolMaps](#PerpetualDataHandler+_fillSymbolMaps)
### liquidatorTool.initSettlementToken(perpStaticInfos)
Initializes settlement currency for all pools by completing this.poolStaticInfos with settlement currency info
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [initSettlementToken](#PerpetualDataHandler+initSettlementToken)
| Param | Description |
| --- | --- |
| perpStaticInfos | PerpetualStaticInfo array from contract call
| ### liquidatorTool.getSymbolFromPoolId(poolId) ⇒symbol
Get pool symbol given a pool Id.
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getSymbolFromPoolId](#PerpetualDataHandler+getSymbolFromPoolId)
**Returns**: symbol - Pool symbol, e.g. "USDC".
| Param | Type | Description | | --- | --- | --- | | poolId |number | Pool Id.
| ### liquidatorTool.getPoolIdFromSymbol(symbol) ⇒number
Get pool Id given a pool symbol. Pool IDs start at 1.
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getPoolIdFromSymbol](#PerpetualDataHandler+getPoolIdFromSymbol)
**Returns**: number - Pool Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Pool symbol.
| ### liquidatorTool.getPerpIdFromSymbol(symbol) ⇒number
Get perpetual Id given a perpetual symbol.
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getPerpIdFromSymbol](#PerpetualDataHandler+getPerpIdFromSymbol)
**Returns**: number - Perpetual Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Perpetual symbol, e.g. "BTC-USD-MATIC".
| ### liquidatorTool.getSymbolFromPerpId(perpId) ⇒string
Get the symbol in long format of the perpetual id
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getSymbolFromPerpId](#PerpetualDataHandler+getSymbolFromPerpId)
**Returns**: string - Symbol
| Param | Type | Description | | --- | --- | --- | | perpId |number | perpetual id
| ### liquidatorTool.symbol4BToLongSymbol(sym) ⇒string
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [symbol4BToLongSymbol](#PerpetualDataHandler+symbol4BToLongSymbol)
**Returns**: string - Long symbol
| Param | Type | Description | | --- | --- | --- | | sym |string | Short symbol
| ### liquidatorTool.fetchPriceSubmissionInfoForPerpetual(symbol) ⇒Get PriceFeedSubmission data required for blockchain queries that involve price data, and the corresponding triangulated prices for the indices S2 and S3
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [fetchPriceSubmissionInfoForPerpetual](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual)
**Returns**: PriceFeedSubmission and prices for S2 and S3. [S2price, 0] if S3 not defined.
| Param | Description | | --- | --- | | symbol |pool symbol of the form "ETH-USD-MATIC"
| ### liquidatorTool.getIndexSymbols(symbol) ⇒Get the symbols required as indices for the given perpetual
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getIndexSymbols](#PerpetualDataHandler+getIndexSymbols)
**Returns**: name of underlying index prices, e.g. ["MATIC-USD", ""]
| Param | Description | | --- | --- | | symbol |of the form ETH-USD-MATIC, specifying the perpetual
| ### liquidatorTool.fetchLatestFeedPriceInfo(symbol) ⇒Get the latest prices for a given perpetual from the offchain oracle networks
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [fetchLatestFeedPriceInfo](#PerpetualDataHandler+fetchLatestFeedPriceInfo)
**Returns**: array of price feed updates that can be submitted to the smart contract and corresponding price information
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form BTC-USD-MATIC
| ### liquidatorTool.fetchCollateralToSettlementConversion(symbol)fetchCollateralToSettlementConversion returns the price which converts the collateral currency into settlement currency. For example if BTC-USD-STUSD has settlement currency USDC, we get let px = fetchCollateralToSettlementConversion("BTC-USD-STUSD") valueInUSDC = collateralInSTUSD * px
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [fetchCollateralToSettlementConversion](#PerpetualDataHandler+fetchCollateralToSettlementConversion)
| Param | Description |
| --- | --- |
| symbol | either perpetual symbol of the form BTC-USD-MATIC or just collateral token
| ### liquidatorTool.getPriceIds(symbol) ⇒Get list of required pyth price source IDs for given perpetual
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getPriceIds](#PerpetualDataHandler+getPriceIds)
**Returns**: list of required pyth price sources for this perpetual
| Param | Description | | --- | --- | | symbol |perpetual symbol, e.g., BTC-USD-MATIC
| ### liquidatorTool.getPerpetualSymbolsInPool(poolSymbol) ⇒Get ('normal'-state) perpetual symbols for a given pool
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getPerpetualSymbolsInPool](#PerpetualDataHandler+getPerpetualSymbolsInPool)
**Returns**: array of perpetual symbols in this pool
| Param | Description | | --- | --- | | poolSymbol |pool symbol such as "MATIC"
| ### liquidatorTool.getAllOpenOrders(symbol) ⇒All the orders in the order book for a given symbol that are currently open.
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getAllOpenOrders](#PerpetualDataHandler+getAllOpenOrders)
**Returns**: Array with all open orders and their IDs.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Total number of limit orders for this symbol, excluding those that have been cancelled/removed.
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [numberOfOpenOrders](#PerpetualDataHandler+numberOfOpenOrders)
**Returns**: number - Number of open orders.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Get a list of active conditional orders in the order book. This a read-only action and does not incur in gas costs.
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [pollLimitOrders](#PerpetualDataHandler+pollLimitOrders)
**Returns**: Array of orders and corresponding order IDs
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| | numElements |number | Maximum number of orders to poll.
| | [startAfter] |string | Optional order ID from where to start polling. Defaults to the first order.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Gets the pool index (starting at 0 in exchangeInfo, not ID!) corresponding to a given symbol.
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getPoolStaticInfoIndexFromSymbol](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol)
**Returns**: Pool index
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-MATIC
| ### liquidatorTool.getMarginTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getMarginTokenFromSymbol](#PerpetualDataHandler+getMarginTokenFromSymbol)
**Returns**: Address of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### liquidatorTool.getSettlementTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getSettlementTokenFromSymbol](#PerpetualDataHandler+getSettlementTokenFromSymbol)
**Returns**: Address of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### liquidatorTool.getMarginTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getMarginTokenDecimalsFromSymbol](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol)
**Returns**: Decimals of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### liquidatorTool.getSettlementTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getSettlementTokenDecimalsFromSymbol](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol)
**Returns**: Decimals of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### liquidatorTool.getABI(contract) ⇒Get ABI for LimitOrderBook, Proxy, or Share Pool Token
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getABI](#PerpetualDataHandler+getABI)
**Returns**: ABI for the requested contract
| Param | Description | | --- | --- | | contract |name of contract: proxy|lob|sharetoken
| ### liquidatorTool.isPredictionMarket(symbol) ⇒Determines whether a given perpetual represents a prediction market
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [isPredictionMarket](#PerpetualDataHandler+isPredictionMarket)
**Returns**: True if this is a prediction market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form TRUMP24-USD-USDC
| ### liquidatorTool.isLowLiquidityMarket(symbol) ⇒Determines whether a given perpetual represents a low-liquidity market
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [isLowLiquidityMarket](#PerpetualDataHandler+isLowLiquidityMarket)
**Returns**: True if this is a low-liquidity market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form DIRAC-HONEY-USDC
| ### liquidatorTool.isTradFiMarket(symbol) ⇒Determines whether a given perpetual represents a tradfi market
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [isTradFiMarket](#PerpetualDataHandler+isTradFiMarket)
**Returns**: True if this is a tradfi market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### liquidatorTool.getMarketDayTradingOpenCloseSec(symbol) ⇒Returns day trading times for tradfi markets
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getMarketDayTradingOpenCloseSec](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec)
**Returns**: open time in seconds within day, close time in seconds within day
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### liquidatorTool.getInitialMarginRate(symbol) ⇒getInitialMarginRate
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getInitialMarginRate](#PerpetualDataHandler+getInitialMarginRate)
**Returns**: initial margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### liquidatorTool.getMaintenanceMarginRate(symbol) ⇒getMaintenanceMarginRate
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getMaintenanceMarginRate](#PerpetualDataHandler+getMaintenanceMarginRate)
**Returns**: maintenance margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### liquidatorTool.getShortSymbol(symbol) ⇒Short symbol corresponding to a given long symbol.
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getShortSymbol](#PerpetualDataHandler+getShortSymbol)
**Returns**: Short symbol (e.g. NHL0)
| Param | Description | | --- | --- | | symbol |Long symbol (e.g. NHL_TOR_DAL_251015)
| ### liquidatorTool.refreshSymbols()Refreshes symbol mappings if at least one prediction market is expired
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [refreshSymbols](#PerpetualDataHandler+refreshSymbols)
### liquidatorTool.getLocalPerpetualStates() ⇒
Get state of perpetuals as currently known locally
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [getLocalPerpetualStates](#PerpetualDataHandler+getLocalPerpetualStates)
**Returns**: Array of [perpetual Id, perpetual state (string)]
### liquidatorTool.fetchOnChainPerpetualStates() ⇒Fetches on-chain state of local perpetual ids. Does not run if SDK is not ready.
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [fetchOnChainPerpetualStates](#PerpetualDataHandler+fetchOnChainPerpetualStates)
**Returns**: Array of [perpetual Id, perpetual state (string)]
### liquidatorTool.checkHeartbeat() ⇒Check that states of all perps known locally match on-chain states
**Kind**: instance method of [LiquidatorTool](#LiquidatorTool)
**Overrides**: [checkHeartbeat](#PerpetualDataHandler+checkHeartbeat)
**Returns**: True if all perp states are correct
## LiquidityProviderTool ⇐ [WriteAccessHandler](#WriteAccessHandler)
Functions to provide liquidity. This class requires a private key and executes smart-contract interactions that require gas-payments.
**Kind**: global class **Extends**: [WriteAccessHandler](#WriteAccessHandler)
* [LiquidityProviderTool](#LiquidityProviderTool) ⇐ [WriteAccessHandler](#WriteAccessHandler)
* [new LiquidityProviderTool(config, signer)](#new_LiquidityProviderTool_new)
* [.addLiquidity(poolSymbolName, amountCC)](#LiquidityProviderTool+addLiquidity) ⇒
* [.initiateLiquidityWithdrawal(poolSymbolName, amountPoolShares)](#LiquidityProviderTool+initiateLiquidityWithdrawal) ⇒
* [.executeLiquidityWithdrawal(poolSymbolName)](#LiquidityProviderTool+executeLiquidityWithdrawal) ⇒
* [.createProxyInstance(provider)](#WriteAccessHandler+createProxyInstance)
* [.setAllowance(symbol, amount)](#WriteAccessHandler+setAllowance) ⇒
* [.getAddress()](#WriteAccessHandler+getAddress) ⇒ string
* [.swapForMockToken(symbol, amountToPay)](#WriteAccessHandler+swapForMockToken) ⇒
* [.fetchSymbolList()](#PerpetualDataHandler+fetchSymbolList)
* [.getOrderBookContract(symbol)](#PerpetualDataHandler+getOrderBookContract) ⇒
* [.getOrderBookAddress(symbol)](#PerpetualDataHandler+getOrderBookAddress) ⇒
* [.getPerpetuals(ids, overrides)](#PerpetualDataHandler+getPerpetuals) ⇒
* [.getLiquidityPools(fromIdx, toIdx, overrides)](#PerpetualDataHandler+getLiquidityPools) ⇒
* [._fillSymbolMaps()](#PerpetualDataHandler+_fillSymbolMaps)
* [.initSettlementToken(perpStaticInfos)](#PerpetualDataHandler+initSettlementToken)
* [.getSymbolFromPoolId(poolId)](#PerpetualDataHandler+getSymbolFromPoolId) ⇒ symbol
* [.getPoolIdFromSymbol(symbol)](#PerpetualDataHandler+getPoolIdFromSymbol) ⇒ number
* [.getPerpIdFromSymbol(symbol)](#PerpetualDataHandler+getPerpIdFromSymbol) ⇒ number
* [.getSymbolFromPerpId(perpId)](#PerpetualDataHandler+getSymbolFromPerpId) ⇒ string
* [.symbol4BToLongSymbol(sym)](#PerpetualDataHandler+symbol4BToLongSymbol) ⇒ string
* [.fetchPriceSubmissionInfoForPerpetual(symbol)](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual) ⇒
* [.getIndexSymbols(symbol)](#PerpetualDataHandler+getIndexSymbols) ⇒
* [.fetchLatestFeedPriceInfo(symbol)](#PerpetualDataHandler+fetchLatestFeedPriceInfo) ⇒
* [.fetchCollateralToSettlementConversion(symbol)](#PerpetualDataHandler+fetchCollateralToSettlementConversion)
* [.getPriceIds(symbol)](#PerpetualDataHandler+getPriceIds) ⇒
* [.getPerpetualSymbolsInPool(poolSymbol)](#PerpetualDataHandler+getPerpetualSymbolsInPool) ⇒
* [.getAllOpenOrders(symbol)](#PerpetualDataHandler+getAllOpenOrders) ⇒
* [.numberOfOpenOrders(symbol)](#PerpetualDataHandler+numberOfOpenOrders) ⇒ number
* [.pollLimitOrders(symbol, numElements, [startAfter])](#PerpetualDataHandler+pollLimitOrders) ⇒
* [.getPoolStaticInfoIndexFromSymbol(symbol)](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol) ⇒
* [.getMarginTokenFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenFromSymbol) ⇒
* [.getSettlementTokenFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenFromSymbol) ⇒
* [.getMarginTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol) ⇒
* [.getSettlementTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol) ⇒
* [.getABI(contract)](#PerpetualDataHandler+getABI) ⇒
* [.isPredictionMarket(symbol)](#PerpetualDataHandler+isPredictionMarket) ⇒
* [.isLowLiquidityMarket(symbol)](#PerpetualDataHandler+isLowLiquidityMarket) ⇒
* [.isTradFiMarket(symbol)](#PerpetualDataHandler+isTradFiMarket) ⇒
* [.getMarketDayTradingOpenCloseSec(symbol)](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec) ⇒
* [.getInitialMarginRate(symbol)](#PerpetualDataHandler+getInitialMarginRate) ⇒
* [.getMaintenanceMarginRate(symbol)](#PerpetualDataHandler+getMaintenanceMarginRate) ⇒
* [.getShortSymbol(symbol)](#PerpetualDataHandler+getShortSymbol) ⇒
* [.refreshSymbols()](#PerpetualDataHandler+refreshSymbols)
* [.getLocalPerpetualStates()](#PerpetualDataHandler+getLocalPerpetualStates) ⇒
* [.fetchOnChainPerpetualStates()](#PerpetualDataHandler+fetchOnChainPerpetualStates) ⇒
* [.checkHeartbeat()](#PerpetualDataHandler+checkHeartbeat) ⇒
### new LiquidityProviderTool(config, signer)
Constructor
| Param | Type | Description | | --- | --- | --- | | config |NodeSDKConfig | Configuration object, see PerpetualDataHandler. readSDKConfig.
| | signer |string \| Signer | Private key or ethers Signer of the account
| **Example** ```js import { LiquidityProviderTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(LiquidityProviderTool); // load configuration for Polygon zkEVM (testnet) const config = PerpetualDataHandler.readSDKConfig("cardona"); // LiquidityProviderTool (authentication required, PK is an environment variable with a private key) const pk: string =Add liquidity to the PnL participant fund. The address gets pool shares in return.
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Returns**: Transaction object
| Param | Type | Description | | --- | --- | --- | | poolSymbolName |string | Name of pool symbol (e.g. MATIC)
| | amountCC |number | Amount in pool-collateral currency
| **Example** ```js import { LiquidityProviderTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(LiquidityProviderTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Initiates a liquidity withdrawal from the pool It triggers a time-delayed unlocking of the given number of pool shares. The amount of pool shares to be unlocked is fixed by this call, but not their value in pool currency.
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Returns**: Transaction object.
| Param | Type | Description | | --- | --- | --- | | poolSymbolName |string | Name of pool symbol (e.g. MATIC).
| | amountPoolShares |string | Amount in pool-shares, removes everything if > available amount.
| **Example** ```js import { LiquidityProviderTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(LiquidityProviderTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Withdraws as much liquidity as there is available after a call to initiateLiquidityWithdrawal. The address loses pool shares in return.
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Returns**: Transaction object.
| Param | | --- | | poolSymbolName | **Example** ```js import { LiquidityProviderTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(LiquidityProviderTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Initialize the writeAccessHandler-Class with this function to create instance of D8X perpetual contract and gather information about perpetual currencies
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [createProxyInstance](#WriteAccessHandler+createProxyInstance)
| Param | Description |
| --- | --- |
| provider | optional provider
| ### liquidityProviderTool.setAllowance(symbol, amount) ⇒Set allowance for ar margin token (e.g., MATIC, ETH, USDC)
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [setAllowance](#WriteAccessHandler+setAllowance)
**Returns**: Contract Transaction
| Param | Description | | --- | --- | | symbol |token in 'long-form' such as MATIC, symbol also fine (ETH-USD-MATIC)
| | amount |optional, amount to approve if not 'infinity'
| ### liquidityProviderTool.getAddress() ⇒string
Address corresponding to the private key used to instantiate this class.
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getAddress](#WriteAccessHandler+getAddress)
**Returns**: string - Address of this wallet.
### liquidityProviderTool.swapForMockToken(symbol, amountToPay) ⇒Converts a given amount of chain native currency (test MATIC) into a mock token used for trading on testnet, with a rate of 1:100_000
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [swapForMockToken](#WriteAccessHandler+swapForMockToken)
**Returns**: Transaction object
| Param | Description | | --- | --- | | symbol |Pool margin token e.g. MATIC
| | amountToPay |Amount in chain currency, e.g. "0.1" for 0.1 MATIC
| ### liquidityProviderTool.fetchSymbolList()sets the symbollist if a remote config url is specified
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [fetchSymbolList](#PerpetualDataHandler+fetchSymbolList)
### liquidityProviderTool.getOrderBookContract(symbol) ⇒
Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getOrderBookContract](#PerpetualDataHandler+getOrderBookContract)
**Returns**: order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### liquidityProviderTool.getOrderBookAddress(symbol) ⇒Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getOrderBookAddress](#PerpetualDataHandler+getOrderBookAddress)
**Returns**: order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### liquidityProviderTool.getPerpetuals(ids, overrides) ⇒Get perpetuals for the given ids from onchain
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getPerpetuals](#PerpetualDataHandler+getPerpetuals)
**Returns**: array of PerpetualData converted into decimals
| Param | Description | | --- | --- | | ids |perpetual ids
| | overrides |optional
| ### liquidityProviderTool.getLiquidityPools(fromIdx, toIdx, overrides) ⇒Get liquidity pools data
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getLiquidityPools](#PerpetualDataHandler+getLiquidityPools)
**Returns**: array of LiquidityPoolData converted into decimals
| Param | Description | | --- | --- | | fromIdx |starting index (>=1)
| | toIdx |to index (inclusive)
| | overrides |optional
| ### liquidityProviderTool.\_fillSymbolMaps()Called when initializing. This function fills this.symbolToTokenAddrMap, and this.nestedPerpetualIDs and this.symbolToPerpStaticInfo
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [\_fillSymbolMaps](#PerpetualDataHandler+_fillSymbolMaps)
### liquidityProviderTool.initSettlementToken(perpStaticInfos)
Initializes settlement currency for all pools by completing this.poolStaticInfos with settlement currency info
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [initSettlementToken](#PerpetualDataHandler+initSettlementToken)
| Param | Description |
| --- | --- |
| perpStaticInfos | PerpetualStaticInfo array from contract call
| ### liquidityProviderTool.getSymbolFromPoolId(poolId) ⇒symbol
Get pool symbol given a pool Id.
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getSymbolFromPoolId](#PerpetualDataHandler+getSymbolFromPoolId)
**Returns**: symbol - Pool symbol, e.g. "USDC".
| Param | Type | Description | | --- | --- | --- | | poolId |number | Pool Id.
| ### liquidityProviderTool.getPoolIdFromSymbol(symbol) ⇒number
Get pool Id given a pool symbol. Pool IDs start at 1.
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getPoolIdFromSymbol](#PerpetualDataHandler+getPoolIdFromSymbol)
**Returns**: number - Pool Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Pool symbol.
| ### liquidityProviderTool.getPerpIdFromSymbol(symbol) ⇒number
Get perpetual Id given a perpetual symbol.
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getPerpIdFromSymbol](#PerpetualDataHandler+getPerpIdFromSymbol)
**Returns**: number - Perpetual Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Perpetual symbol, e.g. "BTC-USD-MATIC".
| ### liquidityProviderTool.getSymbolFromPerpId(perpId) ⇒string
Get the symbol in long format of the perpetual id
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getSymbolFromPerpId](#PerpetualDataHandler+getSymbolFromPerpId)
**Returns**: string - Symbol
| Param | Type | Description | | --- | --- | --- | | perpId |number | perpetual id
| ### liquidityProviderTool.symbol4BToLongSymbol(sym) ⇒string
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [symbol4BToLongSymbol](#PerpetualDataHandler+symbol4BToLongSymbol)
**Returns**: string - Long symbol
| Param | Type | Description | | --- | --- | --- | | sym |string | Short symbol
| ### liquidityProviderTool.fetchPriceSubmissionInfoForPerpetual(symbol) ⇒Get PriceFeedSubmission data required for blockchain queries that involve price data, and the corresponding triangulated prices for the indices S2 and S3
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [fetchPriceSubmissionInfoForPerpetual](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual)
**Returns**: PriceFeedSubmission and prices for S2 and S3. [S2price, 0] if S3 not defined.
| Param | Description | | --- | --- | | symbol |pool symbol of the form "ETH-USD-MATIC"
| ### liquidityProviderTool.getIndexSymbols(symbol) ⇒Get the symbols required as indices for the given perpetual
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getIndexSymbols](#PerpetualDataHandler+getIndexSymbols)
**Returns**: name of underlying index prices, e.g. ["MATIC-USD", ""]
| Param | Description | | --- | --- | | symbol |of the form ETH-USD-MATIC, specifying the perpetual
| ### liquidityProviderTool.fetchLatestFeedPriceInfo(symbol) ⇒Get the latest prices for a given perpetual from the offchain oracle networks
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [fetchLatestFeedPriceInfo](#PerpetualDataHandler+fetchLatestFeedPriceInfo)
**Returns**: array of price feed updates that can be submitted to the smart contract and corresponding price information
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form BTC-USD-MATIC
| ### liquidityProviderTool.fetchCollateralToSettlementConversion(symbol)fetchCollateralToSettlementConversion returns the price which converts the collateral currency into settlement currency. For example if BTC-USD-STUSD has settlement currency USDC, we get let px = fetchCollateralToSettlementConversion("BTC-USD-STUSD") valueInUSDC = collateralInSTUSD * px
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [fetchCollateralToSettlementConversion](#PerpetualDataHandler+fetchCollateralToSettlementConversion)
| Param | Description |
| --- | --- |
| symbol | either perpetual symbol of the form BTC-USD-MATIC or just collateral token
| ### liquidityProviderTool.getPriceIds(symbol) ⇒Get list of required pyth price source IDs for given perpetual
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getPriceIds](#PerpetualDataHandler+getPriceIds)
**Returns**: list of required pyth price sources for this perpetual
| Param | Description | | --- | --- | | symbol |perpetual symbol, e.g., BTC-USD-MATIC
| ### liquidityProviderTool.getPerpetualSymbolsInPool(poolSymbol) ⇒Get ('normal'-state) perpetual symbols for a given pool
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getPerpetualSymbolsInPool](#PerpetualDataHandler+getPerpetualSymbolsInPool)
**Returns**: array of perpetual symbols in this pool
| Param | Description | | --- | --- | | poolSymbol |pool symbol such as "MATIC"
| ### liquidityProviderTool.getAllOpenOrders(symbol) ⇒All the orders in the order book for a given symbol that are currently open.
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getAllOpenOrders](#PerpetualDataHandler+getAllOpenOrders)
**Returns**: Array with all open orders and their IDs.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Total number of limit orders for this symbol, excluding those that have been cancelled/removed.
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [numberOfOpenOrders](#PerpetualDataHandler+numberOfOpenOrders)
**Returns**: number - Number of open orders.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Get a list of active conditional orders in the order book. This a read-only action and does not incur in gas costs.
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [pollLimitOrders](#PerpetualDataHandler+pollLimitOrders)
**Returns**: Array of orders and corresponding order IDs
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| | numElements |number | Maximum number of orders to poll.
| | [startAfter] |string | Optional order ID from where to start polling. Defaults to the first order.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Gets the pool index (starting at 0 in exchangeInfo, not ID!) corresponding to a given symbol.
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getPoolStaticInfoIndexFromSymbol](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol)
**Returns**: Pool index
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-MATIC
| ### liquidityProviderTool.getMarginTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getMarginTokenFromSymbol](#PerpetualDataHandler+getMarginTokenFromSymbol)
**Returns**: Address of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### liquidityProviderTool.getSettlementTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getSettlementTokenFromSymbol](#PerpetualDataHandler+getSettlementTokenFromSymbol)
**Returns**: Address of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### liquidityProviderTool.getMarginTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getMarginTokenDecimalsFromSymbol](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol)
**Returns**: Decimals of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### liquidityProviderTool.getSettlementTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getSettlementTokenDecimalsFromSymbol](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol)
**Returns**: Decimals of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### liquidityProviderTool.getABI(contract) ⇒Get ABI for LimitOrderBook, Proxy, or Share Pool Token
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getABI](#PerpetualDataHandler+getABI)
**Returns**: ABI for the requested contract
| Param | Description | | --- | --- | | contract |name of contract: proxy|lob|sharetoken
| ### liquidityProviderTool.isPredictionMarket(symbol) ⇒Determines whether a given perpetual represents a prediction market
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [isPredictionMarket](#PerpetualDataHandler+isPredictionMarket)
**Returns**: True if this is a prediction market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form TRUMP24-USD-USDC
| ### liquidityProviderTool.isLowLiquidityMarket(symbol) ⇒Determines whether a given perpetual represents a low-liquidity market
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [isLowLiquidityMarket](#PerpetualDataHandler+isLowLiquidityMarket)
**Returns**: True if this is a low-liquidity market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form DIRAC-HONEY-USDC
| ### liquidityProviderTool.isTradFiMarket(symbol) ⇒Determines whether a given perpetual represents a tradfi market
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [isTradFiMarket](#PerpetualDataHandler+isTradFiMarket)
**Returns**: True if this is a tradfi market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### liquidityProviderTool.getMarketDayTradingOpenCloseSec(symbol) ⇒Returns day trading times for tradfi markets
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getMarketDayTradingOpenCloseSec](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec)
**Returns**: open time in seconds within day, close time in seconds within day
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### liquidityProviderTool.getInitialMarginRate(symbol) ⇒getInitialMarginRate
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getInitialMarginRate](#PerpetualDataHandler+getInitialMarginRate)
**Returns**: initial margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### liquidityProviderTool.getMaintenanceMarginRate(symbol) ⇒getMaintenanceMarginRate
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getMaintenanceMarginRate](#PerpetualDataHandler+getMaintenanceMarginRate)
**Returns**: maintenance margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### liquidityProviderTool.getShortSymbol(symbol) ⇒Short symbol corresponding to a given long symbol.
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getShortSymbol](#PerpetualDataHandler+getShortSymbol)
**Returns**: Short symbol (e.g. NHL0)
| Param | Description | | --- | --- | | symbol |Long symbol (e.g. NHL_TOR_DAL_251015)
| ### liquidityProviderTool.refreshSymbols()Refreshes symbol mappings if at least one prediction market is expired
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [refreshSymbols](#PerpetualDataHandler+refreshSymbols)
### liquidityProviderTool.getLocalPerpetualStates() ⇒
Get state of perpetuals as currently known locally
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [getLocalPerpetualStates](#PerpetualDataHandler+getLocalPerpetualStates)
**Returns**: Array of [perpetual Id, perpetual state (string)]
### liquidityProviderTool.fetchOnChainPerpetualStates() ⇒Fetches on-chain state of local perpetual ids. Does not run if SDK is not ready.
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [fetchOnChainPerpetualStates](#PerpetualDataHandler+fetchOnChainPerpetualStates)
**Returns**: Array of [perpetual Id, perpetual state (string)]
### liquidityProviderTool.checkHeartbeat() ⇒Check that states of all perps known locally match on-chain states
**Kind**: instance method of [LiquidityProviderTool](#LiquidityProviderTool)
**Overrides**: [checkHeartbeat](#PerpetualDataHandler+checkHeartbeat)
**Returns**: True if all perp states are correct
## MarketData ⇐ [PerpetualDataHandler](#PerpetualDataHandler)
Functions to access market data (e.g., information on open orders, information on products that can be traded). This class requires no private key and is blockchain read-only. No gas required for the queries here.
**Kind**: global class **Extends**: [PerpetualDataHandler](#PerpetualDataHandler)
* [MarketData](#MarketData) ⇐ [PerpetualDataHandler](#PerpetualDataHandler)
* [new MarketData(config)](#new_MarketData_new)
* _instance_
* [.createProxyInstance(providerOrMarketData)](#MarketData+createProxyInstance)
* [.getProxyAddress()](#MarketData+getProxyAddress) ⇒ string
* [.getTriangulations()](#MarketData+getTriangulations) ⇒
* [.smartContractOrderToOrder(smOrder)](#MarketData+smartContractOrderToOrder) ⇒ Order
* [.getReadOnlyProxyInstance()](#MarketData+getReadOnlyProxyInstance) ⇒
* [.exchangeInfo()](#MarketData+exchangeInfo) ⇒ [ExchangeInfo](#ExchangeInfo)
* [.openOrders(traderAddr, symbol)](#MarketData+openOrders) ⇒
* [.positionRisk(traderAddr, symbol)](#MarketData+positionRisk) ⇒ Array.<MarginAccount>
* [.positionRiskOnTrade(traderAddr, order, signedPositionNotionalBaseCCY, tradingFeeTbps, indexPriceInfo)](#MarketData+positionRiskOnTrade) ⇒
* [.positionRiskOnCollateralAction(deltaCollateral, account)](#MarketData+positionRiskOnCollateralAction) ⇒ MarginAccount
* [.getWalletBalance(address, symbol)](#MarketData+getWalletBalance) ⇒
* [.getPoolShareTokenBalance(address, symbolOrId)](#MarketData+getPoolShareTokenBalance) ⇒ number
* [.getShareTokenPrice(symbolOrId)](#MarketData+getShareTokenPrice) ⇒ number
* [.getParticipationValue(address, symbolOrId)](#MarketData+getParticipationValue) ⇒
* [.maxOrderSizeForTrader(traderAddr, symbol)](#MarketData+maxOrderSizeForTrader) ⇒
* [.pmMaxOrderSizeForTrader(traderAddr, symbol, overrides)](#MarketData+pmMaxOrderSizeForTrader) ⇒
* [.getMaxShortLongTrade(perpId, currentTraderPos, overrides)](#MarketData+getMaxShortLongTrade) ⇒
* [.rmMaxOrderSizeForTrader(traderAddr, symbol, overrides)](#MarketData+rmMaxOrderSizeForTrader) ⇒
* [.maxSignedPosition(side, symbol)](#MarketData+maxSignedPosition) ⇒ number
* [.getOraclePrice(base, quote)](#MarketData+getOraclePrice) ⇒ number
* [.getOrderStatus(symbol, orderId, overrides)](#MarketData+getOrderStatus) ⇒
* [.getOrdersStatus(symbol, orderId)](#MarketData+getOrdersStatus) ⇒
* [.getMarkPrice(symbol, indexPrices)](#MarketData+getMarkPrice) ⇒ number
* [.getPerpetualPrice(symbol, quantity, priceInfo)](#MarketData+getPerpetualPrice) ⇒ number
* [.getPerpetualState(symbol)](#MarketData+getPerpetualState) ⇒ PerpetualState
* [.getPoolState(poolSymbol)](#MarketData+getPoolState) ⇒ [PoolState](#PoolState)
* [.getPerpetualStaticInfo(symbol)](#MarketData+getPerpetualStaticInfo) ⇒ PerpetualStaticInfo
* [.getPerpetualMidPrice(symbol)](#MarketData+getPerpetualMidPrice) ⇒ number
* [.getAvailableMargin(traderAddr, symbol, indexPrices)](#MarketData+getAvailableMargin) ⇒
* [.getTraderLoyalityScore(traderAddr)](#MarketData+getTraderLoyalityScore) ⇒ number
* [.isMarketClosed(symbol)](#MarketData+isMarketClosed) ⇒ boolean
* [.getPriceInUSD(symbol)](#MarketData+getPriceInUSD) ⇒ Map.<string, number>
* [.fetchPricesForPerpetual(symbol)](#MarketData+fetchPricesForPerpetual) ⇒
* [.fetchPrdMktMetaData(symbol)](#MarketData+fetchPrdMktMetaData) ⇒
* [.fetchPythMetaData(symbol)](#MarketData+fetchPythMetaData) ⇒
* [.fetchSymbolList()](#PerpetualDataHandler+fetchSymbolList)
* [.getOrderBookContract(symbol)](#PerpetualDataHandler+getOrderBookContract) ⇒
* [.getOrderBookAddress(symbol)](#PerpetualDataHandler+getOrderBookAddress) ⇒
* [.getPerpetuals(ids, overrides)](#PerpetualDataHandler+getPerpetuals) ⇒
* [.getLiquidityPools(fromIdx, toIdx, overrides)](#PerpetualDataHandler+getLiquidityPools) ⇒
* [._fillSymbolMaps()](#PerpetualDataHandler+_fillSymbolMaps)
* [.initSettlementToken(perpStaticInfos)](#PerpetualDataHandler+initSettlementToken)
* [.getSymbolFromPoolId(poolId)](#PerpetualDataHandler+getSymbolFromPoolId) ⇒ symbol
* [.getPoolIdFromSymbol(symbol)](#PerpetualDataHandler+getPoolIdFromSymbol) ⇒ number
* [.getPerpIdFromSymbol(symbol)](#PerpetualDataHandler+getPerpIdFromSymbol) ⇒ number
* [.getSymbolFromPerpId(perpId)](#PerpetualDataHandler+getSymbolFromPerpId) ⇒ string
* [.symbol4BToLongSymbol(sym)](#PerpetualDataHandler+symbol4BToLongSymbol) ⇒ string
* [.fetchPriceSubmissionInfoForPerpetual(symbol)](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual) ⇒
* [.getIndexSymbols(symbol)](#PerpetualDataHandler+getIndexSymbols) ⇒
* [.fetchLatestFeedPriceInfo(symbol)](#PerpetualDataHandler+fetchLatestFeedPriceInfo) ⇒
* [.fetchCollateralToSettlementConversion(symbol)](#PerpetualDataHandler+fetchCollateralToSettlementConversion)
* [.getPriceIds(symbol)](#PerpetualDataHandler+getPriceIds) ⇒
* [.getPerpetualSymbolsInPool(poolSymbol)](#PerpetualDataHandler+getPerpetualSymbolsInPool) ⇒
* [.getAllOpenOrders(symbol)](#PerpetualDataHandler+getAllOpenOrders) ⇒
* [.numberOfOpenOrders(symbol)](#PerpetualDataHandler+numberOfOpenOrders) ⇒ number
* [.pollLimitOrders(symbol, numElements, [startAfter])](#PerpetualDataHandler+pollLimitOrders) ⇒
* [.getPoolStaticInfoIndexFromSymbol(symbol)](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol) ⇒
* [.getMarginTokenFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenFromSymbol) ⇒
* [.getSettlementTokenFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenFromSymbol) ⇒
* [.getMarginTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol) ⇒
* [.getSettlementTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol) ⇒
* [.getABI(contract)](#PerpetualDataHandler+getABI) ⇒
* [.isPredictionMarket(symbol)](#PerpetualDataHandler+isPredictionMarket) ⇒
* [.isLowLiquidityMarket(symbol)](#PerpetualDataHandler+isLowLiquidityMarket) ⇒
* [.isTradFiMarket(symbol)](#PerpetualDataHandler+isTradFiMarket) ⇒
* [.getMarketDayTradingOpenCloseSec(symbol)](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec) ⇒
* [.getInitialMarginRate(symbol)](#PerpetualDataHandler+getInitialMarginRate) ⇒
* [.getMaintenanceMarginRate(symbol)](#PerpetualDataHandler+getMaintenanceMarginRate) ⇒
* [.getShortSymbol(symbol)](#PerpetualDataHandler+getShortSymbol) ⇒
* [.refreshSymbols()](#PerpetualDataHandler+refreshSymbols)
* [.getLocalPerpetualStates()](#PerpetualDataHandler+getLocalPerpetualStates) ⇒
* [.fetchOnChainPerpetualStates()](#PerpetualDataHandler+fetchOnChainPerpetualStates) ⇒
* [.checkHeartbeat()](#PerpetualDataHandler+checkHeartbeat) ⇒
* _static_
* [.exchangeFeePrdMkts()](#MarketData.exchangeFeePrdMkts) ⇒
### new MarketData(config)
Constructor
| Param | Type | Description | | --- | --- | --- | | config |NodeSDKConfig | Configuration object, see PerpetualDataHandler.readSDKConfig.
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // load configuration for Polygon zkEVM (testnet) const config = PerpetualDataHandler.readSDKConfig("cardona"); // MarketData (read only, no authentication needed) let mktData = new MarketData(config); // Create a proxy instance to access the blockchain await mktData.createProxyInstance(); } main(); ``` ### marketData.createProxyInstance(providerOrMarketData)Initialize the marketData-Class with this function to create instance of D8X perpetual contract and gather information about perpetual currencies
**Kind**: instance method of [MarketData](#MarketData)
| Param | Description |
| --- | --- |
| providerOrMarketData | optional provider or existing market data instance
| ### marketData.getProxyAddress() ⇒string
Get the proxy address
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: string - Address of the perpetual proxy contract
### marketData.getTriangulations() ⇒Get the pre-computed triangulations
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: Triangulations
### marketData.smartContractOrderToOrder(smOrder) ⇒Order
Convert the smart contract output of an order into a convenient format of type "Order"
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: Order - more convenient format of order, type "Order"
| Param | Type | Description | | --- | --- | --- | | smOrder | [SmartContractOrder](#SmartContractOrder) | SmartContractOrder, as obtained e.g., by PerpetualLimitOrderCreated event
| ### marketData.getReadOnlyProxyInstance() ⇒Get contract instance. Useful for event listening.
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: read-only proxy instance
**Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // Get contract instance let proxy = await mktData.getReadOnlyProxyInstance(); console.log(proxy); } main(); ``` ### marketData.exchangeInfo() ⇒ [ExchangeInfo](#ExchangeInfo)
Information about the products traded in the exchange.
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: [ExchangeInfo](#ExchangeInfo) - Array of static data for all the pools and perpetuals in the system.
**Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // Get exchange info let info = await mktData.exchangeInfo(); console.log(info); } main(); ``` ### marketData.openOrders(traderAddr, symbol) ⇒All open orders for a trader-address and a symbol.
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: For each perpetual an array of open orders and corresponding order-ids.
| Param | Type | Description | | --- | --- | --- | | traderAddr |string | Address of the trader for which we get the open orders.
| | symbol |string | Symbol of the form ETH-USD-MATIC or a pool symbol, or undefined. If a poolSymbol is provided, the response includes orders in all perpetuals of the given pool. If no symbol is provided, the response includes orders from all perpetuals in all pools.
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // Get all open orders for a trader/symbol let opOrder = await mktData.openOrders("0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B", "ETH-USD-MATIC"); console.log(opOrder); } main(); ``` ### marketData.positionRisk(traderAddr, symbol) ⇒Array.<MarginAccount>
Information about the position open by a given trader in a given perpetual contract, or for all perpetuals in a pool
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: Array.<MarginAccount> - Array of position risks of trader.
| Param | Type | Description | | --- | --- | --- | | traderAddr |string | Address of the trader for which we get the position risk.
| | symbol |string | Symbol of the form ETH-USD-MATIC, or pool symbol ("MATIC") to get all positions in a given pool, or no symbol to get all positions in all pools.
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // Get position risk info let posRisk = await mktData.positionRisk("0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B", "ETH-USD-MATIC"); console.log(posRisk); } main(); ``` ### marketData.positionRiskOnTrade(traderAddr, order, signedPositionNotionalBaseCCY, tradingFeeTbps, indexPriceInfo) ⇒Estimates what the position risk will be if a given order is executed.
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: Position risk after trade, including order cost and maximal trade sizes for position
| Param | Description | | --- | --- | | traderAddr |Address of trader
| | order |Order to be submitted
| | signedPositionNotionalBaseCCY |signed position notional of current position (before trade)
| | tradingFeeTbps |trading fee in tenth of basis points (exchange fee and broker fee)
| | indexPriceInfo |Index prices and market status (open/closed). Defaults to current market status if not given.
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); const mktData = new MarketData(config); await mktData.createProxyInstance(); const order: Order = { symbol: "MATIC-USD-MATIC", side: "BUY", type: "MARKET", quantity: 100, leverage: 2, executionTimestamp: Date.now()/1000, }; // Get position risk conditional on this order being executed const posRisk = await mktData.positionRiskOnTrade("0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B", order, 0, 60); console.log(posRisk); } main(); ``` ### marketData.positionRiskOnCollateralAction(deltaCollateral, account) ⇒MarginAccount
Estimates what the position risk will be if given amount of collateral is added/removed from the account.
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: MarginAccount - Position risk after collateral has been added/removed
| Param | Type | Description | | --- | --- | --- | | deltaCollateral |number | Amount of collateral to add or remove (signed)
| | account |MarginAccount | Position risk before collateral is added or removed
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); const mktData = new MarketData(config); await mktData.createProxyInstance(); // Get position risk conditional on removing 3.14 MATIC const traderAddr = "0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B"; const curPos = await mktData.positionRisk("traderAddr", "BTC-USD-MATIC"); const posRisk = await mktData.positionRiskOnCollateralAction(-3.14, curPos); console.log(posRisk); } main(); ``` ### marketData.getWalletBalance(address, symbol) ⇒Gets the wallet balance in the settlement currency corresponding to a given perpetual symbol. The settlement currency is usually the same as the collateral currency.
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: Perpetual's collateral token balance of the given address.
| Param | Description | | --- | --- | | address |Address to check
| | symbol |Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); let md = new MarketData(config); await md.createProxyInstance(); // get MATIC balance of address let marginTokenBalance = await md.getWalletBalance(myaddress, "BTC-USD-MATIC"); console.log(marginTokenBalance); } main(); ``` ### marketData.getPoolShareTokenBalance(address, symbolOrId) ⇒number
Get the address' balance of the pool share token
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: number - Pool share token balance of the given address (e.g. dMATIC balance)
| Param | Type | Description | | --- | --- | --- | | address |string | address of the liquidity provider
| | symbolOrId |string \| number | Symbol of the form ETH-USD-MATIC, or MATIC (collateral only), or Pool-Id
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); let md = new MarketData(config); await md.createProxyInstance(); // get dMATIC balance of address let shareTokenBalance = await md.getPoolShareTokenBalance(myaddress, "MATIC"); console.log(shareTokenBalance); } main(); ``` ### marketData.getShareTokenPrice(symbolOrId) ⇒number
Value of pool token in collateral currency
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: number - current pool share token price in collateral currency
| Param | Type | Description | | --- | --- | --- | | symbolOrId |string \| number | symbol of the form ETH-USD-MATIC, MATIC (collateral), or poolId
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); let md = new MarketData(config); await md.createProxyInstance(); // get price of 1 dMATIC in MATIC let shareTokenPrice = await md.getShareTokenPrice(myaddress, "MATIC"); console.log(shareTokenPrice); } main(); ``` ### marketData.getParticipationValue(address, symbolOrId) ⇒Value of the pool share tokens for this liquidity provider in poolSymbol-currency (e.g. MATIC, USDC).
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: the value (in collateral tokens) of the pool share, #share tokens, shareTokenAddress
| Param | Type | Description | | --- | --- | --- | | address |string | address of liquidity provider
| | symbolOrId |string \| number | symbol of the form ETH-USD-MATIC, MATIC (collateral), or poolId
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); let md = new MarketData(config); await md.createProxyInstance(); // get value of pool share token let shareToken = await md.getParticipationValue(myaddress, "MATIC"); console.log(shareToken); } main(); ``` ### marketData.maxOrderSizeForTrader(traderAddr, symbol) ⇒Gets the maximal order sizes to open/close/flip positions, both long and short, considering the existing position, state of the perpetual Accounts for user's wallet balance only in rmMaxOrderSizeForTrader case.
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: Maximal buy and sell trade sizes (positive)
| Param | Type | Description | | --- | --- | --- | | traderAddr |string | Address of trader
| | symbol |symbol | Symbol of the form ETH-USD-MATIC
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); let md = new MarketData(config); await md.createProxyInstance(); // max order sizes let shareToken = await md.maxOrderSizeForTrader(myaddress, "BTC-USD-MATIC"); console.log(shareToken); // {buy: 314, sell: 415} } main(); ``` ### marketData.pmMaxOrderSizeForTrader(traderAddr, symbol, overrides) ⇒pmMaxOrderSizeForTrader returns the max order size for the trader that is possible from AMM perspective (agnostic about wallet balance and leverage, also correct if trader is shrinking their position)
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: buy: number; sell: number absolute
| Param | Description | | --- | --- | | traderAddr |address of trader
| | symbol |perp symbol
| | overrides |optional
| ### marketData.getMaxShortLongTrade(perpId, currentTraderPos, overrides) ⇒Returns the maximal allowed short trade and long trade (signed) for a trader that has a given notional (in ABDK format) in the perpetual, ignoring the traders wallet balance
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: [maxShortPos, maxLongPos] signed maximal trade sizes
| Param | Description | | --- | --- | | perpId | | | currentTraderPos |ABDK64x64 signed notional position of trader
| | overrides | | ### marketData.rmMaxOrderSizeForTrader(traderAddr, symbol, overrides) ⇒Returns the maximal order size. Also applies to closing positions.
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: max buy and sell order size in absolute terms
| Param | Description | | --- | --- | | traderAddr |trader addr to get their position
| | symbol |symbol we are trading
| | overrides | | ### marketData.maxSignedPosition(side, symbol) ⇒number
Perpetual-wide maximal signed position size in perpetual.
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: number - signed maximal position size in base currency
| Param | Type | Description | | --- | --- | --- | | side | |BUY_SIDE or SELL_SIDE
| | symbol |string | of the form ETH-USD-MATIC.
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get oracle price let maxLongPos = await mktData.maxSignedPosition(BUY_SIDE, "BTC-USD-MATIC"); console.log(maxLongPos); } main(); ``` ### marketData.getOraclePrice(base, quote) ⇒number
Uses the Oracle(s) in the exchange to get the latest price of a given index in a given currency, if a route exists.
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: number - Price of index in given currency.
| Param | Type | Description | | --- | --- | --- | | base |string | Index name, e.g. ETH.
| | quote |string | Quote currency, e.g. USD.
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get oracle price let price = await mktData.getOraclePrice("ETH", "USD"); console.log(price); } main(); ``` ### marketData.getOrderStatus(symbol, orderId, overrides) ⇒Get the status of an order given a symbol and order Id
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: Order status (cancelled = 0, executed = 1, open = 2, unkown = 3)
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-MATIC
| | orderId |Order Id
| | overrides | | **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get order stauts let status = await mktData.getOrderStatus("ETH-USD-MATIC", "0xmyOrderId"); console.log(status); } main(); ``` ### marketData.getOrdersStatus(symbol, orderId) ⇒Get the status of an array of orders given a symbol and their Ids
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: Array of order status
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-MATIC
| | orderId |Array of order Ids
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get order stauts let status = await mktData.getOrdersStatus("ETH-USD-MATIC", ["0xmyOrderId1", "0xmyOrderId2"]); console.log(status); } main(); ``` ### marketData.getMarkPrice(symbol, indexPrices) ⇒number
Get the current mark price
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: number - mark price
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| | indexPrices |optional. IdxPriceInfo
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get mark price let price = await mktData.getMarkPrice("ETH-USD-MATIC"); console.log(price); } main(); ``` ### marketData.getPerpetualPrice(symbol, quantity, priceInfo) ⇒number
get the current price for a given quantity
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: number - price
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| | quantity |quantity to be traded, negative if short
| | priceInfo |[s2, s3, conf, params]; for non-prediction markets conf/params can be 0
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get perpetual price let price = await mktData.getPerpetualPrice("ETH-USD-MATIC", 1); console.log(price); } main(); ``` ### marketData.getPerpetualState(symbol) ⇒PerpetualState
Query recent perpetual state from blockchain
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: PerpetualState - PerpetualState copy
| Param | Type | Description | | --- | --- | --- | | symbol |string | symbol of the form ETH-USD-MATIC
| ### marketData.getPoolState(poolSymbol) ⇒ [PoolState](#PoolState)
Query recent pool state from blockchain, not including perpetual states
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: [PoolState](#PoolState) - PoolState copy
| Param | Type | Description | | --- | --- | --- | | poolSymbol |string | symbol of the form USDC
| ### marketData.getPerpetualStaticInfo(symbol) ⇒PerpetualStaticInfo
Query perpetual static info. This information is queried once at createProxyInstance-time, and remains static after that.
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: PerpetualStaticInfo - Perpetual static info copy.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Perpetual symbol
| ### marketData.getPerpetualMidPrice(symbol) ⇒number
get the current mid-price for a perpetual
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: number - price
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get perpetual mid price let midPrice = await mktData.getPerpetualMidPrice("ETH-USD-MATIC"); console.log(midPrice); } main(); ``` ### marketData.getAvailableMargin(traderAddr, symbol, indexPrices) ⇒Query the available margin conditional on the given (or current) index prices Result is in collateral currency
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: available margin in collateral currency
| Param | Type | Description | | --- | --- | --- | | traderAddr |string | address of the trader
| | symbol |string | perpetual symbol of the form BTC-USD-MATIC
| | indexPrices | |optional indexPriceInfo
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get available margin let mgn = await mktData.getAvailableMargin("0xmyAddress", "ETH-USD-MATIC"); console.log(mgn); } main(); ``` ### marketData.getTraderLoyalityScore(traderAddr) ⇒number
Calculate a type of exchange loyality score based on trader volume
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: number - a loyality score (4 worst, 1 best)
| Param | Type | Description | | --- | --- | --- | | traderAddr |string | address of the trader
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get scpre let s = await mktData.getTraderLoyalityScore("0xmyAddress"); console.log(s); } main(); ``` ### marketData.isMarketClosed(symbol) ⇒boolean
Get market open/closed status
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: boolean - True if the market is closed
| Param | Type | Description | | --- | --- | --- | | symbol |string | Perpetual symbol of the form ETH-USD-MATIC
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // is market closed? let s = await mktData.isMarketClosed("ETH-USD-MATIC"); console.log(s); } main(); ``` ### marketData.getPriceInUSD(symbol) ⇒Map.<string, number>
Get the latest on-chain price of a perpetual base index in USD.
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: Map.<string, number> - Price of the base index in USD, e.g. for ETH-USDC-MATIC, it returns the value of ETH-USD.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USDC-MATIC. If a pool symbol is used, it returns an array of all the USD prices of the indices in the pool. If no argument is provided, it returns all prices of all the indices in the pools of the exchange.
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // is market closed? let px = await mktData.getPriceInUSD("ETH-USDC-USDC"); console.log(px); // {'ETH-USD' -> 1800} } main(); ``` ### marketData.fetchPricesForPerpetual(symbol) ⇒Fetch latest off-chain index and collateral prices
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: Prices and market-closed information
| Param | Description | | --- | --- | | symbol |Perpetual symbol of the form BTC-USDc-USDC
| ### marketData.fetchPrdMktMetaData(symbol) ⇒fetch prediction markets meta data
**Kind**: instance method of [MarketData](#MarketData)
**Returns**: question for given symbol
| Param | Description | | --- | --- | | symbol |symbol of the form "TRUMP24-USD"
| ### marketData.fetchPythMetaData(symbol) ⇒Fetch Pyth metadata of a given symbol. The priority is:
MarketData](#MarketData)
**Returns**: description of feed underlying given symbol
| Param | Description | | --- | --- | | symbol |symbol of the form "BERA-USD"
| ### marketData.fetchSymbolList()sets the symbollist if a remote config url is specified
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [fetchSymbolList](#PerpetualDataHandler+fetchSymbolList)
### marketData.getOrderBookContract(symbol) ⇒
Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getOrderBookContract](#PerpetualDataHandler+getOrderBookContract)
**Returns**: order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### marketData.getOrderBookAddress(symbol) ⇒Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getOrderBookAddress](#PerpetualDataHandler+getOrderBookAddress)
**Returns**: order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### marketData.getPerpetuals(ids, overrides) ⇒Get perpetuals for the given ids from onchain
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getPerpetuals](#PerpetualDataHandler+getPerpetuals)
**Returns**: array of PerpetualData converted into decimals
| Param | Description | | --- | --- | | ids |perpetual ids
| | overrides |optional
| ### marketData.getLiquidityPools(fromIdx, toIdx, overrides) ⇒Get liquidity pools data
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getLiquidityPools](#PerpetualDataHandler+getLiquidityPools)
**Returns**: array of LiquidityPoolData converted into decimals
| Param | Description | | --- | --- | | fromIdx |starting index (>=1)
| | toIdx |to index (inclusive)
| | overrides |optional
| ### marketData.\_fillSymbolMaps()Called when initializing. This function fills this.symbolToTokenAddrMap, and this.nestedPerpetualIDs and this.symbolToPerpStaticInfo
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [\_fillSymbolMaps](#PerpetualDataHandler+_fillSymbolMaps)
### marketData.initSettlementToken(perpStaticInfos)
Initializes settlement currency for all pools by completing this.poolStaticInfos with settlement currency info
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [initSettlementToken](#PerpetualDataHandler+initSettlementToken)
| Param | Description |
| --- | --- |
| perpStaticInfos | PerpetualStaticInfo array from contract call
| ### marketData.getSymbolFromPoolId(poolId) ⇒symbol
Get pool symbol given a pool Id.
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getSymbolFromPoolId](#PerpetualDataHandler+getSymbolFromPoolId)
**Returns**: symbol - Pool symbol, e.g. "USDC".
| Param | Type | Description | | --- | --- | --- | | poolId |number | Pool Id.
| ### marketData.getPoolIdFromSymbol(symbol) ⇒number
Get pool Id given a pool symbol. Pool IDs start at 1.
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getPoolIdFromSymbol](#PerpetualDataHandler+getPoolIdFromSymbol)
**Returns**: number - Pool Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Pool symbol.
| ### marketData.getPerpIdFromSymbol(symbol) ⇒number
Get perpetual Id given a perpetual symbol.
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getPerpIdFromSymbol](#PerpetualDataHandler+getPerpIdFromSymbol)
**Returns**: number - Perpetual Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Perpetual symbol, e.g. "BTC-USD-MATIC".
| ### marketData.getSymbolFromPerpId(perpId) ⇒string
Get the symbol in long format of the perpetual id
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getSymbolFromPerpId](#PerpetualDataHandler+getSymbolFromPerpId)
**Returns**: string - Symbol
| Param | Type | Description | | --- | --- | --- | | perpId |number | perpetual id
| ### marketData.symbol4BToLongSymbol(sym) ⇒string
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [symbol4BToLongSymbol](#PerpetualDataHandler+symbol4BToLongSymbol)
**Returns**: string - Long symbol
| Param | Type | Description | | --- | --- | --- | | sym |string | Short symbol
| ### marketData.fetchPriceSubmissionInfoForPerpetual(symbol) ⇒Get PriceFeedSubmission data required for blockchain queries that involve price data, and the corresponding triangulated prices for the indices S2 and S3
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [fetchPriceSubmissionInfoForPerpetual](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual)
**Returns**: PriceFeedSubmission and prices for S2 and S3. [S2price, 0] if S3 not defined.
| Param | Description | | --- | --- | | symbol |pool symbol of the form "ETH-USD-MATIC"
| ### marketData.getIndexSymbols(symbol) ⇒Get the symbols required as indices for the given perpetual
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getIndexSymbols](#PerpetualDataHandler+getIndexSymbols)
**Returns**: name of underlying index prices, e.g. ["MATIC-USD", ""]
| Param | Description | | --- | --- | | symbol |of the form ETH-USD-MATIC, specifying the perpetual
| ### marketData.fetchLatestFeedPriceInfo(symbol) ⇒Get the latest prices for a given perpetual from the offchain oracle networks
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [fetchLatestFeedPriceInfo](#PerpetualDataHandler+fetchLatestFeedPriceInfo)
**Returns**: array of price feed updates that can be submitted to the smart contract and corresponding price information
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form BTC-USD-MATIC
| ### marketData.fetchCollateralToSettlementConversion(symbol)fetchCollateralToSettlementConversion returns the price which converts the collateral currency into settlement currency. For example if BTC-USD-STUSD has settlement currency USDC, we get let px = fetchCollateralToSettlementConversion("BTC-USD-STUSD") valueInUSDC = collateralInSTUSD * px
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [fetchCollateralToSettlementConversion](#PerpetualDataHandler+fetchCollateralToSettlementConversion)
| Param | Description |
| --- | --- |
| symbol | either perpetual symbol of the form BTC-USD-MATIC or just collateral token
| ### marketData.getPriceIds(symbol) ⇒Get list of required pyth price source IDs for given perpetual
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getPriceIds](#PerpetualDataHandler+getPriceIds)
**Returns**: list of required pyth price sources for this perpetual
| Param | Description | | --- | --- | | symbol |perpetual symbol, e.g., BTC-USD-MATIC
| ### marketData.getPerpetualSymbolsInPool(poolSymbol) ⇒Get ('normal'-state) perpetual symbols for a given pool
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getPerpetualSymbolsInPool](#PerpetualDataHandler+getPerpetualSymbolsInPool)
**Returns**: array of perpetual symbols in this pool
| Param | Description | | --- | --- | | poolSymbol |pool symbol such as "MATIC"
| ### marketData.getAllOpenOrders(symbol) ⇒All the orders in the order book for a given symbol that are currently open.
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getAllOpenOrders](#PerpetualDataHandler+getAllOpenOrders)
**Returns**: Array with all open orders and their IDs.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Total number of limit orders for this symbol, excluding those that have been cancelled/removed.
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [numberOfOpenOrders](#PerpetualDataHandler+numberOfOpenOrders)
**Returns**: number - Number of open orders.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Get a list of active conditional orders in the order book. This a read-only action and does not incur in gas costs.
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [pollLimitOrders](#PerpetualDataHandler+pollLimitOrders)
**Returns**: Array of orders and corresponding order IDs
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| | numElements |number | Maximum number of orders to poll.
| | [startAfter] |string | Optional order ID from where to start polling. Defaults to the first order.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Gets the pool index (starting at 0 in exchangeInfo, not ID!) corresponding to a given symbol.
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getPoolStaticInfoIndexFromSymbol](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol)
**Returns**: Pool index
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-MATIC
| ### marketData.getMarginTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getMarginTokenFromSymbol](#PerpetualDataHandler+getMarginTokenFromSymbol)
**Returns**: Address of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### marketData.getSettlementTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getSettlementTokenFromSymbol](#PerpetualDataHandler+getSettlementTokenFromSymbol)
**Returns**: Address of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### marketData.getMarginTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getMarginTokenDecimalsFromSymbol](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol)
**Returns**: Decimals of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### marketData.getSettlementTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getSettlementTokenDecimalsFromSymbol](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol)
**Returns**: Decimals of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### marketData.getABI(contract) ⇒Get ABI for LimitOrderBook, Proxy, or Share Pool Token
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getABI](#PerpetualDataHandler+getABI)
**Returns**: ABI for the requested contract
| Param | Description | | --- | --- | | contract |name of contract: proxy|lob|sharetoken
| ### marketData.isPredictionMarket(symbol) ⇒Determines whether a given perpetual represents a prediction market
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [isPredictionMarket](#PerpetualDataHandler+isPredictionMarket)
**Returns**: True if this is a prediction market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form TRUMP24-USD-USDC
| ### marketData.isLowLiquidityMarket(symbol) ⇒Determines whether a given perpetual represents a low-liquidity market
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [isLowLiquidityMarket](#PerpetualDataHandler+isLowLiquidityMarket)
**Returns**: True if this is a low-liquidity market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form DIRAC-HONEY-USDC
| ### marketData.isTradFiMarket(symbol) ⇒Determines whether a given perpetual represents a tradfi market
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [isTradFiMarket](#PerpetualDataHandler+isTradFiMarket)
**Returns**: True if this is a tradfi market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### marketData.getMarketDayTradingOpenCloseSec(symbol) ⇒Returns day trading times for tradfi markets
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getMarketDayTradingOpenCloseSec](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec)
**Returns**: open time in seconds within day, close time in seconds within day
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### marketData.getInitialMarginRate(symbol) ⇒getInitialMarginRate
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getInitialMarginRate](#PerpetualDataHandler+getInitialMarginRate)
**Returns**: initial margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### marketData.getMaintenanceMarginRate(symbol) ⇒getMaintenanceMarginRate
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getMaintenanceMarginRate](#PerpetualDataHandler+getMaintenanceMarginRate)
**Returns**: maintenance margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### marketData.getShortSymbol(symbol) ⇒Short symbol corresponding to a given long symbol.
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getShortSymbol](#PerpetualDataHandler+getShortSymbol)
**Returns**: Short symbol (e.g. NHL0)
| Param | Description | | --- | --- | | symbol |Long symbol (e.g. NHL_TOR_DAL_251015)
| ### marketData.refreshSymbols()Refreshes symbol mappings if at least one prediction market is expired
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [refreshSymbols](#PerpetualDataHandler+refreshSymbols)
### marketData.getLocalPerpetualStates() ⇒
Get state of perpetuals as currently known locally
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [getLocalPerpetualStates](#PerpetualDataHandler+getLocalPerpetualStates)
**Returns**: Array of [perpetual Id, perpetual state (string)]
### marketData.fetchOnChainPerpetualStates() ⇒Fetches on-chain state of local perpetual ids. Does not run if SDK is not ready.
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [fetchOnChainPerpetualStates](#PerpetualDataHandler+fetchOnChainPerpetualStates)
**Returns**: Array of [perpetual Id, perpetual state (string)]
### marketData.checkHeartbeat() ⇒Check that states of all perps known locally match on-chain states
**Kind**: instance method of [MarketData](#MarketData)
**Overrides**: [checkHeartbeat](#PerpetualDataHandler+checkHeartbeat)
**Returns**: True if all perp states are correct
### MarketData.exchangeFeePrdMkts() ⇒Fee is relative to base-currency amount (=trade amount)
**Kind**: static method of [MarketData](#MarketData)
**Returns**: relative exchange fee in decimals
## OnChainPxFeedOnChainPxFeed: get a price from a chainlink-style oracle
**Kind**: global class ## OnChainPxFeedAngleOnChainPxFeedAngle: get STUSD-USDC exchange rate
**Kind**: global class ## OnChainPxFeedRedStoneOnChainPxFeedRedStone: get a price from a chainlink-style oracle
**Kind**: global class ## OrderExecutorTool ⇐ [WriteAccessHandler](#WriteAccessHandler)
Functions to execute existing conditional orders from the limit order book. This class requires a private key and executes smart-contract interactions that require gas-payments.
**Kind**: global class **Extends**: [WriteAccessHandler](#WriteAccessHandler)
* [OrderExecutorTool](#OrderExecutorTool) ⇐ [WriteAccessHandler](#WriteAccessHandler)
* [new OrderExecutorTool(config, signer)](#new_OrderExecutorTool_new)
* [.executeOrder(symbol, orderId, executorAddr, nonce, [submission])](#OrderExecutorTool+executeOrder) ⇒
* [.executeOrders(symbol, orderIds, executorAddr, nonce, [submission])](#OrderExecutorTool+executeOrders) ⇒
* [.getOrderById(symbol, digest)](#OrderExecutorTool+getOrderById) ⇒
* [.isTradeable(order, indexPrices)](#OrderExecutorTool+isTradeable) ⇒
* [.isTradeableBatch(orders, indexPrice)](#OrderExecutorTool+isTradeableBatch) ⇒
* [.smartContractOrderToOrder(scOrder)](#OrderExecutorTool+smartContractOrderToOrder) ⇒
* [.getTransactionCount(blockTag)](#OrderExecutorTool+getTransactionCount) ⇒
* [.createProxyInstance(provider)](#WriteAccessHandler+createProxyInstance)
* [.setAllowance(symbol, amount)](#WriteAccessHandler+setAllowance) ⇒
* [.getAddress()](#WriteAccessHandler+getAddress) ⇒ string
* [.swapForMockToken(symbol, amountToPay)](#WriteAccessHandler+swapForMockToken) ⇒
* [.fetchSymbolList()](#PerpetualDataHandler+fetchSymbolList)
* [.getOrderBookContract(symbol)](#PerpetualDataHandler+getOrderBookContract) ⇒
* [.getOrderBookAddress(symbol)](#PerpetualDataHandler+getOrderBookAddress) ⇒
* [.getPerpetuals(ids, overrides)](#PerpetualDataHandler+getPerpetuals) ⇒
* [.getLiquidityPools(fromIdx, toIdx, overrides)](#PerpetualDataHandler+getLiquidityPools) ⇒
* [._fillSymbolMaps()](#PerpetualDataHandler+_fillSymbolMaps)
* [.initSettlementToken(perpStaticInfos)](#PerpetualDataHandler+initSettlementToken)
* [.getSymbolFromPoolId(poolId)](#PerpetualDataHandler+getSymbolFromPoolId) ⇒ symbol
* [.getPoolIdFromSymbol(symbol)](#PerpetualDataHandler+getPoolIdFromSymbol) ⇒ number
* [.getPerpIdFromSymbol(symbol)](#PerpetualDataHandler+getPerpIdFromSymbol) ⇒ number
* [.getSymbolFromPerpId(perpId)](#PerpetualDataHandler+getSymbolFromPerpId) ⇒ string
* [.symbol4BToLongSymbol(sym)](#PerpetualDataHandler+symbol4BToLongSymbol) ⇒ string
* [.fetchPriceSubmissionInfoForPerpetual(symbol)](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual) ⇒
* [.getIndexSymbols(symbol)](#PerpetualDataHandler+getIndexSymbols) ⇒
* [.fetchLatestFeedPriceInfo(symbol)](#PerpetualDataHandler+fetchLatestFeedPriceInfo) ⇒
* [.fetchCollateralToSettlementConversion(symbol)](#PerpetualDataHandler+fetchCollateralToSettlementConversion)
* [.getPriceIds(symbol)](#PerpetualDataHandler+getPriceIds) ⇒
* [.getPerpetualSymbolsInPool(poolSymbol)](#PerpetualDataHandler+getPerpetualSymbolsInPool) ⇒
* [.getAllOpenOrders(symbol)](#PerpetualDataHandler+getAllOpenOrders) ⇒
* [.numberOfOpenOrders(symbol)](#PerpetualDataHandler+numberOfOpenOrders) ⇒ number
* [.pollLimitOrders(symbol, numElements, [startAfter])](#PerpetualDataHandler+pollLimitOrders) ⇒
* [.getPoolStaticInfoIndexFromSymbol(symbol)](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol) ⇒
* [.getMarginTokenFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenFromSymbol) ⇒
* [.getSettlementTokenFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenFromSymbol) ⇒
* [.getMarginTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol) ⇒
* [.getSettlementTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol) ⇒
* [.getABI(contract)](#PerpetualDataHandler+getABI) ⇒
* [.isPredictionMarket(symbol)](#PerpetualDataHandler+isPredictionMarket) ⇒
* [.isLowLiquidityMarket(symbol)](#PerpetualDataHandler+isLowLiquidityMarket) ⇒
* [.isTradFiMarket(symbol)](#PerpetualDataHandler+isTradFiMarket) ⇒
* [.getMarketDayTradingOpenCloseSec(symbol)](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec) ⇒
* [.getInitialMarginRate(symbol)](#PerpetualDataHandler+getInitialMarginRate) ⇒
* [.getMaintenanceMarginRate(symbol)](#PerpetualDataHandler+getMaintenanceMarginRate) ⇒
* [.getShortSymbol(symbol)](#PerpetualDataHandler+getShortSymbol) ⇒
* [.refreshSymbols()](#PerpetualDataHandler+refreshSymbols)
* [.getLocalPerpetualStates()](#PerpetualDataHandler+getLocalPerpetualStates) ⇒
* [.fetchOnChainPerpetualStates()](#PerpetualDataHandler+fetchOnChainPerpetualStates) ⇒
* [.checkHeartbeat()](#PerpetualDataHandler+checkHeartbeat) ⇒
### new OrderExecutorTool(config, signer)
Constructor.
| Param | Type | Description | | --- | --- | --- | | config |NodeSDKConfig | Configuration object, see PerpetualDataHandler.readSDKConfig.
| | signer |string \| Signer | Private key or ethers Signer of the account
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // load configuration for Polygon zkEVM (testnet) const config = PerpetualDataHandler.readSDKConfig("cardona"); // OrderExecutorTool (authentication required, PK is an environment variable with a private key) const pk: string =Executes an order by symbol and ID. This action interacts with the blockchain and incurs gas costs.
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Returns**: Transaction object.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| | orderId |string | ID of the order to be executed.
| | executorAddr |string | optional address of the wallet to be credited for executing the order, if different from the one submitting this transaction.
| | nonce |number | optional nonce
| | [submission] |PriceFeedSubmission | optional signed prices obtained via PriceFeeds::fetchLatestFeedPriceInfoForPerpetual
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler, Order } from "@d8x/perpetuals-sdk"; async function main() { console.log(OrderExecutorTool); // Setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Executes a list of orders of the symbol. This action interacts with the blockchain and incurs gas costs.
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Returns**: Transaction object.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| | orderIds |Array.<string> | IDs of the orders to be executed.
| | executorAddr |string | optional address of the wallet to be credited for executing the order, if different from the one submitting this transaction.
| | nonce |number | optional nonce
| | [submission] |PriceFeedSubmission | optional signed prices obtained via PriceFeeds::fetchLatestFeedPriceInfoForPerpetual
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler, Order } from "@d8x/perpetuals-sdk"; async function main() { console.log(OrderExecutorTool); // Setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Get order from the digest (=id)
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Returns**: order or undefined
| Param | Description | | --- | --- | | symbol |symbol of order book, e.g. ETH-USD-MATIC
| | digest |digest of the order (=order ID)
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Check if a conditional order can be executed
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Returns**: true if order can be executed for the current state of the perpetuals
| Param | Description | | --- | --- | | order |order structure
| | indexPrices |pair of index prices S2 and S3. S3 set to zero if not required. If undefined the function will fetch the latest prices from the REST API
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Check for a batch of orders on the same perpetual whether they can be traded
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Returns**: array of tradeable boolean
| Param | Description | | --- | --- | | orders |orders belonging to 1 perpetual
| | indexPrice |S2,S3-index prices for the given perpetual. Will fetch prices from REST API if not defined.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Wrapper of static method to use after mappings have been loaded into memory.
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Returns**: A user-friendly order struct.
| Param | Description | | --- | --- | | scOrder |Perpetual order as received in the proxy events.
| ### orderExecutorTool.getTransactionCount(blockTag) ⇒Gets the current transaction count for the connected signer
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Returns**: The nonce for the next transaction
| Param | | --- | | blockTag | ### orderExecutorTool.createProxyInstance(provider)Initialize the writeAccessHandler-Class with this function to create instance of D8X perpetual contract and gather information about perpetual currencies
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [createProxyInstance](#WriteAccessHandler+createProxyInstance)
| Param | Description |
| --- | --- |
| provider | optional provider
| ### orderExecutorTool.setAllowance(symbol, amount) ⇒Set allowance for ar margin token (e.g., MATIC, ETH, USDC)
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [setAllowance](#WriteAccessHandler+setAllowance)
**Returns**: Contract Transaction
| Param | Description | | --- | --- | | symbol |token in 'long-form' such as MATIC, symbol also fine (ETH-USD-MATIC)
| | amount |optional, amount to approve if not 'infinity'
| ### orderExecutorTool.getAddress() ⇒string
Address corresponding to the private key used to instantiate this class.
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getAddress](#WriteAccessHandler+getAddress)
**Returns**: string - Address of this wallet.
### orderExecutorTool.swapForMockToken(symbol, amountToPay) ⇒Converts a given amount of chain native currency (test MATIC) into a mock token used for trading on testnet, with a rate of 1:100_000
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [swapForMockToken](#WriteAccessHandler+swapForMockToken)
**Returns**: Transaction object
| Param | Description | | --- | --- | | symbol |Pool margin token e.g. MATIC
| | amountToPay |Amount in chain currency, e.g. "0.1" for 0.1 MATIC
| ### orderExecutorTool.fetchSymbolList()sets the symbollist if a remote config url is specified
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [fetchSymbolList](#PerpetualDataHandler+fetchSymbolList)
### orderExecutorTool.getOrderBookContract(symbol) ⇒
Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getOrderBookContract](#PerpetualDataHandler+getOrderBookContract)
**Returns**: order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### orderExecutorTool.getOrderBookAddress(symbol) ⇒Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getOrderBookAddress](#PerpetualDataHandler+getOrderBookAddress)
**Returns**: order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### orderExecutorTool.getPerpetuals(ids, overrides) ⇒Get perpetuals for the given ids from onchain
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getPerpetuals](#PerpetualDataHandler+getPerpetuals)
**Returns**: array of PerpetualData converted into decimals
| Param | Description | | --- | --- | | ids |perpetual ids
| | overrides |optional
| ### orderExecutorTool.getLiquidityPools(fromIdx, toIdx, overrides) ⇒Get liquidity pools data
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getLiquidityPools](#PerpetualDataHandler+getLiquidityPools)
**Returns**: array of LiquidityPoolData converted into decimals
| Param | Description | | --- | --- | | fromIdx |starting index (>=1)
| | toIdx |to index (inclusive)
| | overrides |optional
| ### orderExecutorTool.\_fillSymbolMaps()Called when initializing. This function fills this.symbolToTokenAddrMap, and this.nestedPerpetualIDs and this.symbolToPerpStaticInfo
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [\_fillSymbolMaps](#PerpetualDataHandler+_fillSymbolMaps)
### orderExecutorTool.initSettlementToken(perpStaticInfos)
Initializes settlement currency for all pools by completing this.poolStaticInfos with settlement currency info
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [initSettlementToken](#PerpetualDataHandler+initSettlementToken)
| Param | Description |
| --- | --- |
| perpStaticInfos | PerpetualStaticInfo array from contract call
| ### orderExecutorTool.getSymbolFromPoolId(poolId) ⇒symbol
Get pool symbol given a pool Id.
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getSymbolFromPoolId](#PerpetualDataHandler+getSymbolFromPoolId)
**Returns**: symbol - Pool symbol, e.g. "USDC".
| Param | Type | Description | | --- | --- | --- | | poolId |number | Pool Id.
| ### orderExecutorTool.getPoolIdFromSymbol(symbol) ⇒number
Get pool Id given a pool symbol. Pool IDs start at 1.
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getPoolIdFromSymbol](#PerpetualDataHandler+getPoolIdFromSymbol)
**Returns**: number - Pool Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Pool symbol.
| ### orderExecutorTool.getPerpIdFromSymbol(symbol) ⇒number
Get perpetual Id given a perpetual symbol.
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getPerpIdFromSymbol](#PerpetualDataHandler+getPerpIdFromSymbol)
**Returns**: number - Perpetual Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Perpetual symbol, e.g. "BTC-USD-MATIC".
| ### orderExecutorTool.getSymbolFromPerpId(perpId) ⇒string
Get the symbol in long format of the perpetual id
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getSymbolFromPerpId](#PerpetualDataHandler+getSymbolFromPerpId)
**Returns**: string - Symbol
| Param | Type | Description | | --- | --- | --- | | perpId |number | perpetual id
| ### orderExecutorTool.symbol4BToLongSymbol(sym) ⇒string
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [symbol4BToLongSymbol](#PerpetualDataHandler+symbol4BToLongSymbol)
**Returns**: string - Long symbol
| Param | Type | Description | | --- | --- | --- | | sym |string | Short symbol
| ### orderExecutorTool.fetchPriceSubmissionInfoForPerpetual(symbol) ⇒Get PriceFeedSubmission data required for blockchain queries that involve price data, and the corresponding triangulated prices for the indices S2 and S3
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [fetchPriceSubmissionInfoForPerpetual](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual)
**Returns**: PriceFeedSubmission and prices for S2 and S3. [S2price, 0] if S3 not defined.
| Param | Description | | --- | --- | | symbol |pool symbol of the form "ETH-USD-MATIC"
| ### orderExecutorTool.getIndexSymbols(symbol) ⇒Get the symbols required as indices for the given perpetual
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getIndexSymbols](#PerpetualDataHandler+getIndexSymbols)
**Returns**: name of underlying index prices, e.g. ["MATIC-USD", ""]
| Param | Description | | --- | --- | | symbol |of the form ETH-USD-MATIC, specifying the perpetual
| ### orderExecutorTool.fetchLatestFeedPriceInfo(symbol) ⇒Get the latest prices for a given perpetual from the offchain oracle networks
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [fetchLatestFeedPriceInfo](#PerpetualDataHandler+fetchLatestFeedPriceInfo)
**Returns**: array of price feed updates that can be submitted to the smart contract and corresponding price information
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form BTC-USD-MATIC
| ### orderExecutorTool.fetchCollateralToSettlementConversion(symbol)fetchCollateralToSettlementConversion returns the price which converts the collateral currency into settlement currency. For example if BTC-USD-STUSD has settlement currency USDC, we get let px = fetchCollateralToSettlementConversion("BTC-USD-STUSD") valueInUSDC = collateralInSTUSD * px
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [fetchCollateralToSettlementConversion](#PerpetualDataHandler+fetchCollateralToSettlementConversion)
| Param | Description |
| --- | --- |
| symbol | either perpetual symbol of the form BTC-USD-MATIC or just collateral token
| ### orderExecutorTool.getPriceIds(symbol) ⇒Get list of required pyth price source IDs for given perpetual
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getPriceIds](#PerpetualDataHandler+getPriceIds)
**Returns**: list of required pyth price sources for this perpetual
| Param | Description | | --- | --- | | symbol |perpetual symbol, e.g., BTC-USD-MATIC
| ### orderExecutorTool.getPerpetualSymbolsInPool(poolSymbol) ⇒Get ('normal'-state) perpetual symbols for a given pool
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getPerpetualSymbolsInPool](#PerpetualDataHandler+getPerpetualSymbolsInPool)
**Returns**: array of perpetual symbols in this pool
| Param | Description | | --- | --- | | poolSymbol |pool symbol such as "MATIC"
| ### orderExecutorTool.getAllOpenOrders(symbol) ⇒All the orders in the order book for a given symbol that are currently open.
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getAllOpenOrders](#PerpetualDataHandler+getAllOpenOrders)
**Returns**: Array with all open orders and their IDs.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Total number of limit orders for this symbol, excluding those that have been cancelled/removed.
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [numberOfOpenOrders](#PerpetualDataHandler+numberOfOpenOrders)
**Returns**: number - Number of open orders.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Get a list of active conditional orders in the order book. This a read-only action and does not incur in gas costs.
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [pollLimitOrders](#PerpetualDataHandler+pollLimitOrders)
**Returns**: Array of orders and corresponding order IDs
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| | numElements |number | Maximum number of orders to poll.
| | [startAfter] |string | Optional order ID from where to start polling. Defaults to the first order.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Gets the pool index (starting at 0 in exchangeInfo, not ID!) corresponding to a given symbol.
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getPoolStaticInfoIndexFromSymbol](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol)
**Returns**: Pool index
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-MATIC
| ### orderExecutorTool.getMarginTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getMarginTokenFromSymbol](#PerpetualDataHandler+getMarginTokenFromSymbol)
**Returns**: Address of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### orderExecutorTool.getSettlementTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getSettlementTokenFromSymbol](#PerpetualDataHandler+getSettlementTokenFromSymbol)
**Returns**: Address of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### orderExecutorTool.getMarginTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getMarginTokenDecimalsFromSymbol](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol)
**Returns**: Decimals of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### orderExecutorTool.getSettlementTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getSettlementTokenDecimalsFromSymbol](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol)
**Returns**: Decimals of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### orderExecutorTool.getABI(contract) ⇒Get ABI for LimitOrderBook, Proxy, or Share Pool Token
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getABI](#PerpetualDataHandler+getABI)
**Returns**: ABI for the requested contract
| Param | Description | | --- | --- | | contract |name of contract: proxy|lob|sharetoken
| ### orderExecutorTool.isPredictionMarket(symbol) ⇒Determines whether a given perpetual represents a prediction market
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [isPredictionMarket](#PerpetualDataHandler+isPredictionMarket)
**Returns**: True if this is a prediction market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form TRUMP24-USD-USDC
| ### orderExecutorTool.isLowLiquidityMarket(symbol) ⇒Determines whether a given perpetual represents a low-liquidity market
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [isLowLiquidityMarket](#PerpetualDataHandler+isLowLiquidityMarket)
**Returns**: True if this is a low-liquidity market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form DIRAC-HONEY-USDC
| ### orderExecutorTool.isTradFiMarket(symbol) ⇒Determines whether a given perpetual represents a tradfi market
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [isTradFiMarket](#PerpetualDataHandler+isTradFiMarket)
**Returns**: True if this is a tradfi market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### orderExecutorTool.getMarketDayTradingOpenCloseSec(symbol) ⇒Returns day trading times for tradfi markets
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getMarketDayTradingOpenCloseSec](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec)
**Returns**: open time in seconds within day, close time in seconds within day
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### orderExecutorTool.getInitialMarginRate(symbol) ⇒getInitialMarginRate
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getInitialMarginRate](#PerpetualDataHandler+getInitialMarginRate)
**Returns**: initial margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### orderExecutorTool.getMaintenanceMarginRate(symbol) ⇒getMaintenanceMarginRate
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getMaintenanceMarginRate](#PerpetualDataHandler+getMaintenanceMarginRate)
**Returns**: maintenance margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### orderExecutorTool.getShortSymbol(symbol) ⇒Short symbol corresponding to a given long symbol.
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getShortSymbol](#PerpetualDataHandler+getShortSymbol)
**Returns**: Short symbol (e.g. NHL0)
| Param | Description | | --- | --- | | symbol |Long symbol (e.g. NHL_TOR_DAL_251015)
| ### orderExecutorTool.refreshSymbols()Refreshes symbol mappings if at least one prediction market is expired
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [refreshSymbols](#PerpetualDataHandler+refreshSymbols)
### orderExecutorTool.getLocalPerpetualStates() ⇒
Get state of perpetuals as currently known locally
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [getLocalPerpetualStates](#PerpetualDataHandler+getLocalPerpetualStates)
**Returns**: Array of [perpetual Id, perpetual state (string)]
### orderExecutorTool.fetchOnChainPerpetualStates() ⇒Fetches on-chain state of local perpetual ids. Does not run if SDK is not ready.
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [fetchOnChainPerpetualStates](#PerpetualDataHandler+fetchOnChainPerpetualStates)
**Returns**: Array of [perpetual Id, perpetual state (string)]
### orderExecutorTool.checkHeartbeat() ⇒Check that states of all perps known locally match on-chain states
**Kind**: instance method of [OrderExecutorTool](#OrderExecutorTool)
**Overrides**: [checkHeartbeat](#PerpetualDataHandler+checkHeartbeat)
**Returns**: True if all perp states are correct
## PerpetualDataHandlerParent class for MarketData and WriteAccessHandler that handles common data and chain operations.
**Kind**: global class * [PerpetualDataHandler](#PerpetualDataHandler) * [new PerpetualDataHandler(config)](#new_PerpetualDataHandler_new) * _instance_ * [.fetchSymbolList()](#PerpetualDataHandler+fetchSymbolList) * [.getOrderBookContract(symbol)](#PerpetualDataHandler+getOrderBookContract) ⇒ * [.getOrderBookAddress(symbol)](#PerpetualDataHandler+getOrderBookAddress) ⇒ * [.getPerpetuals(ids, overrides)](#PerpetualDataHandler+getPerpetuals) ⇒ * [.getLiquidityPools(fromIdx, toIdx, overrides)](#PerpetualDataHandler+getLiquidityPools) ⇒ * [._fillSymbolMaps()](#PerpetualDataHandler+_fillSymbolMaps) * [.initSettlementToken(perpStaticInfos)](#PerpetualDataHandler+initSettlementToken) * [.getSymbolFromPoolId(poolId)](#PerpetualDataHandler+getSymbolFromPoolId) ⇒symbol
* [.getPoolIdFromSymbol(symbol)](#PerpetualDataHandler+getPoolIdFromSymbol) ⇒ number
* [.getPerpIdFromSymbol(symbol)](#PerpetualDataHandler+getPerpIdFromSymbol) ⇒ number
* [.getSymbolFromPerpId(perpId)](#PerpetualDataHandler+getSymbolFromPerpId) ⇒ string
* [.symbol4BToLongSymbol(sym)](#PerpetualDataHandler+symbol4BToLongSymbol) ⇒ string
* [.fetchPriceSubmissionInfoForPerpetual(symbol)](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual) ⇒
* [.getIndexSymbols(symbol)](#PerpetualDataHandler+getIndexSymbols) ⇒
* [.fetchLatestFeedPriceInfo(symbol)](#PerpetualDataHandler+fetchLatestFeedPriceInfo) ⇒
* [.fetchCollateralToSettlementConversion(symbol)](#PerpetualDataHandler+fetchCollateralToSettlementConversion)
* [.getPriceIds(symbol)](#PerpetualDataHandler+getPriceIds) ⇒
* [.getPerpetualSymbolsInPool(poolSymbol)](#PerpetualDataHandler+getPerpetualSymbolsInPool) ⇒
* [.getAllOpenOrders(symbol)](#PerpetualDataHandler+getAllOpenOrders) ⇒
* [.numberOfOpenOrders(symbol)](#PerpetualDataHandler+numberOfOpenOrders) ⇒ number
* [.pollLimitOrders(symbol, numElements, [startAfter])](#PerpetualDataHandler+pollLimitOrders) ⇒
* [.getPoolStaticInfoIndexFromSymbol(symbol)](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol) ⇒
* [.getMarginTokenFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenFromSymbol) ⇒
* [.getSettlementTokenFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenFromSymbol) ⇒
* [.getMarginTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol) ⇒
* [.getSettlementTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol) ⇒
* [.getABI(contract)](#PerpetualDataHandler+getABI) ⇒
* [.isPredictionMarket(symbol)](#PerpetualDataHandler+isPredictionMarket) ⇒
* [.isLowLiquidityMarket(symbol)](#PerpetualDataHandler+isLowLiquidityMarket) ⇒
* [.isTradFiMarket(symbol)](#PerpetualDataHandler+isTradFiMarket) ⇒
* [.getMarketDayTradingOpenCloseSec(symbol)](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec) ⇒
* [.getInitialMarginRate(symbol)](#PerpetualDataHandler+getInitialMarginRate) ⇒
* [.getMaintenanceMarginRate(symbol)](#PerpetualDataHandler+getMaintenanceMarginRate) ⇒
* [.getShortSymbol(symbol)](#PerpetualDataHandler+getShortSymbol) ⇒
* [.refreshSymbols()](#PerpetualDataHandler+refreshSymbols)
* [.getLocalPerpetualStates()](#PerpetualDataHandler+getLocalPerpetualStates) ⇒
* [.fetchOnChainPerpetualStates()](#PerpetualDataHandler+fetchOnChainPerpetualStates) ⇒
* [.checkHeartbeat()](#PerpetualDataHandler+checkHeartbeat) ⇒
* _static_
* [.fetchSlotsInfo(chainId, short)](#PerpetualDataHandler.fetchSlotsInfo) ⇒
* [.getPerpetualStaticInfo(_proxyContract, nestedPerpetualIDs, symbolList)](#PerpetualDataHandler.getPerpetualStaticInfo) ⇒
* [.nestedIDsToChunks(chunkSize, nestedIDs)](#PerpetualDataHandler.nestedIDsToChunks) ⇒ Array.<Array.<number>>
* [._getLiquidityPools(ids, _proxyContract, _symbolList, overrides)](#PerpetualDataHandler._getLiquidityPools) ⇒
* [._getPerpetuals(ids, _proxyContract, _symbolList, overrides)](#PerpetualDataHandler._getPerpetuals) ⇒
* [.getMarginAccount(traderAddr, symbol, symbolToPerpStaticInfo, _proxyContract, _pxInfo, overrides)](#PerpetualDataHandler.getMarginAccount) ⇒
* [.getMarginAccounts(traderAddrs, symbols, symbolToPerpStaticInfo, _multicall, _proxyContract, _pxInfo, overrides)](#PerpetualDataHandler.getMarginAccounts) ⇒
* [._queryPerpetualMarkPrice(symbol, symbolToPerpStaticInfo, _proxyContract, indexPrices, isPredMkt, overrides)](#PerpetualDataHandler._queryPerpetualMarkPrice) ⇒
* [._oiAndAmmPosToLongShort(oi, ammPos)](#PerpetualDataHandler._oiAndAmmPosToLongShort) ⇒
* [._calculateLiquidationPrice(symbol, traderState, S2, symbolToPerpStaticInfo)](#PerpetualDataHandler._calculateLiquidationPrice) ⇒
* [.symbolToPerpetualId(symbol, symbolToPerpStaticInfo)](#PerpetualDataHandler.symbolToPerpetualId) ⇒
* [.toSmartContractOrder(order, traderAddr, symbolToPerpetualMap)](#PerpetualDataHandler.toSmartContractOrder) ⇒
* [.fromSmartContratOrderToClientOrder(scOrder, parentChildIds)](#PerpetualDataHandler.fromSmartContratOrderToClientOrder) ⇒
* [.toClientOrder(order, parentChildIds)](#PerpetualDataHandler.toClientOrder) ⇒
* [.fromClientOrder(obOrder)](#PerpetualDataHandler.fromClientOrder) ⇒
* [._orderTypeToFlag(order)](#PerpetualDataHandler._orderTypeToFlag) ⇒
* [.readSDKConfig(configNameOrfileLocation, version)](#PerpetualDataHandler.readSDKConfig) ⇒
* [.getConfigByName(name, version)](#PerpetualDataHandler.getConfigByName) ⇒
* [.getConfigByLocation(filename, version)](#PerpetualDataHandler.getConfigByLocation) ⇒
* [.getConfigByChainId(chainId, version)](#PerpetualDataHandler.getConfigByChainId) ⇒
* [.getAvailableConfigs()](#PerpetualDataHandler.getAvailableConfigs) ⇒
* [._getABIFromContract(contract, functionName)](#PerpetualDataHandler._getABIFromContract) ⇒
* [.checkOrder(order, traderAccount, perpStaticInfo)](#PerpetualDataHandler.checkOrder)
* [.fromClientOrderToTypeSafeOrder(order)](#PerpetualDataHandler.fromClientOrderToTypeSafeOrder) ⇒
* [.isTradFiMarketStatic(staticInfo)](#PerpetualDataHandler.isTradFiMarketStatic) ⇒
* [.isPredictionMarketStatic(staticInfo)](#PerpetualDataHandler.isPredictionMarketStatic) ⇒
* [.getInitialMarginRate(staticInfo)](#PerpetualDataHandler.getInitialMarginRate) ⇒
* [.getMaintenanceMarginRate(staticInfo)](#PerpetualDataHandler.getMaintenanceMarginRate) ⇒
* [.isMarketDayTime(fAMMTargetDD)](#PerpetualDataHandler.isMarketDayTime) ⇒
* [.getIndexSymbol(_symbolList, info)](#PerpetualDataHandler.getIndexSymbol) ⇒
* [.extractStatesFromStaticInfos(perpInfos)](#PerpetualDataHandler.extractStatesFromStaticInfos) ⇒
### new PerpetualDataHandler(config)
Constructor
| Param | Type | Description | | --- | --- | --- | | config |NodeSDKConfig | Configuration object, see PerpetualDataHandler.readSDKConfig.
| ### perpetualDataHandler.fetchSymbolList()sets the symbollist if a remote config url is specified
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
### perpetualDataHandler.getOrderBookContract(symbol) ⇒
Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### perpetualDataHandler.getOrderBookAddress(symbol) ⇒Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### perpetualDataHandler.getPerpetuals(ids, overrides) ⇒Get perpetuals for the given ids from onchain
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: array of PerpetualData converted into decimals
| Param | Description | | --- | --- | | ids |perpetual ids
| | overrides |optional
| ### perpetualDataHandler.getLiquidityPools(fromIdx, toIdx, overrides) ⇒Get liquidity pools data
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: array of LiquidityPoolData converted into decimals
| Param | Description | | --- | --- | | fromIdx |starting index (>=1)
| | toIdx |to index (inclusive)
| | overrides |optional
| ### perpetualDataHandler.\_fillSymbolMaps()Called when initializing. This function fills this.symbolToTokenAddrMap, and this.nestedPerpetualIDs and this.symbolToPerpStaticInfo
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
### perpetualDataHandler.initSettlementToken(perpStaticInfos)
Initializes settlement currency for all pools by completing this.poolStaticInfos with settlement currency info
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
| Param | Description |
| --- | --- |
| perpStaticInfos | PerpetualStaticInfo array from contract call
| ### perpetualDataHandler.getSymbolFromPoolId(poolId) ⇒symbol
Get pool symbol given a pool Id.
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: symbol - Pool symbol, e.g. "USDC".
| Param | Type | Description | | --- | --- | --- | | poolId |number | Pool Id.
| ### perpetualDataHandler.getPoolIdFromSymbol(symbol) ⇒number
Get pool Id given a pool symbol. Pool IDs start at 1.
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: number - Pool Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Pool symbol.
| ### perpetualDataHandler.getPerpIdFromSymbol(symbol) ⇒number
Get perpetual Id given a perpetual symbol.
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: number - Perpetual Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Perpetual symbol, e.g. "BTC-USD-MATIC".
| ### perpetualDataHandler.getSymbolFromPerpId(perpId) ⇒string
Get the symbol in long format of the perpetual id
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: string - Symbol
| Param | Type | Description | | --- | --- | --- | | perpId |number | perpetual id
| ### perpetualDataHandler.symbol4BToLongSymbol(sym) ⇒string
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: string - Long symbol
| Param | Type | Description | | --- | --- | --- | | sym |string | Short symbol
| ### perpetualDataHandler.fetchPriceSubmissionInfoForPerpetual(symbol) ⇒Get PriceFeedSubmission data required for blockchain queries that involve price data, and the corresponding triangulated prices for the indices S2 and S3
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: PriceFeedSubmission and prices for S2 and S3. [S2price, 0] if S3 not defined.
| Param | Description | | --- | --- | | symbol |pool symbol of the form "ETH-USD-MATIC"
| ### perpetualDataHandler.getIndexSymbols(symbol) ⇒Get the symbols required as indices for the given perpetual
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: name of underlying index prices, e.g. ["MATIC-USD", ""]
| Param | Description | | --- | --- | | symbol |of the form ETH-USD-MATIC, specifying the perpetual
| ### perpetualDataHandler.fetchLatestFeedPriceInfo(symbol) ⇒Get the latest prices for a given perpetual from the offchain oracle networks
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: array of price feed updates that can be submitted to the smart contract and corresponding price information
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form BTC-USD-MATIC
| ### perpetualDataHandler.fetchCollateralToSettlementConversion(symbol)fetchCollateralToSettlementConversion returns the price which converts the collateral currency into settlement currency. For example if BTC-USD-STUSD has settlement currency USDC, we get let px = fetchCollateralToSettlementConversion("BTC-USD-STUSD") valueInUSDC = collateralInSTUSD * px
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
| Param | Description |
| --- | --- |
| symbol | either perpetual symbol of the form BTC-USD-MATIC or just collateral token
| ### perpetualDataHandler.getPriceIds(symbol) ⇒Get list of required pyth price source IDs for given perpetual
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: list of required pyth price sources for this perpetual
| Param | Description | | --- | --- | | symbol |perpetual symbol, e.g., BTC-USD-MATIC
| ### perpetualDataHandler.getPerpetualSymbolsInPool(poolSymbol) ⇒Get ('normal'-state) perpetual symbols for a given pool
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: array of perpetual symbols in this pool
| Param | Description | | --- | --- | | poolSymbol |pool symbol such as "MATIC"
| ### perpetualDataHandler.getAllOpenOrders(symbol) ⇒All the orders in the order book for a given symbol that are currently open.
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: Array with all open orders and their IDs.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =number
Total number of limit orders for this symbol, excluding those that have been cancelled/removed.
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: number - Number of open orders.
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Get a list of active conditional orders in the order book. This a read-only action and does not incur in gas costs.
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: Array of orders and corresponding order IDs
| Param | Type | Description | | --- | --- | --- | | symbol |string | Symbol of the form ETH-USD-MATIC.
| | numElements |number | Maximum number of orders to poll.
| | [startAfter] |string | Optional order ID from where to start polling. Defaults to the first order.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =Gets the pool index (starting at 0 in exchangeInfo, not ID!) corresponding to a given symbol.
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: Pool index
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-MATIC
| ### perpetualDataHandler.getMarginTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: Address of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### perpetualDataHandler.getSettlementTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: Address of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### perpetualDataHandler.getMarginTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: Decimals of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### perpetualDataHandler.getSettlementTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: Decimals of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### perpetualDataHandler.getABI(contract) ⇒Get ABI for LimitOrderBook, Proxy, or Share Pool Token
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: ABI for the requested contract
| Param | Description | | --- | --- | | contract |name of contract: proxy|lob|sharetoken
| ### perpetualDataHandler.isPredictionMarket(symbol) ⇒Determines whether a given perpetual represents a prediction market
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: True if this is a prediction market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form TRUMP24-USD-USDC
| ### perpetualDataHandler.isLowLiquidityMarket(symbol) ⇒Determines whether a given perpetual represents a low-liquidity market
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: True if this is a low-liquidity market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form DIRAC-HONEY-USDC
| ### perpetualDataHandler.isTradFiMarket(symbol) ⇒Determines whether a given perpetual represents a tradfi market
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: True if this is a tradfi market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### perpetualDataHandler.getMarketDayTradingOpenCloseSec(symbol) ⇒Returns day trading times for tradfi markets
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: open time in seconds within day, close time in seconds within day
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### perpetualDataHandler.getInitialMarginRate(symbol) ⇒getInitialMarginRate
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: initial margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### perpetualDataHandler.getMaintenanceMarginRate(symbol) ⇒getMaintenanceMarginRate
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: maintenance margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### perpetualDataHandler.getShortSymbol(symbol) ⇒Short symbol corresponding to a given long symbol.
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: Short symbol (e.g. NHL0)
| Param | Description | | --- | --- | | symbol |Long symbol (e.g. NHL_TOR_DAL_251015)
| ### perpetualDataHandler.refreshSymbols()Refreshes symbol mappings if at least one prediction market is expired
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
### perpetualDataHandler.getLocalPerpetualStates() ⇒
Get state of perpetuals as currently known locally
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: Array of [perpetual Id, perpetual state (string)]
### perpetualDataHandler.fetchOnChainPerpetualStates() ⇒Fetches on-chain state of local perpetual ids. Does not run if SDK is not ready.
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: Array of [perpetual Id, perpetual state (string)]
### perpetualDataHandler.checkHeartbeat() ⇒Check that states of all perps known locally match on-chain states
**Kind**: instance method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: True if all perp states are correct
### PerpetualDataHandler.fetchSlotsInfo(chainId, short) ⇒Fetch list of {short,long} symbols from API. Symbol is left unchanged if unknown.
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: List of long perp symbols
| Param | Description | | --- | --- | | chainId |Chain id
| | short |List of short perp symbols (<=4 chars)
| ### PerpetualDataHandler.getPerpetualStaticInfo(_proxyContract, nestedPerpetualIDs, symbolList) ⇒Collect all perpetuals static info
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: array with PerpetualStaticInfo for each perpetual
| Param | Type | Description | | --- | --- | --- | | _proxyContract |ethers.Contract | perpetuals contract with getter
| | nestedPerpetualIDs |Array.<Array.<number>> | perpetual id-array for each pool
| | symbolList |Map.<string, string> | mapping of symbols to convert long-format <-> blockchain-format
| ### PerpetualDataHandler.nestedIDsToChunks(chunkSize, nestedIDs) ⇒Array.<Array.<number>>
Breaks up an array of nested arrays into chunks of a specified size.
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: Array.<Array.<number>> - An array of subarrays, each containing chunkSize or fewer elements from nestedIDs.
number | The size of each chunk.
| | nestedIDs |Array.<Array.<number>> | The array of nested arrays to chunk.
| ### PerpetualDataHandler.\_getLiquidityPools(ids, _proxyContract, _symbolList, overrides) ⇒Query perpetuals
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: array of PerpetualData converted into decimals
| Param | Description | | --- | --- | | ids |perpetual ids
| | _proxyContract |proxy contract instance
| | _symbolList |symbol mappings to convert the bytes encoded symbol name to string
| | overrides |optional
| ### PerpetualDataHandler.\_getPerpetuals(ids, _proxyContract, _symbolList, overrides) ⇒Query perpetuals
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: array of PerpetualData converted into decimals
| Param | Description | | --- | --- | | ids |perpetual ids
| | _proxyContract |proxy contract instance
| | _symbolList |symbol mappings to convert the bytes encoded symbol name to string
| | overrides |optional
| ### PerpetualDataHandler.getMarginAccount(traderAddr, symbol, symbolToPerpStaticInfo, _proxyContract, _pxInfo, overrides) ⇒Get trader state from the blockchain and parse into a human-readable margin account
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: A Margin account
| Param | Description | | --- | --- | | traderAddr |Trader address
| | symbol |Perpetual symbol
| | symbolToPerpStaticInfo |Symbol to perp static info mapping
| | _proxyContract |Proxy contract instance
| | _pxInfo |index price info
| | overrides |Optional overrides for eth_call
| ### PerpetualDataHandler.getMarginAccounts(traderAddrs, symbols, symbolToPerpStaticInfo, _multicall, _proxyContract, _pxInfo, overrides) ⇒Get trader states from the blockchain and parse into a list of human-readable margin accounts
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: List of margin accounts
| Param | Description | | --- | --- | | traderAddrs |List of trader addresses
| | symbols |List of symbols
| | symbolToPerpStaticInfo |Symbol to perp static info mapping
| | _multicall |Multicall3 contract instance
| | _proxyContract |Proxy contract instance
| | _pxInfo |List of price info
| | overrides |Optional eth_call overrides
| ### PerpetualDataHandler.\_queryPerpetualMarkPrice(symbol, symbolToPerpStaticInfo, _proxyContract, indexPrices, isPredMkt, overrides) ⇒ **Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: mark price
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form BTC-USDC-USDC
| | symbolToPerpStaticInfo |mapping
| | _proxyContract |contract instance
| | indexPrices |IdxPriceInfo
| | isPredMkt |true if prediction market perpetual
| | overrides | | ### PerpetualDataHandler.\_oiAndAmmPosToLongShort(oi, ammPos) ⇒Calculate long and short exposures from open interest and long/short
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: long, short exposure
| Param | Description | | --- | --- | | oi |open interest
| | ammPos |amm net exposure
| ### PerpetualDataHandler.\_calculateLiquidationPrice(symbol, traderState, S2, symbolToPerpStaticInfo) ⇒Liquidation price
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler)
**Returns**: liquidation mark-price, corresponding collateral/quote conversion
| Param | Description | | --- | --- | | symbol |symbol of the form BTC-USD-MATIC
| | traderState |BigInt array according to smart contract
| | S2 |number, index price S2
| | symbolToPerpStaticInfo |mapping symbol->PerpStaticInfo
| ### PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo) ⇒Finds the perpetual id for a symbol of the form
-. The function first converts the token names into bytes4 representation **Kind**: static method of [ PerpetualDataHandler](#PerpetualDataHandler) **Returns**:perpetual id or it fails
| Param | Description | | --- | --- | | symbol |symbol (e.g., BTC-USD-MATC)
| | symbolToPerpStaticInfo |map that contains the bytes4-symbol to PerpetualStaticInfo including id mapping
| ### PerpetualDataHandler.toSmartContractOrder(order, traderAddr, symbolToPerpetualMap) ⇒Transform the convenient form of the order into a smart-contract accepted type of order
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:SmartContractOrder
| Param | Description | | --- | --- | | order |order type
| | traderAddr |address of the trader
| | symbolToPerpetualMap |mapping of symbol to perpetual Id
| ### PerpetualDataHandler.fromSmartContratOrderToClientOrder(scOrder, parentChildIds) ⇒Converts a smart contract order to a client order
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:Client order that can be submitted to the corresponding LOB
| Param | Description | | --- | --- | | scOrder |Smart contract order
| | parentChildIds |Optional parent-child dependency
| ### PerpetualDataHandler.toClientOrder(order, parentChildIds) ⇒Converts a user-friendly order to a client order
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:Client order that can be submitted to the corresponding LOB
| Param | Description | | --- | --- | | order |Order
| | parentChildIds |Optional parent-child dependency
| ### PerpetualDataHandler.fromClientOrder(obOrder) ⇒Converts an order as stored in the LOB smart contract into a user-friendly order type
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:User friendly order struct
| Param | Description | | --- | --- | | obOrder |Order-book contract order type
| ### PerpetualDataHandler.\_orderTypeToFlag(order) ⇒Determine the correct order flags based on the order-properties. Checks for some misspecifications.
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:BigNumber flags
| Param | Description | | --- | --- | | order |order type
| ### PerpetualDataHandler.readSDKConfig(configNameOrfileLocation, version) ⇒Get NodeSDKConfig from a chain ID, known config name, or custom file location..
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:NodeSDKConfig
| Param | Description | | --- | --- | | configNameOrfileLocation |Name of a known default config, or chain ID, or json-file with required variables for config
| | version |Config version number. Defaults to highest version if name or chain ID are not unique
| ### PerpetualDataHandler.getConfigByName(name, version) ⇒Get a NodeSDKConfig from its name
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:NodeSDKConfig
| Param | Description | | --- | --- | | name |Name of the known config
| | version |Version of the config. Defaults to highest available.
| ### PerpetualDataHandler.getConfigByLocation(filename, version) ⇒Get a NodeSDKConfig from a json file.
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:NodeSDKConfig
| Param | Description | | --- | --- | | filename |Location of the file
| | version |Version of the config. Defaults to highest available.
| ### PerpetualDataHandler.getConfigByChainId(chainId, version) ⇒Get a NodeSDKConfig from its chain Id
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:NodeSDKConfig
| Param | Description | | --- | --- | | chainId |Chain Id
| | version |Version of the config. Defaults to highest available.
| ### PerpetualDataHandler.getAvailableConfigs() ⇒Get available configurations in a Set. You can use the output to determine the config file that you get via 'let config = PerpetualDataHandler.readSDKConfig(196);'
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:set of chain-ids and name separated by ;
**Example** ```js import { PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { const configs = PerpetualDataHandler.getAvailableConfigs(); console.log(configs); // output of the form: // Set(2) { '1101; zkevm', `196; xlayer'} } main(); ``` ### PerpetualDataHandler.\_getABIFromContract(contract, functionName) ⇒Get the ABI of a function in a given contract. Undefined if it doesn't exist.
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:Function ABI as a single JSON string
| Param | Description | | --- | --- | | contract |A contract instance, e.g. this.proxyContract
| | functionName |Name of the function whose ABI we want
| ### PerpetualDataHandler.checkOrder(order, traderAccount, perpStaticInfo)Performs basic validity checks on a given order
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) | Param | Description | | --- | --- | | order |Order struct
| | traderAccount |Trader account
| | perpStaticInfo |Symbol to perpetual info map
| ### PerpetualDataHandler.fromClientOrderToTypeSafeOrder(order) ⇒Converts a client order (with BigNumberish types) to a type-safe order (with number/bigint types)
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:Order that can be submitted to the corresponding LOB via ethers v6 or viem
| Param | Description | | --- | --- | | order |Client order
| ### PerpetualDataHandler.isTradFiMarketStatic(staticInfo) ⇒Determines whether a given perpetual represents a tradfi market which has open/close times
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:True if perp has tradfi market flag set
| Param | Description | | --- | --- | | staticInfo |Perpetual static info
| ### PerpetualDataHandler.isPredictionMarketStatic(staticInfo) ⇒Determines whether a given perpetual represents a prediction market
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:True if this is a prediction market
| Param | Description | | --- | --- | | staticInfo |Perpetual static info
| ### PerpetualDataHandler.getInitialMarginRate(staticInfo) ⇒Get initial margin rate from static data considering open/close of tradfi markets
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:initial margin rate in decimals
| Param | Description | | --- | --- | | staticInfo |static info
| ### PerpetualDataHandler.getMaintenanceMarginRate(staticInfo) ⇒Get maintenance margin rate from static data considering open/close of tradfi markets
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:maintenance margin rate in decimals
| Param | Description | | --- | --- | | staticInfo |static info
| ### PerpetualDataHandler.isMarketDayTime(fAMMTargetDD) ⇒Determine whether the market is in day trading, given the parameter fAMMTargetDD
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:true if currently the market is in day trading status
| Param | Description | | --- | --- | | fAMMTargetDD |bigint that encodes market day trading times
| ### PerpetualDataHandler.getIndexSymbol(_symbolList, info) ⇒Static function to get index symbol from perp static info
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:Index symbol
| Param | Description | | --- | --- | | _symbolList |Mapping from long symbol (e.g. NHL_TOR_DAL_251015) to price-feed API symbol (NHL0-USD:84532)
| | info |Perpetual static info
| ### PerpetualDataHandler.extractStatesFromStaticInfos(perpInfos) ⇒Extract perpetual states from collection of static infos
**Kind**: static method of [PerpetualDataHandler](#PerpetualDataHandler) **Returns**:Array of [perpetual Id, perpetual state (string)]
| Param | Description | | --- | --- | | perpInfos |Perpetual static infos, either a symbol => PerpInfo mapping, or a PerpInfo array
| ## PerpetualEventHandlerThis class handles events and stores relevant variables as member variables. The events change the state of the member variables: mktData : MarketData relevant market data with current state (e.g. index price) ordersInPerpetual: Map<number, OrderStruct> all open orders for the given trader positionInPerpetual: Map<number, MarginAccount> all open positions for the given trader
Get data:
- getPerpetualData(perp id (string) or symbol) : PerpetualState. This is a reference!
- getExchangeInfo() : ExchangeInfo. This is a reference!
- getCurrentPositionRisk(perp id (string) or symbol) : MarginAccount. This is a reference!
- getOrdersInPerpetualMap : Map<number, OrderStruct>. This is a reference!
- getpositionInPerpetualMap : Map<number, MarginAccount>. This is a reference!
Construct with a trader address and a marketData object Initialize to gather all the relevant data. Send event variables to event handler "on
" - this updates members **Kind**: global class * [PerpetualEventHandler](#PerpetualEventHandler) * _instance_ * [.initialize()](#PerpetualEventHandler+initialize) * [.getExchangeInfo()](#PerpetualEventHandler+getExchangeInfo) ⇒ * [.getOrdersInPerpetualMap()](#PerpetualEventHandler+getOrdersInPerpetualMap) ⇒ * [.getpositionInPerpetualMap()](#PerpetualEventHandler+getpositionInPerpetualMap) ⇒ * [.getPerpetualData(perpetualIdOrSymbol)](#PerpetualEventHandler+getPerpetualData) ⇒ * [.getCurrentPositionRisk(perpetualIdOrSymbol)](#PerpetualEventHandler+getCurrentPositionRisk) ⇒ * [.updatePrices(perpetualIdOrSymbol)](#PerpetualEventHandler+updatePrices) * [.onUpdateMarkPrice(perpetualId, fMarkPricePremium, fSpotIndexPrice)](#PerpetualEventHandler+onUpdateMarkPrice) ⇒ * [.onUpdateUpdateFundingRate(fFundingRate)](#PerpetualEventHandler+onUpdateUpdateFundingRate) * [.onExecutionFailed(perpetualId, trader, digest, reason)](#PerpetualEventHandler+onExecutionFailed) * [.onPerpetualLimitOrderCancelled(orderId)](#PerpetualEventHandler+onPerpetualLimitOrderCancelled) * [.onPerpetualLimitOrderCreated(perpetualId, trader, executorAddr, brokerAddr, Order, digest)](#PerpetualEventHandler+onPerpetualLimitOrderCreated) * [.onUpdateMarginAccount(perpetualId, trader, positionId, fPositionBC, fCashCC, fLockedInValueQC, fFundingPaymentCC, fOpenInterestBC)](#PerpetualEventHandler+onUpdateMarginAccount) * [.onTrade(perpetualId, trader, positionId, order, orderDigest, newPositionSizeBC, price)](#PerpetualEventHandler+onTrade) ⇒ * _static_ * [.findOrderForId(orderId, orderMap)](#PerpetualEventHandler.findOrderForId) ⇒ * [.deleteOrder(orderStructs, orderId)](#PerpetualEventHandler.deleteOrder) ⇒ * [.ConvertUpdateMarkPrice(fMarkPricePremium, fSpotIndexPrice)](#PerpetualEventHandler.ConvertUpdateMarkPrice) ⇒ ### perpetualEventHandler.initialize()
- [x] onUpdateMarkPrice : emitted on proxy; updates markprice and index price data
- [x] onUpdateUpdateFundingRate : emitted on proxy; sets funding rate
- [x] onExecutionFailed : emitted on order book; removes an open order
- [x] onPerpetualLimitOrderCancelled : emitted on order book; removes an open order
- [x] onPerpetualLimitOrderCreated : emitted on order book; adds an open order to the data
- [x] async onUpdateMarginAccount : emitted on proxy; updates position data and open interest
- [x] onTrade : emitted on proxy; returns TradeEvent to be displayed
Call this async function to initialize the market data
**Kind**: instance method of [PerpetualEventHandler](#PerpetualEventHandler) ### perpetualEventHandler.getExchangeInfo() ⇒Get the current exchange info
**Kind**: instance method of [PerpetualEventHandler](#PerpetualEventHandler) **Returns**:exchange info
### perpetualEventHandler.getOrdersInPerpetualMap() ⇒getOrdersInPerpetualMap
**Kind**: instance method of [PerpetualEventHandler](#PerpetualEventHandler) **Returns**:this.ordersInPerpetual
### perpetualEventHandler.getpositionInPerpetualMap() ⇒getpositionInPerpetualMap
**Kind**: instance method of [PerpetualEventHandler](#PerpetualEventHandler) **Returns**:this.positionInPerpetual
### perpetualEventHandler.getPerpetualData(perpetualIdOrSymbol) ⇒Get the data for a perpetual with a given index
**Kind**: instance method of [PerpetualEventHandler](#PerpetualEventHandler) **Returns**:perpetual data for this idx
| Param | Description | | --- | --- | | perpetualIdOrSymbol |perpetual idx as string or symbol for which we want the data
| ### perpetualEventHandler.getCurrentPositionRisk(perpetualIdOrSymbol) ⇒Get the trader's current position risk (margin account data)
**Kind**: instance method of [PerpetualEventHandler](#PerpetualEventHandler) **Returns**:undefined if no position or margin account (='position risk')
| Param | Description | | --- | --- | | perpetualIdOrSymbol |perpetual id as string ('100003') or symbol ('BTC-USD-MATIC')
| ### perpetualEventHandler.updatePrices(perpetualIdOrSymbol)Update the following prices:
**Kind**: instance method of [
- index price
- collateral price
- mid-price
PerpetualEventHandler](#PerpetualEventHandler) | Param | Description | | --- | --- | | perpetualIdOrSymbol |perpetual id as string ('100003') or symbol ('BTC-USD-MATIC')
| ### perpetualEventHandler.onUpdateMarkPrice(perpetualId, fMarkPricePremium, fSpotIndexPrice) ⇒Handle the event UpdateMarkPrice and update relevant data
**Kind**: instance method of [PerpetualEventHandler](#PerpetualEventHandler) **Returns**:void
| Param | Description | | --- | --- | | perpetualId |perpetual Id
| | fMarkPricePremium |premium rate in ABDK format
| | fSpotIndexPrice |spot index price in ABDK format
| ### perpetualEventHandler.onUpdateUpdateFundingRate(fFundingRate)Handle the event UpdateFundingRate and update relevant data UpdateFundingRate(uint24 indexed perpetualId, int128 fFundingRate)
**Kind**: instance method of [PerpetualEventHandler](#PerpetualEventHandler) | Param | Description | | --- | --- | | fFundingRate |funding rate in ABDK format
| ### perpetualEventHandler.onExecutionFailed(perpetualId, trader, digest, reason)event ExecutionFailed( uint24 indexed perpetualId, address indexed trader, bytes32 digest, string reason );
**Kind**: instance method of [PerpetualEventHandler](#PerpetualEventHandler) | Param | Description | | --- | --- | | perpetualId |id of the perpetual
| | trader |address of the trader
| | digest |digest of the order/cancel order
| | reason |reason why the execution failed
| ### perpetualEventHandler.onPerpetualLimitOrderCancelled(orderId)Event emitted by perpetual proxy event PerpetualLimitOrderCancelled(bytes32 indexed orderHash);
**Kind**: instance method of [PerpetualEventHandler](#PerpetualEventHandler) | Param | Description | | --- | --- | | orderId |string order id/digest
| ### perpetualEventHandler.onPerpetualLimitOrderCreated(perpetualId, trader, executorAddr, brokerAddr, Order, digest)event PerpetualLimitOrderCreated( uint24 indexed perpetualId, address indexed trader, address executorAddr, address brokerAddr, Order order, bytes32 digest )
**Kind**: instance method of [PerpetualEventHandler](#PerpetualEventHandler) | Param | Description | | --- | --- | | perpetualId |id of the perpetual
| | trader |address of the trader
| | executorAddr |address of the executor
| | brokerAddr |address of the broker
| | Order |order struct
| | digest |order id
| ### perpetualEventHandler.onUpdateMarginAccount(perpetualId, trader, positionId, fPositionBC, fCashCC, fLockedInValueQC, fFundingPaymentCC, fOpenInterestBC)This function is async -> queries the margin account
**Kind**: instance method of [PerpetualEventHandler](#PerpetualEventHandler) | Param | Description | | --- | --- | | perpetualId |id of the perpetual
| | trader |trader address
| | positionId |position id
| | fPositionBC |position size in base currency
| | fCashCC |margin collateral in margin account
| | fLockedInValueQC |pos*average opening price
| | fFundingPaymentCC |funding payment made
| | fOpenInterestBC |open interest
| ### perpetualEventHandler.onTrade(perpetualId, trader, positionId, order, orderDigest, newPositionSizeBC, price) ⇒ **Kind**: instance method of [PerpetualEventHandler](#PerpetualEventHandler) **Returns**:trade event data in regular number format
| Param | Description | | --- | --- | | perpetualId |perpetual id
| | trader |trader address
| | positionId |position id
| | order |order struct
| | orderDigest |order id
| | newPositionSizeBC |new pos size in base currency ABDK
| | price |price in ABDK format
| ### PerpetualEventHandler.findOrderForId(orderId, orderMap) ⇒static function to find the number of the OrderStruct with given orderId
**Kind**: static method of [PerpetualEventHandler](#PerpetualEventHandler) **Returns**:id of perpetual that contains order with id = orderId or undefined
| Param | Description | | --- | --- | | orderId |id/digest of order
| | orderMap |mapping for perpetualId->OrderStruct
| ### PerpetualEventHandler.deleteOrder(orderStructs, orderId) ⇒Delete the order with given id from the class member data
**Kind**: static method of [PerpetualEventHandler](#PerpetualEventHandler) **Returns**:void
| Param | Description | | --- | --- | | orderStructs |array of order struct as stored for the trader and a given perpetual
| | orderId |digest/order id
| ### PerpetualEventHandler.ConvertUpdateMarkPrice(fMarkPricePremium, fSpotIndexPrice) ⇒UpdateMarkPrice( uint24 indexed perpetualId, int128 fMarkPricePremium, int128 fSpotIndexPrice )
**Kind**: static method of [PerpetualEventHandler](#PerpetualEventHandler) **Returns**:midPrice, markPricePremium, indexPrice in float
| Param | Description | | --- | --- | | fMarkPricePremium |premium rate in ABDK format
| | fSpotIndexPrice |spot index price in ABDK format
| ## PolyMktsPxFeedPolyMktsPxFeed gets prices from the official polymarket api and applies the 1+px transformation
**Kind**: global class ## PriceFeedsThis class communicates with the REST API that provides price-data that is to be submitted to the smart contracts for certain functions such as trader liquidations, trade executions, change of trader margin amount.
**Kind**: global class * [PriceFeeds](#PriceFeeds) * _instance_ * [.init()](#PriceFeeds+init) * [.initializeTriangulations(symbols)](#PriceFeeds+initializeTriangulations) * [.getTriangulations()](#PriceFeeds+getTriangulations) ⇒ * [.setTriangulations()](#PriceFeeds+setTriangulations) * [.fetchFeedPriceInfoAndIndicesForPerpetual(symbol)](#PriceFeeds+fetchFeedPriceInfoAndIndicesForPerpetual) ⇒ * [.fetchPrices(symbol)](#PriceFeeds+fetchPrices) ⇒ * [.fetchPricesForPerpetual(symbol)](#PriceFeeds+fetchPricesForPerpetual) ⇒ * [.fetchFeedPrices(symbols)](#PriceFeeds+fetchFeedPrices) ⇒ * [.fetchAllFeedPrices()](#PriceFeeds+fetchAllFeedPrices) ⇒ * [.fetchLatestFeedPriceInfoForPerpetual(symbol)](#PriceFeeds+fetchLatestFeedPriceInfoForPerpetual) ⇒ * [.calculateTriangulatedPricesFromFeedInfo(symbols, feeds)](#PriceFeeds+calculateTriangulatedPricesFromFeedInfo) ⇒ * [.triangulatePricesFromFeedPrices(symbols, feeds)](#PriceFeeds+triangulatePricesFromFeedPrices) ⇒ * [.fetchVAAQuery(query)](#PriceFeeds+fetchVAAQuery) ⇒ * [.fetchPriceQuery(query)](#PriceFeeds+fetchPriceQuery) ⇒ * [.fetchFullPriceQuery(query)](#PriceFeeds+fetchFullPriceQuery) ⇒ * _static_ * [.trimEndpoint(endp)](#PriceFeeds.trimEndpoint) ⇒ * [._selectConfig(configs, network)](#PriceFeeds._selectConfig) ⇒ * [._constructFeedInfo(config)](#PriceFeeds._constructFeedInfo) ⇒ ### priceFeeds.init()initialization function. Gathers config from config-hub if url specified
**Kind**: instance method of [PriceFeeds](#PriceFeeds) ### priceFeeds.initializeTriangulations(symbols)Pre-processing of triangulations for symbols, given the price feeds
**Kind**: instance method of [PriceFeeds](#PriceFeeds) | Param | Description | | --- | --- | | symbols |set of symbols we want to triangulate from price feeds
| ### priceFeeds.getTriangulations() ⇒Returns computed triangulation map
**Kind**: instance method of [PriceFeeds](#PriceFeeds) **Returns**:Triangulation map
### priceFeeds.setTriangulations()Set pre-computed triangulation map
**Kind**: instance method of [PriceFeeds](#PriceFeeds) ### priceFeeds.fetchFeedPriceInfoAndIndicesForPerpetual(symbol) ⇒Get required information to be able to submit a blockchain transaction with price-update such as trade execution, liquidation. Uses write price feed endpoints.
**Kind**: instance method of [PriceFeeds](#PriceFeeds) **Returns**:PriceFeedSubmission, index prices, market closed information
| Param | Description | | --- | --- | | symbol |symbol of perpetual, e.g., BTC-USD-MATIC
| ### priceFeeds.fetchPrices(symbol) ⇒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. Uses read endpoints.
**Kind**: instance method of [PriceFeeds](#PriceFeeds) **Returns**:map of feed-price symbol to price/isMarketClosed
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form BTC-USD-MATIC
| ### priceFeeds.fetchPricesForPerpetual(symbol) ⇒Get index prices and market closed information for the given perpetual
**Kind**: instance method of [PriceFeeds](#PriceFeeds) **Returns**:Index prices and market closed information; for prediction markets also ema, confidence, and order book parameters.
| Param | Description | | --- | --- | | symbol |perpetual symbol such as ETH-USD-MATIC
| ### priceFeeds.fetchFeedPrices(symbols) ⇒Fetch the provided feed prices and bool whether market is closed or open
**Kind**: instance method of [
- requires the feeds to be defined in priceFeedConfig.json
- vaas are not of interest here, therefore only readonly price feed endpoints are used
PriceFeeds](#PriceFeeds) **Returns**:mapping symbol-> [price, isMarketClosed], also has an entry
| Param | Description | | --- | --- | | symbols |:ema for each polymarket symbol that maps to the ema price array of feed-price symbols (e.g., [btc-usd, eth-usd])
| ### priceFeeds.fetchAllFeedPrices() ⇒Get all required feed prices via "latest_price_feeds". 'required' means part of perpetuals/triangulations
**Kind**: instance method of [PriceFeeds](#PriceFeeds) **Returns**:map of feed-price symbol to price/isMarketClosed
### priceFeeds.fetchLatestFeedPriceInfoForPerpetual(symbol) ⇒Get the latest prices for a given perpetual from the offchain oracle networks. Uses write price feed endpoints.
**Kind**: instance method of [PriceFeeds](#PriceFeeds) **Returns**:array of price feed updates that can be submitted to the smart contract and corresponding price information
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form BTC-USD-MATIC
| ### priceFeeds.calculateTriangulatedPricesFromFeedInfo(symbols, feeds) ⇒Extract pair-prices from underlying price feeds via triangulation The function either needs a direct price feed or a defined triangulation to succesfully return a triangulated price
**Kind**: instance method of [PriceFeeds](#PriceFeeds) **Returns**:array of prices with same order as symbols
| Param | Description | | --- | --- | | symbols |array of pairs for which we want prices, e.g., [BTC-USDC, ETH-USD]
| | feeds |data obtained via fetchLatestFeedPriceInfo or fetchLatestFeedPrices
| ### priceFeeds.triangulatePricesFromFeedPrices(symbols, feeds) ⇒Extract pair-prices from underlying price feeds via triangulation The function either needs a direct price feed or a defined triangulation to succesfully return a triangulated price
**Kind**: instance method of [PriceFeeds](#PriceFeeds) **Returns**:array of prices with same order as symbols
| Param | Description | | --- | --- | | symbols |array of pairs for which we want prices, e.g., [BTC-USDC, ETH-USD]
| | feeds |data obtained via fetchLatestFeedPriceInfo or fetchLatestFeedPrices
| ### priceFeeds.fetchVAAQuery(query) ⇒Queries the REST endpoint and returns parsed VAA price data We expect one single id in the query, otherwise the VAA is a compressed VAA for all prices which is not suited for the smart contracts
**Kind**: instance method of [PriceFeeds](#PriceFeeds) **Returns**:vaa and price info
| Param | Description | | --- | --- | | query |query price-info from endpoint
| ### priceFeeds.fetchPriceQuery(query) ⇒Queries the REST endpoint and returns parsed price data
**Kind**: instance method of [PriceFeeds](#PriceFeeds) **Returns**:array of vaa and price info
| Param | Description | | --- | --- | | query |query price-info from endpoint
| ### priceFeeds.fetchFullPriceQuery(query) ⇒Queries the REST endpoint and returns parsed price data
**Kind**: instance method of [PriceFeeds](#PriceFeeds) **Returns**:object with vaa and price info (both spot and ema)
| Param | Description | | --- | --- | | query |query price-info from endpoint
| ### PriceFeeds.trimEndpoint(endp) ⇒We cut last / or legacy url format /api/ if any
**Kind**: static method of [PriceFeeds](#PriceFeeds) **Returns**:trimmed string
| Param | Description | | --- | --- | | endp |endpoint string
| ### PriceFeeds.\_selectConfig(configs, network) ⇒Searches for configuration for given network
**Kind**: static method of [PriceFeeds](#PriceFeeds) **Returns**:selected configuration
| Param | Description | | --- | --- | | configs |pricefeed configuration from json
| | network |e.g. testnet
| ### PriceFeeds.\_constructFeedInfo(config) ⇒Wraps configuration into convenient data-structure
**Kind**: static method of [PriceFeeds](#PriceFeeds) **Returns**:feedInfo-map and endPoints-array
| Param | Description | | --- | --- | | config |configuration for the selected network
| ## ReferralCodeSignerThis is a 'standalone' class that deals with signatures required for referral codes:
- referrer creates a new referral code for trader (no agency involved)
- agency creates a new referral code for a referrer and their trader
- trader selects a referral code to trade with
Note that since the back-end is chain specific, the referral code is typically bound to one chain, unless the backend employs code transferrals
**Kind**: global class * [ReferralCodeSigner](#ReferralCodeSigner) * [.getSignatureForNewReferral(rc, signingFun)](#ReferralCodeSigner.getSignatureForNewReferral) ⇒ * [.getSignatureForNewCode(rc, signingFun)](#ReferralCodeSigner.getSignatureForNewCode) ⇒ * [.newReferralPayloadToTypedData(rc)](#ReferralCodeSigner.newReferralPayloadToTypedData) ⇒ * [._referralCodeNewCodePayloadToMessage(rc)](#ReferralCodeSigner._referralCodeNewCodePayloadToMessage) ⇒ * [.referralCodeNewCodePayloadToTypedData(rc)](#ReferralCodeSigner.referralCodeNewCodePayloadToTypedData) ⇒ * [._codeSelectionPayloadToMessage(rc)](#ReferralCodeSigner._codeSelectionPayloadToMessage) ⇒ * [.codeSelectionPayloadToTypedData(rc)](#ReferralCodeSigner.codeSelectionPayloadToTypedData) ⇒ * [.checkNewCodeSignature(rc)](#ReferralCodeSigner.checkNewCodeSignature) ⇒ ### ReferralCodeSigner.getSignatureForNewReferral(rc, signingFun) ⇒New agency/broker to agency referral rc.PassOnPercTDF must be in 100*percentage unit
**Kind**: static method of [ReferralCodeSigner](#ReferralCodeSigner) **Returns**:signature
| Param | Description | | --- | --- | | rc |payload to sign
| | signingFun |signing function
| ### ReferralCodeSigner.getSignatureForNewCode(rc, signingFun) ⇒New code rc.PassOnPercTDF must be in 100*percentage unit
**Kind**: static method of [ReferralCodeSigner](#ReferralCodeSigner) **Returns**:signature string
| Param | Description | | --- | --- | | rc |APIReferralCodePayload without signature
| | signingFun |function that signs
| ### ReferralCodeSigner.newReferralPayloadToTypedData(rc) ⇒Convert payload to data struct to sign
**Kind**: static method of [ReferralCodeSigner](#ReferralCodeSigner) **Returns**:typed data
| Param | Description | | --- | --- | | rc |payload
| ### ReferralCodeSigner.\_referralCodeNewCodePayloadToMessage(rc) ⇒Create digest for referralCodePayload that is to be signed
**Kind**: static method of [ReferralCodeSigner](#ReferralCodeSigner) **Returns**:the hex-string to be signed
| Param | Description | | --- | --- | | rc |payload
| ### ReferralCodeSigner.referralCodeNewCodePayloadToTypedData(rc) ⇒Convert payload to data struct to sign
**Kind**: static method of [ReferralCodeSigner](#ReferralCodeSigner) **Returns**:typed data
| Param | Description | | --- | --- | | rc |payload
| ### ReferralCodeSigner.\_codeSelectionPayloadToMessage(rc) ⇒Create digest for APIReferralCodeSelectionPayload that is to be signed
**Kind**: static method of [ReferralCodeSigner](#ReferralCodeSigner) **Returns**:the hex-string to be signed
| Param | Description | | --- | --- | | rc |payload
| ### ReferralCodeSigner.codeSelectionPayloadToTypedData(rc) ⇒Convert payload to data struct to sign
**Kind**: static method of [ReferralCodeSigner](#ReferralCodeSigner) **Returns**:typed data
| Param | Description | | --- | --- | | rc |payload
| ### ReferralCodeSigner.checkNewCodeSignature(rc) ⇒Check whether signature is correct on payload:
**Kind**: static method of [
- the referrer always signs
- if the agency is not an agency for this referrer, the backend will reject
ReferralCodeSigner](#ReferralCodeSigner) **Returns**:true if correctly signed, false otherwise
| Param | Description | | --- | --- | | rc |referralcode payload with a signature
| ## TraderInterface ⇐ [MarketData](#MarketData)Interface that can be used by front-end that wraps all private functions so that signatures can be handled in frontend via wallet
**Kind**: global class **Extends**: [MarketData](#MarketData) * [TraderInterface](#TraderInterface) ⇐ [MarketData](#MarketData) * [new TraderInterface(config)](#new_TraderInterface_new) * _instance_ * [.queryExchangeFee(poolSymbolName, traderAddr, brokerAddr)](#TraderInterface+queryExchangeFee) ⇒ * [.getCurrentTraderVolume(poolSymbolName, traderAddr)](#TraderInterface+getCurrentTraderVolume) ⇒ * [.cancelOrderDigest(symbol, orderId)](#TraderInterface+cancelOrderDigest) ⇒ * [.getOrderBookAddress(symbol)](#TraderInterface+getOrderBookAddress) ⇒ * [.createSmartContractOrder(order, traderAddr)](#TraderInterface+createSmartContractOrder) ⇒ * [.orderDigest(scOrder)](#TraderInterface+orderDigest) ⇒ * [.getProxyABI(method)](#TraderInterface+getProxyABI) ⇒ * [.getOrderBookABI(symbol, method)](#TraderInterface+getOrderBookABI) ⇒ * [.addLiquidity(signer, poolSymbolName, amountCC)](#TraderInterface+addLiquidity) ⇒ * [.initiateLiquidityWithdrawal(signer, poolSymbolName, amountPoolShares)](#TraderInterface+initiateLiquidityWithdrawal) ⇒ * [.executeLiquidityWithdrawal(signer, poolSymbolName)](#TraderInterface+executeLiquidityWithdrawal) ⇒ * [.createProxyInstance(providerOrMarketData)](#MarketData+createProxyInstance) * [.getProxyAddress()](#MarketData+getProxyAddress) ⇒string* [.getTriangulations()](#MarketData+getTriangulations) ⇒ * [.smartContractOrderToOrder(smOrder)](#MarketData+smartContractOrderToOrder) ⇒Order* [.getReadOnlyProxyInstance()](#MarketData+getReadOnlyProxyInstance) ⇒ * [.exchangeInfo()](#MarketData+exchangeInfo) ⇒ [ExchangeInfo](#ExchangeInfo) * [.openOrders(traderAddr, symbol)](#MarketData+openOrders) ⇒ * [.positionRisk(traderAddr, symbol)](#MarketData+positionRisk) ⇒Array.<MarginAccount>* [.positionRiskOnTrade(traderAddr, order, signedPositionNotionalBaseCCY, tradingFeeTbps, indexPriceInfo)](#MarketData+positionRiskOnTrade) ⇒ * [.positionRiskOnCollateralAction(deltaCollateral, account)](#MarketData+positionRiskOnCollateralAction) ⇒MarginAccount* [.getWalletBalance(address, symbol)](#MarketData+getWalletBalance) ⇒ * [.getPoolShareTokenBalance(address, symbolOrId)](#MarketData+getPoolShareTokenBalance) ⇒number* [.getShareTokenPrice(symbolOrId)](#MarketData+getShareTokenPrice) ⇒number* [.getParticipationValue(address, symbolOrId)](#MarketData+getParticipationValue) ⇒ * [.maxOrderSizeForTrader(traderAddr, symbol)](#MarketData+maxOrderSizeForTrader) ⇒ * [.pmMaxOrderSizeForTrader(traderAddr, symbol, overrides)](#MarketData+pmMaxOrderSizeForTrader) ⇒ * [.getMaxShortLongTrade(perpId, currentTraderPos, overrides)](#MarketData+getMaxShortLongTrade) ⇒ * [.rmMaxOrderSizeForTrader(traderAddr, symbol, overrides)](#MarketData+rmMaxOrderSizeForTrader) ⇒ * [.maxSignedPosition(side, symbol)](#MarketData+maxSignedPosition) ⇒number* [.getOraclePrice(base, quote)](#MarketData+getOraclePrice) ⇒number* [.getOrderStatus(symbol, orderId, overrides)](#MarketData+getOrderStatus) ⇒ * [.getOrdersStatus(symbol, orderId)](#MarketData+getOrdersStatus) ⇒ * [.getMarkPrice(symbol, indexPrices)](#MarketData+getMarkPrice) ⇒number* [.getPerpetualPrice(symbol, quantity, priceInfo)](#MarketData+getPerpetualPrice) ⇒number* [.getPerpetualState(symbol)](#MarketData+getPerpetualState) ⇒PerpetualState* [.getPoolState(poolSymbol)](#MarketData+getPoolState) ⇒ [PoolState](#PoolState) * [.getPerpetualStaticInfo(symbol)](#MarketData+getPerpetualStaticInfo) ⇒PerpetualStaticInfo* [.getPerpetualMidPrice(symbol)](#MarketData+getPerpetualMidPrice) ⇒number* [.getAvailableMargin(traderAddr, symbol, indexPrices)](#MarketData+getAvailableMargin) ⇒ * [.getTraderLoyalityScore(traderAddr)](#MarketData+getTraderLoyalityScore) ⇒number* [.isMarketClosed(symbol)](#MarketData+isMarketClosed) ⇒boolean* [.getPriceInUSD(symbol)](#MarketData+getPriceInUSD) ⇒Map.<string, number>* [.fetchPricesForPerpetual(symbol)](#MarketData+fetchPricesForPerpetual) ⇒ * [.fetchPrdMktMetaData(symbol)](#MarketData+fetchPrdMktMetaData) ⇒ * [.fetchPythMetaData(symbol)](#MarketData+fetchPythMetaData) ⇒ * [.fetchSymbolList()](#PerpetualDataHandler+fetchSymbolList) * [.getOrderBookContract(symbol)](#PerpetualDataHandler+getOrderBookContract) ⇒ * [.getPerpetuals(ids, overrides)](#PerpetualDataHandler+getPerpetuals) ⇒ * [.getLiquidityPools(fromIdx, toIdx, overrides)](#PerpetualDataHandler+getLiquidityPools) ⇒ * [._fillSymbolMaps()](#PerpetualDataHandler+_fillSymbolMaps) * [.initSettlementToken(perpStaticInfos)](#PerpetualDataHandler+initSettlementToken) * [.getSymbolFromPoolId(poolId)](#PerpetualDataHandler+getSymbolFromPoolId) ⇒symbol* [.getPoolIdFromSymbol(symbol)](#PerpetualDataHandler+getPoolIdFromSymbol) ⇒number* [.getPerpIdFromSymbol(symbol)](#PerpetualDataHandler+getPerpIdFromSymbol) ⇒number* [.getSymbolFromPerpId(perpId)](#PerpetualDataHandler+getSymbolFromPerpId) ⇒string* [.symbol4BToLongSymbol(sym)](#PerpetualDataHandler+symbol4BToLongSymbol) ⇒string* [.fetchPriceSubmissionInfoForPerpetual(symbol)](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual) ⇒ * [.getIndexSymbols(symbol)](#PerpetualDataHandler+getIndexSymbols) ⇒ * [.fetchLatestFeedPriceInfo(symbol)](#PerpetualDataHandler+fetchLatestFeedPriceInfo) ⇒ * [.fetchCollateralToSettlementConversion(symbol)](#PerpetualDataHandler+fetchCollateralToSettlementConversion) * [.getPriceIds(symbol)](#PerpetualDataHandler+getPriceIds) ⇒ * [.getPerpetualSymbolsInPool(poolSymbol)](#PerpetualDataHandler+getPerpetualSymbolsInPool) ⇒ * [.getAllOpenOrders(symbol)](#PerpetualDataHandler+getAllOpenOrders) ⇒ * [.numberOfOpenOrders(symbol)](#PerpetualDataHandler+numberOfOpenOrders) ⇒number* [.pollLimitOrders(symbol, numElements, [startAfter])](#PerpetualDataHandler+pollLimitOrders) ⇒ * [.getPoolStaticInfoIndexFromSymbol(symbol)](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol) ⇒ * [.getMarginTokenFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenFromSymbol) ⇒ * [.getSettlementTokenFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenFromSymbol) ⇒ * [.getMarginTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol) ⇒ * [.getSettlementTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol) ⇒ * [.getABI(contract)](#PerpetualDataHandler+getABI) ⇒ * [.isPredictionMarket(symbol)](#PerpetualDataHandler+isPredictionMarket) ⇒ * [.isLowLiquidityMarket(symbol)](#PerpetualDataHandler+isLowLiquidityMarket) ⇒ * [.isTradFiMarket(symbol)](#PerpetualDataHandler+isTradFiMarket) ⇒ * [.getMarketDayTradingOpenCloseSec(symbol)](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec) ⇒ * [.getInitialMarginRate(symbol)](#PerpetualDataHandler+getInitialMarginRate) ⇒ * [.getMaintenanceMarginRate(symbol)](#PerpetualDataHandler+getMaintenanceMarginRate) ⇒ * [.getShortSymbol(symbol)](#PerpetualDataHandler+getShortSymbol) ⇒ * [.refreshSymbols()](#PerpetualDataHandler+refreshSymbols) * [.getLocalPerpetualStates()](#PerpetualDataHandler+getLocalPerpetualStates) ⇒ * [.fetchOnChainPerpetualStates()](#PerpetualDataHandler+fetchOnChainPerpetualStates) ⇒ * [.checkHeartbeat()](#PerpetualDataHandler+checkHeartbeat) ⇒ * _static_ * [.chainOrders(orders, ids)](#TraderInterface.chainOrders) ⇒ ### new TraderInterface(config)Constructor
| Param | Type | Description | | --- | --- | --- | | config |NodeSDKConfig|Configuration object, see PerpetualDataHandler.readSDKConfig.
| ### traderInterface.queryExchangeFee(poolSymbolName, traderAddr, brokerAddr) ⇒Get the fee that is charged to the trader for a given broker (can be ZERO-address), without broker fee
**Kind**: instance method of [TraderInterface](#TraderInterface) **Returns**:fee (in decimals) that is charged by exchange (without broker)
| Param | Description | | --- | --- | | poolSymbolName |pool currency (e.g. MATIC)
| | traderAddr |address of trader
| | brokerAddr |address of broker
| **Example** ```js import { TraderInterface, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(TraderInterface); const config = PerpetualDataHandler.readSDKConfig("cardona"); let traderAPI = new TraderInterface(config); await traderAPI.createProxyInstance(); // query exchange fee let fees = await traderAPI.queryExchangeFee("MATIC"); console.log(fees); } main(); ``` ### traderInterface.getCurrentTraderVolume(poolSymbolName, traderAddr) ⇒ **Kind**: instance method of [TraderInterface](#TraderInterface) **Returns**:volume in USD
| Param | Description | | --- | --- | | poolSymbolName |pool symbol, e.g. MATIC
| | traderAddr |address of the trader
| **Example** ```js import { TraderInterface, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(TraderInterface); const config = PerpetualDataHandler.readSDKConfig("cardona"); let traderAPI = new TraderInterface(config); await traderAPI.createProxyInstance(); // query volume let vol = await traderAPI.getCurrentTraderVolume("MATIC", "0xmyAddress"); console.log(vol); } main(); ``` ### traderInterface.cancelOrderDigest(symbol, orderId) ⇒Get digest to cancel an order. Digest needs to be signed and submitted via orderBookContract.cancelOrder(orderId, signature);
**Kind**: instance method of [TraderInterface](#TraderInterface) **Returns**:tuple of digest which the trader needs to sign and address of order book contract
| Param | | --- | | symbol | | orderId | **Example** ```js import { TraderInterface, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(TraderInterface); const config = PerpetualDataHandler.readSDKConfig("x1"); let traderAPI = new TraderInterface(config); await traderAPI.createProxyInstance(); // submit order let resp = await accTrade.order(order, undefined, { gasLimit: 800_000 }); await resp.tx.wait(); // cancel what we just submitted let d = await traderAPI.cancelOrderDigest("ETH-USDC-USDC", resp.orderId); console.log(d); } main(); ``` ### traderInterface.getOrderBookAddress(symbol) ⇒Get the order book address for a perpetual
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getOrderBookAddress](#PerpetualDataHandler+getOrderBookAddress) **Returns**:order book address for the perpetual
| Param | Description | | --- | --- | | symbol |symbol (e.g. MATIC-USD-MATIC)
| **Example** ```js import { TraderInterface, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(TraderInterface); const config = PerpetualDataHandler.readSDKConfig("cardona"); let traderAPI = new TraderInterface(config); await traderAPI.createProxyInstance(); // get order book address let ob = traderAPI.getOrderBookAddress("BTC-USD-MATIC"); console.log(ob); } main(); ``` ### traderInterface.createSmartContractOrder(order, traderAddr) ⇒createSmartContractOrder from user-friendly order
**Kind**: instance method of [TraderInterface](#TraderInterface) **Returns**:Smart contract type order struct
| Param | Description | | --- | --- | | order |order struct
| | traderAddr |address of trader
| ### traderInterface.orderDigest(scOrder) ⇒Create smart contract order and digest that the trader signs. await orderBookContract.postOrder(scOrder, signature, { gasLimit: gasLimit }); Order must contain broker fee and broker address if there is supposed to be a broker.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Returns**:digest that the trader has to sign
| Param | Description | | --- | --- | | scOrder |smart contract order struct (get from order via createSCOrder)
| ### traderInterface.getProxyABI(method) ⇒Get the ABI of a method in the proxy contract. Throws if non-existent
**Kind**: instance method of [TraderInterface](#TraderInterface) **Returns**:ABI as a single string
| Param | Description | | --- | --- | | method |Name of the method
| ### traderInterface.getOrderBookABI(symbol, method) ⇒Get the ABI of a method in the Limit Order Book contract corresponding to a given symbol.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Returns**:ABI as a single string
| Param | Description | | --- | --- | | symbol |Symbol of the form MATIC-USD-MATIC
| | method |Name of the method
| ### traderInterface.addLiquidity(signer, poolSymbolName, amountCC) ⇒Add liquidity to the PnL participant fund via signer. The address gets pool shares in return.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Returns**:Transaction object
| Param | Type | Description | | --- | --- | --- | | signer |Signer|Signer that will deposit liquidity
| | poolSymbolName |string|Name of pool symbol (e.g. MATIC)
| | amountCC |number|Amount in pool-collateral currency
| **Example** ```js import { TraderInterface, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(TraderInterface); const config = PerpetualDataHandler.readSDKConfig("cardona"); const signer = // ethers Signer, e.g. from Metamask let traderAPI = new TraderInterface(config); await traderAPI.createProxyInstance(); // add liquidity let respAddLiquidity = await traderAPI.addLiquidity(signer, "MATIC", 0.1); console.log(respAddLiquidity); } main(); ``` ### traderInterface.initiateLiquidityWithdrawal(signer, poolSymbolName, amountPoolShares) ⇒Initiates a liquidity withdrawal from the pool It triggers a time-delayed unlocking of the given number of pool shares. The amount of pool shares to be unlocked is fixed by this call, but not their value in pool currency.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Returns**:Transaction object.
| Param | Type | Description | | --- | --- | --- | | signer |Signer|Signer that will initiate liquidity withdrawal
| | poolSymbolName |string|Name of pool symbol (e.g. MATIC).
| | amountPoolShares |string|Amount in pool-shares, removes everything if > available amount.
| **Example** ```js import { TraderInterface, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(TraderInterface); const config = PerpetualDataHandler.readSDKConfig("cardona"); const signer = // ethers Signer, e.g. from Metamask let traderAPI = new TraderInterface(config); await traderAPI.createProxyInstance(); // submit txn let tx = await traderAPI.initiateLiquidityWithdrawal(signer, "MATIC", 10.2); console.log(tx); } main(); ``` ### traderInterface.executeLiquidityWithdrawal(signer, poolSymbolName) ⇒Withdraws as much liquidity as there is available after a call to initiateLiquidityWithdrawal. The address loses pool shares in return.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Returns**:Transaction object.
| Param | Type | Description | | --- | --- | --- | | signer |Signer|Signer that will execute the liquidity withdrawal
| | poolSymbolName | | | **Example** ```js import { TraderInterface, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(TraderInterface); const config = PerpetualDataHandler.readSDKConfig("cardona"); const signer = // ethers Signer, e.g. from Metamask let traderAPI = new TraderInterface(config); await traderAPI.createProxyInstance(); // submit txn let tx = await traderAPI.executeLiquidityWithdrawal(signer, "MATIC"); console.log(tx); } main(); ``` ### traderInterface.createProxyInstance(providerOrMarketData)Initialize the marketData-Class with this function to create instance of D8X perpetual contract and gather information about perpetual currencies
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [createProxyInstance](#MarketData+createProxyInstance) | Param | Description | | --- | --- | | providerOrMarketData |optional provider or existing market data instance
| ### traderInterface.getProxyAddress() ⇒stringGet the proxy address
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getProxyAddress](#MarketData+getProxyAddress) **Returns**:string-Address of the perpetual proxy contract
### traderInterface.getTriangulations() ⇒Get the pre-computed triangulations
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getTriangulations](#MarketData+getTriangulations) **Returns**:Triangulations
### traderInterface.smartContractOrderToOrder(smOrder) ⇒OrderConvert the smart contract output of an order into a convenient format of type "Order"
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [smartContractOrderToOrder](#MarketData+smartContractOrderToOrder) **Returns**:Order-more convenient format of order, type "Order"
| Param | Type | Description | | --- | --- | --- | | smOrder | [SmartContractOrder](#SmartContractOrder) |SmartContractOrder, as obtained e.g., by PerpetualLimitOrderCreated event
| ### traderInterface.getReadOnlyProxyInstance() ⇒Get contract instance. Useful for event listening.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getReadOnlyProxyInstance](#MarketData+getReadOnlyProxyInstance) **Returns**:read-only proxy instance
**Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // Get contract instance let proxy = await mktData.getReadOnlyProxyInstance(); console.log(proxy); } main(); ``` ### traderInterface.exchangeInfo() ⇒ [ExchangeInfo](#ExchangeInfo)Information about the products traded in the exchange.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [exchangeInfo](#MarketData+exchangeInfo) **Returns**: [ExchangeInfo](#ExchangeInfo) -Array of static data for all the pools and perpetuals in the system.
**Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // Get exchange info let info = await mktData.exchangeInfo(); console.log(info); } main(); ``` ### traderInterface.openOrders(traderAddr, symbol) ⇒All open orders for a trader-address and a symbol.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [openOrders](#MarketData+openOrders) **Returns**:For each perpetual an array of open orders and corresponding order-ids.
| Param | Type | Description | | --- | --- | --- | | traderAddr |string|Address of the trader for which we get the open orders.
| | symbol |string|Symbol of the form ETH-USD-MATIC or a pool symbol, or undefined. If a poolSymbol is provided, the response includes orders in all perpetuals of the given pool. If no symbol is provided, the response includes orders from all perpetuals in all pools.
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // Get all open orders for a trader/symbol let opOrder = await mktData.openOrders("0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B", "ETH-USD-MATIC"); console.log(opOrder); } main(); ``` ### traderInterface.positionRisk(traderAddr, symbol) ⇒Array.<MarginAccount>Information about the position open by a given trader in a given perpetual contract, or for all perpetuals in a pool
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [positionRisk](#MarketData+positionRisk) **Returns**:Array.<MarginAccount>-Array of position risks of trader.
| Param | Type | Description | | --- | --- | --- | | traderAddr |string|Address of the trader for which we get the position risk.
| | symbol |string|Symbol of the form ETH-USD-MATIC, or pool symbol ("MATIC") to get all positions in a given pool, or no symbol to get all positions in all pools.
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // Get position risk info let posRisk = await mktData.positionRisk("0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B", "ETH-USD-MATIC"); console.log(posRisk); } main(); ``` ### traderInterface.positionRiskOnTrade(traderAddr, order, signedPositionNotionalBaseCCY, tradingFeeTbps, indexPriceInfo) ⇒Estimates what the position risk will be if a given order is executed.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [positionRiskOnTrade](#MarketData+positionRiskOnTrade) **Returns**:Position risk after trade, including order cost and maximal trade sizes for position
| Param | Description | | --- | --- | | traderAddr |Address of trader
| | order |Order to be submitted
| | signedPositionNotionalBaseCCY |signed position notional of current position (before trade)
| | tradingFeeTbps |trading fee in tenth of basis points (exchange fee and broker fee)
| | indexPriceInfo |Index prices and market status (open/closed). Defaults to current market status if not given.
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); const mktData = new MarketData(config); await mktData.createProxyInstance(); const order: Order = { symbol: "MATIC-USD-MATIC", side: "BUY", type: "MARKET", quantity: 100, leverage: 2, executionTimestamp: Date.now()/1000, }; // Get position risk conditional on this order being executed const posRisk = await mktData.positionRiskOnTrade("0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B", order, 0, 60); console.log(posRisk); } main(); ``` ### traderInterface.positionRiskOnCollateralAction(deltaCollateral, account) ⇒MarginAccountEstimates what the position risk will be if given amount of collateral is added/removed from the account.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [positionRiskOnCollateralAction](#MarketData+positionRiskOnCollateralAction) **Returns**:MarginAccount-Position risk after collateral has been added/removed
| Param | Type | Description | | --- | --- | --- | | deltaCollateral |number|Amount of collateral to add or remove (signed)
| | account |MarginAccount|Position risk before collateral is added or removed
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); const mktData = new MarketData(config); await mktData.createProxyInstance(); // Get position risk conditional on removing 3.14 MATIC const traderAddr = "0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B"; const curPos = await mktData.positionRisk("traderAddr", "BTC-USD-MATIC"); const posRisk = await mktData.positionRiskOnCollateralAction(-3.14, curPos); console.log(posRisk); } main(); ``` ### traderInterface.getWalletBalance(address, symbol) ⇒Gets the wallet balance in the settlement currency corresponding to a given perpetual symbol. The settlement currency is usually the same as the collateral currency.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getWalletBalance](#MarketData+getWalletBalance) **Returns**:Perpetual's collateral token balance of the given address.
| Param | Description | | --- | --- | | address |Address to check
| | symbol |Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); let md = new MarketData(config); await md.createProxyInstance(); // get MATIC balance of address let marginTokenBalance = await md.getWalletBalance(myaddress, "BTC-USD-MATIC"); console.log(marginTokenBalance); } main(); ``` ### traderInterface.getPoolShareTokenBalance(address, symbolOrId) ⇒numberGet the address' balance of the pool share token
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getPoolShareTokenBalance](#MarketData+getPoolShareTokenBalance) **Returns**:number-Pool share token balance of the given address (e.g. dMATIC balance)
| Param | Type | Description | | --- | --- | --- | | address |string|address of the liquidity provider
| | symbolOrId |string\|number|Symbol of the form ETH-USD-MATIC, or MATIC (collateral only), or Pool-Id
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); let md = new MarketData(config); await md.createProxyInstance(); // get dMATIC balance of address let shareTokenBalance = await md.getPoolShareTokenBalance(myaddress, "MATIC"); console.log(shareTokenBalance); } main(); ``` ### traderInterface.getShareTokenPrice(symbolOrId) ⇒numberValue of pool token in collateral currency
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getShareTokenPrice](#MarketData+getShareTokenPrice) **Returns**:number-current pool share token price in collateral currency
| Param | Type | Description | | --- | --- | --- | | symbolOrId |string\|number|symbol of the form ETH-USD-MATIC, MATIC (collateral), or poolId
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); let md = new MarketData(config); await md.createProxyInstance(); // get price of 1 dMATIC in MATIC let shareTokenPrice = await md.getShareTokenPrice(myaddress, "MATIC"); console.log(shareTokenPrice); } main(); ``` ### traderInterface.getParticipationValue(address, symbolOrId) ⇒Value of the pool share tokens for this liquidity provider in poolSymbol-currency (e.g. MATIC, USDC).
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getParticipationValue](#MarketData+getParticipationValue) **Returns**:the value (in collateral tokens) of the pool share, #share tokens, shareTokenAddress
| Param | Type | Description | | --- | --- | --- | | address |string|address of liquidity provider
| | symbolOrId |string\|number|symbol of the form ETH-USD-MATIC, MATIC (collateral), or poolId
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); let md = new MarketData(config); await md.createProxyInstance(); // get value of pool share token let shareToken = await md.getParticipationValue(myaddress, "MATIC"); console.log(shareToken); } main(); ``` ### traderInterface.maxOrderSizeForTrader(traderAddr, symbol) ⇒Gets the maximal order sizes to open/close/flip positions, both long and short, considering the existing position, state of the perpetual Accounts for user's wallet balance only in rmMaxOrderSizeForTrader case.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [maxOrderSizeForTrader](#MarketData+maxOrderSizeForTrader) **Returns**:Maximal buy and sell trade sizes (positive)
| Param | Type | Description | | --- | --- | --- | | traderAddr |string|Address of trader
| | symbol |symbol|Symbol of the form ETH-USD-MATIC
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); let md = new MarketData(config); await md.createProxyInstance(); // max order sizes let shareToken = await md.maxOrderSizeForTrader(myaddress, "BTC-USD-MATIC"); console.log(shareToken); // {buy: 314, sell: 415} } main(); ``` ### traderInterface.pmMaxOrderSizeForTrader(traderAddr, symbol, overrides) ⇒pmMaxOrderSizeForTrader returns the max order size for the trader that is possible from AMM perspective (agnostic about wallet balance and leverage, also correct if trader is shrinking their position)
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [pmMaxOrderSizeForTrader](#MarketData+pmMaxOrderSizeForTrader) **Returns**:buy: number; sell: number absolute
| Param | Description | | --- | --- | | traderAddr |address of trader
| | symbol |perp symbol
| | overrides |optional
| ### traderInterface.getMaxShortLongTrade(perpId, currentTraderPos, overrides) ⇒Returns the maximal allowed short trade and long trade (signed) for a trader that has a given notional (in ABDK format) in the perpetual, ignoring the traders wallet balance
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getMaxShortLongTrade](#MarketData+getMaxShortLongTrade) **Returns**:[maxShortPos, maxLongPos] signed maximal trade sizes
| Param | Description | | --- | --- | | perpId | | | currentTraderPos |ABDK64x64 signed notional position of trader
| | overrides | | ### traderInterface.rmMaxOrderSizeForTrader(traderAddr, symbol, overrides) ⇒Returns the maximal order size. Also applies to closing positions.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [rmMaxOrderSizeForTrader](#MarketData+rmMaxOrderSizeForTrader) **Returns**:max buy and sell order size in absolute terms
| Param | Description | | --- | --- | | traderAddr |trader addr to get their position
| | symbol |symbol we are trading
| | overrides | | ### traderInterface.maxSignedPosition(side, symbol) ⇒numberPerpetual-wide maximal signed position size in perpetual.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [maxSignedPosition](#MarketData+maxSignedPosition) **Returns**:number-signed maximal position size in base currency
| Param | Type | Description | | --- | --- | --- | | side | |BUY_SIDE or SELL_SIDE
| | symbol |string|of the form ETH-USD-MATIC.
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get oracle price let maxLongPos = await mktData.maxSignedPosition(BUY_SIDE, "BTC-USD-MATIC"); console.log(maxLongPos); } main(); ``` ### traderInterface.getOraclePrice(base, quote) ⇒numberUses the Oracle(s) in the exchange to get the latest price of a given index in a given currency, if a route exists.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getOraclePrice](#MarketData+getOraclePrice) **Returns**:number-Price of index in given currency.
| Param | Type | Description | | --- | --- | --- | | base |string|Index name, e.g. ETH.
| | quote |string|Quote currency, e.g. USD.
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get oracle price let price = await mktData.getOraclePrice("ETH", "USD"); console.log(price); } main(); ``` ### traderInterface.getOrderStatus(symbol, orderId, overrides) ⇒Get the status of an order given a symbol and order Id
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getOrderStatus](#MarketData+getOrderStatus) **Returns**:Order status (cancelled = 0, executed = 1, open = 2, unkown = 3)
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-MATIC
| | orderId |Order Id
| | overrides | | **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get order stauts let status = await mktData.getOrderStatus("ETH-USD-MATIC", "0xmyOrderId"); console.log(status); } main(); ``` ### traderInterface.getOrdersStatus(symbol, orderId) ⇒Get the status of an array of orders given a symbol and their Ids
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getOrdersStatus](#MarketData+getOrdersStatus) **Returns**:Array of order status
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-MATIC
| | orderId |Array of order Ids
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get order stauts let status = await mktData.getOrdersStatus("ETH-USD-MATIC", ["0xmyOrderId1", "0xmyOrderId2"]); console.log(status); } main(); ``` ### traderInterface.getMarkPrice(symbol, indexPrices) ⇒numberGet the current mark price
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getMarkPrice](#MarketData+getMarkPrice) **Returns**:number-mark price
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| | indexPrices |optional. IdxPriceInfo
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get mark price let price = await mktData.getMarkPrice("ETH-USD-MATIC"); console.log(price); } main(); ``` ### traderInterface.getPerpetualPrice(symbol, quantity, priceInfo) ⇒numberget the current price for a given quantity
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getPerpetualPrice](#MarketData+getPerpetualPrice) **Returns**:number-price
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| | quantity |quantity to be traded, negative if short
| | priceInfo |[s2, s3, conf, params]; for non-prediction markets conf/params can be 0
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get perpetual price let price = await mktData.getPerpetualPrice("ETH-USD-MATIC", 1); console.log(price); } main(); ``` ### traderInterface.getPerpetualState(symbol) ⇒PerpetualStateQuery recent perpetual state from blockchain
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getPerpetualState](#MarketData+getPerpetualState) **Returns**:PerpetualState-PerpetualState copy
| Param | Type | Description | | --- | --- | --- | | symbol |string|symbol of the form ETH-USD-MATIC
| ### traderInterface.getPoolState(poolSymbol) ⇒ [PoolState](#PoolState)Query recent pool state from blockchain, not including perpetual states
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getPoolState](#MarketData+getPoolState) **Returns**: [PoolState](#PoolState) -PoolState copy
| Param | Type | Description | | --- | --- | --- | | poolSymbol |string|symbol of the form USDC
| ### traderInterface.getPerpetualStaticInfo(symbol) ⇒PerpetualStaticInfoQuery perpetual static info. This information is queried once at createProxyInstance-time, and remains static after that.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getPerpetualStaticInfo](#MarketData+getPerpetualStaticInfo) **Returns**:PerpetualStaticInfo-Perpetual static info copy.
| Param | Type | Description | | --- | --- | --- | | symbol |string|Perpetual symbol
| ### traderInterface.getPerpetualMidPrice(symbol) ⇒numberget the current mid-price for a perpetual
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getPerpetualMidPrice](#MarketData+getPerpetualMidPrice) **Returns**:number-price
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get perpetual mid price let midPrice = await mktData.getPerpetualMidPrice("ETH-USD-MATIC"); console.log(midPrice); } main(); ``` ### traderInterface.getAvailableMargin(traderAddr, symbol, indexPrices) ⇒Query the available margin conditional on the given (or current) index prices Result is in collateral currency
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getAvailableMargin](#MarketData+getAvailableMargin) **Returns**:available margin in collateral currency
| Param | Type | Description | | --- | --- | --- | | traderAddr |string|address of the trader
| | symbol |string|perpetual symbol of the form BTC-USD-MATIC
| | indexPrices | |optional indexPriceInfo
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get available margin let mgn = await mktData.getAvailableMargin("0xmyAddress", "ETH-USD-MATIC"); console.log(mgn); } main(); ``` ### traderInterface.getTraderLoyalityScore(traderAddr) ⇒numberCalculate a type of exchange loyality score based on trader volume
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getTraderLoyalityScore](#MarketData+getTraderLoyalityScore) **Returns**:number-a loyality score (4 worst, 1 best)
| Param | Type | Description | | --- | --- | --- | | traderAddr |string|address of the trader
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // get scpre let s = await mktData.getTraderLoyalityScore("0xmyAddress"); console.log(s); } main(); ``` ### traderInterface.isMarketClosed(symbol) ⇒booleanGet market open/closed status
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [isMarketClosed](#MarketData+isMarketClosed) **Returns**:boolean-True if the market is closed
| Param | Type | Description | | --- | --- | --- | | symbol |string|Perpetual symbol of the form ETH-USD-MATIC
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // is market closed? let s = await mktData.isMarketClosed("ETH-USD-MATIC"); console.log(s); } main(); ``` ### traderInterface.getPriceInUSD(symbol) ⇒Map.<string, number>Get the latest on-chain price of a perpetual base index in USD.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getPriceInUSD](#MarketData+getPriceInUSD) **Returns**:Map.<string, number>-Price of the base index in USD, e.g. for ETH-USDC-MATIC, it returns the value of ETH-USD.
| Param | Type | Description | | --- | --- | --- | | symbol |string|Symbol of the form ETH-USDC-MATIC. If a pool symbol is used, it returns an array of all the USD prices of the indices in the pool. If no argument is provided, it returns all prices of all the indices in the pools of the exchange.
| **Example** ```js import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(MarketData); // setup const config = PerpetualDataHandler.readSDKConfig("cardona"); let mktData = new MarketData(config); await mktData.createProxyInstance(); // is market closed? let px = await mktData.getPriceInUSD("ETH-USDC-USDC"); console.log(px); // {'ETH-USD' -> 1800} } main(); ``` ### traderInterface.fetchPricesForPerpetual(symbol) ⇒Fetch latest off-chain index and collateral prices
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [fetchPricesForPerpetual](#MarketData+fetchPricesForPerpetual) **Returns**:Prices and market-closed information
| Param | Description | | --- | --- | | symbol |Perpetual symbol of the form BTC-USDc-USDC
| ### traderInterface.fetchPrdMktMetaData(symbol) ⇒fetch prediction markets meta data
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [fetchPrdMktMetaData](#MarketData+fetchPrdMktMetaData) **Returns**:question for given symbol
| Param | Description | | --- | --- | | symbol |symbol of the form "TRUMP24-USD"
| ### traderInterface.fetchPythMetaData(symbol) ⇒Fetch Pyth metadata of a given symbol. The priority is:
**Kind**: instance method of [
- Full match: first feed with exact symbol BERA-USD
- Partial match: if no full match is found, search for first feed with symbol BERA-XYZ
TraderInterface](#TraderInterface) **Overrides**: [fetchPythMetaData](#MarketData+fetchPythMetaData) **Returns**:description of feed underlying given symbol
| Param | Description | | --- | --- | | symbol |symbol of the form "BERA-USD"
| ### traderInterface.fetchSymbolList()sets the symbollist if a remote config url is specified
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [fetchSymbolList](#PerpetualDataHandler+fetchSymbolList) ### traderInterface.getOrderBookContract(symbol) ⇒Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getOrderBookContract](#PerpetualDataHandler+getOrderBookContract) **Returns**:order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### traderInterface.getPerpetuals(ids, overrides) ⇒Get perpetuals for the given ids from onchain
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getPerpetuals](#PerpetualDataHandler+getPerpetuals) **Returns**:array of PerpetualData converted into decimals
| Param | Description | | --- | --- | | ids |perpetual ids
| | overrides |optional
| ### traderInterface.getLiquidityPools(fromIdx, toIdx, overrides) ⇒Get liquidity pools data
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getLiquidityPools](#PerpetualDataHandler+getLiquidityPools) **Returns**:array of LiquidityPoolData converted into decimals
| Param | Description | | --- | --- | | fromIdx |starting index (>=1)
| | toIdx |to index (inclusive)
| | overrides |optional
| ### traderInterface.\_fillSymbolMaps()Called when initializing. This function fills this.symbolToTokenAddrMap, and this.nestedPerpetualIDs and this.symbolToPerpStaticInfo
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [\_fillSymbolMaps](#PerpetualDataHandler+_fillSymbolMaps) ### traderInterface.initSettlementToken(perpStaticInfos)Initializes settlement currency for all pools by completing this.poolStaticInfos with settlement currency info
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [initSettlementToken](#PerpetualDataHandler+initSettlementToken) | Param | Description | | --- | --- | | perpStaticInfos |PerpetualStaticInfo array from contract call
| ### traderInterface.getSymbolFromPoolId(poolId) ⇒symbolGet pool symbol given a pool Id.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getSymbolFromPoolId](#PerpetualDataHandler+getSymbolFromPoolId) **Returns**:symbol-Pool symbol, e.g. "USDC".
| Param | Type | Description | | --- | --- | --- | | poolId |number|Pool Id.
| ### traderInterface.getPoolIdFromSymbol(symbol) ⇒numberGet pool Id given a pool symbol. Pool IDs start at 1.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getPoolIdFromSymbol](#PerpetualDataHandler+getPoolIdFromSymbol) **Returns**:number-Pool Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string|Pool symbol.
| ### traderInterface.getPerpIdFromSymbol(symbol) ⇒numberGet perpetual Id given a perpetual symbol.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getPerpIdFromSymbol](#PerpetualDataHandler+getPerpIdFromSymbol) **Returns**:number-Perpetual Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string|Perpetual symbol, e.g. "BTC-USD-MATIC".
| ### traderInterface.getSymbolFromPerpId(perpId) ⇒stringGet the symbol in long format of the perpetual id
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getSymbolFromPerpId](#PerpetualDataHandler+getSymbolFromPerpId) **Returns**:string-Symbol
| Param | Type | Description | | --- | --- | --- | | perpId |number|perpetual id
| ### traderInterface.symbol4BToLongSymbol(sym) ⇒string**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [symbol4BToLongSymbol](#PerpetualDataHandler+symbol4BToLongSymbol) **Returns**:string-Long symbol
| Param | Type | Description | | --- | --- | --- | | sym |string|Short symbol
| ### traderInterface.fetchPriceSubmissionInfoForPerpetual(symbol) ⇒Get PriceFeedSubmission data required for blockchain queries that involve price data, and the corresponding triangulated prices for the indices S2 and S3
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [fetchPriceSubmissionInfoForPerpetual](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual) **Returns**:PriceFeedSubmission and prices for S2 and S3. [S2price, 0] if S3 not defined.
| Param | Description | | --- | --- | | symbol |pool symbol of the form "ETH-USD-MATIC"
| ### traderInterface.getIndexSymbols(symbol) ⇒Get the symbols required as indices for the given perpetual
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getIndexSymbols](#PerpetualDataHandler+getIndexSymbols) **Returns**:name of underlying index prices, e.g. ["MATIC-USD", ""]
| Param | Description | | --- | --- | | symbol |of the form ETH-USD-MATIC, specifying the perpetual
| ### traderInterface.fetchLatestFeedPriceInfo(symbol) ⇒Get the latest prices for a given perpetual from the offchain oracle networks
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [fetchLatestFeedPriceInfo](#PerpetualDataHandler+fetchLatestFeedPriceInfo) **Returns**:array of price feed updates that can be submitted to the smart contract and corresponding price information
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form BTC-USD-MATIC
| ### traderInterface.fetchCollateralToSettlementConversion(symbol)fetchCollateralToSettlementConversion returns the price which converts the collateral currency into settlement currency. For example if BTC-USD-STUSD has settlement currency USDC, we get let px = fetchCollateralToSettlementConversion("BTC-USD-STUSD") valueInUSDC = collateralInSTUSD * px
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [fetchCollateralToSettlementConversion](#PerpetualDataHandler+fetchCollateralToSettlementConversion) | Param | Description | | --- | --- | | symbol |either perpetual symbol of the form BTC-USD-MATIC or just collateral token
| ### traderInterface.getPriceIds(symbol) ⇒Get list of required pyth price source IDs for given perpetual
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getPriceIds](#PerpetualDataHandler+getPriceIds) **Returns**:list of required pyth price sources for this perpetual
| Param | Description | | --- | --- | | symbol |perpetual symbol, e.g., BTC-USD-MATIC
| ### traderInterface.getPerpetualSymbolsInPool(poolSymbol) ⇒Get ('normal'-state) perpetual symbols for a given pool
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getPerpetualSymbolsInPool](#PerpetualDataHandler+getPerpetualSymbolsInPool) **Returns**:array of perpetual symbols in this pool
| Param | Description | | --- | --- | | poolSymbol |pool symbol such as "MATIC"
| ### traderInterface.getAllOpenOrders(symbol) ⇒All the orders in the order book for a given symbol that are currently open.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getAllOpenOrders](#PerpetualDataHandler+getAllOpenOrders) **Returns**:Array with all open orders and their IDs.
| Param | Type | Description | | --- | --- | --- | | symbol |string|Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =process.env.PK; let orderTool = new OrderExecutorTool(config, pk); await orderTool.createProxyInstance(); // get all open orders let openOrders = await orderTool.getAllOpenOrders("ETH-USD-MATIC"); console.log(openOrders); } main(); ``` ### traderInterface.numberOfOpenOrders(symbol) ⇒ numberTotal number of limit orders for this symbol, excluding those that have been cancelled/removed.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [numberOfOpenOrders](#PerpetualDataHandler+numberOfOpenOrders) **Returns**:number-Number of open orders.
| Param | Type | Description | | --- | --- | --- | | symbol |string|Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =process.env.PK; let orderTool = new OrderExecutorTool(config, pk); await orderTool.createProxyInstance(); // get all open orders let numberOfOrders = await orderTool.numberOfOpenOrders("ETH-USD-MATIC"); console.log(numberOfOrders); } main(); ``` ### traderInterface.pollLimitOrders(symbol, numElements, [startAfter]) ⇒ Get a list of active conditional orders in the order book. This a read-only action and does not incur in gas costs.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [pollLimitOrders](#PerpetualDataHandler+pollLimitOrders) **Returns**:Array of orders and corresponding order IDs
| Param | Type | Description | | --- | --- | --- | | symbol |string|Symbol of the form ETH-USD-MATIC.
| | numElements |number|Maximum number of orders to poll.
| | [startAfter] |string|Optional order ID from where to start polling. Defaults to the first order.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =process.env.PK; let orderTool = new OrderExecutorTool(config, pk); await orderTool.createProxyInstance(); // get all open orders let activeOrders = await orderTool.pollLimitOrders("ETH-USD-MATIC", 2); console.log(activeOrders); } main(); ``` ### traderInterface.getPoolStaticInfoIndexFromSymbol(symbol) ⇒ Gets the pool index (starting at 0 in exchangeInfo, not ID!) corresponding to a given symbol.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getPoolStaticInfoIndexFromSymbol](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol) **Returns**:Pool index
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-MATIC
| ### traderInterface.getMarginTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getMarginTokenFromSymbol](#PerpetualDataHandler+getMarginTokenFromSymbol) **Returns**:Address of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### traderInterface.getSettlementTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getSettlementTokenFromSymbol](#PerpetualDataHandler+getSettlementTokenFromSymbol) **Returns**:Address of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### traderInterface.getMarginTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getMarginTokenDecimalsFromSymbol](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol) **Returns**:Decimals of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### traderInterface.getSettlementTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getSettlementTokenDecimalsFromSymbol](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol) **Returns**:Decimals of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### traderInterface.getABI(contract) ⇒Get ABI for LimitOrderBook, Proxy, or Share Pool Token
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getABI](#PerpetualDataHandler+getABI) **Returns**:ABI for the requested contract
| Param | Description | | --- | --- | | contract |name of contract: proxy|lob|sharetoken
| ### traderInterface.isPredictionMarket(symbol) ⇒Determines whether a given perpetual represents a prediction market
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [isPredictionMarket](#PerpetualDataHandler+isPredictionMarket) **Returns**:True if this is a prediction market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form TRUMP24-USD-USDC
| ### traderInterface.isLowLiquidityMarket(symbol) ⇒Determines whether a given perpetual represents a low-liquidity market
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [isLowLiquidityMarket](#PerpetualDataHandler+isLowLiquidityMarket) **Returns**:True if this is a low-liquidity market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form DIRAC-HONEY-USDC
| ### traderInterface.isTradFiMarket(symbol) ⇒Determines whether a given perpetual represents a tradfi market
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [isTradFiMarket](#PerpetualDataHandler+isTradFiMarket) **Returns**:True if this is a tradfi market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### traderInterface.getMarketDayTradingOpenCloseSec(symbol) ⇒Returns day trading times for tradfi markets
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getMarketDayTradingOpenCloseSec](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec) **Returns**:open time in seconds within day, close time in seconds within day
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### traderInterface.getInitialMarginRate(symbol) ⇒getInitialMarginRate
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getInitialMarginRate](#PerpetualDataHandler+getInitialMarginRate) **Returns**:initial margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### traderInterface.getMaintenanceMarginRate(symbol) ⇒getMaintenanceMarginRate
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getMaintenanceMarginRate](#PerpetualDataHandler+getMaintenanceMarginRate) **Returns**:maintenance margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### traderInterface.getShortSymbol(symbol) ⇒Short symbol corresponding to a given long symbol.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getShortSymbol](#PerpetualDataHandler+getShortSymbol) **Returns**:Short symbol (e.g. NHL0)
| Param | Description | | --- | --- | | symbol |Long symbol (e.g. NHL_TOR_DAL_251015)
| ### traderInterface.refreshSymbols()Refreshes symbol mappings if at least one prediction market is expired
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [refreshSymbols](#PerpetualDataHandler+refreshSymbols) ### traderInterface.getLocalPerpetualStates() ⇒Get state of perpetuals as currently known locally
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [getLocalPerpetualStates](#PerpetualDataHandler+getLocalPerpetualStates) **Returns**:Array of [perpetual Id, perpetual state (string)]
### traderInterface.fetchOnChainPerpetualStates() ⇒Fetches on-chain state of local perpetual ids. Does not run if SDK is not ready.
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [fetchOnChainPerpetualStates](#PerpetualDataHandler+fetchOnChainPerpetualStates) **Returns**:Array of [perpetual Id, perpetual state (string)]
### traderInterface.checkHeartbeat() ⇒Check that states of all perps known locally match on-chain states
**Kind**: instance method of [TraderInterface](#TraderInterface) **Overrides**: [checkHeartbeat](#PerpetualDataHandler+checkHeartbeat) **Returns**:True if all perp states are correct
### TraderInterface.chainOrders(orders, ids) ⇒Takes up to three orders and designates the first one as "parent" of the others. E.g. the first order opens a position, and the other two are take-profit and/or stop-loss orders.
**Kind**: static method of [TraderInterface](#TraderInterface) **Returns**:client orders with dependency info filled in
| Param | Description | | --- | --- | | orders |1, 2 or 3 smart contract orders
| | ids |order ids
| ## WriteAccessHandler ⇐ [PerpetualDataHandler](#PerpetualDataHandler)This is a parent class for the classes that require write access to the contracts. This class requires a private key and executes smart-contract interaction that require gas-payments.
**Kind**: global class **Extends**: [PerpetualDataHandler](#PerpetualDataHandler) * [WriteAccessHandler](#WriteAccessHandler) ⇐ [PerpetualDataHandler](#PerpetualDataHandler) * [new WriteAccessHandler(signer)](#new_WriteAccessHandler_new) * [.createProxyInstance(provider)](#WriteAccessHandler+createProxyInstance) * [.setAllowance(symbol, amount)](#WriteAccessHandler+setAllowance) ⇒ * [.getAddress()](#WriteAccessHandler+getAddress) ⇒string* [.swapForMockToken(symbol, amountToPay)](#WriteAccessHandler+swapForMockToken) ⇒ * [.fetchSymbolList()](#PerpetualDataHandler+fetchSymbolList) * [.getOrderBookContract(symbol)](#PerpetualDataHandler+getOrderBookContract) ⇒ * [.getOrderBookAddress(symbol)](#PerpetualDataHandler+getOrderBookAddress) ⇒ * [.getPerpetuals(ids, overrides)](#PerpetualDataHandler+getPerpetuals) ⇒ * [.getLiquidityPools(fromIdx, toIdx, overrides)](#PerpetualDataHandler+getLiquidityPools) ⇒ * [._fillSymbolMaps()](#PerpetualDataHandler+_fillSymbolMaps) * [.initSettlementToken(perpStaticInfos)](#PerpetualDataHandler+initSettlementToken) * [.getSymbolFromPoolId(poolId)](#PerpetualDataHandler+getSymbolFromPoolId) ⇒symbol* [.getPoolIdFromSymbol(symbol)](#PerpetualDataHandler+getPoolIdFromSymbol) ⇒number* [.getPerpIdFromSymbol(symbol)](#PerpetualDataHandler+getPerpIdFromSymbol) ⇒number* [.getSymbolFromPerpId(perpId)](#PerpetualDataHandler+getSymbolFromPerpId) ⇒string* [.symbol4BToLongSymbol(sym)](#PerpetualDataHandler+symbol4BToLongSymbol) ⇒string* [.fetchPriceSubmissionInfoForPerpetual(symbol)](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual) ⇒ * [.getIndexSymbols(symbol)](#PerpetualDataHandler+getIndexSymbols) ⇒ * [.fetchLatestFeedPriceInfo(symbol)](#PerpetualDataHandler+fetchLatestFeedPriceInfo) ⇒ * [.fetchCollateralToSettlementConversion(symbol)](#PerpetualDataHandler+fetchCollateralToSettlementConversion) * [.getPriceIds(symbol)](#PerpetualDataHandler+getPriceIds) ⇒ * [.getPerpetualSymbolsInPool(poolSymbol)](#PerpetualDataHandler+getPerpetualSymbolsInPool) ⇒ * [.getAllOpenOrders(symbol)](#PerpetualDataHandler+getAllOpenOrders) ⇒ * [.numberOfOpenOrders(symbol)](#PerpetualDataHandler+numberOfOpenOrders) ⇒number* [.pollLimitOrders(symbol, numElements, [startAfter])](#PerpetualDataHandler+pollLimitOrders) ⇒ * [.getPoolStaticInfoIndexFromSymbol(symbol)](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol) ⇒ * [.getMarginTokenFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenFromSymbol) ⇒ * [.getSettlementTokenFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenFromSymbol) ⇒ * [.getMarginTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol) ⇒ * [.getSettlementTokenDecimalsFromSymbol(symbol)](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol) ⇒ * [.getABI(contract)](#PerpetualDataHandler+getABI) ⇒ * [.isPredictionMarket(symbol)](#PerpetualDataHandler+isPredictionMarket) ⇒ * [.isLowLiquidityMarket(symbol)](#PerpetualDataHandler+isLowLiquidityMarket) ⇒ * [.isTradFiMarket(symbol)](#PerpetualDataHandler+isTradFiMarket) ⇒ * [.getMarketDayTradingOpenCloseSec(symbol)](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec) ⇒ * [.getInitialMarginRate(symbol)](#PerpetualDataHandler+getInitialMarginRate) ⇒ * [.getMaintenanceMarginRate(symbol)](#PerpetualDataHandler+getMaintenanceMarginRate) ⇒ * [.getShortSymbol(symbol)](#PerpetualDataHandler+getShortSymbol) ⇒ * [.refreshSymbols()](#PerpetualDataHandler+refreshSymbols) * [.getLocalPerpetualStates()](#PerpetualDataHandler+getLocalPerpetualStates) ⇒ * [.fetchOnChainPerpetualStates()](#PerpetualDataHandler+fetchOnChainPerpetualStates) ⇒ * [.checkHeartbeat()](#PerpetualDataHandler+checkHeartbeat) ⇒ ### new WriteAccessHandler(signer)Constructor
| Param | Type | Description | | --- | --- | --- | | signer |string\|Signer|Private key or ethers Signer of the account
| ### writeAccessHandler.createProxyInstance(provider)Initialize the writeAccessHandler-Class with this function to create instance of D8X perpetual contract and gather information about perpetual currencies
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) | Param | Description | | --- | --- | | provider |optional provider
| ### writeAccessHandler.setAllowance(symbol, amount) ⇒Set allowance for ar margin token (e.g., MATIC, ETH, USDC)
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Returns**:Contract Transaction
| Param | Description | | --- | --- | | symbol |token in 'long-form' such as MATIC, symbol also fine (ETH-USD-MATIC)
| | amount |optional, amount to approve if not 'infinity'
| ### writeAccessHandler.getAddress() ⇒stringAddress corresponding to the private key used to instantiate this class.
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Returns**:string-Address of this wallet.
### writeAccessHandler.swapForMockToken(symbol, amountToPay) ⇒Converts a given amount of chain native currency (test MATIC) into a mock token used for trading on testnet, with a rate of 1:100_000
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Returns**:Transaction object
| Param | Description | | --- | --- | | symbol |Pool margin token e.g. MATIC
| | amountToPay |Amount in chain currency, e.g. "0.1" for 0.1 MATIC
| ### writeAccessHandler.fetchSymbolList()sets the symbollist if a remote config url is specified
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [fetchSymbolList](#PerpetualDataHandler+fetchSymbolList) ### writeAccessHandler.getOrderBookContract(symbol) ⇒Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getOrderBookContract](#PerpetualDataHandler+getOrderBookContract) **Returns**:order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### writeAccessHandler.getOrderBookAddress(symbol) ⇒Returns the order-book contract for the symbol if found or fails
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getOrderBookAddress](#PerpetualDataHandler+getOrderBookAddress) **Returns**:order book contract for the perpetual
| Param | Description | | --- | --- | | symbol |symbol of the form ETH-USD-MATIC
| ### writeAccessHandler.getPerpetuals(ids, overrides) ⇒Get perpetuals for the given ids from onchain
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getPerpetuals](#PerpetualDataHandler+getPerpetuals) **Returns**:array of PerpetualData converted into decimals
| Param | Description | | --- | --- | | ids |perpetual ids
| | overrides |optional
| ### writeAccessHandler.getLiquidityPools(fromIdx, toIdx, overrides) ⇒Get liquidity pools data
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getLiquidityPools](#PerpetualDataHandler+getLiquidityPools) **Returns**:array of LiquidityPoolData converted into decimals
| Param | Description | | --- | --- | | fromIdx |starting index (>=1)
| | toIdx |to index (inclusive)
| | overrides |optional
| ### writeAccessHandler.\_fillSymbolMaps()Called when initializing. This function fills this.symbolToTokenAddrMap, and this.nestedPerpetualIDs and this.symbolToPerpStaticInfo
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [\_fillSymbolMaps](#PerpetualDataHandler+_fillSymbolMaps) ### writeAccessHandler.initSettlementToken(perpStaticInfos)Initializes settlement currency for all pools by completing this.poolStaticInfos with settlement currency info
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [initSettlementToken](#PerpetualDataHandler+initSettlementToken) | Param | Description | | --- | --- | | perpStaticInfos |PerpetualStaticInfo array from contract call
| ### writeAccessHandler.getSymbolFromPoolId(poolId) ⇒symbolGet pool symbol given a pool Id.
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getSymbolFromPoolId](#PerpetualDataHandler+getSymbolFromPoolId) **Returns**:symbol-Pool symbol, e.g. "USDC".
| Param | Type | Description | | --- | --- | --- | | poolId |number|Pool Id.
| ### writeAccessHandler.getPoolIdFromSymbol(symbol) ⇒numberGet pool Id given a pool symbol. Pool IDs start at 1.
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getPoolIdFromSymbol](#PerpetualDataHandler+getPoolIdFromSymbol) **Returns**:number-Pool Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string|Pool symbol.
| ### writeAccessHandler.getPerpIdFromSymbol(symbol) ⇒numberGet perpetual Id given a perpetual symbol.
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getPerpIdFromSymbol](#PerpetualDataHandler+getPerpIdFromSymbol) **Returns**:number-Perpetual Id.
| Param | Type | Description | | --- | --- | --- | | symbol |string|Perpetual symbol, e.g. "BTC-USD-MATIC".
| ### writeAccessHandler.getSymbolFromPerpId(perpId) ⇒stringGet the symbol in long format of the perpetual id
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getSymbolFromPerpId](#PerpetualDataHandler+getSymbolFromPerpId) **Returns**:string-Symbol
| Param | Type | Description | | --- | --- | --- | | perpId |number|perpetual id
| ### writeAccessHandler.symbol4BToLongSymbol(sym) ⇒string**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [symbol4BToLongSymbol](#PerpetualDataHandler+symbol4BToLongSymbol) **Returns**:string-Long symbol
| Param | Type | Description | | --- | --- | --- | | sym |string|Short symbol
| ### writeAccessHandler.fetchPriceSubmissionInfoForPerpetual(symbol) ⇒Get PriceFeedSubmission data required for blockchain queries that involve price data, and the corresponding triangulated prices for the indices S2 and S3
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [fetchPriceSubmissionInfoForPerpetual](#PerpetualDataHandler+fetchPriceSubmissionInfoForPerpetual) **Returns**:PriceFeedSubmission and prices for S2 and S3. [S2price, 0] if S3 not defined.
| Param | Description | | --- | --- | | symbol |pool symbol of the form "ETH-USD-MATIC"
| ### writeAccessHandler.getIndexSymbols(symbol) ⇒Get the symbols required as indices for the given perpetual
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getIndexSymbols](#PerpetualDataHandler+getIndexSymbols) **Returns**:name of underlying index prices, e.g. ["MATIC-USD", ""]
| Param | Description | | --- | --- | | symbol |of the form ETH-USD-MATIC, specifying the perpetual
| ### writeAccessHandler.fetchLatestFeedPriceInfo(symbol) ⇒Get the latest prices for a given perpetual from the offchain oracle networks
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [fetchLatestFeedPriceInfo](#PerpetualDataHandler+fetchLatestFeedPriceInfo) **Returns**:array of price feed updates that can be submitted to the smart contract and corresponding price information
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form BTC-USD-MATIC
| ### writeAccessHandler.fetchCollateralToSettlementConversion(symbol)fetchCollateralToSettlementConversion returns the price which converts the collateral currency into settlement currency. For example if BTC-USD-STUSD has settlement currency USDC, we get let px = fetchCollateralToSettlementConversion("BTC-USD-STUSD") valueInUSDC = collateralInSTUSD * px
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [fetchCollateralToSettlementConversion](#PerpetualDataHandler+fetchCollateralToSettlementConversion) | Param | Description | | --- | --- | | symbol |either perpetual symbol of the form BTC-USD-MATIC or just collateral token
| ### writeAccessHandler.getPriceIds(symbol) ⇒Get list of required pyth price source IDs for given perpetual
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getPriceIds](#PerpetualDataHandler+getPriceIds) **Returns**:list of required pyth price sources for this perpetual
| Param | Description | | --- | --- | | symbol |perpetual symbol, e.g., BTC-USD-MATIC
| ### writeAccessHandler.getPerpetualSymbolsInPool(poolSymbol) ⇒Get ('normal'-state) perpetual symbols for a given pool
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getPerpetualSymbolsInPool](#PerpetualDataHandler+getPerpetualSymbolsInPool) **Returns**:array of perpetual symbols in this pool
| Param | Description | | --- | --- | | poolSymbol |pool symbol such as "MATIC"
| ### writeAccessHandler.getAllOpenOrders(symbol) ⇒All the orders in the order book for a given symbol that are currently open.
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getAllOpenOrders](#PerpetualDataHandler+getAllOpenOrders) **Returns**:Array with all open orders and their IDs.
| Param | Type | Description | | --- | --- | --- | | symbol |string|Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =process.env.PK; let orderTool = new OrderExecutorTool(config, pk); await orderTool.createProxyInstance(); // get all open orders let openOrders = await orderTool.getAllOpenOrders("ETH-USD-MATIC"); console.log(openOrders); } main(); ``` ### writeAccessHandler.numberOfOpenOrders(symbol) ⇒ numberTotal number of limit orders for this symbol, excluding those that have been cancelled/removed.
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [numberOfOpenOrders](#PerpetualDataHandler+numberOfOpenOrders) **Returns**:number-Number of open orders.
| Param | Type | Description | | --- | --- | --- | | symbol |string|Symbol of the form ETH-USD-MATIC.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =process.env.PK; let orderTool = new OrderExecutorTool(config, pk); await orderTool.createProxyInstance(); // get all open orders let numberOfOrders = await orderTool.numberOfOpenOrders("ETH-USD-MATIC"); console.log(numberOfOrders); } main(); ``` ### writeAccessHandler.pollLimitOrders(symbol, numElements, [startAfter]) ⇒ Get a list of active conditional orders in the order book. This a read-only action and does not incur in gas costs.
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [pollLimitOrders](#PerpetualDataHandler+pollLimitOrders) **Returns**:Array of orders and corresponding order IDs
| Param | Type | Description | | --- | --- | --- | | symbol |string|Symbol of the form ETH-USD-MATIC.
| | numElements |number|Maximum number of orders to poll.
| | [startAfter] |string|Optional order ID from where to start polling. Defaults to the first order.
| **Example** ```js import { OrderExecutorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk'; async function main() { console.log(OrderExecutorTool); // setup (authentication required, PK is an environment variable with a private key) const config = PerpetualDataHandler.readSDKConfig("cardona"); const pk: string =process.env.PK; let orderTool = new OrderExecutorTool(config, pk); await orderTool.createProxyInstance(); // get all open orders let activeOrders = await orderTool.pollLimitOrders("ETH-USD-MATIC", 2); console.log(activeOrders); } main(); ``` ### writeAccessHandler.getPoolStaticInfoIndexFromSymbol(symbol) ⇒ Gets the pool index (starting at 0 in exchangeInfo, not ID!) corresponding to a given symbol.
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getPoolStaticInfoIndexFromSymbol](#PerpetualDataHandler+getPoolStaticInfoIndexFromSymbol) **Returns**:Pool index
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-MATIC
| ### writeAccessHandler.getMarginTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getMarginTokenFromSymbol](#PerpetualDataHandler+getMarginTokenFromSymbol) **Returns**:Address of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### writeAccessHandler.getSettlementTokenFromSymbol(symbol) ⇒ **Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getSettlementTokenFromSymbol](#PerpetualDataHandler+getSettlementTokenFromSymbol) **Returns**:Address of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### writeAccessHandler.getMarginTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getMarginTokenDecimalsFromSymbol](#PerpetualDataHandler+getMarginTokenDecimalsFromSymbol) **Returns**:Decimals of the corresponding margin token
| Param | Description | | --- | --- | | symbol |Symbol of the form USDC
| ### writeAccessHandler.getSettlementTokenDecimalsFromSymbol(symbol) ⇒ **Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getSettlementTokenDecimalsFromSymbol](#PerpetualDataHandler+getSettlementTokenDecimalsFromSymbol) **Returns**:Decimals of the corresponding settlement token
| Param | Description | | --- | --- | | symbol |Symbol of the form ETH-USD-WEETH
| ### writeAccessHandler.getABI(contract) ⇒Get ABI for LimitOrderBook, Proxy, or Share Pool Token
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getABI](#PerpetualDataHandler+getABI) **Returns**:ABI for the requested contract
| Param | Description | | --- | --- | | contract |name of contract: proxy|lob|sharetoken
| ### writeAccessHandler.isPredictionMarket(symbol) ⇒Determines whether a given perpetual represents a prediction market
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [isPredictionMarket](#PerpetualDataHandler+isPredictionMarket) **Returns**:True if this is a prediction market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form TRUMP24-USD-USDC
| ### writeAccessHandler.isLowLiquidityMarket(symbol) ⇒Determines whether a given perpetual represents a low-liquidity market
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [isLowLiquidityMarket](#PerpetualDataHandler+isLowLiquidityMarket) **Returns**:True if this is a low-liquidity market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form DIRAC-HONEY-USDC
| ### writeAccessHandler.isTradFiMarket(symbol) ⇒Determines whether a given perpetual represents a tradfi market
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [isTradFiMarket](#PerpetualDataHandler+isTradFiMarket) **Returns**:True if this is a tradfi market
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### writeAccessHandler.getMarketDayTradingOpenCloseSec(symbol) ⇒Returns day trading times for tradfi markets
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getMarketDayTradingOpenCloseSec](#PerpetualDataHandler+getMarketDayTradingOpenCloseSec) **Returns**:open time in seconds within day, close time in seconds within day
| Param | Description | | --- | --- | | symbol |perpetual symbol of the form MSTR-HONEY-BUSD
| ### writeAccessHandler.getInitialMarginRate(symbol) ⇒getInitialMarginRate
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getInitialMarginRate](#PerpetualDataHandler+getInitialMarginRate) **Returns**:initial margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### writeAccessHandler.getMaintenanceMarginRate(symbol) ⇒getMaintenanceMarginRate
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getMaintenanceMarginRate](#PerpetualDataHandler+getMaintenanceMarginRate) **Returns**:maintenance margin rate
| Param | Description | | --- | --- | | symbol |perpetual symbol MSTR-USD-BUSD
| ### writeAccessHandler.getShortSymbol(symbol) ⇒Short symbol corresponding to a given long symbol.
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getShortSymbol](#PerpetualDataHandler+getShortSymbol) **Returns**:Short symbol (e.g. NHL0)
| Param | Description | | --- | --- | | symbol |Long symbol (e.g. NHL_TOR_DAL_251015)
| ### writeAccessHandler.refreshSymbols()Refreshes symbol mappings if at least one prediction market is expired
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [refreshSymbols](#PerpetualDataHandler+refreshSymbols) ### writeAccessHandler.getLocalPerpetualStates() ⇒Get state of perpetuals as currently known locally
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [getLocalPerpetualStates](#PerpetualDataHandler+getLocalPerpetualStates) **Returns**:Array of [perpetual Id, perpetual state (string)]
### writeAccessHandler.fetchOnChainPerpetualStates() ⇒Fetches on-chain state of local perpetual ids. Does not run if SDK is not ready.
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [fetchOnChainPerpetualStates](#PerpetualDataHandler+fetchOnChainPerpetualStates) **Returns**:Array of [perpetual Id, perpetual state (string)]
### writeAccessHandler.checkHeartbeat() ⇒Check that states of all perps known locally match on-chain states
**Kind**: instance method of [WriteAccessHandler](#WriteAccessHandler) **Overrides**: [checkHeartbeat](#PerpetualDataHandler+checkHeartbeat) **Returns**:True if all perp states are correct
## default ⇒Gets the price of one Angle stUSD in USDC from on-chain
**Kind**: global variable **Returns**:STUSD-USDC
| Param | Description | | --- | --- | | provider |arbitrum provider
| ## referralDomainLiquidityPoolData corresponding to the data in the smart contract
**Kind**: global constant ## ExchangeInfo :Object**Kind**: global typedef **Properties** | Name | Type | Description | | --- | --- | --- | | pools | [Array.<PoolState>](#PoolState) |Array of state objects for all pools in the exchange.
| | oracleFactoryAddr |string|Address of the oracle factory used by the pools in the exchange.
| ## PoolState :Object**Kind**: global typedef **Properties** | Name | Type | Description | | --- | --- | --- | | isRunning |boolean|True if the pool is running.
| | marginTokenAddr |string|Address of the token used by the pool. This is the token used for margin deposits, liquidity provision, and trading fees.
| | poolShareTokenAddr |string|Address of the pool share token. This is the token issued to external liquidity providers.
| | defaultFundCashCC |number|Amount of cash in the default fund of this pool, denominated in margin tokens.
| | pnlParticipantCashCC |number|Amount of cash in the PnL participation pool, i.e. cash deposited by external liquidity providers.
| | totalTargetAMMFundSizeCC |number|Target AMM funds aggregated across all perpetuals in this pool.
| | brokerCollateralLotSize |number|Price of one lot for brokers who wish to participate in this pool. Denominated in margin tokens.
| | perpetuals |Array.<PerpetualState>|Array of all perpetuals in this pool.
| ## SmartContractOrder :Object**Kind**: global typedef **Properties** | Name | Type | | --- | --- | | flags |bigint| | iPerpetualId |number| | brokerFeeTbps |number| | traderAddr |string| | brokerAddr |string| | executorAddr |string| | brokerSignature |BytesLike| | fAmount |bigint| | fLimitPrice |bigint| | fTriggerPrice |bigint| | leverageTDR |number| | iDeadline |number| | executionTimestamp |number| | submittedTimestamp |number| ## ClientOrder :Object**Kind**: global typedef **Properties** | Name | Type | | --- | --- | | flags |bigint| | iPerpetualId |bigint| | brokerFeeTbps |bigint| | traderAddr |string| | brokerAddr |string| | executorAddr |string| | brokerSignature |BytesLike| | fAmount |bigint| | fLimitPrice |bigint| | fTriggerPrice |bigint| | leverageTDR |bigint| | iDeadline |bigint| | executionTimestamp |bigint| | parentChildDigest1 |string| | parentChildDigest2 |string| | callbackTarget |string|