Options
All
  • Public
  • Public/Protected
  • All
Menu

Hierarchy

  • Client

Index

Constructors

Properties

Accessors

Methods

Object literals

Constructors

constructor

  • Create a new instance of Client

    Parameters

    Returns Client

    Example

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

Properties

Private _socket

_socket: any = null

Private Optional account

account: SignInResult["signIn"]["account"]

apiKey

apiKey: APIKey

Private apiUri

apiUri: string

assetData

assetData: {}

Type declaration

Private assetNonces

assetNonces: {}

Type declaration

  • [key: string]: number[]

Private authorization

authorization: string

Private casCookie

casCookie: string

Private clientOpts

clientOpts: ClientOptions

Private connection

connection: NashSocketEvents

Private currentOrderNonce

currentOrderNonce: number

ethVaultContract

ethVaultContract: Contract

Private gql

gql: GQL

Private initParams

initParams: InitParams

Private isMainNet

isMainNet: boolean

marketData

marketData: {}

Type declaration

Private maxEthCostPrTransaction

maxEthCostPrTransaction: BigNumber

Private mode

mode: ClientMode = ClientMode.NONE

Private nashCoreConfig

nashCoreConfig: Config

nashProtocolMarketData

nashProtocolMarketData: ReturnType<typeof mapMarketsForNashProtocol>

Private opts

perfClient

perfClient: PerfClient

Private publicKey

publicKey: string

Private tradedAssets

tradedAssets: string[] = []

Private walletIndices

walletIndices: {}

Type declaration

  • [key: string]: number

Private web3

web3: Web3

Private wsToken

wsToken: string

Private wsUri

wsUri: string

Accessors

Private headers

  • get headers(): Record<string, string>
  • Returns Record<string, string>

Methods

Private _createSocket

  • _createSocket(): any
  • Returns any

Private _resumeVaultTransaction

  • _resumeVaultTransaction(unfinishedTransaction: { blockchainSignature?: string; movement: Movement; signature: PayloadSignature }, emit: Promievent<any>["emit"]): Promise<{ txId: string }>
  • Parameters

    Returns Promise<{ txId: string }>

Private _transferToTradingContract

  • _transferToTradingContract(quantity: CurrencyAmount, movementType: typeof MovementTypeDeposit | typeof MovementTypeWithdrawal, emit: Promievent<any>["emit"]): Promise<{ movementId: string; txId: string }>
  • Parameters

    • quantity: CurrencyAmount
    • movementType: typeof MovementTypeDeposit | typeof MovementTypeWithdrawal
    • emit: Promievent<any>["emit"]

    Returns Promise<{ movementId: string; txId: string }>

Private approveAndAwaitAllowance

  • approveAndAwaitAllowance(assetData: AssetData, childKey: ChildKey, amount: string): Promise<void>
  • Parameters

    • assetData: AssetData
    • childKey: ChildKey
    • amount: string

    Returns Promise<void>

Private approveERC20Transaction

  • approveERC20Transaction(asset: AssetData, childKey: ChildKey, amount: BigNumber): Promise<TransactionReceipt>
  • Parameters

    • asset: AssetData
    • childKey: ChildKey
    • amount: BigNumber

    Returns Promise<TransactionReceipt>

cancelAllOrders

  • cancelAllOrders(marketName?: string): Promise<boolean>
  • Cancel all orders by market name

    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>
  • Cancel an order by ID.

    Parameters

    • orderID: string
    • marketName: string

    Returns Promise<CancelledOrder>

    Example

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

Private completeBtcTransactionSignatures

Private completePayloadSignature

Private createAndUploadKeys

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

    • encryptionKey: Buffer
    • Optional presetWallets: object

    Returns Promise<void>

createSocketConnection

  • Sets up a websocket and authenticates it using the current token.

    Returns NashSocketEvents

    Example

    import { Client, EnvironmentConfiguration } from '@neon-exchange/api-client-typescript'
    
    const nash = new Client(EnvironmentConfiguration.sandbox)
    await nash.login(...)
    
    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

depositToTradingContract

  • Parameters

    Returns PromiEvent<{ movementId: string; txId: string }>

disconnect

  • disconnect(): void
  • Returns void

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>>

Private fillPoolFn

  • fillPoolFn(arg: { blockchain: Blockchain; client_dh_publics: string[] }): Promise<string[]>
  • Parameters

    • arg: { blockchain: Blockchain; client_dh_publics: string[] }
      • blockchain: Blockchain
      • client_dh_publics: string[]

    Returns Promise<string[]>

