Class TradeAccount

A trade account instance. The instance is connected to a specific equity token, and will only have access to LPs with that same underlying token.

Implements

ITradeAccount

Constructors

constructor

new TradeAccount(id, realizedEquity, positions, openOrders, protocol, adapter, reader, equityTokenAddress): TradeAccount
Parameters
- id: number
- realizedEquity: BigNumber
- positions: Position[]
- openOrders: {
      accountId: number;
      accountUser: string;
      createdTimestampUnixMillis: number;
      expiryTimestampUnixMillis: number;
      id: string;
      kind: {
          kind: "market";
      } | {
          args: {
              limitPrice: BigNumber;
          };
          kind: "limit";
      } | {
          args: {
              stopLoss?: null | {
                  kind: "position";
              } | {
                  id: string;
                  kind: "order";
              };
              triggerPrice: BigNumber;
          };
          kind: "stopMarket";
      } | {
          args: {
              limitPrice: BigNumber;
              triggerPrice: BigNumber;
          };
          kind: "stopLimit";
      } | {
          args: {
              takeProfit?: null | {
                  kind: "position";
              } | {
                  id: string;
                  kind: "order";
              };
              triggerPrice: BigNumber;
          };
          kind: "limitTrigger";
      } | {
          kind: string;
      };
      lpId: string;
      nonce: string;
      pair: Pair;
      signature: string;
      size: {
          amount: BigNumber;
          unit: "lpc" | "lot";
      };
      status: {
          content: {
              status: "placed";
          } | {
              content: {
                  timestampUnixMillis: number;
                  triggerPrice: BigNumber;
              };
              status: "triggered";
          };
          status: "open";
      } | {
          content: {
              price: BigNumber;
              settlementStatus: {
                  status: "queued";
              } | {
                  status: "beforeTx";
              } | {
                  status: "indexing";
              } | {
                  content: {
                      txHash: string;
                  };
                  status: "settled";
              };
              timestampUnixMillis: number;
          };
          status: "filled";
      } | {
          content: {
              reason: string;
              timestampUnixMillis: number;
              userCancellation?: null | {
                  address: string;
                  nonce: string;
                  signature: {
                      r: string;
                      s: string;
                      v: number;
                  };
              };
          };
          status: "cancelled";
      };
  }[]
- protocol: TradeProtocol
- adapter: TradeAdapter
- reader: TradeReader
- equityTokenAddress: string
Returns TradeAccount
- Defined in src/components/trade/account.ts:164

Properties

`Private` `Readonly` adapter

adapter: TradeAdapter

`Readonly` equityTokenAddress

equityTokenAddress: string

`Readonly` id

id: number

`Private` isProcessingSubscriptionRequest

isProcessingSubscriptionRequest: boolean = false

`Optional` onUpdate

onUpdate?: (() => void)

Type declaration

- (): void
- Returns void

`Private` openOrders

