@com-chain/jsc3l 2.0.1-rc.2 → 2.0.1-rc.20

package/src/bcTransaction.ts

@@ -2,7 +2,7 @@
 import { getNakedAddress, padLeft, encodeNumber } from './ethereum/ethFuncs'
 import { generateTx } from './ethereum/uiFuncs'
 import AjaxReq from './rest/ajaxReq'
-
+import * as utils from './utils'
 
 function roundCent (strAmount:string) {
   return Math.round(100 * parseFloat(strAmount))
@@ -13,20 +13,26 @@ function typeConv (label: string): (x:any) => (string | number) {
   if (label.endsWith('Address')) {
     return (a) => padLeft(getNakedAddress(a), 64)
   }
+  if (label === 'int') {
+    return (nb) => encodeNumber(parseInt(nb, 10))
+  }
   if (label.startsWith('limit') || label === 'amount') {
     return (nb) => encodeNumber(roundCent(nb))
   }
-  if (label.endsWith('Status') || label.endsWith('Type')) {
+  if (label.endsWith('Status') || label.endsWith('Type') || label.endsWith('Int')) {
     return (nb) => encodeNumber(nb)
   }
+  if (label.endsWith('Hex')) {
+    return (s) => s.padEnd(128, '0')
+  }
   if (label === 'status') {
-    return (nb) => (parseInt(nb, 10) === 0 ? 0 : 1)
+    return (nb) => encodeNumber(parseInt(nb, 10) === 0 ? 0 : 1)
   }
   throw new Error(`Unexpected label '${label}' in FnDefs.`)
 }
 
 
-export default abstract class BcTransactionAbstract {
+export abstract class BcTransactionAbstract {
 
   abstract ajaxReq: AjaxReq
   abstract contracts: string[]
@@ -34,124 +40,147 @@ export default abstract class BcTransactionAbstract {
   // //////////////////////////////////////////////////////////////////////////
   //  CM VS Nant Handling
 
-  getSplitting (nantVal, cmVal, cmMinusLim, amount) {
-    cmVal = parseFloat(cmVal)
-    nantVal = parseFloat(nantVal)
-    let nant = 0
-    let cm = 0
-
-    let res = parseFloat(amount)
-    if (cmVal > 0) {
-      if (cmVal >= res) {
-        cm = res
-        res = 0
-      } else {
-        cm = cmVal
-        res = res - cmVal
-        cmVal = 0
-      }
-    }
-
-    if (nantVal > 0) {
-      if (nantVal >= res) {
-        nant = res
-        res = 0
-      } else {
-        nant = nantVal
-        res = res - nantVal
-        // nantVal=0;
-      }
-    }
-
-    if (res > 0 && cmVal - parseFloat(cmMinusLim) >= res) {
-      cm = cm + res
-      res = 0
+  static getSplitting (nantBal, cmBal, cmSrcMin, amount) {
+    console.warn("Obsolete usage of `BcTransactionAbstract.getSplitting()'," +
+                 " prefer `jsc3l.utils.getSplitting()'")
+    cmBal = parseFloat(cmBal)
+    nantBal = parseFloat(nantBal)
+    amount = parseFloat(amount)
+    cmSrcMin = parseFloat(cmSrcMin)
+
+    try {
+      let {nant, cm} = utils.getSplitting(amount, { cm: cmBal, nant: nantBal}, cmSrcMin)
+      return { possible: true, nant, cm}
+    } catch(e: any) {
+      return { possible: false}
     }
-
-    const possible = res === 0
-    return { possible: possible, nant: nant, cm: cm }
   }
+  getSplitting = BcTransactionAbstract.getSplitting
 
-  // //////////////////////////////////////////////////////////////////////////
+}
 
+/* @skip-prod-transpilation */
+if (import.meta.vitest) {
+  const { it, expect, describe } = import.meta.vitest
+  describe('split', () => {
+    it('should split 0 to cm: 0, nant: 0', () => {
+      expect(BcTransactionAbstract.getSplitting(0, 0, 0, 0))
+        .toStrictEqual({ possible: true, nant: 0, cm: 0})
+    });
+    it('should NOT split 1 with no funds', () => {
+      expect(BcTransactionAbstract.getSplitting(0, 0, 0, 1).possible)
+        .toBe(false)
+    });
+    // Only Cm
+    it('should split 1 to cm: 1, nant: 0 with bal cm: 2, nant: 0', () => {
+      expect(BcTransactionAbstract.getSplitting(0, 2, 0, 1))
+        .toStrictEqual({ possible: true, nant: 0, cm: 1})
+    });
+    it('should split 2 to cm: 2, nant: 0 with bal cm: 2, nant: 0', () => {
+      expect(BcTransactionAbstract.getSplitting(0, 2, 0, 2))
+        .toStrictEqual({ possible: true, nant: 0, cm: 2})
+    });
+    it('should NOT split 3 with bal cm: 2, nant: 0', () => {
+      expect(BcTransactionAbstract.getSplitting(0, 2, 0, 3).possible)
+        .toBe(false)
+    });
+    // Only Nant
+    it('should split 1 to cm: 0, nant: 1 with bal cm: 0, nant: 2', () => {
+      expect(BcTransactionAbstract.getSplitting(2, 0, 0, 1))
+        .toStrictEqual({ possible: true, nant: 1, cm: 0})
+    });
+    it('should split 2 to cm: 0, nant: 2 with bal cm: 0, nant: 2', () => {
+      expect(BcTransactionAbstract.getSplitting(2, 0, 0, 2))
+        .toStrictEqual({ possible: true, nant: 2, cm: 0})
+    });
+    it('should NOT split 3 with bal cm: 0, nant: 2', () => {
+      expect(BcTransactionAbstract.getSplitting(2, 0, 0, 3).possible)
+        .toBe(false)
+    });
+    // Both Nant and Cm
+    it('should split 2 to cm: 1, nant: 1 with bal cm: 1, nant: 1', () => {
+      expect(BcTransactionAbstract.getSplitting(1, 1, 0, 2))
+        .toStrictEqual({ possible: true, nant: 1, cm: 1})
+    });
+    it('should split 2 to cm: 0, nant: 2 with bal cm: 0, nant: 2 (limSrcCm: -2)', () => {
+      expect(BcTransactionAbstract.getSplitting(2, 0, -2, 2))
+        .toStrictEqual({ possible: true, nant: 2, cm: 0})
+    });
+    it('should split 2 to cm: 1, nant: 1 with bal cm: 0, nant: 1 (limSrcCm: -1)', () => {
+      expect(BcTransactionAbstract.getSplitting(1, 0, -1, 2))
+        .toStrictEqual({ possible: true, nant: 1, cm: 1})
+    });
+    it('should NOT split 3 with bal cm: 0, nant: 1 (limSrcCm: -1)', () => {
+      expect(BcTransactionAbstract.getSplitting(1, 0, -1, 3).possible)
+        .toBe(false)
+    });
+    it('should split 3 to cm: 2, nant: 1 with bal cm: 1, nant: 1 (limSrcCm: -1)', () => {
+      expect(BcTransactionAbstract.getSplitting(1, 1, -1, 3))
+        .toStrictEqual({ possible: true, nant: 1, cm: 2})
+    });
+    // Negative cm bal and limSrcCm
+    it('should split 1 to cm: -1, nant: 0 with bal cm: -1, nant: 0 (limSrcCm: -2)', () => {
+      expect(BcTransactionAbstract.getSplitting(0, -1, -2, 1))
+        .toStrictEqual({ possible: true, nant: 0, cm: 1})
+    });
+    it('should NOT split 2 with bal cm: -1, nant: 0 (limSrcCm: -2)', () => {
+      expect(BcTransactionAbstract.getSplitting(0, -1, -2, 2).possible)
+        .toBe(false)
+    });
+
+  });
 }
 
+export function transactionFactory(transactionDefs: any[], bcTransactionClass: any) {
 
-[
-  // First Contract
-  {
-    setAccountParam: '848b2592:accAddress accStatus accType limitPlus limitMinus',
-    pledgeAccount: '6c343eef:accAddress amount *',
-    setAllowance: 'd4e12f2e:spenderAddress amount',
-    setDelegation: '75741c79:spenderAddress limit',
-    setTaxAmount: 'f6f1897d:amount',
-    setTaxLegAmount: 'fafaf4c0:amount',
-    setTaxAccount: 'd0385b5e:accAddress',
-    setOwnerAccount: 'f2fde38b:accAddress',
-    setContractStatus: '0x88b8084f:status',
-  },
-  // Second Contract
-  {
-    transferNant: 'a5f7c148:toAddress amount *',
-    transferCM: '60ca9c4c:toAddress amount *',
-    transferOnBehalfNant: '1b6b1ee5:fromAddress toAddress amount D',
-    transferOnBehalfCM: '74c421fe:fromAddress toAddress amount D',
-    askTransferFrom: '58258353:fromAddress amount',
-    askTransferCMFrom: '2ef9ade2:fromAddress amount',
-    payRequestNant: '132019f4:toAddress amount *',
-    payRequestCM: '1415707c:toAddress amount *',
-    rejectRequest: 'af98f757:toAddress',
-    dismissAcceptedInfo: 'ccf93c7a:accAddress',
-    dismissRejectedInfo: '88759215:accAddress',
-  }
-].forEach((contractFnDefs, contractNb) => {
-
-  for (const fnName in contractFnDefs) {
-
-    const [fnHash, argStringList] = contractFnDefs[fnName].split(':')
-    const argList = argStringList.split(' ')
-    let hasAdditionalPostData = false
-    let hasDelegate = false
-    if (argList.slice(-1)[0] === '*') {
-      hasAdditionalPostData = true
-      argList.pop()
-    } else if (argList.slice(-1)[0] === 'D') {
-      hasAdditionalPostData = true
-      hasDelegate = true
-      argList.pop()
-    }
+  transactionDefs.forEach((contractFnDefs, contractNb) => {
 
-    // Build argument array function
-    const argFnList = argList.map((arg) => typeConv(arg))
-    const concatArgs = (args) =>
-      args.map((arg, idx) => argFnList[idx](arg)).join('')
-
-    BcTransactionAbstract.prototype[fnName] = async function (wallet, ...args) {
-      const addr = wallet.getAddressString()
-      const data = await this.ajaxReq.getTransactionData(addr)
-      // TODO: must test this
-      if (data.error) {
-        console.log(`Failed getTransactionData(${addr})`)
-        throw new Error(data.msg)
+    for (const fnName in contractFnDefs) {
+
+      const [fnHash, argStringList] = contractFnDefs[fnName].split(':')
+      const argList = argStringList.split(' ')
+      let hasAdditionalPostData = false
+      let hasDelegate = false
+      if (argList.slice(-1)[0] === '*') {
+        hasAdditionalPostData = true
+        argList.pop()
+      } else if (argList.slice(-1)[0] === 'D') {
+        hasAdditionalPostData = true
+        hasDelegate = true
+        argList.pop()
       }
-      const additionalPostData = hasAdditionalPostData ? args.pop() : {}
-      if (hasDelegate) {
-        additionalPostData.delegate = wallet.getAddressString()
+
+      // Build argument array function
+      const argFnList = argList.map((arg) => typeConv(arg))
+      const concatArgs = (args) =>
+        args.map((arg, idx) => argFnList[idx](arg)).join('')
+
+      bcTransactionClass.prototype[fnName] = async function (wallet, ...args) {
+        const addr = wallet.getAddressString()
+        const data = await this.ajaxReq.getTransactionData(addr)
+        // TODO: must test this
+        if (data.error) {
+          console.log(`Failed getTransactionData(${addr})`)
+          throw new Error(data.msg)
+        }
+        const additionalPostData = hasAdditionalPostData ? args.pop() : {}
+        if (hasDelegate) {
+          additionalPostData.delegate = wallet.getAddressString()
+        }
+        const rawSignedTx = generateTx({
+          gasLimit: 500000,
+          data: fnHash + concatArgs(args),
+          to: this.contracts[contractNb],
+          unit: 'ether',
+          value: 0,
+          nonce: 1,
+          gasPrice: null,
+          donate: false,
+          from: addr,
+          key: wallet.getPrivateKeyString()
+        }, data)
+        return this.ajaxReq.sendTx(rawSignedTx, additionalPostData)
       }
-      const rawTx = generateTx({
-        gasLimit: 500000,
-        data: fnHash + concatArgs(args),
-        to: this.contracts[contractNb],
-        unit: 'ether',
-        value: 0,
-        nonce: 1,
-        gasPrice: null,
-        donate: false,
-        from: addr,
-        key: wallet.getPrivateKeyString()
-      }, data)
-      if (rawTx.isError) return rawTx
-      return this.ajaxReq.sendTx(rawTx.signedTx, additionalPostData)
     }
-  }
-})
+  })
+}

package/src/config/transactions.ts

@@ -0,0 +1,30 @@
+
+
+export default [
+  // First Contract
+  {
+    setAccountParam: '848b2592:accAddress accStatus accType limitPlus limitMinus',
+    pledgeAccount: '6c343eef:accAddress amount *',
+    setAllowance: 'd4e12f2e:spenderAddress amount',
+    setDelegation: '75741c79:spenderAddress limit',
+    setTaxAmount: 'f6f1897d:int',
+    setTaxLegAmount: 'fafaf4c0:int',
+    setTaxAccount: 'd0385b5e:accAddress',
+    setOwnerAccount: 'f2fde38b:accAddress',
+    setContractStatus: '88b8084f:status',
+  },
+  // Second Contract
+  {
+    transferNant: 'a5f7c148:toAddress amount *',
+    transferCM: '60ca9c4c:toAddress amount *',
+    transferOnBehalfNant: '1b6b1ee5:fromAddress toAddress amount D',
+    transferOnBehalfCM: '74c421fe:fromAddress toAddress amount D',
+    askTransferFrom: '58258353:fromAddress amount',
+    askTransferCMFrom: '2ef9ade2:fromAddress amount',
+    payRequestNant: '132019f4:toAddress amount *',
+    payRequestCM: '1415707c:toAddress amount *',
+    rejectRequest: 'af98f757:toAddress',
+    dismissAcceptedInfo: 'ccf93c7a:accAddress',
+    dismissRejectedInfo: '88759215:accAddress',
+  },
+]

package/src/connection.ts

@@ -1,7 +1,11 @@
 import * as config from './config'
 import HttpAbstract from './rest/http'
 import * as t from './type'
+import * as e from './exception'
 
+const wait = async (ms: number): Promise<void> => {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
 
 abstract class ConnectionAbstract {
 
@@ -36,15 +40,42 @@ abstract class ConnectionAbstract {
   public async acquireEndPoint (repo: string) {
     const apiNodes = await this.getCCEndPointList(repo)
     if (!apiNodes) return false
-    const endpoint = await this.selectEndPoint(apiNodes)
+    let endpoint: boolean | string = false
+    let retry = 30
+    let count = 0
+    console.log(`Pick first endpoint that pass checkdb test`)
+    while (!endpoint) {
+      if (count >= 1) {
+        await wait(200)
+        console.log(`No endpoints passed the checkdb test... retry (${count}/${retry})`)
+      }
+      endpoint = await this.selectEndPoint([...apiNodes])
+      count++
+      if (count >= retry) {
+        break
+      }
+    }
+    if (typeof endpoint === 'string') {
+      console.log(`  endpoint ${endpoint} %cpassed%c the checkdb test`,
+                  'color: #0b0;', 'color: none')
+    } else {
+      console.log(`Failed to find a functional endpoint passing checkdb.`)
+    }
     return { apiNodes, endpoint }
   }
 
   ///
   // [Lower level] Get the list of ComChain end-points from given repo
   ///
-  getCCEndPointList (repo: string) {
-    return this.http.get(repo + config.nodesRepo, { _: new Date().getTime() })
+  async getCCEndPointList (repo: string) {
+    try {
+      return await this.http.get(
+        repo + config.nodesRepo,
+        { _: new Date().getTime() })
+    } catch (e) {
+      console.error(`Failed to get endpoint list on ${repo}`, e)
+      return false
+    }
   }
 
   ///
@@ -59,6 +90,7 @@ abstract class ConnectionAbstract {
       // check the node is up and running
       const success = await this.testNode(node)
       if (success) return node
+      console.log(`  endpoint ${node} %cfailed%c the checkdb test`, 'color: #b00;', 'color:none')
       nodes.splice(id, 1)
     }
     return false
@@ -187,7 +219,7 @@ export default abstract class ConnectionMgrAbstract extends ConnectionAbstract {
     }
     const { apiNodes, endpoint } = apiNodesEndpoint
     if (typeof endpoint !== 'string') {
-      throw new Error('No endpoint in list seems available.')
+      throw new e.NoEndpointAvailable('No endpoint in list seems available.')
     }
 
     this.persistentStore.set('ApiNodes', JSON.stringify(apiNodes))
@@ -232,11 +264,12 @@ export default abstract class ConnectionMgrAbstract extends ConnectionAbstract {
   public getLocalConfJSON () {
     if (this.conf) return this.conf
     const cfgJson = this.persistentStore.get('ServerConf')
-    if (!cfgJson) return null
-    const cfg = JSON.parse(cfgJson)
-    // Completing with other informations
-    cfg.repo = this.repo
-    cfg.custoRepo = this.repo + config.custoRepo
+    const cfg = cfgJson ? JSON.parse(cfgJson) : {}
+    // Completing with other informations if available
+    if (this.repo) {
+      cfg.repo = this.repo
+      cfg.custoRepo = this.repo + config.custoRepo
+    }
     return cfg
   }
 

package/src/customization.ts

@@ -131,14 +131,25 @@ export default abstract class CustomizationAbstract {
     if (!currencyName) {
       currencyName = this.cfg.server.name
     }
+    if (!this.cfg.custoRepo) {
+      throw Error(
+        'Requested getCurrencyAssetBaseUrl while configuration is not available (yet?)'
+      )
+    }
     return `${this.cfg.custoRepo}${currencyName}`
   }
 
   public getCssUrl (currencyName?: string) {
     try {
-      // XXXvlab: I guess that we don't need to keep 'etherwallet' css names
-      return `${this.getCurrencyAssetBaseUrl(currencyName)}/css/etherwallet-master.min.css`
+      // XXXvlab: I guess that we don't need to keep 'etherwallet' css
+      // names
+      return this.getCurrencyAssetBaseUrl(currencyName) +
+        '/css/etherwallet-master.min.css'
     } catch (e) {
+      console.log(
+        '`customization.getCssUrl(..)` called before configuration was ' +
+          "ready. Returning `localDefaultConf`'s value."
+      )
       return this.localDefaultConf.server.url_Css
     }
   }
@@ -149,6 +160,10 @@ export default abstract class CustomizationAbstract {
       // be agnostic ?
       return `${this.getCurrencyAssetBaseUrl(currencyName)}/images/lem.png`
     } catch (e) {
+      console.log(
+        '`customization.getCurrencyLogoUrl(..)` called before configuration ' +
+        'was ready. Returning empty string.'
+      )
       return ''
     }
   }

package/src/ethereum/ethFuncs.ts

@@ -36,7 +36,7 @@ function padLeftEven (hex) {
 }
 
 export function addTinyMoreToGas (hex) {
-  hex = this.sanitizeHex(hex)
+  hex = sanitizeHex(hex)
   return new BigNumber(hex).plus(etherUnits.getValueOfUnit('gwei'))
     .toDigits(2).toString(16)
 }
@@ -71,3 +71,44 @@ export function encodeNumber (number) {
 
   return valueHex
 }
+
+
+/* @skip-prod-transpilation */
+if (import.meta.vitest) {
+  const { it, expect, describe } = import.meta.vitest
+  describe('encodeNumber', () => {
+    it('should encode 0 to "00...0000"', () => {
+      expect(encodeNumber(0)).toBe('0000000000000000000000000000000000000000000000000000000000000000')
+    })
+    it('should encode 1 to "00...0001"', () => {
+      expect(encodeNumber(1)).toBe('0000000000000000000000000000000000000000000000000000000000000001')
+    })
+    it('should encode 16 to "00...0010"', () => {
+      expect(encodeNumber(16)).toBe('0000000000000000000000000000000000000000000000000000000000000010')
+    })
+    it('should encode 0x1f_ffff_ffff_ffff to "00...001f_ffff_ffff_ffff"', () => {
+      expect(encodeNumber(0x1f_ffff_ffff_ffff)).toBe('000000000000000000000000000000000000000000000000001fffffffffffff')
+    })
+
+    it('should encode -1 to "ff...ffff"', () => {
+      expect(encodeNumber(-1)).toBe('ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
+    })
+    it('should encode -0xf to "ff...fff1"', () => {
+      expect(encodeNumber(-0xf)).toBe('fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1')
+    })
+    it('should encode -0x10 to "ff...fff0"', () => {
+      expect(encodeNumber(-0x10)).toBe('fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0')
+    })
+    it('should encode -0x1f_ffff_ffff_fffff to "ff...ffe0_0000_0000_0001"', () => {
+      expect(encodeNumber(-0x1f_ffff_ffff_ffff)).toBe('ffffffffffffffffffffffffffffffffffffffffffffffffffe0000000000001')
+    })
+
+    it('should refuse to encode 0x20_0000_0000_0000', () => {
+      expect(() => encodeNumber(0x20_0000_0000_0000)).toThrowError('number type')
+    })
+    it('should refuse to encode -0x20_0000_0000_0000', () => {
+      expect(() => encodeNumber(-0x20_0000_0000_0000)).toThrowError('number type')
+    })
+
+  })
+}

package/src/ethereum/etherUnits.ts

@@ -41,26 +41,26 @@ export function getValueOfUnit (unit) {
 export function fiatToWei (number, pricePerEther) {
   return new BigNumber(String(number))
     .div(pricePerEther)
-    .times(this.getValueOfUnit('ether'))
+    .times(getValueOfUnit('ether'))
     .round(0)
     .toString(10)
 }
 
 export function toFiat (number, unit, multi) {
-  return new BigNumber(this.toEther(number, unit))
+  return new BigNumber(toEther(number, unit))
     .times(multi)
     .round(5)
     .toString(10)
 }
 
 export function toEther (number, unit) {
-  return new BigNumber(this.toWei(number, unit))
-    .div(this.getValueOfUnit('ether'))
+  return new BigNumber(toWei(number, unit))
+    .div(getValueOfUnit('ether'))
     .toString(10)
 }
 
 export function toWei (number, unit) {
   return new BigNumber(String(number))
-    .times(this.getValueOfUnit(unit))
+    .times(getValueOfUnit(unit))
     .toString(10)
 }

package/src/ethereum/uiFuncs.ts

@@ -24,32 +24,23 @@ function isTxDataValid (txData) {
 }
 
 export function generateTx (txData, data) {
-  try {
-    isTxDataValid(txData)
+  isTxDataValid(txData)
 
-    const rawTx: {[k: string]: any} = {
-      nonce: ethFuncs.sanitizeHex(data.nonce),
-      gasPrice: ethFuncs.sanitizeHex(
-        ethFuncs.addTinyMoreToGas(data.gasprice)),
-      gasLimit: ethFuncs.sanitizeHex(
-        ethFuncs.decimalToHex(txData.gasLimit)),
-      to: ethFuncs.sanitizeHex(txData.to),
-      value: ethFuncs.sanitizeHex(
-        ethFuncs.decimalToHex(etherUnits.toWei(txData.value, txData.unit))),
-      data: ethFuncs.sanitizeHex(txData.data)
-    }
-    const eTx = new Tx(rawTx)
-
-    eTx.sign(Buffer.from(txData.key, 'hex'))
-    rawTx.rawTx = JSON.stringify(rawTx)
-    rawTx.signedTx = '0x' + eTx.serialize().toString('hex')
-    rawTx.isError = false
-    return rawTx
-  } catch (e) {
-    return {
-      isError: true,
-      error: e
-    }
+  const rawTx: {[k: string]: any} = {
+    nonce: ethFuncs.sanitizeHex(data.nonce),
+    gasPrice: ethFuncs.sanitizeHex(
+      ethFuncs.addTinyMoreToGas(data.gasprice)),
+    gasLimit: ethFuncs.sanitizeHex(
+      ethFuncs.decimalToHex(txData.gasLimit)),
+    to: ethFuncs.sanitizeHex(txData.to),
+    value: ethFuncs.sanitizeHex(
+      ethFuncs.decimalToHex(etherUnits.toWei(txData.value, txData.unit))),
+    data: ethFuncs.sanitizeHex(txData.data)
   }
+  const eTx = new Tx(rawTx)
+
+  eTx.sign(Buffer.from(txData.key, 'hex'))
+  rawTx.rawTx = JSON.stringify(rawTx)
+  return '0x' + eTx.serialize().toString('hex')
 }
 

package/src/exception.ts

@@ -0,0 +1,16 @@
+export class APIError extends Error {
+  data: string
+  constructor (message, data) {
+    super(message)
+    this.name = 'APIError'
+    this.data = data
+  }
+}
+
+export class NoEndpointAvailable extends Error {
+  data: string
+  constructor (message) {
+    super(message)
+    this.name = 'NoEndpointAvailable'
+  }
+}