@d8x/perpetuals-sdk 0.0.1

package/abi/LimitOrderBookFactory.json

@@ -0,0 +1,166 @@
+[
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "_initImplementation",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "previousOwner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnershipTransferred",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "uint24",
+                "name": "perpetualId",
+                "type": "uint24"
+            },
+            {
+                "indexed": false,
+                "internalType": "address",
+                "name": "perpManagerAddress",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "address",
+                "name": "limitOrderBookAddress",
+                "type": "address"
+            }
+        ],
+        "name": "PerpetualLimitOrderBookDeployed",
+        "type": "event"
+    },
+    {
+        "inputs": [],
+        "name": "beacon",
+        "outputs": [
+            {
+                "internalType": "contract LimitOrderBookBeacon",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "_perpetualManagerAddr",
+                "type": "address"
+            },
+            {
+                "internalType": "uint24",
+                "name": "_perpetualId",
+                "type": "uint24"
+            }
+        ],
+        "name": "deployLimitOrderBookProxy",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getBeacon",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getImplementation",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint24",
+                "name": "_perpetualId",
+                "type": "uint24"
+            }
+        ],
+        "name": "getOrderBookAddress",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "owner",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "renounceOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "transferOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    }
+]

package/config/defaultConfig.json

@@ -0,0 +1,9 @@
+{
+  "name": "v1.1",
+  "proxyAddr": "0x55F4041DAea27c6F380d6E221d63EF300a293Ee5",
+  "nodeURL": "https://rpc-mumbai.maticvigil.com/",
+  "proxyABILocation": "../abi/IPerpetualManager.json",
+  "limitOrderBookFactoryAddr": "0xd63Faf780687795EBac85ce248a45E457752f021",
+  "limitOrderBookFactoryABILocation": "../abi/LimitOrderBookFactory.json",
+  "limitOrderBookABILocation": "../abi/LimitOrderBook.json"
+}

package/config/oldConfig.json

@@ -0,0 +1,9 @@
+{
+  "name": "v1.0",
+  "proxyAddr": "0xB1f0069E9adE96045Ad2800da99C823F504040D0",
+  "nodeURL": "https://rpc-mumbai.maticvigil.com/",
+  "proxyABILocation": "../abi/IPerpetualManager.json",
+  "limitOrderBookFactoryAddr": "0x63787232Ac59C5eC12F07DcF37a9B2a4F86AbdD5",
+  "limitOrderBookFactoryABILocation": "../abi/LimitOrderBookFactory.json",
+  "limitOrderBookABILocation": "../abi/LimitOrderBook.json"
+}

package/dist/accountTrade.d.ts

@@ -0,0 +1,54 @@
+import { ethers } from "ethers";
+import { NodeSDKConfig, Order, PerpetualStaticInfo } from "./nodeSDKTypes";
+import WriteAccessHandler from "./writeAccessHandler";
+/**
+ * Account and Trade.
+ * This class requires a private key and executes smart-contract interaction that
+ * require gas-payments.
+ */
+export default class AccountTrade extends WriteAccessHandler {
+    /**
+     * Constructor
+     * @param {NodeSDKConfig} config Configuration object, see PerpetualDataHandler.readSDKConfig.
+     * @param {string} privateKey Private key of account that trades.
+     */
+    constructor(config: NodeSDKConfig, privateKey: string);
+    /**
+     * Cancels an existing order on the exchange.
+     * @param {string} symbol Symbol of the form ETH-USD-MATIC.
+     * @param {string} orderId ID of the order to be cancelled.
+     */
+    cancelOrder(symbol: string, orderId: string): Promise<string | undefined>;
+    /**
+     * Submits an order to the exchange.
+     * @param {Order} order Order struct.
+     * @returns {string} Transaction hash.
+     */
+    order(order: Order): Promise<string | undefined>;
+    /**
+     * Static order function
+     * @param order order type (not SmartContractOrder but Order)
+     * @param traderAddr trader address
+     * @param symbolToPerpetualMap maps the symbol (MATIC-USD-MATIC)-type format to the perpetual id
+     * @param proxyContract contract instance of D8X perpetuals
+     * @param orderBookContract order book contract or null
+     * @param chainId chain Id of network
+     * @param signer instance of ethers wallet that can write
+     * @param gasLimit gas limit to be used for the trade
+     * @returns transaction hash
+     * @ignore
+     */
+    _order(order: Order, traderAddr: string, symbolToPerpetualMap: Map<string, PerpetualStaticInfo>, proxyContract: ethers.Contract, orderBookContract: ethers.Contract | null, chainId: number, signer: ethers.Wallet, gasLimit: number): Promise<string | undefined>;
+    protected _cancelOrder(symbol: string, orderId: string, orderBookContract: ethers.Contract | null): Promise<string | undefined>;
+    /**
+     * Creates a signature
+     * @param order         smart-contract-type order
+     * @param chainId       chainId of network
+     * @param isNewOrder    true unless we cancel
+     * @param signer        ethereum-type wallet
+     * @param proxyAddress  address of the contract
+     * @returns signature as string
+     * @ignore
+     */
+    private _createSignature;
+}

