@exodus/bitcoin-api 1.0.0-alpha.0

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@exodus/bitcoin-api",
+  "version": "1.0.0-alpha.0",
+  "description": "Exodus bitcoin-api",
+  "main": "src/index.js",
+  "files": [
+    "src",
+    "!src/**/__tests__"
+  ],
+  "author": "Exodus",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "scripts": {
+    "build": "babel --root-mode upward --delete-dir-on-start --ignore '**/__tests__/**' src --out-dir lib",
+    "test": "jest",
+    "lint": "eslint ./src",
+    "lint:fix": "yarn lint --fix"
+  },
+  "dependencies": {
+    "@exodus/asset-lib": "^3.7.1",
+    "@exodus/bitcoinjs-lib": "6.0.2-beta.4",
+    "@exodus/keychain": "^2.0.0",
+    "@exodus/models": "^8.10.4",
+    "@exodus/ravencoin-lib": "^1.0.1",
+    "@exodus/secp256k1": "4.0.2-exodus.0",
+    "bip44-constants": "55.0.0",
+    "coininfo": "5.1.0",
+    "delay": "4.0.1",
+    "querystring": "0.2.0",
+    "socket.io-client": "2.1.1",
+    "url-join": "4.0.0"
+  },
+  "gitHead": "96693adf64f85200d0fb18c7779e23cd93a72e53"
+}

package/src/account-state.js

@@ -0,0 +1,11 @@
+import { AccountState, UtxoCollection } from '@exodus/models'
+
+export function createAccountState({ asset }) {
+  return class BitcoinAccountState extends AccountState {
+    static defaults = {
+      utxos: UtxoCollection.createEmpty({
+        currency: asset.currency,
+      }),
+    }
+  }
+}

package/src/bitcoinjs-lib/ecc/index.js

