Options
All
  • Public
  • Public/Protected
  • All
Menu

Hierarchy

  • Client

Index

Constructors

constructor

  • Parameters

    Returns Client

    Example

    import { Client, EnvironmentConfiguration } from '@neon-exchange/api-client-typescript'
    
    const nash = new Client(EnvironmentConfiguration.sandbox)

Properties

Private account

account: any

Private apiUri

apiUri: string

assetData

assetData: object

Type declaration

Private assetNonces

assetNonces: object

Type declaration

  • [key: string]: number[]

Private casCookie

casCookie: string

Private casUri

casUri: string

Private currentOrderNonce

currentOrderNonce: number

Private gql

gql: GQL

Private initParams

initParams: InitParams

marketData

marketData: object

Type declaration

Private nashCoreConfig

nashCoreConfig: Config

Private opts

Private publicKey

publicKey: string

Private tradedAssets

tradedAssets: string[] = []

Private walletIndices

walletIndices: object

Type declaration

  • [key: string]: number

Private wsUri

wsUri: string

Methods

cancelAllOrders

  • cancelAllOrders(marketName?: string): Promise<boolean>
  • Parameters

    • Optional marketName: string

    Returns Promise<boolean>

    Example

    const result = await nash.cancelAllOrders('neo_gas')
    console.log(result)

cancelOrder

  • cancelOrder(orderID: string, marketName: string): Promise<CancelledOrder>
  • Parameters

    • orderID: string
    • marketName: string

    Returns Promise<CancelledOrder>

    Example

    const cancelledOrder = await nash.cancelOrder('11')
    console.log(cancelledOrder)

Private createAndUploadKeys

  • createAndUploadKeys(encryptionKey: Buffer, casCookie: string, presetWallets?: object): Promise<void>
  • Parameters

    • encryptionKey: Buffer
    • casCookie: string
    • Optional presetWallets: object

    Returns Promise<void>

createSocketConnection

  • Returns NashSocketEvents

    Example

    import { Client, EnvironmentConfiguration } from '@neon-exchange/api-client-typescript'
    
    const nash = new Client(EnvironmentConfiguration.sandbox)
    await nash.login({ email, password })
    
    const connection = nash.createSocketConnection()
    
    // Getting the orderbook for the neo_eth marked
    connection.onUpdatedOrderbook(
     { marketName: 'neo_eth' },
     {
       onResult: ({
         data: {
           updatedOrderBook: { bids, asks }
         }
       }) => {
         console.log(`updated bids ${bids.length}`)
         console.log(`updated asks ${asks.length}`)
       }
     }
    )
    
    // Getting the user orderobok for all markets
    connection.onUpdatedAccountOrders(
     {},
     {
       onResult: ({
         data: {
           updatedAccountOrders
         }
       }) => {
         console.log(`Updated orders: {updatedAccountOrders.length}`)
       }
     }
    )
    

Private createTimestamp32

  • createTimestamp32(): number
  • Returns number

Private doTwoFactorLogin

  • doTwoFactorLogin(twoFaCode: string): Promise<any>
  • Parameters

    • twoFaCode: string

    Returns Promise<any>

Private fetchAssetData

  • fetchAssetData(): Promise<Record<string, AssetData>>
  • Returns Promise<Record<string, AssetData>>

Private fetchMarketData

  • fetchMarketData(): Promise<Record<string, Market>>
  • Returns Promise<Record<string, Market>>

getAccountBalance

  • Parameters

    Returns Promise<AccountBalance>

    Example

    import { CryptoCurrency } from '@neon-exchange/api-client-typescript'
    
    const accountBalance = await nash.getAcountBalance(CryptoCurrency.ETH)
    console.log(accountBalance)

getAccountOrder

  • getAccountOrder(orderID: string): Promise<Order>
  • Parameters

    • orderID: string

    Returns Promise<Order>

    Example

    const order = await nash.getAccountOrder('999')
    console.log(order)

getAccountPortfolio

  • Parameters

    Returns Promise<AccountPortfolio>

    Example

    const accountPortfolio = await nash.getAccountPortfolio()
    console.log(accountPortfolio)

getAssetNonces

  • Parameters

    • assetList: string[]

    Returns Promise<AssetsNoncesData[]>

    Example

    const getNoncesData = await nash.getAssetNonces()
    console.log(getNoncesData)

getDepositAddress

  • Parameters

    Returns Promise<AccountDepositAddress>

    Example

    import { CryptoCurrency } from '@neon-exchange/api-client-typescript'
    
    const address = await nash.getDepositAddress(CryptoCurrency.NEO)
    console.log(address)