findPendingChainMovements

  • findPendingChainMovements(chain: TSAPIBlockchain): Promise<Movement[]>
  • Parameters

    • chain: TSAPIBlockchain

    Returns Promise<Movement[]>

getAccountAddress

  • getAccountAddress(currency: CryptoCurrency): Promise<GetAccountAddressResult["getAccountAddress"]>
  • Get the deposit address for the given crypto currency.

    Parameters

    Returns Promise<GetAccountAddressResult["getAccountAddress"]>

    Example

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

getAccountBalance

  • Get AccountBalance for the given crypto currency.

    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>
  • Get an order by ID.

    Parameters

    • orderId: string

    Returns Promise<Order>

    Example

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

getAccountPortfolio

  • Get the AccountPortfolio for the current authenticated account.

    Parameters

    Returns Promise<AccountPortfolio>

    Example

    const accountPortfolio = await nash.getAccountPortfolio({
      fiatSymbol: "USD",
    
    })
    console.log(accountPortfolio)

getAssetNonces

  • List all current asset nonces

    Parameters

    • assetList: string[]

    Returns Promise<AssetsNoncesData[]>

    Example

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

getBtcAddress

  • getBtcAddress(): string
  • Returns string

getDepositAddress

  • getDepositAddress(currency: CryptoCurrency): Promise<GetAccountAddressResult["getAccountAddress"]>
  • deprecated

    will be removed in next major version use getAccountAddress

    Parameters

    Returns Promise<GetAccountAddressResult["getAccountAddress"]>

    [description]

getEthAddress

  • getEthAddress(): string
  • Returns string

getMarket

  • getMarket(marketName: string): Promise<Market>
  • Get a specific Market by name.

    Parameters

    • marketName: string

    Returns Promise<Market>

    Example

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

getMovement

  • getMovement(movementID: number): Promise<Movement>
  • Get a Movement by the given id.

    Parameters

    • movementID: number

    Returns Promise<Movement>

    Example

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

getNeoAddress

  • getNeoAddress(): string
  • Returns string

Private getNoncesForTrade

  • Parameters

    Returns NonceSet

getOrderBook

  • getOrderBook(marketName: string): Promise<OrderBook>
  • Get the OrderBook for the given market.

    Parameters

    • marketName: string

    Returns Promise<OrderBook>

    Example

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

getOrdersForMovement

  • List all orders for a given movement

    Parameters

    • asset: string

    Returns Promise<OrdersForMovementData>

    Example

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

getSignAndSyncStates

  • Gets Balance States, Signs Balance States, then Syncs Balance states to the server

    Parameters

    • Default value sync: boolean = false

      Whether to sync the state updates to the blockchain. Defaults to false

    Returns Promise<SyncStatesData | SignStatesData>

    Example

    // sign states
    const signStates = await nash.getSignAndSyncStates()
    console.log(signStates)
    
    // sign and sync states to blockchain
    const signAndSyncStates = await nash.getSignAndSyncStates(true)
    console.log(signAndSyncStates)
    

Private getSocket

  • getSocket(): any
  • Returns any

getTicker

  • getTicker(marketName: string): Promise<Ticker>
  • Get a single Ticker for the given market name.

    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

isMovementCompleted

  • isMovementCompleted(movementId: string): Promise<boolean>
  • Parameters

    • movementId: string

    Returns Promise<boolean>

legacyAddMovement

legacyLogin

  • legacyLogin(__namedParameters: { email: string; password: string; presetWallets: object; salt: string; twoFaCode: string; walletIndices: object }): Promise<void>
  • Legacy login against the central account service. Note: you should prefer to use an API key with the login method.

    Be careful about using this feature, private keys are derived using the password. So this technically gives full access to the account. Because of this the following features are not supported using legacy login.

    • transferToExternal
    • depositToTradingContract
    • withdrawFromTradingContract

    Parameters

    • __namedParameters: { email: string; password: string; presetWallets: object; salt: string; twoFaCode: string; walletIndices: object }
      • email: string

        string

      • password: string

        string

      • presetWallets: object
      • salt: string
      • twoFaCode: string

        string

      • walletIndices: object
        • btc: number
        • eth: number
        • neo: number

    Returns Promise<void>

    Example

    try {
      nash.legacyLogin({
        email: "email@domain.com",
        password: "example"
      })
    } catch (e) {
      console.error(`login failed ${e}`)
    }

