Simple wax express trade wrapper with a few helper funtions

wet.js

const assert = require('assert')
const axios = require('axios')
const join = require('url-join')
const lodash = require('lodash')
const Promise = require('bluebird')
const twoFactor = require('node-2fa')

const BASE_URL = 'https://api-trade.opskins.com'

module.exports = function(config) {
  assert(config, 'requires api config')
  assert(config.key, 'requires expresstrade key')
  // assert(config.secret, 'requires expresstrade secret')
  var methods = {}

  function callAPI(method, endpoint, params) {
    var url = join(BASE_URL, endpoint)

    // set default params to include the API_KEY
    if (!params) params = {}
    params.key = config.key
    // params.affiliate_eth_address = config.affiliate_eth_address

    if (method === 'get')
      params = {
        params,
      }

    return axios[method](url, params).then(res => res.data)
  }

  // ICase
  methods.getCaseSchema = Promise.method(function(cases) {
    // assert(cases, 'requires cases')
    if (cases) cases = cases.toString()
    return callAPI('get', 'ICase/GetCaseSchema/v1', {
      cases,
    })
  })

  methods.getMinimumOpenVolume = Promise.method(function() {
    return callAPI('get', 'ICase/GetMinimumOpenVolume/v1')
  })

  methods.openWithKeys = Promise.method(function(case_id, amount) {
    assert(case_id, 'requires case_id')
    assert(amount, 'requires amount')
    return callAPI('post', 'ICase/OpenWithKeys/v1', {
      case_id,
      amount,
    })
  })

  // ICaseSite
  methods.sendKeyRequest = Promise.method(function(
    trade_url,
    case_id,
    amount,
    referral_uid
  ) {
    assert(trade_url, 'requires trade_url')
    assert(case_id, 'requires case_id')
    assert(amount, 'requires amount')
    assert(amount >= 1, 'requires amount to be at least 1')
    return callAPI('post', 'ICaseSite/SendKeyRequest/v1', {
      trade_url,
      steam_id,
      case_id,
      amount,
      referral_uid,
    })
  })

  methods.sendKeyRequestWithSteamid = Promise.method(function(
    steam_id,
    case_id,
    amount,
    referral_uid
  ) {
    assert(steam_id, 'requires steam_id')
    assert(case_id, 'requires case_id')
    assert(amount, 'requires amount')
    assert(amount >= 1, 'requires amount to be at least 1')
    return callAPI('post', 'ICaseSite/SendKeyRequest/v1', {
      steam_id,
      case_id,
      amount,
      referral_uid,
    })
  })

  methods.getTradeStatus = Promise.method(function(offer_id) {
    assert(offer_id, 'requires offer_id')
    return callAPI('get', 'ICaseSite/GetTradeStatus/v1', {
      offer_id,
    })
  })

  methods.getKeyCount = Promise.method(function(trade_url) {
    assert(trade_url, 'requires trade_url')
    return callAPI('get', 'ICaseSite/GetKeyCount/v1', {
      trade_url,
    })
  })

  methods.getKeyCountWithSteamid = Promise.method(function(steam_id) {
    assert(steam_id, 'requires steam_id')
    return callAPI('get', 'ICaseSite/GetKeyCount/v1', {
      steam_id,
    })
  })

  methods.updateCommissionSettings = Promise.method(function(
    network_id,
    network_user_id,
    referral_commission_rate
  ) {
    assert(network_id, 'requires network_id')
    assert(network_user_id, 'requires network_user_id')
    return callAPI('post', 'ICaseSite/UpdateCommissionSettings/v1', {
      network_id,
      network_user_id,
      referral_commission_rate,
    })
  })

  // IEthereum
  methods.getContractAddress = Promise.method(function() {
    return callAPI('get', 'IEthereum/GetContractAddress/v1')
  })

  // IItem
  methods.getItems = Promise.method(function(sku_filter, wear_tier_index) {
    assert(sku_filter, 'requires sku_filter')
    sku_filter = sku_filter.toString()
    return callAPI('get', 'IItem/GetItems/v1', {
      sku_filter,
      wear_tier_index,
    })
  })

  methods.getItemsById = Promise.method(function(item_id) {
    assert(item_id, 'requires item_id')
    return callAPI('get', 'IItem/GetItemsById/v1/', {
      item_id,
    })
  })

  methods.withdrawToOpskins = Promise.method(function(item_id) {
    assert(item_id, 'requires item_id')
    return callAPI('post', 'IItem/WithdrawToOpskins/v1/', {
      item_id,
    })
  })

  // ITrade
  methods.acceptOffer = Promise.method(function(offer_id) {
    assert(offer_id, 'requires offer_id')
    assert(config.secret, 'requires two_factor secret env var')
    var twofactor_code = twoFactor.generateToken(config.secret).token
    return callAPI('post', 'ITrade/AcceptOffer/v1/', {
      twofactor_code,
      offer_id,
    })
  })

  methods.cancelOffer = Promise.method(function(offer_id) {
    assert(offer_id, 'requires offer_id')
    return callAPI('post', 'ITrade/CancelOffer/v1/', {
      offer_id,
    })
  })

  methods.getApps = Promise.method(function() {
    return callAPI('get', 'ITrade/GetApps/v1/')
  })

  methods.getOffer = Promise.method(function(offer_id) {
    assert(offer_id, 'requires offer_id')
    return callAPI('get', 'ITrade/GetOffer/v1/', {
      offer_id,
    })
  })

  methods.getOffers = Promise.method(function(options) {
    options = options || {}
    assert(lodash.isObject(options), 'requires options')
    var { uid, state, type, page, per_page, ids, sort, ...options } = options
    return callAPI('get', 'ITrade/GetOffers/v1/', {
      uid,
      state,
      type,
      page,
      per_page,
      ids,
      sort,
    })
  })

  methods.getTradeURL = Promise.method(function() {
    return callAPI('get', 'ITrade/GetTradeURL/v1/')
  })

  methods.getUserInventory = Promise.method(function(uid, app_id, options) {
    assert(uid, 'requires uid')
    // assert(app_id, 'requires app_id')
    app_id = app_id || 1 // default to VGO items.
    options = options || {}
    assert(lodash.isObject(options), 'requires options')
    var { page, per_page, search, sort, ...options } = options
    return callAPI('get', 'ITrade/GetUserInventory/v1/', {
      uid,
      app_id,
      page,
      per_page,
      search,
      sort,
    })
  })

  methods.getUserInventoryFromSteamId = Promise.method(function(
    steam_id,
    app_id,
    options
  ) {
    assert(steam_id, 'requires steam_id')
    // assert(app_id, 'requires app_id')
    app_id = app_id || 1 // default to VGO items.
    options = options || {}
    assert(lodash.isObject(options), 'requires options')
    var { page, per_page, search, sort, ...options } = options
    return callAPI('get', 'ITrade/GetUserInventoryFromSteamId/v1/', {
      steam_id,
      app_id,
      page,
      per_page,
      search,
      sort,
    })
  })

  methods.regenerateTradeURL = Promise.method(function() {
    return callAPI('post', 'ITrade/RegenerateTradeURL/v1/')
  })

  methods.sendOffer = Promise.method(function(
    uid,
    token,
    items_to_send = [],
    items_to_receive = [],
    message = 'automated trade offer'
  ) {
    assert(uid, 'requires uid')
    assert(token, 'requires token')
    items_to_send = items_to_send.toString()
    items_to_receive = items_to_receive.toString()
    assert(config.secret, 'requires two_factor secret env var')
    var twofactor_code = twoFactor.generateToken(config.secret).token
    return callAPI('post', 'ITrade/SendOffer/v1/', {
      uid,
      token,
      items_to_send,
      items_to_receive,
      twofactor_code,
      message,
    })
  })

  methods.sendOfferToSteamId = Promise.method(function(
    steam_id,
    items_to_send = [],
    items_to_receive = [],
    message = 'automated trade offer'
  ) {
    assert(steam_id, 'requires steam_id')
    items_to_send = items_to_send.toString()
    items_to_receive = items_to_receive.toString()
    assert(config.secret, 'requires two_factor secret env var')
    var twofactor_code = twoFactor.generateToken(config.secret).token
    return callAPI('post', 'ITrade/SendOfferToSteamId/v1/', {
      steam_id,
      items_to_send,
      items_to_receive,
      twofactor_code,
      message,
    })
  })

  // IUser
  methods.createVCaseUser = Promise.method(function(site_url, display_name) {
    assert(site_url, 'requires site_url')
    assert(display_name, 'requires display_name')
    return callAPI('post', 'IUser/CreateVCaseUser/v1', {
      site_url,
      display_name,
    })
  })

  methods.getInventory = Promise.method(function(app_id = 1, options) {
    assert(app_id, 'requires app_id')
    options = options || {}
    assert(lodash.isObject(options), 'requires options')
    var { page, per_page, search, sort, ...options } = options
    return callAPI('get', 'IUser/GetInventory/v1', {
      app_id,
      page,
      per_page,
      search,
      sort,
    })
  })

  methods.getProfile = Promise.method(function(with_extra) {
    return callAPI('get', 'IUser/GetProfile/v1', {
      with_extra,
    })
  })

  methods.updateProfile = Promise.method(function(options) {
    options = options || {}
    assert(lodash.isObject(options), 'requires options')
    var {
      display_name,
      inventory_is_private,
      allow_twofactor_code_reuse,
      ...options
    } = options
    return callAPI('get', 'IUser/UpdateProfile/v1', {
      display_name,
      inventory_is_private,
      allow_twofactor_code_reuse,
    })
  })

  // CUSTOM METHODS

  methods.listAvailableCases = Promise.method(function(params) {
    return methods.getCaseSchema().then(result => result.response.cases)
  })

  methods.getCaseContents = Promise.method(function(caseid) {
    return methods.getCaseSchema(caseid).then(result => {
      var opCase = result.response.cases[0]
      return methods.getItems(opCase.skus).then(itemsResult => {
        var items = lodash.reduce(
          itemsResult.response.items,
          (memo, wears, sku) => {
            wears = lodash.map(wears, (wear, id) => {
              wear.id = `${sku}_${id}`
              wear.wearid = id
              wear.sku = sku
              return wear
            })
            memo = lodash.concat(memo, wears)
            return memo
          },
          []
        )
        opCase.items = items
        ;(opCase.totalValue =
          lodash.sumBy(items, 'suggested_price_floor') / 100),
          (opCase.worstItem = lodash.minBy(items, 'suggested_price_floor')),
          (opCase.bestItem = lodash.maxBy(items, 'suggested_price_floor'))
        return opCase
      })
    })
  })

  methods.listAvailableCasesWithContents = function() {
    return methods.listAvailableCases().then(cases => {
      return Promise.map(cases, box => {
        return methods.getCaseContents(box.id)
      })
    })
  }

  return methods
}