# GNSTradingStorage

*Facet #5: Trading storage*

## constructor

```solidity
constructor() public
```

## initializeTradingStorage

```solidity
function initializeTradingStorage(address _gns, address _gnsStaking, address[] _collaterals, address[] _gTokens) external
```

*Initializes the trading storage facet*

### Parameters

| Name          | Type       | Description                         |
| ------------- | ---------- | ----------------------------------- |
| \_gns         | address    | address of the gns token            |
| \_gnsStaking  | address    | address of the gns staking contract |
| \_collaterals | address\[] |                                     |
| \_gTokens     | address\[] |                                     |

## updateTradingActivated

```solidity
function updateTradingActivated(enum ITradingStorage.TradingActivated _activated) external
```

*Updates the trading activated state*

### Parameters

| Name        | Type                                  | Description                     |
| ----------- | ------------------------------------- | ------------------------------- |
| \_activated | enum ITradingStorage.TradingActivated | the new trading activated state |

## addCollateral

```solidity
function addCollateral(address _collateral, address _gToken) external
```

*Adds a new supported collateral*

### Parameters

| Name         | Type    | Description                           |
| ------------ | ------- | ------------------------------------- |
| \_collateral | address | the address of the collateral         |
| \_gToken     | address | the gToken contract of the collateral |

## toggleCollateralActiveState

```solidity
function toggleCollateralActiveState(uint8 _collateralIndex) external
```

*Toggles the active state of a supported collateral*

### Parameters

| Name              | Type  | Description             |
| ----------------- | ----- | ----------------------- |
| \_collateralIndex | uint8 | index of the collateral |

## updateGToken

```solidity
function updateGToken(address _collateral, address _gToken) external
```

*Updates the contracts of a supported collateral trading stack*

### Parameters

| Name         | Type    | Description                           |
| ------------ | ------- | ------------------------------------- |
| \_collateral | address | address of the collateral             |
| \_gToken     | address | the gToken contract of the collateral |

## storeTrade

```solidity
function storeTrade(struct ITradingStorage.Trade _trade, struct ITradingStorage.TradeInfo _tradeInfo) external virtual returns (struct ITradingStorage.Trade)
```

*Stores a new trade (trade/limit/stop)*

### Parameters

