# ITradingInteractionsUtils

*Interface for GNSTradingInteractions facet (inherits types and also contains functions, events, and custom errors)*

## initializeTrading

```solidity
function initializeTrading(uint16 _marketOrdersTimeoutBlocks, address[] _usersByPassTriggerLink) external
```

*Initializes the trading facet*

### Parameters

| Name                        | Type       | Description                                                             |
| --------------------------- | ---------- | ----------------------------------------------------------------------- |
| \_marketOrdersTimeoutBlocks | uint16     | The number of blocks after which a market order is considered timed out |
| \_usersByPassTriggerLink    | address\[] |                                                                         |

## updateMarketOrdersTimeoutBlocks

```solidity
function updateMarketOrdersTimeoutBlocks(uint16 _valueBlocks) external
```

*Updates marketOrdersTimeoutBlocks*

### Parameters

| Name          | Type   | Description                                 |
| ------------- | ------ | ------------------------------------------- |
| \_valueBlocks | uint16 | blocks after which a market order times out |

## updateByPassTriggerLink

```solidity
function updateByPassTriggerLink(address[] _users, bool[] _shouldByPass) external
```

*Updates the users that can bypass the link cost of triggerOrder*

### Parameters

| Name           | Type       | Description                                                      |
| -------------- | ---------- | ---------------------------------------------------------------- |
| \_users        | address\[] | array of addresses that can bypass the link cost of triggerOrder |
| \_shouldByPass | bool\[]    | whether each user should bypass the link cost                    |

## setTradingDelegate

```solidity
function setTradingDelegate(address _delegate) external
```

\_Sets *delegate as the new delegate of caller (can call delegatedAction)*

### Parameters

| Name       | Type    | Description              |
| ---------- | ------- | ------------------------ |
| \_delegate | address | the new delegate address |

## removeTradingDelegate

```solidity
function removeTradingDelegate() external
```