package/dist/accountTrade.js

@@ -0,0 +1,164 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const nodeSDKTypes_1 = require("./nodeSDKTypes");
+const writeAccessHandler_1 = __importDefault(require("./writeAccessHandler"));
+//import { abi, rawEncode } from "ethereumjs-abi";
+/**
+ * Account and Trade.
+ * This class requires a private key and executes smart-contract interaction that
+ * require gas-payments.
+ */
+class AccountTrade extends writeAccessHandler_1.default {
+    /**
+     * Constructor
+     * @param {NodeSDKConfig} config Configuration object, see PerpetualDataHandler.readSDKConfig.
+     * @param {string} privateKey Private key of account that trades.
+     */
+    constructor(config, privateKey) {
+        super(config, privateKey);
+    }
+    /**
+     * Cancels an existing order on the exchange.
+     * @param {string} symbol Symbol of the form ETH-USD-MATIC.
+     * @param {string} orderId ID of the order to be cancelled.
+     */
+    cancelOrder(symbol, orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null || this.signer == null) {
+                throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+            }
+            let orderBookContract = null;
+            orderBookContract = this.getOrderBookContract(symbol);
+            return yield this._cancelOrder(symbol, orderId, orderBookContract);
+        });
+    }
+    /*
+      TODO: -deposit (margin into account)
+            -withdraw margin withdraw(uint24 _iPerpetualId, int128 _fAmount)
+  
+    */
+    /**
+     * Submits an order to the exchange.
+     * @param {Order} order Order struct.
+     * @returns {string} Transaction hash.
+     */
+    order(order) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null || this.signer == null) {
+                throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+            }
+            let orderBookContract = null;
+            if (order.type != nodeSDKTypes_1.ORDER_TYPE_MARKET) {
+                orderBookContract = this.getOrderBookContract(order.symbol);
+            }
+            return yield this._order(order, this.traderAddr, this.symbolToPerpStaticInfo, this.proxyContract, orderBookContract, this.chainId, this.signer, this.gasLimit);
+        });
+    }
+    /**
+     * Static order function
+     * @param order order type (not SmartContractOrder but Order)
+     * @param traderAddr trader address
+     * @param symbolToPerpetualMap maps the symbol (MATIC-USD-MATIC)-type format to the perpetual id
+     * @param proxyContract contract instance of D8X perpetuals
+     * @param orderBookContract order book contract or null
+     * @param chainId chain Id of network
+     * @param signer instance of ethers wallet that can write
+     * @param gasLimit gas limit to be used for the trade
+     * @returns transaction hash
+     * @ignore
+     */
+    _order(order, traderAddr, symbolToPerpetualMap, proxyContract, orderBookContract, chainId, signer, gasLimit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let scOrder = AccountTrade.toSmartContractOrder(order, traderAddr, symbolToPerpetualMap);
+            // if we are here, we have a clean order
+            // decide whether to send order to Limit Order Book or AMM based on order type
+            let tx;
+            if (order.type == nodeSDKTypes_1.ORDER_TYPE_MARKET) {
+                // send market order
+                tx = yield proxyContract.trade(scOrder, { gasLimit: gasLimit });
+            }
+            else {
+                // conditional order so the order is sent to the order-book
+                if (orderBookContract == null) {
+                    throw Error("Order book contract not provided.");
+                }
+                let signature = yield this._createSignature(scOrder, chainId, true, signer, proxyContract.address);
+                tx = yield orderBookContract.createLimitOrder(scOrder, signature, { gasLimit: gasLimit });
+            }
+            return tx.hash;
+        });
+    }
+    _cancelOrder(symbol, orderId, orderBookContract) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (orderBookContract == null || this.signer == null) {
+                throw Error(`Order Book contract for symbol ${symbol} or signer not defined`);
+            }
+            let scOrder = yield orderBookContract.orderOfDigest(orderId);
+            let signature = yield this._createSignature(scOrder, this.chainId, false, this.signer, this.proxyAddr);
+            return yield orderBookContract.cancelLimitOrder(orderId, signature);
+        });
+    }
+    /**
+     * Creates a signature
+     * @param order         smart-contract-type order
+     * @param chainId       chainId of network
+     * @param isNewOrder    true unless we cancel
+     * @param signer        ethereum-type wallet
+     * @param proxyAddress  address of the contract
+     * @returns signature as string
+     * @ignore
+     */
+    _createSignature(order, chainId, isNewOrder, signer, proxyAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const NAME = "Perpetual Trade Manager";
+            const DOMAIN_TYPEHASH = ethers_1.ethers.utils.keccak256(Buffer.from("EIP712Domain(string name,uint256 chainId,address verifyingContract)"));
+            let abiCoder = ethers_1.ethers.utils.defaultAbiCoder;
+            let domainSeparator = ethers_1.ethers.utils.keccak256(abiCoder.encode(["bytes32", "bytes32", "uint256", "address"], [DOMAIN_TYPEHASH, ethers_1.ethers.utils.keccak256(Buffer.from(NAME)), chainId, proxyAddress]));
+            const TRADE_ORDER_TYPEHASH = ethers_1.ethers.utils.keccak256(Buffer.from("Order(uint24 iPerpetualId,uint16 brokerFeeTbps,address traderAddr,address brokerAddr,int128 fAmount,int128 fLimitPrice,int128 fTriggerPrice,uint256 iDeadline,uint32 flags,int128 fLeverage,uint256 createdTimestamp)"));
+            let structHash = ethers_1.ethers.utils.keccak256(abiCoder.encode([
+                "bytes32",
+                "uint24",
+                "uint16",
+                "address",
+                "address",
+                "int128",
+                "int128",
+                "int128",
+                "uint256",
+                "uint32",
+                "int128",
+                "uint256",
+            ], [
+                TRADE_ORDER_TYPEHASH,
+                order.iPerpetualId,
+                order.brokerFeeTbps,
+                order.traderAddr,
+                order.brokerAddr,
+                order.fAmount,
+                order.fLimitPrice,
+                order.fTriggerPrice,
+                order.iDeadline,
+                order.flags,
+                order.fLeverage,
+                order.createdTimestamp,
+            ]));
+            let digest = ethers_1.ethers.utils.keccak256(abiCoder.encode(["bytes32", "bytes32", "bool"], [domainSeparator, structHash, isNewOrder]));
+            let digestBuffer = Buffer.from(digest.substring(2, digest.length), "hex");
+            return yield signer.signMessage(digestBuffer);
+        });
+    }
+}
+exports.default = AccountTrade;