getMarket

  • getMarket(marketName: string): Promise<Market>
  • Parameters

    • marketName: string

    Returns Promise<Market>

    Example

    const market = await nash.getMarket('neo_gas')
    console.log(market)

getMovement

  • getMovement(movementID: number): Promise<Movement>
  • Parameters

    • movementID: number

    Returns Promise<Movement>

    Example

    const movement = await nash.getMovement(1)
    console.log(movement)

Private getNoncesForTrade

getOrderBook

  • getOrderBook(marketName: string): Promise<OrderBook>
  • Parameters

    • marketName: string

    Returns Promise<OrderBook>

    Example

    const orderBook = await nash.getOrderBook('neo_gas')
    console.log(orderBook.bids)

getOrdersForMovement

  • Parameters

    • asset: string

    Returns Promise<OrdersForMovementData>

    Example

    const getOrdersForMovementData = await nash.getOrdersForMovement(unit)
    console.log(getOrdersForMovementData)

getSignAndSyncStates

  • getSignAndSyncStates(): Promise<SyncState[]>
  • Returns Promise<SyncState[]>

    Example

    const getSignSyncStates = await nash.getSignAndSyncStates()
    console.log(getSignSyncStates)

getTicker

  • getTicker(marketName: string): Promise<Ticker>
  • Parameters

    • marketName: string

    Returns Promise<Ticker>

    Example

    const ticker = await nash.getTicker('neo_gas')
    console.log(ticker)

Private handleOrderError

  • handleOrderError(error: Error, signedPayload: any): any
  • Parameters

    • error: Error
    • signedPayload: any

    Returns any

listAccountBalances

  • listAccountBalances(ignoreLowBalance: any): Promise<AccountBalance[]>
  • Parameters

    • ignoreLowBalance: any

    Returns Promise<AccountBalance[]>

    Example

    const accountBalance = await nash.listAccountBalances()
    console.log(accountBalance)

listAccountOrders

  • listAccountOrders(__namedParameters?: object): Promise<AccountOrder>
  • Parameters

    • Default value __namedParameters: object = {}
      • before: string
      • buyOrSell: OrderBuyOrSell
      • limit: number
      • marketName: string
      • rangeStart: string
      • rangeStop: string
      • shouldIncludeTrades: boolean
      • status: Object
      • type: Object

    Returns Promise<AccountOrder>

    Example

    const accountOrder = await nash.listAccountOrders({
      marketName : 'neo_eth'
    })
    console.log(accountOrder.orders)

listAccountTrades

  • listAccountTrades(__namedParameters?: object): Promise<TradeHistory>
  • Parameters

    • Default value __namedParameters: object = {}
      • before: string
      • limit: number
      • marketName: string

    Returns Promise<TradeHistory>

    Example

    const tradeHistory = await nash.listAccountTrades({
      limit : 10,
      marketName : 'neo_eth'
    })
    console.log(tradeHistory.trades)

listAccountTransactions

  • Parameters

    • __namedParameters: object
      • cursor: string
      • fiatSymbol: string
      • limit: number

    Returns Promise<AccountTransaction>

    Example

    const accountTransaction = await nash.listAccountTransactions({
      limit : 150,
      ${paramName} : ${paramValue}
    })
    console.log(accountTransaction.transactions)

listAccountVolumes

  • Returns Promise<AccountVolume>

    Example

    const accountVolume = await nash.listAccountVolumes()
    console.log(accountVolume.thirtyDayTotalVolumePercent)

listAssets

  • listAssets(): Promise<Asset[]>
  • Returns Promise<Asset[]>

    Example

    const assets = await nash.listAssets()
    console.log(assets)