openOrders: {
    accountId: number;
    accountUser: string;
    createdTimestampUnixMillis: number;
    expiryTimestampUnixMillis: number;
    id: string;
    kind: {
        kind: "market";
    } | {
        args: {
            limitPrice: BigNumber;
        };
        kind: "limit";
    } | {
        args: {
            stopLoss?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "stopMarket";
    } | {
        args: {
            limitPrice: BigNumber;
            triggerPrice: BigNumber;
        };
        kind: "stopLimit";
    } | {
        args: {
            takeProfit?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "limitTrigger";
    } | {
        kind: string;
    };
    lpId: string;
    nonce: string;
    pair: Pair;
    signature: string;
    size: {
        amount: BigNumber;
        unit: "lpc" | "lot";
    };
    status: {
        content: {
            status: "placed";
        } | {
            content: {
                timestampUnixMillis: number;
                triggerPrice: BigNumber;
            };
            status: "triggered";
        };
        status: "open";
    } | {
        content: {
            price: BigNumber;
            settlementStatus: {
                status: "queued";
            } | {
                status: "beforeTx";
            } | {
                status: "indexing";
            } | {
                content: {
                    txHash: string;
                };
                status: "settled";
            };
            timestampUnixMillis: number;
        };
        status: "filled";
    } | {
        content: {
            reason: string;
            timestampUnixMillis: number;
            userCancellation?: null | {
                address: string;
                nonce: string;
                signature: {
                    r: string;
                    s: string;
                    v: number;
                };
            };
        };
        status: "cancelled";
    };
}[]

Type declaration

accountId: number
accountUser: string
createdTimestampUnixMillis: number
expiryTimestampUnixMillis: number
id: string
kind: {
    kind: "market";
} | {
    args: {
        limitPrice: BigNumber;
    };
    kind: "limit";
} | {
    args: {
        stopLoss?: null | {
            kind: "position";
        } | {
            id: string;
            kind: "order";
        };
        triggerPrice: BigNumber;
    };
    kind: "stopMarket";
} | {
    args: {
        limitPrice: BigNumber;
        triggerPrice: BigNumber;
    };
    kind: "stopLimit";
} | {
    args: {
        takeProfit?: null | {
            kind: "position";
        } | {
            id: string;
            kind: "order";
        };
        triggerPrice: BigNumber;
    };
    kind: "limitTrigger";
} | {
    kind: string;
}
lpId: string
nonce: string
pair: Pair
signature: string
size: {
amount: BigNumber;
unit: "lpc" | "lot";
}
- amount: BigNumber
- unit: "lpc" | "lot"
status: {
    content: {
        status: "placed";
    } | {
        content: {
            timestampUnixMillis: number;
            triggerPrice: BigNumber;
        };
        status: "triggered";
    };
    status: "open";
} | {
    content: {
        price: BigNumber;
        settlementStatus: {
            status: "queued";
        } | {
            status: "beforeTx";
        } | {
            status: "indexing";
        } | {
            content: {
                txHash: string;
            };
            status: "settled";
        };
        timestampUnixMillis: number;
    };
    status: "filled";
} | {
    content: {
        reason: string;
        timestampUnixMillis: number;
        userCancellation?: null | {
            address: string;
            nonce: string;
            signature: {
                r: string;
                s: string;
                v: number;
            };
        };
    };
    status: "cancelled";
}

`Private` orderPublicationListener

orderPublicationListener: undefined | OrderPublicationListener

`Private` positions

positions: Position[]

`Private` `Readonly` protocol

protocol: TradeProtocol

`Private` `Readonly` reader

reader: TradeReader

`Private` realizedEquity

realizedEquity: BigNumber

`Private` subsriptionId

subsriptionId: null | string = null

Methods

`Private` applyTradeEffect

applyTradeEffect(pairId, effect, size, gasFee): Position
Parameters
- pairId: TradePairId
- effect: TradeEffect
- size: BigNumber
- gasFee: BigNumber
Returns Position
- Defined in src/components/trade/account.ts:495

cancelOrder

cancelOrder(args): Promise<void>
Parameters
- args: CancelOrderArgs
Returns Promise<void>
Implementation of ITradeAccount.cancelOrder
- Defined in src/components/trade/account.ts:473

cancelSubscriptionToRemoteUpdates

cancelSubscriptionToRemoteUpdates(): void
Returns void
- Defined in src/components/trade/account.ts:199

deposit

deposit(args): Promise<void>
Parameters
- args: DepositArgs
Returns Promise<void>
Implementation of ITradeAccount.deposit
- Defined in src/components/trade/account.ts:586

getActiveOrders

getActiveOrders(): Promise<ActiveOrder[]>
Returns Promise<ActiveOrder[]>
Implementation of ITradeAccount.getActiveOrders
- Defined in src/components/trade/account.ts:320

getAllPositions

getAllPositions(): Position[]
Returns Position[]
Implementation of ITradeAccount.getAllPositions
- Defined in src/components/trade/account.ts:249

getAvailableEquity

getAvailableEquity(): BigNumber
Returns the available equity for the account.

Returns BigNumber
Implementation of ITradeAccount.getAvailableEquity
- Defined in src/components/trade/account.ts:338

getDepositWithdrawHistory

getDepositWithdrawHistory(args): Promise<DepositOrWithdrawal[]>
Parameters
- args: GetSubgraphHistoryArgs
Returns Promise<DepositOrWithdrawal[]>
Implementation of ITradeAccount.getDepositWithdrawHistory
- Defined in src/components/trade/account.ts:261

getEquity

getEquity(): BigNumber
Returns the available equity for the account.

Returns BigNumber
Implementation of ITradeAccount.getEquity
- Defined in src/components/trade/account.ts:327

getInitialMarginRequirement

getInitialMarginRequirement(): BigNumber
Returns BigNumber
Implementation of ITradeAccount.getInitialMarginRequirement
- Defined in src/components/trade/account.ts:365

getLeverage

getLeverage(): BigNumber
Returns BigNumber
Implementation of ITradeAccount.getLeverage
- Defined in src/components/trade/account.ts:400

getMaintenanceMarginRequirement

getMaintenanceMarginRequirement(): BigNumber
Returns BigNumber
Implementation of ITradeAccount.getMaintenanceMarginRequirement
- Defined in src/components/trade/account.ts:375

getOpenInterest

getOpenInterest(): BigNumber
Returns BigNumber
The total value of all positions in the liquidity token currency (currently USD).
Implementation of ITradeAccount.getOpenInterest
- Defined in src/components/trade/account.ts:389

getOpenOrders

getOpenOrders(): {
    accountId: number;
    accountUser: string;
    createdTimestampUnixMillis: number;
    expiryTimestampUnixMillis: number;
    id: string;
    kind: {
        kind: "market";
    } | {
        args: {
            limitPrice: BigNumber;
        };
        kind: "limit";
    } | {
        args: {
            stopLoss?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "stopMarket";
    } | {
        args: {
            limitPrice: BigNumber;
            triggerPrice: BigNumber;
        };
        kind: "stopLimit";
    } | {
        args: {
            takeProfit?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "limitTrigger";
    } | {
        kind: string;
    };
    lpId: string;
    nonce: string;
    pair: Pair;
    signature: string;
    size: {
        amount: BigNumber;
        unit: "lpc" | "lot";
    };
    status: {
        content: {
            status: "placed";
        } | {
            content: {
                timestampUnixMillis: number;
                triggerPrice: BigNumber;
            };
            status: "triggered";
        };
        status: "open";
    } | {
        content: {
            price: BigNumber;
            settlementStatus: {
                status: "queued";
            } | {
                status: "beforeTx";
            } | {
                status: "indexing";
            } | {
                content: {
                    txHash: string;
                };
                status: "settled";
            };
            timestampUnixMillis: number;
        };
        status: "filled";
    } | {
        content: {
            reason: string;
            timestampUnixMillis: number;
            userCancellation?: null | {
                address: string;
                nonce: string;
                signature: {
                    r: string;
                    s: string;
                    v: number;
                };
            };
        };
        status: "cancelled";
    };
}[]
Returns {
    accountId: number;
    accountUser: string;
    createdTimestampUnixMillis: number;
    expiryTimestampUnixMillis: number;
    id: string;
    kind: {
        kind: "market";
    } | {
        args: {
            limitPrice: BigNumber;
        };
        kind: "limit";
    } | {
        args: {
            stopLoss?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "stopMarket";
    } | {
        args: {
            limitPrice: BigNumber;
            triggerPrice: BigNumber;
        };
        kind: "stopLimit";
    } | {
        args: {
            takeProfit?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "limitTrigger";
    } | {
        kind: string;
    };
    lpId: string;
    nonce: string;
    pair: Pair;
    signature: string;
    size: {
        amount: BigNumber;
        unit: "lpc" | "lot";
    };
    status: {
        content: {
            status: "placed";
        } | {
            content: {
                timestampUnixMillis: number;
                triggerPrice: BigNumber;
            };
            status: "triggered";
        };
        status: "open";
    } | {
        content: {
            price: BigNumber;
            settlementStatus: {
                status: "queued";
            } | {
                status: "beforeTx";
            } | {
                status: "indexing";
            } | {
                content: {
                    txHash: string;
                };
                status: "settled";
            };
            timestampUnixMillis: number;
        };
        status: "filled";
    } | {
        content: {
            reason: string;
            timestampUnixMillis: number;
            userCancellation?: null | {
                address: string;
                nonce: string;
                signature: {
                    r: string;
                    s: string;
                    v: number;
                };
            };
        };
        status: "cancelled";
    };
}[]
Implementation of ITradeAccount.getOpenOrders
- Defined in src/components/trade/account.ts:253

getPosition

getPosition(pair): Position
Parameters
- pair: TradePairId
Returns Position
Implementation of ITradeAccount.getPosition
- Defined in src/components/trade/account.ts:242

getPositionLeverage

getPositionLeverage(id): BigNumber
Parameters
- id: TradePairId
Returns BigNumber
Implementation of ITradeAccount.getPositionLeverage
- Defined in src/components/trade/account.ts:408

getRealisedEquity

getRealisedEquity(): BigNumber
Returns BigNumber
Implementation of ITradeAccount.getRealisedEquity
- Defined in src/components/trade/account.ts:331

getRolesArgs

getRolesArgs(_): Promise<TradeAccountRole[]>
Parameters
- _: GetRolesArgs
Returns Promise<TradeAccountRole[]>
Implementation of ITradeAccount.getRolesArgs
- Defined in src/components/trade/account.ts:737

getTradeHistory

getTradeHistory(args): Promise<{
    accountId: number;
    accountUser: string;
    createdTimestampUnixMillis: number;
    expiryTimestampUnixMillis: number;
    id: string;
    kind: {
        kind: "market";
    } | {
        args: {
            limitPrice: BigNumber;
        };
        kind: "limit";
    } | {
        args: {
            stopLoss?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "stopMarket";
    } | {
        args: {
            limitPrice: BigNumber;
            triggerPrice: BigNumber;
        };
        kind: "stopLimit";
    } | {
        args: {
            takeProfit?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "limitTrigger";
    } | {
        kind: string;
    };
    lpId: string;
    nonce: string;
    pair: Pair;
    signature: string;
    size: {
        amount: BigNumber;
        unit: "lpc" | "lot";
    };
    status: {
        content: {
            status: "placed";
        } | {
            content: {
                timestampUnixMillis: number;
                triggerPrice: BigNumber;
            };
            status: "triggered";
        };
        status: "open";
    } | {
        content: {
            price: BigNumber;
            settlementStatus: {
                status: "queued";
            } | {
                status: "beforeTx";
            } | {
                status: "indexing";
            } | {
                content: {
                    txHash: string;
                };
                status: "settled";
            };
            timestampUnixMillis: number;
        };
        status: "filled";
    } | {
        content: {
            reason: string;
            timestampUnixMillis: number;
            userCancellation?: null | {
                address: string;
                nonce: string;
                signature: {
                    r: string;
                    s: string;
                    v: number;
                };
            };
        };
        status: "cancelled";
    };
}[]>
Parameters
- args: GetTradeHistoryArgs
Returns Promise<{
    accountId: number;
    accountUser: string;
    createdTimestampUnixMillis: number;
    expiryTimestampUnixMillis: number;
    id: string;
    kind: {
        kind: "market";
    } | {
        args: {
            limitPrice: BigNumber;
        };
        kind: "limit";
    } | {
        args: {
            stopLoss?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "stopMarket";
    } | {
        args: {
            limitPrice: BigNumber;
            triggerPrice: BigNumber;
        };
        kind: "stopLimit";
    } | {
        args: {
            takeProfit?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "limitTrigger";
    } | {
        kind: string;
    };
    lpId: string;
    nonce: string;
    pair: Pair;
    signature: string;
    size: {
        amount: BigNumber;
        unit: "lpc" | "lot";
    };
    status: {
        content: {
            status: "placed";
        } | {
            content: {
                timestampUnixMillis: number;
                triggerPrice: BigNumber;
            };
            status: "triggered";
        };
        status: "open";
    } | {
        content: {
            price: BigNumber;
            settlementStatus: {
                status: "queued";
            } | {
                status: "beforeTx";
            } | {
                status: "indexing";
            } | {
                content: {
                    txHash: string;
                };
                status: "settled";
            };
            timestampUnixMillis: number;
        };
        status: "filled";
    } | {
        content: {
            reason: string;
            timestampUnixMillis: number;
            userCancellation?: null | {
                address: string;
                nonce: string;
                signature: {
                    r: string;
                    s: string;
                    v: number;
                };
            };
        };
        status: "cancelled";
    };
}[]>
Implementation of ITradeAccount.getTradeHistory
- Defined in src/components/trade/account.ts:257

getUnrealisedEquity

getUnrealisedEquity(): BigNumber
Returns the unrealised equity for the account.

Returns BigNumber
Implementation of ITradeAccount.getUnrealisedEquity
- Defined in src/components/trade/account.ts:345

grantRole

grantRole(args): Promise<void>
Parameters
- args: GrantRoleArgs
Returns Promise<void>
Implementation of ITradeAccount.grantRole
- Defined in src/components/trade/account.ts:707

`Private` handleAccountPublication

handleAccountPublication(content, topic): void
Parameters
- content: AccountSubscriptionContent
- topic: string
Returns void
- Defined in src/components/trade/account.ts:209

placeOrder

placeOrder(args): Promise<{
    accountId: number;
    accountUser: string;
    createdTimestampUnixMillis: number;
    expiryTimestampUnixMillis: number;
    id: string;
    kind: {
        kind: "market";
    } | {
        args: {
            limitPrice: BigNumber;
        };
        kind: "limit";
    } | {
        args: {
            stopLoss?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "stopMarket";
    } | {
        args: {
            limitPrice: BigNumber;
            triggerPrice: BigNumber;
        };
        kind: "stopLimit";
    } | {
        args: {
            takeProfit?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "limitTrigger";
    } | {
        kind: string;
    };
    lpId: string;
    nonce: string;
    pair: Pair;
    signature: string;
    size: {
        amount: BigNumber;
        unit: "lpc" | "lot";
    };
    status: {
        content: {
            status: "placed";
        } | {
            content: {
                timestampUnixMillis: number;
                triggerPrice: BigNumber;
            };
            status: "triggered";
        };
        status: "open";
    } | {
        content: {
            price: BigNumber;
            settlementStatus: {
                status: "queued";
            } | {
                status: "beforeTx";
            } | {
                status: "indexing";
            } | {
                content: {
                    txHash: string;
                };
                status: "settled";
            };
            timestampUnixMillis: number;
        };
        status: "filled";
    } | {
        content: {
            reason: string;
            timestampUnixMillis: number;
            userCancellation?: null | {
                address: string;
                nonce: string;
                signature: {
                    r: string;
                    s: string;
                    v: number;
                };
            };
        };
        status: "cancelled";
    };
}>
Parameters
- args: PlaceOrderArgs
Returns Promise<{
    accountId: number;
    accountUser: string;
    createdTimestampUnixMillis: number;
    expiryTimestampUnixMillis: number;
    id: string;
    kind: {
        kind: "market";
    } | {
        args: {
            limitPrice: BigNumber;
        };
        kind: "limit";
    } | {
        args: {
            stopLoss?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "stopMarket";
    } | {
        args: {
            limitPrice: BigNumber;
            triggerPrice: BigNumber;
        };
        kind: "stopLimit";
    } | {
        args: {
            takeProfit?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "limitTrigger";
    } | {
        kind: string;
    };
    lpId: string;
    nonce: string;
    pair: Pair;
    signature: string;
    size: {
        amount: BigNumber;
        unit: "lpc" | "lot";
    };
    status: {
        content: {
            status: "placed";
        } | {
            content: {
                timestampUnixMillis: number;
                triggerPrice: BigNumber;
            };
            status: "triggered";
        };
        status: "open";
    } | {
        content: {
            price: BigNumber;
            settlementStatus: {
                status: "queued";
            } | {
                status: "beforeTx";
            } | {
                status: "indexing";
            } | {
                content: {
                    txHash: string;
                };
                status: "settled";
            };
            timestampUnixMillis: number;
        };
        status: "filled";
    } | {
        content: {
            reason: string;
            timestampUnixMillis: number;
            userCancellation?: null | {
                address: string;
                nonce: string;
                signature: {
                    r: string;
                    s: string;
                    v: number;
                };
            };
        };
        status: "cancelled";
    };
}>
Implementation of ITradeAccount.placeOrder
- Defined in src/components/trade/account.ts:415

placeOrders

placeOrders(args): Promise<{
    accountId: number;
    accountUser: string;
    createdTimestampUnixMillis: number;
    expiryTimestampUnixMillis: number;
    id: string;
    kind: {
        kind: "market";
    } | {
        args: {
            limitPrice: BigNumber;
        };
        kind: "limit";
    } | {
        args: {
            stopLoss?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "stopMarket";
    } | {
        args: {
            limitPrice: BigNumber;
            triggerPrice: BigNumber;
        };
        kind: "stopLimit";
    } | {
        args: {
            takeProfit?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "limitTrigger";
    } | {
        kind: string;
    };
    lpId: string;
    nonce: string;
    pair: Pair;
    signature: string;
    size: {
        amount: BigNumber;
        unit: "lpc" | "lot";
    };
    status: {
        content: {
            status: "placed";
        } | {
            content: {
                timestampUnixMillis: number;
                triggerPrice: BigNumber;
            };
            status: "triggered";
        };
        status: "open";
    } | {
        content: {
            price: BigNumber;
            settlementStatus: {
                status: "queued";
            } | {
                status: "beforeTx";
            } | {
                status: "indexing";
            } | {
                content: {
                    txHash: string;
                };
                status: "settled";
            };
            timestampUnixMillis: number;
        };
        status: "filled";
    } | {
        content: {
            reason: string;
            timestampUnixMillis: number;
            userCancellation?: null | {
                address: string;
                nonce: string;
                signature: {
                    r: string;
                    s: string;
                    v: number;
                };
            };
        };
        status: "cancelled";
    };
}[]>
Parameters
- args: PlaceOrderArgs[]
Returns Promise<{
    accountId: number;
    accountUser: string;
    createdTimestampUnixMillis: number;
    expiryTimestampUnixMillis: number;
    id: string;
    kind: {
        kind: "market";
    } | {
        args: {
            limitPrice: BigNumber;
        };
        kind: "limit";
    } | {
        args: {
            stopLoss?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "stopMarket";
    } | {
        args: {
            limitPrice: BigNumber;
            triggerPrice: BigNumber;
        };
        kind: "stopLimit";
    } | {
        args: {
            takeProfit?: null | {
                kind: "position";
            } | {
                id: string;
                kind: "order";
            };
            triggerPrice: BigNumber;
        };
        kind: "limitTrigger";
    } | {
        kind: string;
    };
    lpId: string;
    nonce: string;
    pair: Pair;
    signature: string;
    size: {
        amount: BigNumber;
        unit: "lpc" | "lot";
    };
    status: {
        content: {
            status: "placed";
        } | {
            content: {
                timestampUnixMillis: number;
                triggerPrice: BigNumber;
            };
            status: "triggered";
        };
        status: "open";
    } | {
        content: {
            price: BigNumber;
            settlementStatus: {
                status: "queued";
            } | {
                status: "beforeTx";
            } | {
                status: "indexing";
            } | {
                content: {
                    txHash: string;
                };
                status: "settled";
            };
            timestampUnixMillis: number;
        };
        status: "filled";
    } | {
        content: {
            reason: string;
            timestampUnixMillis: number;
            userCancellation?: null | {
                address: string;
                nonce: string;
                signature: {
                    r: string;
                    s: string;
                    v: number;
                };
            };
        };
        status: "cancelled";
    };
}[]>
Implementation of ITradeAccount.placeOrders
- Defined in src/components/trade/account.ts:445

replaceOrder

replaceOrder(args): Promise<OrderReplacementResult>
Parameters
- args: ReplaceOrderArgs
Returns Promise<OrderReplacementResult>
Implementation of ITradeAccount.replaceOrder
- Defined in src/components/trade/account.ts:423

revokeRole

revokeRole(args): Promise<void>
Parameters
- args: RevokeRoleArgs
Returns Promise<void>
Implementation of ITradeAccount.revokeRole
- Defined in src/components/trade/account.ts:720

setOrderPublicationListener

setOrderPublicationListener(listener): void
Parameters
- listener: undefined | OrderPublicationListener
Returns void
- Defined in src/components/trade/account.ts:203

simulateTrade

simulateTrade(args): TradeSimulation
Parameters
- args: SimulateTradeArgs
Returns TradeSimulation
Implementation of ITradeAccount.simulateTrade
- Defined in src/components/trade/account.ts:524

subscribeToRemoteUpdates

subscribeToRemoteUpdates(): void
Returns void
- Defined in src/components/trade/account.ts:184

transfer

transfer(_): Promise<void>
Parameters
- _: TransferArgs
Returns Promise<void>
Implementation of ITradeAccount.transfer
- Defined in src/components/trade/account.ts:733

withdraw

withdraw(args): Promise<void>
Parameters
- args: WithdrawArgs
Returns Promise<void>
Implementation of ITradeAccount.withdraw
- Defined in src/components/trade/account.ts:604

`Static` fromId

fromId(id, reader, protocol, adapter, equityTokenAddress): Promise<TradeAccount>
Parameters
- id: number
- reader: TradeReader
- protocol: TradeProtocol
- adapter: TradeAdapter
- equityTokenAddress: string
Returns Promise<TradeAccount>
- Defined in src/components/trade/account.ts:661

`Static` open

open(__namedParameters): Promise<TradeAccount>
Parameters
- __namedParameters: AccountOpenArgs
Returns Promise<TradeAccount>
- Defined in src/components/trade/account.ts:622

Class TradeAccount

Implements

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns TradeAccount

Properties

Private Readonly adapter

Readonly equityTokenAddress

Readonly id

Private isProcessingSubscriptionRequest

Optional onUpdate

Type declaration

Returns void

Private openOrders

Type declaration

accountId: number

accountUser: string

createdTimestampUnixMillis: number

expiryTimestampUnixMillis: number

id: string

lpId: string

nonce: string

pair: Pair

signature: string

size: { amount: BigNumber; unit: "lpc" | "lot"; }

amount: BigNumber

unit: "lpc" | "lot"

Private orderPublicationListener

Private positions

Private Readonly protocol

Private Readonly reader

Private realizedEquity

Private subsriptionId

Methods

Private applyTradeEffect

Parameters

Returns Position

cancelOrder

Parameters

Returns Promise<void>

cancelSubscriptionToRemoteUpdates

Returns void

deposit

Parameters

Returns Promise<void>

getActiveOrders

Returns Promise<ActiveOrder[]>

getAllPositions

Returns Position[]

getAvailableEquity

Returns BigNumber

getDepositWithdrawHistory

Parameters

Returns Promise<DepositOrWithdrawal[]>

getEquity

Returns BigNumber

getInitialMarginRequirement

Returns BigNumber

getLeverage

Returns BigNumber

getMaintenanceMarginRequirement

Returns BigNumber

getOpenInterest

Returns BigNumber

getOpenOrders

getPosition

Parameters

Returns Position

getPositionLeverage

Parameters

Returns BigNumber

getRealisedEquity

Returns BigNumber

getRolesArgs

Parameters

`Private` `Readonly` adapter

`Readonly` equityTokenAddress

`Readonly` id

`Private` isProcessingSubscriptionRequest

`Optional` onUpdate

`Private` openOrders

size: {
amount: BigNumber;
unit: "lpc" | "lot";
}

`Private` orderPublicationListener

`Private` positions

`Private` `Readonly` protocol

`Private` `Readonly` reader

`Private` realizedEquity

`Private` subsriptionId

`Private` applyTradeEffect

`Private` handleAccountPublication

`Static` fromId

`Static` open