package/dist/brokerTool.d.ts

@@ -0,0 +1,41 @@
+import WriteAccessHandler from "./writeAccessHandler";
+import { NodeSDKConfig, Order } from "./nodeSDKTypes";
+import { ethers } from "ethers";
+/**
+ * BrokerTool.
+ * Signature method for brokers
+ */
+export default class BrokerTool extends WriteAccessHandler {
+    /**
+     * Constructor
+     * @param config configuration
+     * @param privateKey private key of account that trades
+     */
+    constructor(config: NodeSDKConfig, privateKey: string);
+    /**
+     *
+     * @param symbol symbol of the form "ETH-USD-MATIC" or just "MATIC"
+     * @returns broker lot size in collateral currency, e.g. in MATIC for symbol ETH-USD-MATIC or MATIC
+     */
+    getLotSize(symbol: string): Promise<number | undefined>;
+    brokerDepositToDefaultFund(symbol: string, lots: number): Promise<ethers.providers.TransactionResponse>;
+    getFeeForBrokerVolume(symbol: string): Promise<number | undefined>;
+    /**
+     *
+     * @param symbol symbol of the form "ETH-USD-MATIC" or just "MATIC"
+     * @returns number of lots deposited by broker
+     */
+    getBrokerDesignation(symbol: string): Promise<number>;
+    /**
+     * @param symbol symbol of the form "ETH-USD-MATIC" or just "MATIC"
+     * @param lots number of lots for which to get the fee. Defaults to this broker's current deposit if not specified
+     * @returns fee in decimals based on given number of lots
+     */
+    getFeeForBrokerDesignation(symbol: string, newLots?: number): Promise<number | undefined>;
+    /**
+     * @param order order for which to determine the trading fee
+     * @param traderAddr address of the trader for whom to determine the fee, defaults to lowest tier
+     * @returns fee in decimals (1% is 0.01)
+     */
+    determineExchangeFee(order: Order, traderAddr?: string): Promise<number | undefined>;
+}