@@ -0,0 +1,81 @@
+import { TinySecp256k1Interface } from '@exodus/bitcoinjs-lib'
+// TODO: temp import until '@noble/secp256k1' can be used
+import tinySecp256k1 from 'tiny-secp256k1'
+import secp256k1 from '@exodus/secp256k1'
+
+// TODO: migrate library
+// import { sign, schnorr, Point } from '@noble/secp256k1'
+
+/**
+ * Wrapper around `secp256k1` in order to follow the bitcoinjs-lib `TinySecp256k1Interface`
+ * Schnorr signatures are offered by @noble/secp256k1
+ */
+export const ecc: TinySecp256k1Interface = {
+  // These methods have been addded in order to comply with the public interface
+  // In practice the async version will be used
+  sign: (h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array =>
+    secp256k1.ecdsaSign(h, d, { data: e }).signature,
+  verify: (h: Uint8Array, Q: Uint8Array, signature: Uint8Array, strict?: boolean): boolean =>
+    secp256k1.ecdsaVerify(signature, h, Q),
+
+  signAsync: async (h: Uint8Array, d: Uint8Array, extraEntropy?: Uint8Array): Uint8Array =>
+    secp256k1.ecdsaSign(h, d, { data: extraEntropy }).signature,
+
+  // TODO: waiting for the '@noble/secp256k1' lib
+  // signSchnorrAsync: async (h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array =>
+  //   schnorr.sign(h, d, e),
+  // verifySchnorrAsync: async (h: Uint8Array, Q: Uint8Array, signature: Uint8Array): boolean =>
+  //   schnorr.verify(signature, h, Q),
+
+  // The underlying library does not expose sync functions for Schnorr sign and verify.
+  // These function are explicitly defined here as `null` for documentation purposes.
+  signSchnorr: null,
+  verifySchnorr: null,
+
+  isPoint: (p: Uint8Array): boolean => {
+    try {
+      // temp solution secp256k1 does not actually verify the value range, only the data length
+      return tinySecp256k1.isPoint(Buffer.from(p))
+    } catch {
+      return false
+    }
+  },
+
+  isXOnlyPoint: (p: Uint8Array): boolean => {
+    try {
+      // temp solution secp256k1 does not actually verify the value range, only the data length
+      return tinySecp256k1.isPoint(Buffer.from(toPubKey(p)))
+    } catch (err) {
+      return false
+    }
+  },
+  xOnlyPointAddTweak: (p: Uint8Array, tweak: Uint8Array) => {
+    try {
+      const t = secp256k1.publicKeyTweakAdd(toPubKey(p), tweak)
+      return {
+        parity: t[0] === 0x02 ? 0 : 1,
+        xOnlyPubkey: t.slice(1, 33),
+      }
+    } catch (err) {
+      return null
+    }
+  },
+
+  privateAdd: (d: Uint8Array, tweak: Uint8Array): Uint8Array | null =>
+    secp256k1.privateKeyTweakAdd(d, tweak),
+
+  privateNegate: (d: Uint8Array): Uint8Array => secp256k1.privateKeyNegate(d),
+
+  pointCompress: (p: Uint8Array, compressed?: boolean): Uint8Array =>
+    secp256k1.publicKeyConvert(p, compressed),
+  isPrivate: (d: Uint8Array): boolean => secp256k1.privateKeyVerify(d),
+  pointFromScalar: (d: Uint8Array, compressed?: boolean): Uint8Array | null =>
+    secp256k1.publicKeyCreate(d, compressed),
+}
+
+const toPubKey = (xOnly: Uint8Array) => {
+  const p = new Uint8Array(33)
+  p.set([0x02])
+  p.set(xOnly, 1)
+  return p
+}

package/src/bitcoinjs-lib/index.js

@@ -0,0 +1,4 @@
+import { ecc } from './ecc'
+import { scriptClassify } from './script-classify'
+
+export { ecc, scriptClassify }

package/src/bitcoinjs-lib/script-classify/index.js

@@ -0,0 +1,49 @@
+import { payments } from '@exodus/bitcoinjs-lib'
+import { ecc } from '../ecc'
+
+function isPaymentFactory(payment: any): (script: Buffer, eccLib?: any) => boolean {
+  return (script: Buffer, eccLib?: any): boolean => {
+    try {
+      payment({ output: script }, { eccLib })
+      return true
+    } catch (err) {
+      return false
+    }
+  }
+}
+
+const isP2WPKH = isPaymentFactory(payments.p2wpkh)
+const isP2TR = isPaymentFactory(payments.p2tr)
+const isP2PKH = isPaymentFactory(payments.p2pkh)
+const isP2MS = isPaymentFactory(payments.p2ms)
+const isP2PK = isPaymentFactory(payments.p2pk)
+const isP2WSHScript = isPaymentFactory(payments.p2wsh)
+const isP2SHScript = isPaymentFactory(payments.p2sh)
+
+const types = {
+  P2WPKH: 'witnesspubkeyhash',
+  P2PKH: 'pubkeyhash',
+  P2MS: 'multisig',
+  P2PK: 'pubkey',
+  P2WSH: 'witnessscripthash',
+  P2SH: 'scripthash',
+  P2TR: 'taproot',
+  NONSTANDARD: 'nonstandard',
+}
+
+const clasifyOutput = (script: Buffer) => {
+  if (isP2WPKH(script)) return types.P2WPKH
+  if (isP2TR(script, ecc)) return types.P2TR
+  if (isP2PKH(script)) return types.P2PKH
+  if (isP2MS(script)) return types.P2MS
+  if (isP2PK(script)) return types.P2PK
+  if (isP2WSHScript(script)) return types.P2WSH
+  if (isP2SHScript(script)) return types.P2SH
+
+  return types.NONSTANDARD
+}
+
+export const scriptClassify = {
+  types,
+  output: clasifyOutput,
+}

package/src/btc-address.js

@@ -0,0 +1,7 @@
+export const getBtcVersions = (coinInfo) => ({
+  p2pkh: coinInfo.versions.public,
+  p2sh: coinInfo.versions.scripthash,
+  bech32: coinInfo.bech32,
+  segwit: `${coinInfo.bech32}1q`,
+  taproot: `${coinInfo.bech32}1p`,
+})

package/src/btc-like-address.js

@@ -0,0 +1,110 @@
+import bs58check from 'bs58check'
+import bech32 from 'bech32'
+import assert from 'minimalistic-assert'
+import { identity, pickBy } from 'lodash'
+import { ecc as defaultEcc } from './bitcoinjs-lib'
+
+export const createBtcLikeAddress = ({
+  versions,
+  coinInfo,
+  bitcoinjsLib,
+  ecc = defaultEcc,
+  useBip86 = false,
+  validateFunctions = {},
+  extraFunctions = {},
+}) => {
+  assert(versions, 'versions is required')
+  assert(coinInfo, 'coinInfo is required')
+
+  const bs58validateFactory = (version) =>
+    version === undefined
+      ? undefined
+      : (string) => {
+          const payload = bs58check.decodeUnsafe(string)
+          return payload && payload.length === 21 && payload[0] === version
+        }
+
+  const bech32ValidateFactory = (version, length) =>
+    version === undefined
+      ? undefined
+      : (string) => {
+          try {
+            const decoded = bech32.decode(string)
+            // bech32 lib normalizes prefixes, so not worrying about uppercase
+            if (decoded.prefix !== versions.bech32) return false
+            // NOTE: We only support version zero witness programs
+            if (decoded.words[0] !== 0) return false
+            // Ensure correct length
+            if (bech32.fromWords(decoded.words.slice(1)).length !== length) return false
+            return true
+          } catch (e) {
+            return false
+          }
+        }
+
+  const isP2PKH = validateFunctions.isP2PKH || bs58validateFactory(versions.p2pkh)
+  const isP2SH = validateFunctions.isP2SH || bs58validateFactory(versions.p2sh)
+  const isP2SH2 = validateFunctions.isP2SH2 || bs58validateFactory(versions.p2sh2)
+  const isP2WPKH = validateFunctions.isP2WPKH || bech32ValidateFactory(versions.bech32, 20)
+  const isP2WSH = validateFunctions.isP2WSH || bech32ValidateFactory(versions.bech32, 32)
+  const isP2TR =
+    validateFunctions.isP2TR ||
+    (useBip86 &&
+      bitcoinjsLib &&
+      ((addr) => {
+        try {
+          const network = coinInfo.toBitcoinJS()
+          bitcoinjsLib.payments.p2tr({ address: addr, network }, { eccLib: ecc })
+          return true
+        } catch (e) {
+          return false
+        }
+      })) ||
+    undefined
+
+  const purposeValidators = [
+    { purpose: 44, validator: isP2PKH },
+    { purpose: 49, validator: isP2SH },
+    { purpose: 84, validator: isP2WPKH },
+    { purpose: 86, validator: isP2TR },
+
+    // What are these 2?
+    // { purpose: ?, validator: isP2WSH },
+    // { purpose: ?, validator: isP2SH2 },
+  ].filter(({ validator }) => validator)
+
+  const resolvedValidateFunctions = pickBy(
+    {
+      isP2PKH,
+      isP2SH,
+      isP2SH2,
+      isP2WPKH,
+      isP2WSH,
+      isP2TR,
+    },
+    identity
+  )
+  const resolvePurpose = (string) =>
+    purposeValidators.find(({ validator }) => validator(string))?.purpose
+  const validate = (string) => Object.values(resolvedValidateFunctions).some((fn) => fn(string))
+
+  const toScriptPubKey =
+    coinInfo && bitcoinjsLib?.address?.toOutputScript
+      ? (string) => {
+          const network = coinInfo.toBitcoinJS()
+          return bitcoinjsLib.address.toOutputScript(string, network, ecc)
+        }
+      : undefined
+
+  return pickBy(
+    {
+      versions,
+      ...resolvedValidateFunctions,
+      validate,
+      resolvePurpose,
+      toScriptPubKey,
+      ...extraFunctions,
+    },
+    identity
+  )
+}

package/src/btc-like-keys.js

@@ -0,0 +1,142 @@
+import bs58check from 'bs58check'
+import secp256k1 from 'tiny-secp256k1'
+import wif from 'wif'
+import createHash from 'create-hash'
+import bech32 from 'bech32'
+import assert from 'minimalistic-assert'
+import { identity, pickBy } from 'lodash'
+import * as defaultBitcoinjsLib from '@exodus/bitcoinjs-lib'
+import { ecc } from './bitcoinjs-lib'
+
+export const createBtcLikeKeys = ({
+  coinInfo,
+  versions,
+  useBip86 = false,
+  bitcoinjsLib = defaultBitcoinjsLib,
+  extraFunctions = {},
+}) => {
+  assert(coinInfo, 'coinInfo is required')
+  assert(versions, 'versions is required')
+  const {
+    encodePrivate: encodePrivateCustom,
+    encodePublic: encodePublicCustom,
+    encodePublicFromWIF: encodePublicFromWIFCustom,
+    encodePublicBech32: encodePublicBech32Custom,
+    encodePublicBech32FromWIF: encodePublicBech32FromWIFCustom,
+    encodeNestedP2WPKH: encodeNestedP2WPKHCustom,
+    encodePublicTaproot: encodePublicTaprootCustom,
+    ...unknownExtraFunctions
+  } = extraFunctions
+  const encodePrivate =
+    encodePrivateCustom ||
+    ((privateKey, compressed = true) => {
+      return wif.encode(coinInfo.versions.private, privateKey, compressed)
+    })
+  const encodePublicPurpose44 =
+    encodePublicCustom ||
+    ((publicKey) => {
+      const sha = createHash('sha256')
+        .update(publicKey)
+        .digest()
+      const pubKeyHash = createHash('rmd160')
+        .update(sha)
+        .digest()
+      const payload = Buffer.concat([Buffer.from([versions.p2pkh]), pubKeyHash])
+      return bs58check.encode(payload)
+    })
+  const encodePublicFromWIF =
+    encodePublicFromWIFCustom ||
+    ((privateKeyWIF) => {
+      const { privateKey, compressed } = wif.decode(privateKeyWIF, coinInfo.versions.private)
+      const publicKey = secp256k1.pointFromScalar(privateKey, compressed)
+      return encodePublicPurpose44(publicKey)
+    })
+  const encodePublicBech32 =
+    encodePublicBech32Custom || versions.bech32 !== undefined
+      ? (publicKey) => {
+          const sha = createHash('sha256')
+            .update(publicKey)
+            .digest()
+          const pubKeyHash = createHash('rmd160')
+            .update(sha)
+            .digest()
+          const witnessVersion = Buffer.from([0])
+          const witnessProgram = Buffer.concat([
+            witnessVersion,
+            Buffer.from(bech32.toWords(pubKeyHash)),
+          ])
+          return bech32.encode(versions.bech32, witnessProgram)
+        }
+      : undefined
+  const encodePublicBech32FromWIF =
+    encodePublicBech32FromWIFCustom || encodePublicBech32
+      ? (privateKeyWIF) => {
+          // NOTE: No password support here
+          const { versions } = coinInfo
+          const { privateKey, compressed } = wif.decode(privateKeyWIF, versions.private)
+          const publicKey = secp256k1.pointFromScalar(privateKey, compressed)
+          return encodePublicBech32(publicKey)
+        }
+      : undefined
+
+  const encodeNestedP2WPKH =
+    encodeNestedP2WPKHCustom || bitcoinjsLib
+      ? (publicKey) => {
+          const witnessProgram = bitcoinjsLib.payments.p2wpkh({
+            pubkey: publicKey,
+          }).output
+
+          const witnessProgramHash = bitcoinjsLib.crypto.hash160(witnessProgram)
+          return bitcoinjsLib.address.toBase58Check(
+            witnessProgramHash,
+            coinInfo.versions.scripthash
+          )
+        }
+      : undefined
+
+  const encodePublicTaproot =
+    encodePublicTaprootCustom ||
+    (useBip86
+      ? (publicKey: Buffer): string => {
+          const network = coinInfo.toBitcoinJS()
+          return bitcoinjsLib.payments.p2tr(
+            { internalPubkey: publicKey.slice(1, 33), network },
+            { eccLib: ecc }
+          ).address
+        }
+      : undefined)
+
+  const encodePublic = (publicKey, meta) => {
+    assert(meta?.purpose, 'asset.keys.encodePublic requires meta.purpose')
+    const purpose = meta.purpose
+    const errorMessage = `asset.keys.encodePublic does not support purpose ${purpose}`
+    if (purpose === 44) {
+      assert(encodePublicPurpose44, errorMessage)
+      return encodePublicPurpose44(publicKey)
+    }
+    if (purpose === 49) {
+      assert(encodeNestedP2WPKH, errorMessage)
+      return encodeNestedP2WPKH(publicKey)
+    }
+    if (purpose === 84) {
+      assert(encodePublicBech32, errorMessage)
+      return encodePublicBech32(publicKey)
+    }
+    if (purpose === 86) {
+      assert(encodePublicTaproot, errorMessage)
+      return encodePublicTaproot(publicKey)
+    }
+    throw new Error(errorMessage)
+  }
+
+  return pickBy(
+    {
+      encodePrivate,
+      encodePublic,
+      encodePublicFromWIF,
+      encodePublicBech32FromWIF,
+      ...unknownExtraFunctions,
+    },
+    identity
+  )
+}

package/src/constants/bip44.js

@@ -0,0 +1,27 @@
+import bip44Constants from 'bip44-constants'
+
+// MOVE TO SHARED LIB!!!
+
+// Translate from
+//   array of [bip44, symbol, coin]
+// to
+//   map of symbol ---> bip44
+//
+// Careful: for duplicate symbols only the first definition gets stored.
+// Duplicate symbols: LTBC, DST, SAFE, BCO, RYO, XRD
+// Run tests to find all differences between existing and new constants.
+
+const _bip44Constants = {}
+for (let [c, t] of bip44Constants) {
+  if (!(t in _bip44Constants)) {
+    _bip44Constants[t] = c
+  }
+}
+
+// force NANO to 'Bitcoin Nano'
+_bip44Constants['NANO'] = 0x80000100
+_bip44Constants['HBAR'] = _bip44Constants['XHB']
+_bip44Constants['FLR'] = 0x8000022a
+_bip44Constants['EGLD'] = 0x800001fc
+
+export default _bip44Constants

package/src/index.js

@@ -0,0 +1,12 @@
+export * from './account-state'
+export * from './btc-address'
+export * from './btc-like-address'
+export * from './btc-like-keys'
+export * from './bitcoinjs-lib'
+export { default as InsightAPIClient } from './insight-api-client'
+export { default as bip44Constants } from './constants/bip44'
+export { default as createGetKeyIdentifier } from './key-identifier'
+
+export * from './utxos-utils'
+export * from './tx-log'
+export * from './unconfirmed-ancestor-data'

package/src/insight-api-client/index.js

@@ -0,0 +1,209 @@
+/* @flow */
+/* global fetch */
+import urlJoin from 'url-join'
+import qs from 'querystring'
+import delay from 'delay'
+
+// TODO: use p-retry
+async function fetchJsonRetry(url, fetchOptions) {
+  const waitTimes = [5, 10, 20, 30].map((t) => t * 1000)
+
+  let i = 0
+  while (true) {
+    try {
+      const data = await fetchJson(url, fetchOptions)
+      return data
+    } catch (e) {
+      if (i < waitTimes.length) {
+        await delay(waitTimes[i])
+        i++
+      } else {
+        throw e
+      }
+    }
+  }
+
+  async function fetchJson(url, fetchOptions) {
+    const response = await fetch(url, fetchOptions)
+    if (!response.ok) throw new Error(`${url} returned ${response.status}: ${response.statusText}`)
+    return response.json()
+  }
+}
+
+export default class InsightAPIClient {
+  constructor(baseURL) {
+    this._baseURL = baseURL
+  }
+
+  setBaseUrl(baseURL) {
+    this._baseURL = baseURL
+  }
+
+  async isNetworkConnected() {
+    let url = urlJoin(this._baseURL, '/peer')
+    let resp = await fetch(url, { timeout: 10000 })
+    let peerStatus = await resp.json()
+
+    return !!peerStatus.connected
+  }
+
+  /*
+  async fetchBalance (address) {
+    let addrData = await this.fetchAddress(address)
+    return (addrData.balanceSat + addrData.unconfirmedBalanceSat) | 0
+  }
+  */
+
+  async fetchBlockHeight() {
+    let url = urlJoin(this._baseURL, '/status')
+    let resp = await fetch(url, { timeout: 10000 })
+    let status = await resp.json()
+
+    return status.info.blocks
+  }
+
+  async fetchAddress(address, opts = { includeTxs: false }) {
+    let url = urlJoin(
+      this._baseURL,
+      opts.includeTxs ? `/addr/${address}` : `/addr/${address}?noTxList=1`
+    )
+    let response = await fetch(url)
+
+    return response.json()
+  }
+
+  async fetchUTXOs(addresses, { assetNames = [] } = {}) {
+    if (Array.isArray(addresses)) addresses = addresses.join(',')
+    let query = 'noCache=1'
+    if (assetNames) {
+      query = `${query}&assetNames=${assetNames.join(',')}`
+    }
+    let url = urlJoin(this._baseURL, `/addrs/${addresses}/utxo?${query}`)
+    let response = await fetch(url)
+    let utxos = await response.json()
+
+    return utxos.map((utxo) => ({
+      address: utxo.address,
+      txId: utxo.txid,
+      confirmations: utxo.confirmations || 0,
+      value: utxo.amount,
+      vout: utxo.vout,
+      height: utxo.height,
+      script: utxo.script,
+      asset: utxo.asset,
+    }))
+  }
+
+  async fetchTx(txId: string) {
+    let url = urlJoin(this._baseURL, `/tx/${txId}`)
+    let response = await fetch(url)
+
+    // change in https://github.com/jprichardson/exodus-rn/pull/4336 may break Insight compatibility
+    // we're probably past the point of just spinning up an Insight server and have it plug n' play for Magnifier
+
+    if (response.status === 404) return null
+    return response.json()
+  }
+
+  async fetchRawTx(txId: string) {
+    const url = urlJoin(this._baseURL, `/rawtx/${txId}`)
+    const response = await fetch(url)
+    const { rawtx } = await response.json()
+    return rawtx
+  }
+
+  async fetchTxData(addrs: Array, options = {}) {
+    if (!Array.isArray(addrs) || addrs.length === 0) return { items: [], totalItems: 0 }
+
+    options = { noScriptSig: 1, noAsm: 1, noSpent: 0, from: 0, to: 10, ...options }
+    let url = urlJoin(this._baseURL, `/addrs/txs`)
+    url = `${url}?${qs.stringify(options)}`
+
+    const fetchOptions = {
+      method: 'post',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ addrs: addrs.join(',') }),
+      timeout: 10000,
+    }
+
+    return fetchJsonRetry(url, fetchOptions)
+  }
+
+  async fetchAllTxData(addrs = [], chunk = 25, httpDelay = 2000, shouldStopFetching = () => {}) {
+    const txs = []
+    while (true) {
+      const data = await this.fetchTxData(addrs, { from: txs.length, to: txs.length + chunk })
+      if (!Array.isArray(data.items) || data.items.length === 0) break
+
+      txs.push(...data.items)
+      if ((data.totalItems && data.totalItems <= txs.length) || data.items.length < chunk) break
+
+      if (shouldStopFetching && (await shouldStopFetching(data.items))) break
+
+      await delay(httpDelay)
+    }
+
+    return txs
+  }
+
+  async fetchUnconfirmedAncestorData(txId: string) {
+    const url = urlJoin(this._baseURL, `/unconfirmed_ancestor/${txId}`)
+    const response = await fetch(url)
+    return response.json()
+  }
+
+  async fetchFeeRate() {
+    const url = urlJoin(this._baseURL, '/v2/fees')
+    const response = await fetch(url)
+    return response.json()
+  }
+
+  broadcastTx = async (rawTx) => {
+    console.log('gonna broadcastTx')
+    let url = urlJoin(this._baseURL, '/tx/send')
+    let fetchOptions = {
+      method: 'post',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ rawtx: rawTx }),
+    }
+
+    let response = await fetch(url, fetchOptions)
+    let data = await response.text()
+
+    if (!response.ok) {
+      console.warn('Insight Broadcast HTTP Error:')
+      console.warn(response.statusText)
+      console.warn(data)
+      throw new Error(`Insight Broadcast HTTP Error: ${data}`)
+    }
+
+    try {
+      data = JSON.parse(data)
+    } catch (err) {
+      console.warn('Insight Broadcast JSON Parse Error:', err.message, data)
+      throw new Error(`data: ${data}`, { cause: err })
+    }
+
+    if (!data.txid) throw new Error('transaction id was not returned')
+  }
+
+  async getClaimable(address) {
+    const url = urlJoin(this._baseURL, `/addr/${address}/claimable`)
+    const response = await fetch(url)
+    if (!response.ok) throw new Error(`${url} returned ${response.status}: ${response.statusText}`)
+    return response.json()
+  }
+
+  async getUnclaimed(address) {
+    const url = urlJoin(this._baseURL, `/addr/${address}/unclaimed`)
+    const response = await fetch(url)
+    if (!response.ok) throw new Error(`${url} returned ${response.status}: ${response.statusText}`)
+    return response.json()
+  }
+}