listCandles

  • listCandles(__namedParameters: object): Promise<CandleRange>
  • Parameters

    • __namedParameters: object
      • before: string
      • interval: CandleInterval
      • limit: number
      • marketName: string

    Returns Promise<CandleRange>

    Example ` const candleRange = await nash.listCandles({ marketName : 'neo_gas' }) console.log(candleRange)

listMarkets

  • listMarkets(): Promise<Market[]>
  • Returns Promise<Market[]>

    Example

    const markets = await nash.listMarkets()
    console.log(markets)

listMovements

  • listMovements(__namedParameters: object): Promise<Movement[]>
  • Parameters

    Returns Promise<Movement[]>

    Example

    const movements = await nash.listMovements({
      currency : 'eth'
    })
    console.log(movements)

listTickers

  • listTickers(): Promise<Ticker[]>
  • Returns Promise<Ticker[]>

    Example

    const tickers = await nash.listTickers()
    console.log(tickers)

listTrades

  • listTrades(__namedParameters: object): Promise<TradeHistory>
  • Parameters

    • __namedParameters: object
      • before: string
      • limit: number
      • marketName: string

    Returns Promise<TradeHistory>

    Example

    const tradeHistory = await nash.listTrades({
      marketname : 'neo_gas'
    })
    console.log(tradeHistory.trades)

login

  • login(__namedParameters: object): Promise<void>
  • Parameters

    • __namedParameters: object
      • email: string
      • password: string
      • presetWallets: object
      • twoFaCode: string
      • walletIndices: object
        • btc: number
        • eth: number
        • neo: number

    Returns Promise<void>

placeLimitOrder

  • Parameters

    Returns Promise<OrderPlaced>

    Example

    import {
      createCurrencyAmount,
      createCurrencyPrice,
      OrderBuyOrSell,
      OrderCancellationPolicy
    } from '@neon-exchange/api-client-typescript'
    
    const order = await nash.placeLimitOrder(
      false,
      createCurrencyAmount('1', CryptoCurrency.NEO),
      OrderBuyOrSell.BUY,
      OrdeCancellationPolicy.GOOD_TILL_CANCELLED,
      createCurrencyPrice('0.01', CryptoCurrency.GAS, CryptoCurrency.NEO),
      'neo_gas'
    )
    console.log(order.status)

placeMarketOrder

  • Parameters

    Returns Promise<OrderPlaced>

    Example

    import {
      createCurrencyAmount,
      OrderBuyOrSell,
    } from '@neon-exchange/api-client-typescript'
    
    const order = await nash.placeMarketOrder(
      createCurrencyAmount('1.00', CryptoCurrency.NEO),
      OrderBuyOrSell.SELL,
      'neo_gas'
    )
    console.log(order.status)

placeStopLimitOrder

  • Parameters

    Returns Promise<OrderPlaced>

    Example

    import {
      createCurrencyAmount,
      createCurrencyPrice,
      OrderBuyOrSell,
      OrderCancellationPolicy
    } from '@neon-exchange/api-client-typescript'
    
    const order = await nash.placeStopLimitOrder(
      false,
      createCurrencyAmount('1', CryptoCurrency.NEO),
      OrderBuyOrSell.BUY,
      OrdeCancellationPolicy.GOOD_TILL_CANCELLED,
      createCurrencyPrice('0.01', CryptoCurrency.GAS, CryptoCurrency.NEO),
      'neo_gas'
      createCurrencyPrice('0.02', CryptoCurrency.GAS, CryptoCurrency.NEO)
    )
    console.log(order.status)

placeStopMarketOrder

  • Parameters

    Returns Promise<OrderPlaced>

    Example

    import {
      createCurrencyAmount,
      createCurrencyPrice,
      OrderBuyOrSell,
    } from '@neon-exchange/api-client-typescript'
    
    const order = await nash.placeStopLimitOrder(
      createCurrencyAmount('1', CryptoCurrency.NEO),
      OrderBuyOrSell.BUY,
      'neo_gas'
      createCurrencyPrice('0.02', CryptoCurrency.GAS, CryptoCurrency.NEO)
    )
    console.log(order.status)

signDepositRequest

Private signPayload

  • signPayload(payloadAndKind: PayloadAndKind): Promise<any>
  • Parameters

    • payloadAndKind: PayloadAndKind

    Returns Promise<any>

signStates

  • Parameters

    Returns Promise<SignStatesData>

    Example

    const signStatesResult = await nash.signStates(getStatesResult)
    console.log(signStatesResult)

signWithdrawRequest

  • Parameters

    Returns Promise<SignMovementResult>

    Example

    import { createCurrencyAmount } from '@neon-exchange/api-client-ts'
    
    const address = 'd5480a0b20e2d056720709a9538b17119fbe9fd6';
    const amount = createCurrencyAmount('1.5', CryptoCurrency.ETH);
    const signedMovement = await nash.signWithdrawRequest(address, amount);
    console.log(signedMovement)

Private state_map_from_states

  • state_map_from_states(states: any): any
  • Parameters

    • states: any

    Returns any

syncStates

  • Parameters

    Returns Promise<SyncState[]>

    Example

    const getStatesData = await nash.getStates()
    console.log(getStatesData)

Private updateTradedAssetNonces

  • updateTradedAssetNonces(): Promise<void>
  • Returns Promise<void>

Generated using TypeDoc