listAccountBalances

  • listAccountBalances(ignoreLowBalance: any): Promise<AccountBalance[]>
  • List all balances for current authenticated account.

    Parameters

    • ignoreLowBalance: any

    Returns Promise<AccountBalance[]>

    Example

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

listAccountOrders

  • listAccountOrders(__namedParameters?: { before: string; buyOrSell: OrderBuyOrSell; limit: number; marketName: string; rangeStart: string; rangeStop: string; shouldIncludeTrades: boolean; status: [OrderStatus]; type: [OrderType] }): Promise<AccountOrder>
  • list available orders for the current authenticated account.

    Parameters

    • Default value __namedParameters: { before: string; buyOrSell: OrderBuyOrSell; limit: number; marketName: string; rangeStart: string; rangeStop: string; shouldIncludeTrades: boolean; status: [OrderStatus]; type: [OrderType] } = {}
      • before: string
      • buyOrSell: OrderBuyOrSell
      • limit: number
      • marketName: string
      • rangeStart: string
      • rangeStop: string
      • shouldIncludeTrades: boolean
      • status: [OrderStatus]
      • type: [OrderType]

    Returns Promise<AccountOrder>

    Example

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

listAccountTrades

  • listAccountTrades(__namedParameters?: { before: string; limit: number; marketName: string }): Promise<TradeHistory>
  • list available trades for the current authenticated account.

    Parameters

    • Default value __namedParameters: { before: string; limit: number; marketName: string } = {}
      • 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

  • listAccountTransactions(__namedParameters?: { cursor: string; fiatSymbol: string; limit: number }): Promise<AccountTransaction>
  • List available account transactions.

    Parameters

    • Default value __namedParameters: { cursor: string; fiatSymbol: string; limit: number } = {}
      • cursor: string
      • fiatSymbol: string
      • limit: number

    Returns Promise<AccountTransaction>

    Example

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

listAssets

  • listAssets(): Promise<Asset[]>
  • Fetches as list of all available Asset that are active on the exchange.

    Returns Promise<Asset[]>

    Example

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

listCandles

  • listCandles(__namedParameters: { before: string; interval: CandleInterval; limit: number; marketName: string }): Promise<CandleRange>
  • List a CandleRange for the given market.

    Parameters

    • __namedParameters: { before: string; interval: CandleInterval; limit: number; marketName: string }
      • 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[]>
  • List all available markets.

    Returns Promise<Market[]>

    Example

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

listMovements

  • List all movements for the current authenticated account.

    Parameters

    Returns Promise<Movement[]>

    Example

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

listTickers

  • listTickers(): Promise<Ticker[]>
  • Fetches as list of all available Ticker that are active on the exchange.

    Returns Promise<Ticker[]>

    Example

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

listTrades

  • listTrades(__namedParameters: { before: string; limit: number; marketName: string }): Promise<TradeHistory>
  • Get TradeHistory for the given market name.

    Parameters

    • __namedParameters: { before: string; limit: number; marketName: string }
      • 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: { apiKey: string; secret: string }): Promise<void>
  • Login using an API key.

    request.

    Parameters

    • __namedParameters: { apiKey: string; secret: string }
      • apiKey: string

        string

      • secret: string

        string

    Returns Promise<void>

placeLimitOrder

  • Place a limit order.

    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,
      OrderCancellationPolicy.GOOD_TIL_CANCELLED,
      createCurrencyPrice('0.01', CryptoCurrency.GAS, CryptoCurrency.NEO),
      'neo_gas'
    )
    console.log(order.status)

placeMarketOrder

  • Place a market order.

    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

  • Place a stop limit order.

    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,
      OrderCancellationPolicy.GOOD_TIL_CANCELLED,
      createCurrencyPrice('0.01', CryptoCurrency.GAS, CryptoCurrency.NEO),
      'neo_gas'
      createCurrencyPrice('0.02', CryptoCurrency.GAS, CryptoCurrency.NEO)
    )
    console.log(order.status)

placeStopMarketOrder

  • Place a stop market order.

    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)