package/dist/brokerTool.js

@@ -0,0 +1,129 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const writeAccessHandler_1 = __importDefault(require("./writeAccessHandler"));
+const nodeSDKTypes_1 = require("./nodeSDKTypes");
+const perpetualDataHandler_1 = __importDefault(require("./perpetualDataHandler"));
+const d8XMath_1 = require("./d8XMath");
+const accountTrade_1 = __importDefault(require("./accountTrade"));
+/**
+ * BrokerTool.
+ * Signature method for brokers
+ */
+class BrokerTool extends writeAccessHandler_1.default {
+    /**
+     * Constructor
+     * @param config configuration
+     * @param privateKey private key of account that trades
+     */
+    constructor(config, privateKey) {
+        super(config, privateKey);
+    }
+    /**
+     *
+     * @param symbol symbol of the form "ETH-USD-MATIC" or just "MATIC"
+     * @returns broker lot size in collateral currency, e.g. in MATIC for symbol ETH-USD-MATIC or MATIC
+     */
+    getLotSize(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized. Use createProxyInstance().");
+            }
+            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+            let pool = yield this.proxyContract.getLiquidityPool(poolId);
+            let lot = pool === null || pool === void 0 ? void 0 : pool.fBrokerCollateralLotSize;
+            if (lot != undefined) {
+                lot = (0, d8XMath_1.ABK64x64ToFloat)(pool.fBrokerCollateralLotSize);
+            }
+            return lot;
+        });
+    }
+    brokerDepositToDefaultFund(symbol, lots) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null || this.signer == null) {
+                throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+            }
+            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+            let tx = yield this.proxyContract.brokerDepositToDefaultFund(poolId, lots, { gasLimit: this.gasLimit });
+            return tx;
+        });
+    }
+    getFeeForBrokerVolume(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized.");
+            }
+            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+            let feeTbps = yield this.proxyContract.getFeeForBrokerVolume(poolId, this.traderAddr);
+            return feeTbps / 100000;
+        });
+    }
+    /**
+     *
+     * @param symbol symbol of the form "ETH-USD-MATIC" or just "MATIC"
+     * @returns number of lots deposited by broker
+     */
+    getBrokerDesignation(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized.");
+            }
+            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+            let designation = yield this.proxyContract.getBrokerDesignation(poolId, this.traderAddr);
+            return designation;
+        });
+    }
+    /**
+     * @param symbol symbol of the form "ETH-USD-MATIC" or just "MATIC"
+     * @param lots number of lots for which to get the fee. Defaults to this broker's current deposit if not specified
+     * @returns fee in decimals based on given number of lots
+     */
+    getFeeForBrokerDesignation(symbol, newLots = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized.");
+            }
+            if (newLots < 0) {
+                throw Error("new lots must be a positive number.");
+            }
+            let lots = yield this.getBrokerDesignation(symbol);
+            lots += newLots;
+            let feeTbps = yield this.proxyContract.getFeeForBrokerDesignation(lots);
+            return feeTbps / 100000;
+        });
+    }
+    /**
+     * @param order order for which to determine the trading fee
+     * @param traderAddr address of the trader for whom to determine the fee, defaults to lowest tier
+     * @returns fee in decimals (1% is 0.01)
+     */
+    determineExchangeFee(order, traderAddr = nodeSDKTypes_1.ZERO_ADDRESS) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized.");
+            }
+            // broker does not need to enter address in the order if he's signed in
+            if (order.brokerAddr == undefined) {
+                if (this.signer == null) {
+                    throw Error("no wallet initialized.");
+                }
+                order.brokerAddr = this.traderAddr;
+            }
+            let scOrder = accountTrade_1.default.toSmartContractOrder(order, traderAddr, this.symbolToPerpStaticInfo);
+            let feeTbps = yield this.proxyContract.determineExchangeFee(scOrder);
+            return feeTbps / 100000;
+        });
+    }
+}
+exports.default = BrokerTool;