*Removes the delegate of caller (can't call delegatedAction)*

## delegatedTradingAction

```solidity
function delegatedTradingAction(address _trader, bytes _callData) external returns (bytes)
```

\_Caller executes a trading action on behalf of *trader using delegatecall*

### Parameters

| Name       | Type    | Description                                            |
| ---------- | ------- | ------------------------------------------------------ |
| \_trader   | address | the trader address to execute the trading action for   |
| \_callData | bytes   | the data to be executed (open trade/close trade, etc.) |

## openTrade

```solidity
function openTrade(struct ITradingStorage.Trade _trade, uint16 _maxSlippageP, address _referrer) external
```

*Opens a new trade/limit order/stop order*

### Parameters

| Name           | Type                                                                                                                  | Description                                                        |
| -------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
| \_trade        | [ITradingStorage.Trade](https://docs.gains.trade/developer/technical-reference/contracts/types/itradingstorage#trade) | the trade to be opened                                             |
| \_maxSlippageP | uint16                                                                                                                | the maximum allowed slippage % when open the trade (1e3 precision) |
| \_referrer     | address                                                                                                               | the address of the referrer (can only be set once for a trader)    |

## openTradeNative

```solidity
function openTradeNative(struct ITradingStorage.Trade _trade, uint16 _maxSlippageP, address _referrer) external payable
```

*Wraps native token and opens a new trade/limit order/stop order*

### Parameters

| Name           | Type                                                                                                                  | Description                                                        |
| -------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
| \_trade        | [ITradingStorage.Trade](https://docs.gains.trade/developer/technical-reference/contracts/types/itradingstorage#trade) | the trade to be opened                                             |
| \_maxSlippageP | uint16                                                                                                                | the maximum allowed slippage % when open the trade (1e3 precision) |
| \_referrer     | address                                                                                                               | the address of the referrer (can only be set once for a trader)    |

## updateMaxClosingSlippageP

```solidity
function updateMaxClosingSlippageP(uint32 _index, uint16 _maxSlippageP) external
```

*Updates existing trade's max closing slippage % for caller*

### Parameters

| Name           | Type   | Description                                |
| -------------- | ------ | ------------------------------------------ |
| \_index        | uint32 | index of trade                             |
| \_maxSlippageP | uint16 | new max closing slippage % (1e3 precision) |

## closeTradeMarket

```solidity
function closeTradeMarket(uint32 _index, uint64 _expectedPrice) external
```

*Closes an open trade (market order) for caller*

### Parameters

| Name            | Type   | Description                                                         |
| --------------- | ------ | ------------------------------------------------------------------- |
| \_index         | uint32 | the index of the trade of caller                                    |
| \_expectedPrice | uint64 | expected closing price, used to check max slippage (1e10 precision) |

## updateOpenOrder

```solidity
function updateOpenOrder(uint32 _index, uint64 _triggerPrice, uint64 _tp, uint64 _sl, uint16 _maxSlippageP) external
```

*Updates an existing limit/stop order for caller*

### Parameters

| Name           | Type   | Description                                            |
| -------------- | ------ | ------------------------------------------------------ |
| \_index        | uint32 | index of limit/stop order of caller                    |
| \_triggerPrice | uint64 | new trigger price of limit/stop order (1e10 precision) |
| \_tp           | uint64 | new tp of limit/stop order (1e10 precision)            |
| \_sl           | uint64 | new sl of limit/stop order (1e10 precision)            |
| \_maxSlippageP | uint16 | new max slippage % of limit/stop order (1e3 precision) |

## cancelOpenOrder

```solidity
function cancelOpenOrder(uint32 _index) external
```

*Cancels an open limit/stop order for caller*

### Parameters

| Name    | Type   | Description                         |
| ------- | ------ | ----------------------------------- |
| \_index | uint32 | index of limit/stop order of caller |

## updateTp

```solidity
function updateTp(uint32 _index, uint64 _newTp) external
```

*Updates the tp of an open trade for caller*

### Parameters

| Name    | Type   | Description                           |
| ------- | ------ | ------------------------------------- |
| \_index | uint32 | index of open trade of caller         |
| \_newTp | uint64 | new tp of open trade (1e10 precision) |

## updateSl

```solidity
function updateSl(uint32 _index, uint64 _newSl) external
```

*Updates the sl of an open trade for caller*

### Parameters

| Name    | Type   | Description                           |
| ------- | ------ | ------------------------------------- |
| \_index | uint32 | index of open trade of caller         |
| \_newSl | uint64 | new sl of open trade (1e10 precision) |

## triggerOrder

```solidity
function triggerOrder(uint256 _packed) external
```

*Initiates a new trigger order (for tp/sl/liq/limit/stop orders)*

### Parameters

| Name     | Type    | Description                                                     |
| -------- | ------- | --------------------------------------------------------------- |
| \_packed | uint256 | the packed data of the trigger order (orderType, trader, index) |

## cancelOrderAfterTimeout

```solidity
function cancelOrderAfterTimeout(uint32 _orderIndex) external
```

*Safety function in case oracles don't answer in time, allows caller to cancel a pending order and if relevant claim back any stuck collateral Only allowed for MARKET\_OPEN, MARKET\_CLOSE, UPDATE\_LEVERAGE, MARKET\_PARTIAL\_OPEN, and MARKET\_PARTIAL\_CLOSE orders*

### Parameters

| Name         | Type   | Description                           |
| ------------ | ------ | ------------------------------------- |
| \_orderIndex | uint32 | the id of the pending order to cancel |

## updateLeverage

```solidity
function updateLeverage(uint32 _index, uint24 _newLeverage) external
```

*Update trade leverage*

### Parameters

| Name          | Type   | Description        |
| ------------- | ------ | ------------------ |
| \_index       | uint32 | index of trade     |
| \_newLeverage | uint24 | new leverage (1e3) |

## increasePositionSize

```solidity
function increasePositionSize(uint32 _index, uint120 _collateralDelta, uint24 _leverageDelta, uint64 _expectedPrice, uint16 _maxSlippageP) external
```

*Increase trade position size*

### Parameters

| Name              | Type    | Description                                  |
| ----------------- | ------- | -------------------------------------------- |
| \_index           | uint32  | index of trade                               |
| \_collateralDelta | uint120 | collateral to add (collateral precision)     |
| \_leverageDelta   | uint24  | partial trade leverage (1e3)                 |
| \_expectedPrice   | uint64  | expected price of execution (1e10 precision) |
| \_maxSlippageP    | uint16  | max slippage % (1e3)                         |

## decreasePositionSize

```solidity
function decreasePositionSize(uint32 _index, uint120 _collateralDelta, uint24 _leverageDelta, uint64 _expectedPrice) external
```

*Decrease trade position size*

### Parameters

| Name              | Type    | Description                                                         |
| ----------------- | ------- | ------------------------------------------------------------------- |
| \_index           | uint32  | index of trade                                                      |
| \_collateralDelta | uint120 | collateral to remove (collateral precision)                         |
| \_leverageDelta   | uint24  | leverage to reduce by (1e3)                                         |
| \_expectedPrice   | uint64  | expected closing price, used to check max slippage (1e10 precision) |

## getWrappedNativeToken

```solidity
function getWrappedNativeToken() external view returns (address)
```

*Returns the wrapped native token or address(0) if the current chain, or the wrapped token, is not supported.*

## isWrappedNativeToken

```solidity
function isWrappedNativeToken(address _token) external view returns (bool)
```

*Returns true if the token is the wrapped native token for the current chain, where supported.*

### Parameters

| Name    | Type    | Description   |
| ------- | ------- | ------------- |
| \_token | address | token address |

## getTradingDelegate

```solidity
function getTradingDelegate(address _trader) external view returns (address)
```

*Returns the address a trader delegates his trading actions to*

### Parameters

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

## getMarketOrdersTimeoutBlocks

```solidity
function getMarketOrdersTimeoutBlocks() external view returns (uint16)
```

*Returns the current marketOrdersTimeoutBlocks value*

## getByPassTriggerLink

```solidity
function getByPassTriggerLink(address _user) external view returns (bool)
```

*Returns whether a user bypasses trigger link costs*

### Parameters

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

## MarketOrdersTimeoutBlocksUpdated

```solidity
event MarketOrdersTimeoutBlocksUpdated(uint256 newValueBlocks)
```

*Emitted when marketOrdersTimeoutBlocks is updated*

### Parameters

| Name           | Type    | Description                                |
| -------------- | ------- | ------------------------------------------ |
| newValueBlocks | uint256 | the new value of marketOrdersTimeoutBlocks |

## ByPassTriggerLinkUpdated

```solidity
event ByPassTriggerLinkUpdated(address user, bool bypass)
```

*Emitted when a user is allowed/disallowed to bypass the link cost of triggerOrder*

### Parameters

| Name   | Type    | Description                                               |
| ------ | ------- | --------------------------------------------------------- |
| user   | address | address of the user                                       |
| bypass | bool    | whether the user can bypass the link cost of triggerOrder |

## MarketOrderInitiated

```solidity
event MarketOrderInitiated(struct ITradingStorage.Id orderId, address trader, uint16 pairIndex, bool open)
```

*Emitted when a market order is initiated*

### Parameters

| Name      | Type                      | Description                                                |
| --------- | ------------------------- | ---------------------------------------------------------- |
| orderId   | struct ITradingStorage.Id | price aggregator order id of the pending market order      |
| trader    | address                   | address of the trader                                      |
| pairIndex | uint16                    | index of the trading pair                                  |
| open      | bool                      | whether the market order is for opening or closing a trade |

## OpenOrderPlaced

```solidity
event OpenOrderPlaced(address trader, uint16 pairIndex, uint32 index)
```

*Emitted when a new limit/stop order is placed*

### Parameters

| Name      | Type    | Description                              |
| --------- | ------- | ---------------------------------------- |
| trader    | address | address of the trader                    |
| pairIndex | uint16  | index of the trading pair                |
| index     | uint32  | index of the open limit order for caller |

## OpenLimitUpdated

```solidity
event OpenLimitUpdated(address trader, uint16 pairIndex, uint32 index, uint64 newPrice, uint64 newTp, uint64 newSl, uint64 maxSlippageP)
```

### Parameters

| Name         | Type    | Description                                   |
| ------------ | ------- | --------------------------------------------- |
| trader       | address | address of the trader                         |
| pairIndex    | uint16  | index of the trading pair                     |
| index        | uint32  | index of the open limit/stop order for caller |
| newPrice     | uint64  | new trigger price (1e10 precision)            |
| newTp        | uint64  | new tp (1e10 precision)                       |
| newSl        | uint64  | new sl (1e10 precision)                       |
| maxSlippageP | uint64  | new max slippage % (1e3 precision)            |

## OpenLimitCanceled

```solidity
event OpenLimitCanceled(address trader, uint16 pairIndex, uint32 index)
```

*Emitted when a limit/stop order is canceled (collateral sent back to trader)*

### Parameters

| Name      | Type    | Description                                   |
| --------- | ------- | --------------------------------------------- |
| trader    | address | address of the trader                         |
| pairIndex | uint16  | index of the trading pair                     |
| index     | uint32  | index of the open limit/stop order for caller |

## TriggerOrderInitiated

```solidity
event TriggerOrderInitiated(struct ITradingStorage.Id orderId, address trader, uint16 pairIndex, bool byPassesLinkCost)
```

*Emitted when a trigger order is initiated (tp/sl/liq/limit/stop orders)*

### Parameters

| Name             | Type                      | Description                                            |
| ---------------- | ------------------------- | ------------------------------------------------------ |
| orderId          | struct ITradingStorage.Id | price aggregator order id of the pending trigger order |
| trader           | address                   | address of the trader                                  |
| pairIndex        | uint16                    | index of the trading pair                              |
| byPassesLinkCost | bool                      | whether the caller bypasses the link cost              |

## ChainlinkCallbackTimeout

```solidity
event ChainlinkCallbackTimeout(struct ITradingStorage.Id pendingOrderId, uint256 pairIndex)
```

*Emitted when a pending market order is canceled due to timeout*

### Parameters

| Name           | Type                      | Description               |
| -------------- | ------------------------- | ------------------------- |
| pendingOrderId | struct ITradingStorage.Id | id of the pending order   |
| pairIndex      | uint256                   | index of the trading pair |

## CouldNotCloseTrade

```solidity
event CouldNotCloseTrade(address trader, uint16 pairIndex, uint32 index)
```

*Emitted when a pending market order is canceled due to timeout and new closeTradeMarket() call failed*

### Parameters

| Name      | Type    | Description                        |
| --------- | ------- | ---------------------------------- |
| trader    | address | address of the trader              |
| pairIndex | uint16  | index of the trading pair          |
| index     | uint32  | index of the open trade for caller |

## NativeTokenWrapped

```solidity
event NativeTokenWrapped(address trader, uint256 nativeTokenAmount)
```

*Emitted when a native token is wrapped*

### Parameters

| Name              | Type    | Description                    |
| ----------------- | ------- | ------------------------------ |
| trader            | address | address of the trader          |
| nativeTokenAmount | uint256 | amount of native token wrapped |

## NotWrappedNativeToken

```solidity
error NotWrappedNativeToken()
```

## DelegateNotApproved

```solidity
error DelegateNotApproved()
```

## PriceZero

```solidity
error PriceZero()
```

## AboveExposureLimits

```solidity
error AboveExposureLimits()
```

## CollateralNotActive

```solidity
error CollateralNotActive()
```

## PriceImpactTooHigh

```solidity
error PriceImpactTooHigh()
```

## NoTrade

```solidity
error NoTrade()
```

## NoOrder

```solidity
error NoOrder()
```

## AlreadyBeingMarketClosed

```solidity
error AlreadyBeingMarketClosed()
```

## ConflictingPendingOrder

```solidity
error ConflictingPendingOrder(enum ITradingStorage.PendingOrderType)
```

## WrongLeverage

```solidity
error WrongLeverage()
```

## WrongTp

```solidity
error WrongTp()
```

## WrongSl

```solidity
error WrongSl()
```

## WaitTimeout

```solidity
error WaitTimeout()
```

## PendingTrigger

```solidity
error PendingTrigger()
```

## NoSl

```solidity
error NoSl()
```

## NoTp

```solidity
error NoTp()
```

## NotYourOrder

```solidity
error NotYourOrder()
```

## DelegatedActionNotAllowed

```solidity
error DelegatedActionNotAllowed()
```

## InsufficientCollateral

```solidity
error InsufficientCollateral()
```