Private prepareMovement

  • prepareMovement(payload: Omit<PrepareMovementVariables["payload"], "timestamp">): Promise<PrepareMovementData["prepareMovement"]>
  • Parameters

    • payload: Omit<PrepareMovementVariables["payload"], "timestamp">

    Returns Promise<PrepareMovementData["prepareMovement"]>

queryAllowance

  • queryAllowance(assetData: AssetData): Promise<BigNumber>
  • Parameters

    Returns Promise<BigNumber>

Private requireFull

  • requireFull(): void
  • Returns void

Private requireMPC

  • requireMPC(): void
  • Returns void

Private requireMode

  • requireMode(mode: ClientMode, msg: string): void
  • Parameters

    Returns void

resumeTradingContractTransaction

  • resumeTradingContractTransaction(unfinishedTransaction: { blockchainSignature: string; movement: Movement; signature: PayloadSignature }): Promievent<{ txId: string }>
  • Parameters

    Returns Promievent<{ txId: string }>

Private sendBlockchainRawTransaction

  • sendBlockchainRawTransaction(params: { blockchain: SendBlockchainRawTransactionArgs["payload"]["blockchain"]; payload: SendBlockchainRawTransactionArgs["payload"]["transactionPayload"] }): Promise<string>
  • Parameters

    • params: { blockchain: SendBlockchainRawTransactionArgs["payload"]["blockchain"]; payload: SendBlockchainRawTransactionArgs["payload"]["transactionPayload"] }
      • blockchain: SendBlockchainRawTransactionArgs["payload"]["blockchain"]
      • payload: SendBlockchainRawTransactionArgs["payload"]["transactionPayload"]

    Returns Promise<string>

Private signEthTransaction

  • signEthTransaction(etx: EthTransaction): Promise<string>
  • Parameters

    • etx: EthTransaction

    Returns Promise<string>

Private signNeoPayload

  • signNeoPayload(payload: string): Promise<string>
  • Parameters

    • payload: string

    Returns Promise<string>

Private signPayload

  • helper function that returns the correct types for the needed GQL queries and mutations.

    Parameters

    • payloadAndKind: PayloadAndKind

    Returns Promise<PayloadSignature>

Private signPayloadFull

  • Parameters

    • payloadAndKind: PayloadAndKind

    Returns Promise<PayloadSignature>

Private signPayloadMpc

  • Parameters

    • payloadAndKind: PayloadAndKind

    Returns Promise<PayloadSignature>

signStates

  • Submit all states and open orders to be signed for settlement

    Parameters

    Returns Promise<SignStatesData>

    Example

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

signWithdrawRequest

  • Sign a withdraw request.

    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

  • List all states and open orders to be signed for settlement

    Parameters

    Returns Promise<SyncStatesData>

    Example

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

transferToExternal

  • transferToExternal(params: { address: string; quantity: CurrencyAmount }): Promise<{ gasUsed?: number; txId: string }>
  • Parameters

    Returns Promise<{ gasUsed?: number; txId: string }>

Private transferToTradingContract

  • transferToTradingContract(quantity: CurrencyAmount, movementType: typeof MovementTypeDeposit | typeof MovementTypeWithdrawal): Promievent<{ movementId: string; txId: string }>
  • Parameters

    • quantity: CurrencyAmount
    • movementType: typeof MovementTypeDeposit | typeof MovementTypeWithdrawal

    Returns Promievent<{ movementId: string; txId: string }>

Private updateDepositWithdrawalMovementWithTx

  • updateDepositWithdrawalMovementWithTx(__namedParameters: { blockchainSignature: string; movement: Movement; signedAddMovementPayload: PayloadSignature }): Promise<{ txId: string }>
  • Parameters

    Returns Promise<{ txId: string }>

Private updateMovement

  • updateMovement(payload: Omit<UpdateMovementVariables["payload"], "timestamp">): Promise<UpdateMovementData["updateMovement"]>
  • Parameters

    • payload: Omit<UpdateMovementVariables["payload"], "timestamp">

    Returns Promise<UpdateMovementData["updateMovement"]>

Private updateTradedAssetNonces

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

Private validateTransactionCost

  • validateTransactionCost(gasPrice: string, estimate: number): void
  • Parameters

    • gasPrice: string
    • estimate: number

    Returns void

withdrawFromTradingContract

  • Parameters

    Returns PromiEvent<{ movementId: string; txId: string }>

Object literals

Private _headers

_headers: object

Content-Type

Content-Type: string = "application/json"

Generated using TypeDoc