How to use @liquality/errors - 10 common examples

if (!isString(txHash)) {
      throw new TypeError('Transaction hash should be a string')
    }

    if (!(/^[A-Fa-f0-9]+$/.test(txHash))) {
      throw new TypeError('Transaction hash should be a valid hex string')
    }

    const transaction = await this.client.getMethod('getTransactionByHash')(txHash)

    if (transaction) {
      const valid = this.validateTransaction(transaction)

      if (!valid) {
        const errors = this.validateTransaction.errors
        throw new InvalidProviderResponseError(`Provider returned an invalid transaction: ${errors[0].dataPath} ${errors[0].message}`)
      }
    }

    return transaction
  }

if (!isString(blockHash)) {
      throw new TypeError('Block hash should be a string')
    }

    if (!(/^[A-Fa-f0-9]+$/.test(blockHash))) {
      throw new TypeError('Block hash should be a valid hex string')
    }

    if (!isBoolean(includeTx)) {
      throw new TypeError('Second parameter should be boolean')
    }

    const block = await this.client.getMethod('getBlockByHash')(blockHash, includeTx)

    if (!this.validateBlock(block)) {
      throw new InvalidProviderResponseError('Provider returned an invalid block')
    }

    return block
  }

async generateBlock (numberOfBlocks) {
    if (!isNumber(numberOfBlocks)) {
      throw new TypeError('First argument should be a number')
    }

    const blockHashes = await this.client.getMethod('generateBlock')(numberOfBlocks)

    if (!isArray(blockHashes)) {
      throw new InvalidProviderResponseError('Response should be an array')
    }

    const invalidBlock = find(blockHashes, blockHash => !(/^[A-Fa-f0-9]+$/.test(blockHash)))

    if (invalidBlock) {
      throw new InvalidProviderResponseError('Invalid block(s) found in provider\'s reponse')
    }

    return blockHashes
  }

async generateBlock (numberOfBlocks) {
    if (!isNumber(numberOfBlocks)) {
      throw new TypeError('First argument should be a number')
    }

    const blockHashes = await this.client.getMethod('generateBlock')(numberOfBlocks)

    if (!isArray(blockHashes)) {
      throw new InvalidProviderResponseError('Response should be an array')
    }

    const invalidBlock = find(blockHashes, blockHash => !(/^[A-Fa-f0-9]+$/.test(blockHash)))

    if (invalidBlock) {
      throw new InvalidProviderResponseError('Invalid block(s) found in provider\'s reponse')
    }

    return blockHashes
  }

async getAddresses () {
    const addresses = await this.metamask('eth_accounts')

    if (addresses.length === 0) {
      throw new WalletError('Metamask: No addresses available from wallet')
    }

    return addresses.map((address) => { return new Address({ address: address }) })
  }

async getAddresses () {
    const addresses = await this.metamask('eth_accounts')

    if (addresses.length === 0) {
      throw new WalletError('Metamask: No addresses available from wallet')
    }

    return addresses.map((address) => { return new Address({ address: address }) })
  }

async getApp () {
    try {
      await this.createTransport()
    } catch (e) {
      const { name, ...errorNoName } = e
      throw new WalletError(e.toString(), errorNoName)
    }
    if (!this._appInstance) {
      this._appInstance = new Proxy(new this._App(this._transport), { get: this.errorProxy.bind(this) })
    }
    return this._appInstance
  }

.sendAsync({ method, params }, (err, data) => {
          debug('got', err, data)

          const error = err || data.error
          if (error) {
            reject(new WalletError(error.toString(), error))
            return
          }

          if (!data) {
            reject(new WalletError('Metamask response was empty'))
            return
          }

          if (typeof data.result === 'undefined') {
            reject(new WalletError('Metamask response was empty'))
            return
          }

          const formattedResult = formatEthResponse(data.result)

          resolve(formattedResult)

async assertNetworkMatch () {
    const connectedNetwork = await this.getConnectedNetwork()
    if (!isEqual(connectedNetwork, this._network)) {
      throw new WalletError(`Network mismatch. Configured network '${this._network.name}' does not match connected network '${connectedNetwork.name}'`)
    }
  }

async getApp () {
    try {
      await this.createTransport()
    } catch (e) {
      const { name, ...errorNoName } = e
      throw new WalletError(e.toString(), errorNoName)
    }
    if (!this._appInstance) {
      this._appInstance = new Proxy(new this._App(this._transport), { get: this.errorProxy.bind(this) })
    }
    return this._appInstance
  }