package/dist/d8XMath.d.ts

@@ -0,0 +1,71 @@
+import { BigNumber } from "ethers";
+/**
+ * Convert ABK64x64 bigint-format to float.
+ * Result = x/2^64 if big number, x/2^29 if number
+ * @param   x number in ABDK-format or 2^29
+ * @returns x/2^64 in number-format (float)
+ */
+export declare function ABK64x64ToFloat(x: BigNumber | number): number;
+/**
+ *
+ * @param x BigNumber in Dec18 format
+ * @returns x as a float (number)
+ */
+export declare function dec18ToFloat(x: BigNumber): number;
+/**
+ * Converts x into ABDK64x64 format
+ * @param   x   number (float)
+ * @returns x^64 in big number format
+ */
+export declare function floatToABK64x64(x: number): BigNumber;
+/**
+ *
+ * @param x number (float)
+ * @returns x as a BigNumber in Dec18 format
+ */
+export declare function floatToDec18(x: number): BigNumber;
+/**
+ *
+ * @param x
+ * @param y
+ * @returns x * y
+ */
+export declare function mul64x64(x: BigNumber, y: BigNumber): BigNumber;
+/**
+ *
+ * @param x
+ * @param y
+ * @returns x / y
+ */
+export declare function div64x64(x: BigNumber, y: BigNumber): BigNumber;
+/**
+ * Determine the liquidation price
+ * @param {number} LockedInValueQC - trader locked in value in quote currency
+ * @param {number} position - trader position in base currency
+ * @param {number} cash_cc - trader available margin cash in collateral currency
+ * @param {number} maintenance_margin_rate - maintenance margin ratio
+ * @param {number} S3 - collateral to quote conversion (=S2 if base-collateral, =1 if quuote collateral, = index S3 if quanto)
+ * @returns {number} Amount to be deposited to have the given leverage when trading into position pos
+ */
+export declare function calculateLiquidationPriceCollateralBase(LockedInValueQC: number, position: number, cash_cc: number, maintenance_margin_rate: number): number;
+/**
+ * Determine the liquidation price
+ * @param {number} LockedInValueQC - trader locked in value in quote currency
+ * @param {number} position - trader position in base currency
+ * @param {number} cash_cc - trader available margin cash in collateral currency
+ * @param {number} maintenance_margin_rate - maintenance margin ratio
+ * @param {number} S3 - collateral to quote conversion (=S2 if base-collateral, =1 if quuote collateral, = index S3 if quanto)
+ * @param {number} Sm - mark price
+ * @returns {number} Amount to be deposited to have the given leverage when trading into position pos
+ */
+export declare function calculateLiquidationPriceCollateralQuanto(LockedInValueQC: number, position: number, cash_cc: number, maintenance_margin_rate: number, S3: number, Sm: number): number;
+/**
+ * Determine the liquidation price
+ * @param {number} LockedInValueQC - trader locked in value in quote currency
+ * @param {number} position - trader position in base currency
+ * @param {number} cash_cc - trader available margin cash in collateral currency
+ * @param {number} maintenance_margin_rate - maintenance margin ratio
+ * @param {number} S3 - collateral to quote conversion (=S2 if base-collateral, =1 if quuote collateral, = index S3 if quanto)
+ * @returns {number} Amount to be deposited to have the given leverage when trading into position pos
+ */
+export declare function calculateLiquidationPriceCollateralQuote(LockedInValueQC: number, position: number, cash_cc: number, maintenance_margin_rate: number): number;