| Name        | Type                                                                                                                           | Description             |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------ | ----------------------- |
| \_trade     | [ITradingStorage.Trade](https://docs.gains.trade/developer/technical-reference/interfaces/types/itradingstorage#trade)         | trade to be stored      |
| \_tradeInfo | [ITradingStorage.TradeInfo](https://docs.gains.trade/developer/technical-reference/interfaces/types/itradingstorage#tradeinfo) | trade info to be stored |

## updateTradeMaxClosingSlippageP

```solidity
function updateTradeMaxClosingSlippageP(struct ITradingStorage.Id _tradeId, uint16 _maxSlippageP) external virtual
```

*Updates an existing trade max closing slippage %*

### Parameters

| Name           | Type                                                                                                             | Description                        |
| -------------- | ---------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
| \_tradeId      | [ITradingStorage.Id](https://docs.gains.trade/developer/technical-reference/interfaces/types/itradingstorage#id) | id of the trade                    |
| \_maxSlippageP | uint16                                                                                                           | new max slippage % (1e3 precision) |

## updateTradeCollateralAmount

```solidity
function updateTradeCollateralAmount(struct ITradingStorage.Id _tradeId, uint120 _collateralAmount) external virtual
```

*Updates an open trade collateral*

### Parameters

| Name               | Type                                                                                                             | Description                                        |
| ------------------ | ---------------------------------------------------------------------------------------------------------------- | -------------------------------------------------- |
| \_tradeId          | [ITradingStorage.Id](https://docs.gains.trade/developer/technical-reference/interfaces/types/itradingstorage#id) | id of updated trade                                |
| \_collateralAmount | uint120                                                                                                          | new collateral amount value (collateral precision) |

## updateTradePosition

```solidity
function updateTradePosition(struct ITradingStorage.Id _tradeId, uint120 _collateralAmount, uint24 _leverage, uint64 _openPrice, bool _isPartialIncrease, bool _isPnlPositive) external virtual
```

*Updates an open trade collateral*

### Parameters

| Name                | Type                                                                                                             | Description                                              |
| ------------------- | ---------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------- |
| \_tradeId           | [ITradingStorage.Id](https://docs.gains.trade/developer/technical-reference/interfaces/types/itradingstorage#id) | id of updated trade                                      |
| \_collateralAmount  | uint120                                                                                                          | new collateral amount value (collateral precision)       |
| \_leverage          | uint24                                                                                                           | new leverage value                                       |
| \_openPrice         | uint64                                                                                                           | new open price value                                     |
| \_isPartialIncrease | bool                                                                                                             | refreshes trade liquidation params if true               |
| \_isPnlPositive     | bool                                                                                                             | whether the pnl is positive (only relevant when closing) |

## updateOpenOrderDetails

```solidity
function updateOpenOrderDetails(struct ITradingStorage.Id _tradeId, uint64 _openPrice, uint64 _tp, uint64 _sl, uint16 _maxSlippageP) external virtual
```

*Updates an open order details (limit/stop)*

### Parameters

| Name           | Type                                                                                                             | Description                    |
| -------------- | ---------------------------------------------------------------------------------------------------------------- | ------------------------------ |
| \_tradeId      | [ITradingStorage.Id](https://docs.gains.trade/developer/technical-reference/interfaces/types/itradingstorage#id) | id of updated trade            |
| \_openPrice    | uint64                                                                                                           | new open price (1e10)          |
| \_tp           | uint64                                                                                                           | new take profit price (1e10)   |
| \_sl           | uint64                                                                                                           | new stop loss price (1e10)     |
| \_maxSlippageP | uint16                                                                                                           | new max slippage % value (1e3) |

## updateTradeTp

```solidity
function updateTradeTp(struct ITradingStorage.Id _tradeId, uint64 _newTp) external virtual
```

*Updates the take profit of an open trade*

### Parameters

| Name      | Type                                                                                                             | Description                          |
| --------- | ---------------------------------------------------------------------------------------------------------------- | ------------------------------------ |
| \_tradeId | [ITradingStorage.Id](https://docs.gains.trade/developer/technical-reference/interfaces/types/itradingstorage#id) | the trade id                         |
| \_newTp   | uint64                                                                                                           | the new take profit (1e10 precision) |

## updateTradeSl

```solidity
function updateTradeSl(struct ITradingStorage.Id _tradeId, uint64 _newSl) external virtual
```

*Updates the stop loss of an open trade*

### Parameters

| Name      | Type                                                                                                             | Description                 |
| --------- | ---------------------------------------------------------------------------------------------------------------- | --------------------------- |
| \_tradeId | [ITradingStorage.Id](https://docs.gains.trade/developer/technical-reference/interfaces/types/itradingstorage#id) | the trade id                |
| \_newSl   | uint64                                                                                                           | the new sl (1e10 precision) |

## closeTrade

```solidity
function closeTrade(struct ITradingStorage.Id _tradeId, bool _isPnlPositive) external virtual
```

*Marks an open trade/limit/stop as closed*

### Parameters

| Name            | Type                                                                                                             | Description                 |
| --------------- | ---------------------------------------------------------------------------------------------------------------- | --------------------------- |
| \_tradeId       | [ITradingStorage.Id](https://docs.gains.trade/developer/technical-reference/interfaces/types/itradingstorage#id) | the trade id                |
| \_isPnlPositive | bool                                                                                                             | whether the pnl is positive |

## storePendingOrder

```solidity
function storePendingOrder(struct ITradingStorage.PendingOrder _pendingOrder) external virtual returns (struct ITradingStorage.PendingOrder)
```

*Stores a new pending order*

### Parameters

| Name           | Type                                                                                                                                 | Description                    |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------ |
| \_pendingOrder | [ITradingStorage.PendingOrder](https://docs.gains.trade/developer/technical-reference/interfaces/types/itradingstorage#pendingorder) | the pending order to be stored |

## closePendingOrder

```solidity
function closePendingOrder(struct ITradingStorage.Id _orderId) external virtual
```

*Closes a pending order*

### Parameters

| Name      | Type                                                                                                             | Description                              |
| --------- | ---------------------------------------------------------------------------------------------------------------- | ---------------------------------------- |
| \_orderId | [ITradingStorage.Id](https://docs.gains.trade/developer/technical-reference/interfaces/types/itradingstorage#id) | the id of the pending order to be closed |

## getCollateral

```solidity
function getCollateral(uint8 _index) external view returns (struct ITradingStorage.Collateral)
```

*Returns collateral data by index*

### Parameters

| Name    | Type  | Description                           |
| ------- | ----- | ------------------------------------- |
| \_index | uint8 | the index of the supported collateral |

## isCollateralActive

```solidity
function isCollateralActive(uint8 _index) external view returns (bool)
```

*Returns whether can open new trades with a collateral*

### Parameters

| Name    | Type  | Description                          |
| ------- | ----- | ------------------------------------ |
| \_index | uint8 | the index of the collateral to check |

## isCollateralListed

```solidity
function isCollateralListed(uint8 _index) external view returns (bool)
```

*Returns whether a collateral has been listed*

### Parameters

| Name    | Type  | Description                          |
| ------- | ----- | ------------------------------------ |
| \_index | uint8 | the index of the collateral to check |

## getCollateralsCount

```solidity
function getCollateralsCount() external view returns (uint8)
```

*Returns the number of supported collaterals*

## getCollaterals

```solidity
function getCollaterals() external view returns (struct ITradingStorage.Collateral[])
```

*Returns the supported collaterals*

## getCollateralIndex

```solidity
function getCollateralIndex(address _collateral) external view returns (uint8)
```

*Returns the index of a supported collateral*

### Parameters

| Name         | Type    | Description                   |
| ------------ | ------- | ----------------------------- |
| \_collateral | address | the address of the collateral |

## getTradingActivated

```solidity
function getTradingActivated() external view returns (enum ITradingStorage.TradingActivated)
```

*Returns the trading activated state*

## getTraderStored

```solidity
function getTraderStored(address _trader) external view returns (bool)
```

*Returns whether a trader is stored in the traders array*

### Parameters

| Name     | Type    | Description     |
| -------- | ------- | --------------- |
| \_trader | address | trader to check |

## getTradersCount

```solidity
function getTradersCount() external view returns (uint256)
```

*Returns the length of the traders array*

## getTraders

```solidity
function getTraders(uint32 _offset, uint32 _limit) external view returns (address[])
```

*Returns all traders that have open trades using a pagination system*

### Parameters

| Name     | Type   | Description                      |
| -------- | ------ | -------------------------------- |
| \_offset | uint32 | start index in the traders array |
| \_limit  | uint32 | end index in the traders array   |

## getTrade

```solidity
function getTrade(address _trader, uint32 _index) external view returns (struct ITradingStorage.Trade)
```

*Returns open trade/limit/stop order*

### Parameters

| Name     | Type    | Description                   |
| -------- | ------- | ----------------------------- |
| \_trader | address | address of the trader         |
| \_index  | uint32  | index of the trade for trader |

## getTrades

```solidity
function getTrades(address _trader) external view returns (struct ITradingStorage.Trade[])
```

*Returns all open trades/limit/stop orders for a trader*

### Parameters

| Name     | Type    | Description           |
| -------- | ------- | --------------------- |
| \_trader | address | address of the trader |

## getAllTradesForTraders

```solidity
function getAllTradesForTraders(address[] _traders, uint256 _offset, uint256 _limit) external view returns (struct ITradingStorage.Trade[])
```

*Returns all trade/limit/stop orders using a pagination system*

### Parameters

| Name      | Type       | Description                          |
| --------- | ---------- | ------------------------------------ |
| \_traders | address\[] | list of traders to return trades for |
| \_offset  | uint256    | index of first trade to return       |
| \_limit   | uint256    | index of last trade to return        |

## getAllTrades

```solidity
function getAllTrades(uint256 _offset, uint256 _limit) external view returns (struct ITradingStorage.Trade[])
```

*Returns all trade/limit/stop orders using a pagination system. Calls `getAllTradesForTraders` internally with all traders.*

### Parameters

| Name     | Type    | Description                    |
| -------- | ------- | ------------------------------ |
| \_offset | uint256 | index of first trade to return |
| \_limit  | uint256 | index of last trade to return  |

## getTradeInfo

```solidity
function getTradeInfo(address _trader, uint32 _index) external view returns (struct ITradingStorage.TradeInfo)
```

*Returns trade info of an open trade/limit/stop order*

### Parameters

| Name     | Type    | Description                   |
| -------- | ------- | ----------------------------- |
| \_trader | address | address of the trader         |
| \_index  | uint32  | index of the trade for trader |

## getTradeInfos

```solidity
function getTradeInfos(address _trader) external view returns (struct ITradingStorage.TradeInfo[])
```

*Returns all trade infos of open trade/limit/stop orders for a trader*

### Parameters

| Name     | Type    | Description           |
| -------- | ------- | --------------------- |
| \_trader | address | address of the trader |

## getAllTradeInfosForTraders

```solidity
function getAllTradeInfosForTraders(address[] _traders, uint256 _offset, uint256 _limit) external view returns (struct ITradingStorage.TradeInfo[])
```

*Returns all trade infos of open trade/limit/stop orders using a pagination system*

### Parameters

| Name      | Type       | Description                             |
| --------- | ---------- | --------------------------------------- |
| \_traders | address\[] | list of traders to return tradeInfo for |
| \_offset  | uint256    | index of first tradeInfo to return      |
| \_limit   | uint256    | index of last tradeInfo to return       |

## getAllTradeInfos

```solidity
function getAllTradeInfos(uint256 _offset, uint256 _limit) external view returns (struct ITradingStorage.TradeInfo[])
```

*Returns all trade infos of open trade/limit/stop orders using a pagination system. Calls `getAllTradeInfosForTraders` internally with all traders.*

### Parameters

| Name     | Type    | Description                        |
| -------- | ------- | ---------------------------------- |
| \_offset | uint256 | index of first tradeInfo to return |
| \_limit  | uint256 | index of last tradeInfo to return  |

## getPendingOrder

```solidity
function getPendingOrder(struct ITradingStorage.Id _orderId) external view returns (struct ITradingStorage.PendingOrder)
```

*Returns a pending ordeer*

### Parameters

| Name      | Type                                                                                                             | Description             |
| --------- | ---------------------------------------------------------------------------------------------------------------- | ----------------------- |
| \_orderId | [ITradingStorage.Id](https://docs.gains.trade/developer/technical-reference/interfaces/types/itradingstorage#id) | id of the pending order |

## getPendingOrders

```solidity
function getPendingOrders(address _user) external view returns (struct ITradingStorage.PendingOrder[])
```

*Returns all pending orders for a trader*

### Parameters

| Name   | Type    | Description           |
| ------ | ------- | --------------------- |
| \_user | address | address of the trader |

## getAllPendingOrdersForTraders

```solidity
function getAllPendingOrdersForTraders(address[] _traders, uint256 _offset, uint256 _limit) external view returns (struct ITradingStorage.PendingOrder[])
```

*Returns all pending orders using a pagination system*

### Parameters

| Name      | Type       | Description                                |
| --------- | ---------- | ------------------------------------------ |
| \_traders | address\[] | list of traders to return pendingOrder for |
| \_offset  | uint256    | index of first pendingOrder to return      |
| \_limit   | uint256    | index of last pendingOrder to return       |

## getAllPendingOrders

```solidity
function getAllPendingOrders(uint256 _offset, uint256 _limit) external view returns (struct ITradingStorage.PendingOrder[])
```

*Returns all pending orders using a pagination system Calls `getAllPendingOrdersForTraders` internally with all traders.*

### Parameters

| Name     | Type    | Description                           |
| -------- | ------- | ------------------------------------- |
| \_offset | uint256 | index of first pendingOrder to return |
| \_limit  | uint256 | index of last pendingOrder to return  |

## getTradePendingOrderBlock

```solidity
function getTradePendingOrderBlock(struct ITradingStorage.Id _tradeId, enum ITradingStorage.PendingOrderType _orderType) external view returns (uint256)
```

*Returns the block number of the pending order for a trade (0 = doesn't exist)*

### Parameters

| Name        | Type                                                                                                             | Description                 |
| ----------- | ---------------------------------------------------------------------------------------------------------------- | --------------------------- |
| \_tradeId   | [ITradingStorage.Id](https://docs.gains.trade/developer/technical-reference/interfaces/types/itradingstorage#id) | id of the trade             |
| \_orderType | enum ITradingStorage.PendingOrderType                                                                            | pending order type to check |

## getCounters

```solidity
function getCounters(address _trader, enum ITradingStorage.CounterType _type) external view returns (struct ITradingStorage.Counter)
```

*Returns the counters of a trader (currentIndex / open count for trades/tradeInfos and pendingOrders mappings)*

### Parameters

| Name     | Type                             | Description                            |
| -------- | -------------------------------- | -------------------------------------- |
| \_trader | address                          | address of the trader                  |
| \_type   | enum ITradingStorage.CounterType | the counter type (trade/pending order) |

## getCountersForTraders

```solidity
function getCountersForTraders(address[] _traders, enum ITradingStorage.CounterType _type) external view returns (struct ITradingStorage.Counter[])
```

*Returns the counters for a list of traders*

### Parameters

| Name      | Type                             | Description                            |
| --------- | -------------------------------- | -------------------------------------- |
| \_traders | address\[]                       | the list of traders                    |
| \_type    | enum ITradingStorage.CounterType | the counter type (trade/pending order) |

## getGToken

```solidity
function getGToken(uint8 _collateralIndex) external view returns (address)
```

*Returns the address of the gToken for a collateral stack*

### Parameters

| Name              | Type  | Description                           |
| ----------------- | ----- | ------------------------------------- |
| \_collateralIndex | uint8 | the index of the supported collateral |

## getTradeLiquidationParams

```solidity
function getTradeLiquidationParams(address _trader, uint32 _index) external view returns (struct IPairsStorage.GroupLiquidationParams)
```

*Returns the liquidation params for a trade*

### Parameters

| Name     | Type    | Description                   |
| -------- | ------- | ----------------------------- |
| \_trader | address | address of the trader         |
| \_index  | uint32  | index of the trade for trader |

## getTradesLiquidationParams

```solidity
function getTradesLiquidationParams(address _trader) external view returns (struct IPairsStorage.GroupLiquidationParams[])
```

*Returns all trade liquidation params of open trade/limit/stop orders for a trader*

### Parameters

| Name     | Type    | Description           |
| -------- | ------- | --------------------- |
| \_trader | address | address of the trader |

## getAllTradesLiquidationParamsForTraders

```solidity
function getAllTradesLiquidationParamsForTraders(address[] _traders, uint256 _offset, uint256 _limit) external view returns (struct IPairsStorage.GroupLiquidationParams[])
```

*Returns all trade liquidation params of open trade/limit/stop orders using a pagination system*

### Parameters

| Name      | Type       | Description                              |
| --------- | ---------- | ---------------------------------------- |
| \_traders | address\[] | list of traders to return liq params for |
| \_offset  | uint256    | index of first liq param to return       |
| \_limit   | uint256    | index of last liq param to return        |

## getAllTradesLiquidationParams

```solidity
function getAllTradesLiquidationParams(uint256 _offset, uint256 _limit) external view returns (struct IPairsStorage.GroupLiquidationParams[])
```

*Returns all trade liquidation params of open trade/limit/stop orders using a pagination system Calls `getAllTradesLiquidationParamsForTraders` internally with all traders.*

### Parameters

| Name     | Type    | Description                        |
| -------- | ------- | ---------------------------------- |
| \_offset | uint256 | index of first liq param to return |
| \_limit  | uint256 | index of last liq param to return  |

## getCurrentContractsVersion

```solidity
function getCurrentContractsVersion() external pure returns (enum ITradingStorage.ContractsVersion)
```

*Returns the current contracts version*