add option to not create fresh APIs for every read

src/util/types.ts

 export type Amount = number
 export type TxHash = string
 export type Options = {
-    debug: boolean,
-    connectionTimeout: number
-}
+    debug?: boolean
+    connectionTimeout?: number
+    readFreshApi?: boolean
+}
+
+export const defaultOptions = {
+    debug: false,
+    connectionTimeout: 100000,
+    readFreshApi: true
+  }

src/xrpIO/xrpl-binding.ts

-import { Memo, Options } from '../util/types'
+import { defaultOptions, Memo, Options } from '../util/types'
 import { Client, Payment, TxResponse, Wallet } from 'xrpl'
 
 import * as zlib from 'zlib'
 
   constructor(
     private server: string,
-    private options: Options = {
-      debug: false,
-      connectionTimeout: 100000
-    }
+    private options: Options = defaultOptions
   ) {
+
+    this.options.debug = this.options.debug ? Boolean(this.options.debug) : defaultOptions.debug
+    this.options.connectionTimeout = this.options.connectionTimeout ? Number(this.options.connectionTimeout) : defaultOptions.connectionTimeout
+    this.options.readFreshApi = this.options.readFreshApi ? Boolean(this.options.readFreshApi) : defaultOptions.readFreshApi
+
     this.api = new Client(server, {
       connectionTimeout: this.options.connectionTimeout
     })
   }
 
   public async disconnect(): Promise<void> {
-    try{
+    try {
       await this.api.disconnect()
-    }catch(e){
+    } catch (e) {
       console.log("DISCONNECT ERROR", e)
     }
   }
       connectionTimeout: this.options.connectionTimeout
     })
 
-    while(!_api.isConnected()){
-      try{
+    while (!_api.isConnected()) {
+      try {
         await _api.connect()
         return _api
-      }catch(e){
+      } catch (e) {
         this.dbg('CLONEAPI ERR', 'Connection failed', String(e['message']))
         await _api.disconnect()
         _api = new Client(this.server, {
 
   private async getTransaction(hash: string): Promise<TxResponse> {
     this.dbg("Getting Tx", hash)
-    let _api = await this.cloneApi()
 
-    while(true){
-      try{
-        const response = await _api.request({
-          command: 'tx',
-          transaction: hash,
-        })
-        await _api.disconnect()
-        return response
-      }catch(e){
-        this.dbg("Retrying to get", hash)
-        await _api.disconnect()
-        _api = await this.cloneApi()
+    if (this.options.readFreshApi) {
+      let _api = await this.cloneApi()
+      while (true) {
+        try {
+          const response = await _api.request({
+            command: 'tx',
+            transaction: hash,
+          })
+          await _api.disconnect()
+          return response
+        } catch (e) {
+          this.dbg("Retrying to get", hash)
+          await _api.disconnect()
+          _api = await this.cloneApi()
+        }
       }
+    }else{
+      return await this.api.request({
+        command: 'tx',
+        transaction: hash,
+      })
     }
   }
 
     data = await compressB64(data)
     const chunks = chunkString(data, PAYLOAD_SIZE)
     const latestSequence = await this.getAccountSequence(wallet.address)
-    const hashes = await Promise.all(Object.entries(chunks).map(([i, chunk]) => this.writeRaw({ data: chunk, format: format }, to, secret, latestSequence+Number(i))))
+    const hashes = await Promise.all(Object.entries(chunks).map(([i, chunk]) => this.writeRaw({ data: chunk, format: format }, to, secret, latestSequence + Number(i))))
 
     if (hashes.length === 1) {
       return hashes[0]
     return await this.treeWrite(JSON.stringify(hashes), to, secret, 'N')
   }
 
-  public async treeRead(hashes: string[]): Promise<string>{
+  public async treeRead(hashes: string[]): Promise<string> {
     const memos = await Promise.all(hashes.map(hash => this.readRaw(hash)))
     const payload: string = await decompressB64(memos.map(memo => memo.data).join(''))
-  
+
     if (memos.some(memo => memo.format === 'N')) {
       return await this.treeRead(JSON.parse(payload))
     }
-  
+
     return payload
   }
 
-  public async getAccountSequence(address: string): Promise<number>{
+  public async getAccountSequence(address: string): Promise<number> {
     this.dbg("Getting acc info for", address)
     const accountInfo = await this.api.request({
       command: 'account_info',

test/primitives.ts

 let receiveWallet: Wallet
 let api: xrpIO
 
-const ONLY_LARGE_TESTS = true
-
 describe('XRPIO', () => {
     before(async function(){
         this.timeout(15000)