koilib 2.6.0 → 2.8.0

package/dist/koinos.js

@@ -2887,567 +2887,6 @@ utf8.write = function utf8_write(string, buffer, offset) {
 };
 
 
-/***/ }),
-
-/***/ 4098:
-/***/ (function(module, exports) {
-
-var global = typeof self !== 'undefined' ? self : this;
-var __self__ = (function () {
-function F() {
-this.fetch = false;
-this.DOMException = global.DOMException
-}
-F.prototype = global;
-return new F();
-})();
-(function(self) {
-
-var irrelevant = (function (exports) {
-
-  var support = {
-    searchParams: 'URLSearchParams' in self,
-    iterable: 'Symbol' in self && 'iterator' in Symbol,
-    blob:
-      'FileReader' in self &&
-      'Blob' in self &&
-      (function() {
-        try {
-          new Blob();
-          return true
-        } catch (e) {
-          return false
-        }
-      })(),
-    formData: 'FormData' in self,
-    arrayBuffer: 'ArrayBuffer' in self
-  };
-
-  function isDataView(obj) {
-    return obj && DataView.prototype.isPrototypeOf(obj)
-  }
-
-  if (support.arrayBuffer) {
-    var viewClasses = [
-      '[object Int8Array]',
-      '[object Uint8Array]',
-      '[object Uint8ClampedArray]',
-      '[object Int16Array]',
-      '[object Uint16Array]',
-      '[object Int32Array]',
-      '[object Uint32Array]',
-      '[object Float32Array]',
-      '[object Float64Array]'
-    ];
-
-    var isArrayBufferView =
-      ArrayBuffer.isView ||
-      function(obj) {
-        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
-      };
-  }
-
-  function normalizeName(name) {
-    if (typeof name !== 'string') {
-      name = String(name);
-    }
-    if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name)) {
-      throw new TypeError('Invalid character in header field name')
-    }
-    return name.toLowerCase()
-  }
-
-  function normalizeValue(value) {
-    if (typeof value !== 'string') {
-      value = String(value);
-    }
-    return value
-  }
-
-  // Build a destructive iterator for the value list
-  function iteratorFor(items) {
-    var iterator = {
-      next: function() {
-        var value = items.shift();
-        return {done: value === undefined, value: value}
-      }
-    };
-
-    if (support.iterable) {
-      iterator[Symbol.iterator] = function() {
-        return iterator
-      };
-    }
-
-    return iterator
-  }
-
-  function Headers(headers) {
-    this.map = {};
-
-    if (headers instanceof Headers) {
-      headers.forEach(function(value, name) {
-        this.append(name, value);
-      }, this);
-    } else if (Array.isArray(headers)) {
-      headers.forEach(function(header) {
-        this.append(header[0], header[1]);
-      }, this);
-    } else if (headers) {
-      Object.getOwnPropertyNames(headers).forEach(function(name) {
-        this.append(name, headers[name]);
-      }, this);
-    }
-  }
-
-  Headers.prototype.append = function(name, value) {
-    name = normalizeName(name);
-    value = normalizeValue(value);
-    var oldValue = this.map[name];
-    this.map[name] = oldValue ? oldValue + ', ' + value : value;
-  };
-
-  Headers.prototype['delete'] = function(name) {
-    delete this.map[normalizeName(name)];
-  };
-
-  Headers.prototype.get = function(name) {
-    name = normalizeName(name);
-    return this.has(name) ? this.map[name] : null
-  };
-
-  Headers.prototype.has = function(name) {
-    return this.map.hasOwnProperty(normalizeName(name))
-  };
-
-  Headers.prototype.set = function(name, value) {
-    this.map[normalizeName(name)] = normalizeValue(value);
-  };
-
-  Headers.prototype.forEach = function(callback, thisArg) {
-    for (var name in this.map) {
-      if (this.map.hasOwnProperty(name)) {
-        callback.call(thisArg, this.map[name], name, this);
-      }
-    }
-  };
-
-  Headers.prototype.keys = function() {
-    var items = [];
-    this.forEach(function(value, name) {
-      items.push(name);
-    });
-    return iteratorFor(items)
-  };
-
-  Headers.prototype.values = function() {
-    var items = [];
-    this.forEach(function(value) {
-      items.push(value);
-    });
-    return iteratorFor(items)
-  };
-
-  Headers.prototype.entries = function() {
-    var items = [];
-    this.forEach(function(value, name) {
-      items.push([name, value]);
-    });
-    return iteratorFor(items)
-  };
-
-  if (support.iterable) {
-    Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
-  }
-
-  function consumed(body) {
-    if (body.bodyUsed) {
-      return Promise.reject(new TypeError('Already read'))
-    }
-    body.bodyUsed = true;
-  }
-
-  function fileReaderReady(reader) {
-    return new Promise(function(resolve, reject) {
-      reader.onload = function() {
-        resolve(reader.result);
-      };
-      reader.onerror = function() {
-        reject(reader.error);
-      };
-    })
-  }
-
-  function readBlobAsArrayBuffer(blob) {
-    var reader = new FileReader();
-    var promise = fileReaderReady(reader);
-    reader.readAsArrayBuffer(blob);
-    return promise
-  }
-
-  function readBlobAsText(blob) {
-    var reader = new FileReader();
-    var promise = fileReaderReady(reader);
-    reader.readAsText(blob);
-    return promise
-  }
-
-  function readArrayBufferAsText(buf) {
-    var view = new Uint8Array(buf);
-    var chars = new Array(view.length);
-
-    for (var i = 0; i < view.length; i++) {
-      chars[i] = String.fromCharCode(view[i]);
-    }
-    return chars.join('')
-  }
-
-  function bufferClone(buf) {
-    if (buf.slice) {
-      return buf.slice(0)
-    } else {
-      var view = new Uint8Array(buf.byteLength);
-      view.set(new Uint8Array(buf));
-      return view.buffer
-    }
-  }
-
-  function Body() {
-    this.bodyUsed = false;
-
-    this._initBody = function(body) {
-      this._bodyInit = body;
-      if (!body) {
-        this._bodyText = '';
-      } else if (typeof body === 'string') {
-        this._bodyText = body;
-      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
-        this._bodyBlob = body;
-      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
-        this._bodyFormData = body;
-      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
-        this._bodyText = body.toString();
-      } else if (support.arrayBuffer && support.blob && isDataView(body)) {
-        this._bodyArrayBuffer = bufferClone(body.buffer);
-        // IE 10-11 can't handle a DataView body.
-        this._bodyInit = new Blob([this._bodyArrayBuffer]);
-      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
-        this._bodyArrayBuffer = bufferClone(body);
-      } else {
-        this._bodyText = body = Object.prototype.toString.call(body);
-      }
-
-      if (!this.headers.get('content-type')) {
-        if (typeof body === 'string') {
-          this.headers.set('content-type', 'text/plain;charset=UTF-8');
-        } else if (this._bodyBlob && this._bodyBlob.type) {
-          this.headers.set('content-type', this._bodyBlob.type);
-        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
-          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
-        }
-      }
-    };
-
-    if (support.blob) {
-      this.blob = function() {
-        var rejected = consumed(this);
-        if (rejected) {
-          return rejected
-        }
-
-        if (this._bodyBlob) {
-          return Promise.resolve(this._bodyBlob)
-        } else if (this._bodyArrayBuffer) {
-          return Promise.resolve(new Blob([this._bodyArrayBuffer]))
-        } else if (this._bodyFormData) {
-          throw new Error('could not read FormData body as blob')
-        } else {
-          return Promise.resolve(new Blob([this._bodyText]))
-        }
-      };
-
-      this.arrayBuffer = function() {
-        if (this._bodyArrayBuffer) {
-          return consumed(this) || Promise.resolve(this._bodyArrayBuffer)
-        } else {
-          return this.blob().then(readBlobAsArrayBuffer)
-        }
-      };
-    }
-
-    this.text = function() {
-      var rejected = consumed(this);
-      if (rejected) {
-        return rejected
-      }
-
-      if (this._bodyBlob) {
-        return readBlobAsText(this._bodyBlob)
-      } else if (this._bodyArrayBuffer) {
-        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
-      } else if (this._bodyFormData) {
-        throw new Error('could not read FormData body as text')
-      } else {
-        return Promise.resolve(this._bodyText)
-      }
-    };
-
-    if (support.formData) {
-      this.formData = function() {
-        return this.text().then(decode)
-      };
-    }
-
-    this.json = function() {
-      return this.text().then(JSON.parse)
-    };
-
-    return this
-  }
-
-  // HTTP methods whose capitalization should be normalized
-  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];
-
-  function normalizeMethod(method) {
-    var upcased = method.toUpperCase();
-    return methods.indexOf(upcased) > -1 ? upcased : method
-  }
-
-  function Request(input, options) {
-    options = options || {};
-    var body = options.body;
-
-    if (input instanceof Request) {
-      if (input.bodyUsed) {
-        throw new TypeError('Already read')
-      }
-      this.url = input.url;
-      this.credentials = input.credentials;
-      if (!options.headers) {
-        this.headers = new Headers(input.headers);
-      }
-      this.method = input.method;
-      this.mode = input.mode;
-      this.signal = input.signal;
-      if (!body && input._bodyInit != null) {
-        body = input._bodyInit;
-        input.bodyUsed = true;
-      }
-    } else {
-      this.url = String(input);
-    }
-
-    this.credentials = options.credentials || this.credentials || 'same-origin';
-    if (options.headers || !this.headers) {
-      this.headers = new Headers(options.headers);
-    }
-    this.method = normalizeMethod(options.method || this.method || 'GET');
-    this.mode = options.mode || this.mode || null;
-    this.signal = options.signal || this.signal;
-    this.referrer = null;
-
-    if ((this.method === 'GET' || this.method === 'HEAD') && body) {
-      throw new TypeError('Body not allowed for GET or HEAD requests')
-    }
-    this._initBody(body);
-  }
-
-  Request.prototype.clone = function() {
-    return new Request(this, {body: this._bodyInit})
-  };
-
-  function decode(body) {
-    var form = new FormData();
-    body
-      .trim()
-      .split('&')
-      .forEach(function(bytes) {
-        if (bytes) {
-          var split = bytes.split('=');
-          var name = split.shift().replace(/\+/g, ' ');
-          var value = split.join('=').replace(/\+/g, ' ');
-          form.append(decodeURIComponent(name), decodeURIComponent(value));
-        }
-      });
-    return form
-  }
-
-  function parseHeaders(rawHeaders) {
-    var headers = new Headers();
-    // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
-    // https://tools.ietf.org/html/rfc7230#section-3.2
-    var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
-    preProcessedHeaders.split(/\r?\n/).forEach(function(line) {
-      var parts = line.split(':');
-      var key = parts.shift().trim();
-      if (key) {
-        var value = parts.join(':').trim();
-        headers.append(key, value);
-      }
-    });
-    return headers
-  }
-
-  Body.call(Request.prototype);
-
-  function Response(bodyInit, options) {
-    if (!options) {
-      options = {};
-    }
-
-    this.type = 'default';
-    this.status = options.status === undefined ? 200 : options.status;
-    this.ok = this.status >= 200 && this.status < 300;
-    this.statusText = 'statusText' in options ? options.statusText : 'OK';
-    this.headers = new Headers(options.headers);
-    this.url = options.url || '';
-    this._initBody(bodyInit);
-  }
-
-  Body.call(Response.prototype);
-
-  Response.prototype.clone = function() {
-    return new Response(this._bodyInit, {
-      status: this.status,
-      statusText: this.statusText,
-      headers: new Headers(this.headers),
-      url: this.url
-    })
-  };
-
-  Response.error = function() {
-    var response = new Response(null, {status: 0, statusText: ''});
-    response.type = 'error';
-    return response
-  };
-
-  var redirectStatuses = [301, 302, 303, 307, 308];
-
-  Response.redirect = function(url, status) {
-    if (redirectStatuses.indexOf(status) === -1) {
-      throw new RangeError('Invalid status code')
-    }
-
-    return new Response(null, {status: status, headers: {location: url}})
-  };
-
-  exports.DOMException = self.DOMException;
-  try {
-    new exports.DOMException();
-  } catch (err) {
-    exports.DOMException = function(message, name) {
-      this.message = message;
-      this.name = name;
-      var error = Error(message);
-      this.stack = error.stack;
-    };
-    exports.DOMException.prototype = Object.create(Error.prototype);
-    exports.DOMException.prototype.constructor = exports.DOMException;
-  }
-
-  function fetch(input, init) {
-    return new Promise(function(resolve, reject) {
-      var request = new Request(input, init);
-
-      if (request.signal && request.signal.aborted) {
-        return reject(new exports.DOMException('Aborted', 'AbortError'))
-      }
-
-      var xhr = new XMLHttpRequest();
-
-      function abortXhr() {
-        xhr.abort();
-      }
-
-      xhr.onload = function() {
-        var options = {
-          status: xhr.status,
-          statusText: xhr.statusText,
-          headers: parseHeaders(xhr.getAllResponseHeaders() || '')
-        };
-        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
-        var body = 'response' in xhr ? xhr.response : xhr.responseText;
-        resolve(new Response(body, options));
-      };
-
-      xhr.onerror = function() {
-        reject(new TypeError('Network request failed'));
-      };
-
-      xhr.ontimeout = function() {
-        reject(new TypeError('Network request failed'));
-      };
-
-      xhr.onabort = function() {
-        reject(new exports.DOMException('Aborted', 'AbortError'));
-      };
-
-      xhr.open(request.method, request.url, true);
-
-      if (request.credentials === 'include') {
-        xhr.withCredentials = true;
-      } else if (request.credentials === 'omit') {
-        xhr.withCredentials = false;
-      }
-
-      if ('responseType' in xhr && support.blob) {
-        xhr.responseType = 'blob';
-      }
-
-      request.headers.forEach(function(value, name) {
-        xhr.setRequestHeader(name, value);
-      });
-
-      if (request.signal) {
-        request.signal.addEventListener('abort', abortXhr);
-
-        xhr.onreadystatechange = function() {
-          // DONE (success or failure)
-          if (xhr.readyState === 4) {
-            request.signal.removeEventListener('abort', abortXhr);
-          }
-        };
-      }
-
-      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
-    })
-  }
-
-  fetch.polyfill = true;
-
-  if (!self.fetch) {
-    self.fetch = fetch;
-    self.Headers = Headers;
-    self.Request = Request;
-    self.Response = Response;
-  }
-
-  exports.Headers = Headers;
-  exports.Request = Request;
-  exports.Response = Response;
-  exports.fetch = fetch;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-  return exports;
-
-}({}));
-})(__self__);
-__self__.fetch.ponyfill = true;
-// Remove "polyfill" property added by whatwg-fetch
-delete __self__.fetch.polyfill;
-// Choose between native implementation (global) or custom implementation (__self__)
-// var ctx = global.fetch ? global : __self__;
-var ctx = __self__; // this line disable service worker support temporarily
-exports = ctx.fetch // To enable: import fetch from 'cross-fetch'
-exports["default"] = ctx.fetch // For TypeScript consumers without esModuleInterop.
-exports.fetch = ctx.fetch // To enable: import {fetch} from 'cross-fetch'
-exports.Headers = ctx.Headers
-exports.Request = ctx.Request
-exports.Response = ctx.Response
-module.exports = exports
-
-
 /***/ }),
 
 /***/ 556:
@@ -10357,15 +9796,15 @@ const utils_1 = __webpack_require__(8593);
  *   console.log(result)
  *
  *   // Transfer
- *   const { transaction, transactionResponse } = await koin.transfer({
+ *   const { transaction } = await koin.transfer({
  *     to: "172AB1FgCsYrRAW5cwQ8KjadgxofvgPFd6",
  *     value: "10.0001",
  *   });
  *   console.log(`Transaction id ${transaction.id} submitted`);
  *
  *   // wait to be mined
- *   const blockId = await transactionResponse.wait();
- *   console.log(`Transaction mined. Block id: ${blockId}`);
+ *   const blockNumber = await transaction.wait();
+ *   console.log(`Transaction mined. Block number: ${blockNumber}`);
  * }
  *
  * main();
@@ -10443,7 +9882,7 @@ class Contract {
                     // write contract (sign and send)
                     if (!this.signer)
                         throw new Error("signer not found");
-                    const transaction = await this.signer.encodeTransaction({
+                    const tx = await this.signer.encodeTransaction({
                         ...opts,
                         operations: [operation],
                     });
@@ -10452,8 +9891,8 @@ class Contract {
                         const contractId = (0, utils_1.encodeBase58)(this.id);
                         abis[contractId] = this.abi;
                     }
-                    const transactionResponse = await this.signer.sendTransaction(transaction, abis);
-                    return { operation, transaction, transactionResponse };
+                    const transaction = await this.signer.sendTransaction(tx, abis);
+                    return { operation, transaction };
                 };
             });
         }
@@ -10482,10 +9921,10 @@ class Contract {
      * const signer = new Signer({ privateKey, provider });
      * const bytecode = new Uint8Array([1, 2, 3, 4]);
      * const contract = new Contract({ signer, provider, bytecode });
-     * const { transactionResponse } = await contract.deploy();
+     * const { transaction } = await contract.deploy();
      * // wait to be mined
-     * const blockId = await transactionResponse.wait();
-     * console.log(`Contract uploaded in block id ${blockId}`);
+     * const blockNumber = await transaction.wait();
+     * console.log(`Contract uploaded in block number ${blockNumber}`);
      * ```
      */
     async deploy(options) {
@@ -10506,12 +9945,12 @@ class Contract {
         // return operation if send is false
         if (!(opts === null || opts === void 0 ? void 0 : opts.sendTransaction))
             return { operation };
-        const transaction = await this.signer.encodeTransaction({
+        const tx = await this.signer.encodeTransaction({
             ...opts,
             operations: [operation],
         });
-        const transactionResponse = await this.signer.sendTransaction(transaction);
-        return { operation, transaction, transactionResponse };
+        const transaction = await this.signer.sendTransaction(tx);
+        return { operation, transaction };
     }
     /**
      * Encondes a contract operation using Koinos serialization
@@ -10616,16 +10055,12 @@ exports["default"] = Contract;
 /***/ }),
 
 /***/ 5635:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
 
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Provider = void 0;
-const cross_fetch_1 = __importDefault(__webpack_require__(4098));
 async function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
@@ -10671,7 +10106,7 @@ class Provider {
                     params,
                 };
                 const url = this.rpcNodes[this.currentNodeId];
-                const response = await (0, cross_fetch_1.default)(url, {
+                const response = await fetch(url, {
                     method: "POST",
                     body: JSON.stringify(data),
                 });
@@ -10767,93 +10202,95 @@ class Provider {
         return (await this.getBlocks(height, 1))[0];
     }
     /**
-     * Function to call "chain.submit_transaction" to send a signed
-     * transaction to the blockchain. It returns an object with the async
-     * function "wait", which can be called to wait for the
-     * transaction to be mined (see [[SendTransactionResponse]]).
-     * @param transaction - Signed transaction
+     * Function to wait for a transaction to be mined.
+     * @param txId - transaction id
+     * @param type - Type must be "byBlock" (default) or "byTransactionId".
+     * _byBlock_ will query the blockchain to get blocks and search for the
+     * transaction there. _byTransactionId_ will query the "transaction store"
+     * microservice to search the transaction by its id. If non of them is
+     * specified the function will use "byBlock" (as "byTransactionId"
+     * requires the transaction store, which is an optional microservice).
+     *
+     * When _byBlock_ is used it returns the block number.
+     *
+     * When _byTransactionId_ is used it returns the block id.
+     *
+     * @param timeout - Timeout in milliseconds. By default it is 30000
      * @example
      * ```ts
-     * const { transactionResponse } = await provider.sendTransaction({
-     *   id: "1220...",
-     *   active: "...",
-     *   signatureData: "...",
-     * });
-     * console.log("Transaction submitted to the mempool");
-     * // wait to be mined
-     * const blockNumber = await transactionResponse.wait();
-     * // const blockNumber = await transactionResponse.wait("byBlock", 30000);
-     * // const blockId = await transactionResponse.wait("byTransactionId", 30000);
+     * const blockNumber = await provider.wait(txId);
+     * // const blockNumber = await provider.wait(txId, "byBlock", 30000);
+     * // const blockId = await provider.wait(txId, "byTransactionId", 30000);
      * console.log("Transaction mined")
      * ```
      */
-    async sendTransaction(transaction) {
-        await this.call("chain.submit_transaction", { transaction });
-        return {
-            wait: async (type = "byBlock", timeout = 30000) => {
-                const iniTime = Date.now();
-                if (type === "byTransactionId") {
-                    while (Date.now() < iniTime + timeout) {
-                        await sleep(1000);
-                        const { transactions } = await this.getTransactionsById([
-                            transaction.id,
-                        ]);
-                        if (transactions &&
-                            transactions[0] &&
-                            transactions[0].containing_blocks)
-                            return transactions[0].containing_blocks[0];
-                    }
-                    throw new Error(`Transaction not mined after ${timeout} ms`);
-                }
-                // byBlock
-                const findTxInBlocks = async (ini, numBlocks, idRef) => {
-                    const blocks = await this.getBlocks(ini, numBlocks, idRef);
-                    let bNum = 0;
-                    blocks.forEach((block) => {
-                        if (!block ||
-                            !block.block ||
-                            !block.block_id ||
-                            !block.block.transactions)
-                            return;
-                        const tx = block.block.transactions.find((t) => t.id === transaction.id);
-                        if (tx)
-                            bNum = Number(block.block_height);
-                    });
-                    const lastId = blocks[blocks.length - 1].block_id;
-                    return [bNum, lastId];
-                };
-                let blockNumber = 0;
-                let iniBlock = 0;
-                let previousId = "";
-                while (Date.now() < iniTime + timeout) {
-                    await sleep(1000);
-                    const { head_topology: headTopology } = await this.getHeadInfo();
-                    if (blockNumber === 0) {
-                        blockNumber = Number(headTopology.height);
-                        iniBlock = blockNumber;
-                    }
-                    if (Number(headTopology.height) === blockNumber - 1 &&
-                        previousId &&
-                        previousId !== headTopology.id) {
-                        const [bNum, lastId] = await findTxInBlocks(iniBlock, Number(headTopology.height) - iniBlock + 1, headTopology.id);
-                        if (bNum)
-                            return bNum;
-                        previousId = lastId;
-                        blockNumber = Number(headTopology.height) + 1;
-                    }
-                    // eslint-disable-next-line no-continue
-                    if (blockNumber > Number(headTopology.height))
-                        continue;
-                    const [bNum, lastId] = await findTxInBlocks(blockNumber, 1, headTopology.id);
-                    if (bNum)
-                        return bNum;
-                    if (!previousId)
-                        previousId = lastId;
-                    blockNumber += 1;
-                }
-                throw new Error(`Transaction not mined after ${timeout} ms. Blocks checked from ${iniBlock} to ${blockNumber}`);
-            },
+    async wait(txId, type = "byBlock", timeout = 30000) {
+        const iniTime = Date.now();
+        if (type === "byTransactionId") {
+            while (Date.now() < iniTime + timeout) {
+                await sleep(1000);
+                const { transactions } = await this.getTransactionsById([txId]);
+                if (transactions &&
+                    transactions[0] &&
+                    transactions[0].containing_blocks)
+                    return transactions[0].containing_blocks[0];
+            }
+            throw new Error(`Transaction not mined after ${timeout} ms`);
+        }
+        // byBlock
+        const findTxInBlocks = async (ini, numBlocks, idRef) => {
+            const blocks = await this.getBlocks(ini, numBlocks, idRef);
+            let bNum = 0;
+            blocks.forEach((block) => {
+                if (!block ||
+                    !block.block ||
+                    !block.block_id ||
+                    !block.block.transactions)
+                    return;
+                const tx = block.block.transactions.find((t) => t.id === txId);
+                if (tx)
+                    bNum = Number(block.block_height);
+            });
+            const lastId = blocks[blocks.length - 1].block_id;
+            return [bNum, lastId];
         };
+        let blockNumber = 0;
+        let iniBlock = 0;
+        let previousId = "";
+        while (Date.now() < iniTime + timeout) {
+            await sleep(1000);
+            const { head_topology: headTopology } = await this.getHeadInfo();
+            if (blockNumber === 0) {
+                blockNumber = Number(headTopology.height);
+                iniBlock = blockNumber;
+            }
+            if (Number(headTopology.height) === blockNumber - 1 &&
+                previousId &&
+                previousId !== headTopology.id) {
+                const [bNum, lastId] = await findTxInBlocks(iniBlock, Number(headTopology.height) - iniBlock + 1, headTopology.id);
+                if (bNum)
+                    return bNum;
+                previousId = lastId;
+                blockNumber = Number(headTopology.height) + 1;
+            }
+            // eslint-disable-next-line no-continue
+            if (blockNumber > Number(headTopology.height))
+                continue;
+            const [bNum, lastId] = await findTxInBlocks(blockNumber, 1, headTopology.id);
+            if (bNum)
+                return bNum;
+            if (!previousId)
+                previousId = lastId;
+            blockNumber += 1;
+        }
+        throw new Error(`Transaction not mined after ${timeout} ms. Blocks checked from ${iniBlock} to ${blockNumber}`);
+    }
+    /**
+     * Function to call "chain.submit_transaction" to send a signed
+     * transaction to the blockchain.
+     */
+    async sendTransaction(transaction) {
+        return this.call("chain.submit_transaction", { transaction });
     }
     /**
      * Function to call "chain.read_contract" to read a contract.
@@ -10949,10 +10386,13 @@ class Serializer {
      * It also prepares the bytes for special cases (base58, hex string)
      * when bytesConversion param is true.
      */
-    async serialize(valueDecoded, typeName) {
+    async serialize(valueDecoded, typeName, opts) {
         const protobufType = this.defaultType || this.root.lookupType(typeName);
         let object = {};
-        if (this.bytesConversion) {
+        const bytesConversion = (opts === null || opts === void 0 ? void 0 : opts.bytesConversion) === undefined
+            ? this.bytesConversion
+            : opts.bytesConversion;
+        if (bytesConversion) {
             // TODO: format from Buffer to base58/base64 for nested fields
             Object.keys(protobufType.fields).forEach((fieldName) => {
                 const { options, name, type } = protobufType.fields[fieldName];
@@ -10998,14 +10438,17 @@ class Serializer {
      * It also encodes the bytes for special cases (base58, hex string)
      * when bytesConversion param is true.
      */
-    async deserialize(valueEncoded, typeName) {
+    async deserialize(valueEncoded, typeName, opts) {
         const valueBuffer = typeof valueEncoded === "string"
             ? (0, utils_1.decodeBase64)(valueEncoded)
             : valueEncoded;
         const protobufType = this.defaultType || this.root.lookupType(typeName);
         const message = protobufType.decode(valueBuffer);
         const object = protobufType.toObject(message, { longs: String });
-        if (!this.bytesConversion)
+        const bytesConversion = (opts === null || opts === void 0 ? void 0 : opts.bytesConversion) === undefined
+            ? this.bytesConversion
+            : opts.bytesConversion;
+        if (!bytesConversion)
             return object;
         // TODO: format from Buffer to base58/base64 for nested fields
         Object.keys(protobufType.fields).forEach((fieldName) => {
@@ -11161,7 +10604,6 @@ class Signer {
         }
         else {
             this.serializer = new Serializer_1.Serializer(protocol_proto_json_1.default, {
-                defaultTypeName: "active_transaction_data",
                 bytesConversion: false,
             });
         }
@@ -11263,15 +10705,12 @@ class Signer {
         }
     }
     /**
-     * Function to sign a transaction. It's important to remark that
-     * the transaction parameter is modified inside this function.
-     * @param tx - Unsigned transaction
-     * @returns
+     * Function to sign a hash value. It returns the signature encoded
+     * in base64. The signature is in compact format with the
+     * recovery byte
+     * @param hash Hash value. Also known as digest
      */
-    async signTransaction(tx) {
-        if (!tx.active)
-            throw new Error("Active data is not defined");
-        const hash = (0, sha256_1.sha256)((0, utils_1.decodeBase64)(tx.active));
+    async signHash(hash) {
         const [compSignature, recovery] = await secp.sign(hash, this.privateKey, {
             recovered: true,
             canonical: true,
@@ -11280,11 +10719,41 @@ class Signer {
         const compactSignature = new Uint8Array(65);
         compactSignature.set([recovery + 31], 0);
         compactSignature.set(compSignature, 1);
-        tx.signature_data = (0, utils_1.encodeBase64)(compactSignature);
-        const multihash = `0x1220${(0, utils_1.toHexString)(hash)}`; // 12: code sha2-256. 20: length (32 bytes)
-        tx.id = multihash;
+        return (0, utils_1.encodeBase64)(compactSignature);
+    }
+    /**
+     * Function to sign a transaction. It's important to remark that
+     * the transaction parameter is modified inside this function.
+     * @param tx - Unsigned transaction
+     */
+    async signTransaction(tx) {
+        if (!tx.active)
+            throw new Error("Active data is not defined");
+        const hash = (0, sha256_1.sha256)((0, utils_1.decodeBase64)(tx.active));
+        tx.signature_data = await this.signHash(hash);
+        // multihash 0x1220. 12: code sha2-256. 20: length (32 bytes)
+        tx.id = `0x1220${(0, utils_1.toHexString)(hash)}`;
         return tx;
     }
+    /**
+     * Function to sign a block for federated consensus. That is,
+     * just the ecdsa signature. For other algorithms, like PoW,
+     * you have to sign the block and then process the signature
+     * to add the extra data (nonce in the case of PoW).
+     * @param block - Unsigned block
+     */
+    async signBlock(block) {
+        const activeBytes = (0, utils_1.decodeBase64)(block.active);
+        const headerBytes = await this.serializer.serialize(block.header, "block_header", { bytesConversion: true });
+        const headerActiveBytes = new Uint8Array(headerBytes.length + activeBytes.length);
+        headerActiveBytes.set(headerBytes, 0);
+        headerActiveBytes.set(activeBytes, headerBytes.length);
+        const hash = (0, sha256_1.sha256)(headerActiveBytes);
+        block.signature_data = await this.signHash(hash);
+        // multihash 0x1220. 12: code sha2-256. 20: length (32 bytes)
+        block.id = `0x1220${(0, utils_1.toHexString)(hash)}`;
+        return block;
+    }
     /**
      * Function to sign and send a transaction. It internally uses
      * [[Provider.sendTransaction]]
@@ -11299,7 +10768,15 @@ class Signer {
             await this.signTransaction(tx);
         if (!this.provider)
             throw new Error("provider is undefined");
-        return this.provider.sendTransaction(tx);
+        await this.provider.sendTransaction(tx);
+        return {
+            ...tx,
+            wait: async (type = "byBlock", timeout = 30000) => {
+                if (!this.provider)
+                    throw new Error("provider is undefined");
+                return this.provider.wait(tx.id, type, timeout);
+            },
+        };
     }
     /**
      * Function to recover the public key from a signed
@@ -11342,7 +10819,7 @@ class Signer {
      *   defaultTypeName: "pow_signature_data",
      *  });
      *
-     *  const signer = await Signer.recoverPublicKey(block, {
+     *  const signer = await signer.recoverPublicKey(block, {
      *    transformSignature: async (signatureData) => {
      *      const powSignatureData = await serializer.deserialize(signatureData);
      *      return powSignatureData.recoverable_signature;
@@ -11350,7 +10827,7 @@ class Signer {
      *  });
      * ```
      */
-    static async recoverPublicKey(txOrBlock, opts) {
+    async recoverPublicKey(txOrBlock, opts) {
         if (!txOrBlock.active)
             throw new Error("active is not defined");
         if (!txOrBlock.signature_data)
@@ -11363,7 +10840,20 @@ class Signer {
         if (opts && typeof opts.compressed !== "undefined") {
             compressed = opts.compressed;
         }
-        const hash = (0, sha256_1.sha256)((0, utils_1.decodeBase64)(txOrBlock.active));
+        const block = txOrBlock;
+        let hash;
+        const activeBytes = (0, utils_1.decodeBase64)(block.active);
+        if (block.header) {
+            const headerBytes = await this.serializer.serialize(block.header, "block_header", { bytesConversion: true });
+            const headerActiveBytes = new Uint8Array(headerBytes.length + activeBytes.length);
+            headerActiveBytes.set(headerBytes, 0);
+            headerActiveBytes.set(activeBytes, headerBytes.length);
+            hash = (0, sha256_1.sha256)(headerActiveBytes);
+        }
+        else {
+            // transaction
+            hash = (0, sha256_1.sha256)(activeBytes);
+        }
         const compactSignatureHex = (0, utils_1.toHexString)((0, utils_1.decodeBase64)(signatureData));
         const recovery = Number(`0x${compactSignatureHex.slice(0, 2)}`) - 31;
         const rHex = compactSignatureHex.slice(2, 66);
@@ -11384,7 +10874,7 @@ class Signer {
      * The output format can be compressed (default) or uncompressed.
      * @example
      * ```ts
-     * const publicKey = await Signer.recoverAddress(tx);
+     * const publicKey = await signer.recoverAddress(tx);
      * ```
      *
      * If the signature data contains more data, like in the
@@ -11418,7 +10908,7 @@ class Signer {
      *   defaultTypeName: "pow_signature_data",
      *  });
      *
-     *  const signer = await Signer.recoverAddress(block, {
+     *  const signer = await signer.recoverAddress(block, {
      *    transformSignature: async (signatureData) => {
      *      const powSignatureData = await serializer.deserialize(signatureData);
      *      return powSignatureData.recoverable_signature;
@@ -11426,15 +10916,15 @@ class Signer {
      *  });
      * ```
      */
-    static async recoverAddress(txOrBlock, opts) {
-        const publicKey = await Signer.recoverPublicKey(txOrBlock, opts);
+    async recoverAddress(txOrBlock, opts) {
+        const publicKey = await this.recoverPublicKey(txOrBlock, opts);
         return (0, utils_1.bitcoinAddress)((0, utils_1.toUint8Array)(publicKey));
     }
     /**
      * Function to encode a transaction
      * @param activeData - Active data consists of nonce, rc_limit, and
      * operations. Do not set the nonce to get it from the blockchain
-     * using the provider. The rc_limit is 1000000 by default.
+     * using the provider. The rc_limit is 1e8 by default.
      * @returns A transaction encoded. The active field is encoded in
      * base64url
      */
@@ -11447,14 +10937,14 @@ class Signer {
             // this depends on the final architecture for names on Koinos
             nonce = await this.provider.getNonce(this.getAddress());
         }
-        const rcLimit = activeData.rc_limit === undefined ? 1000000 : activeData.rc_limit;
+        const rcLimit = activeData.rc_limit === undefined ? 1e8 : activeData.rc_limit;
         const operations = activeData.operations ? activeData.operations : [];
         const activeData2 = {
             rc_limit: rcLimit,
             nonce,
             operations,
         };
-        const buffer = await this.serializer.serialize(activeData2);
+        const buffer = await this.serializer.serialize(activeData2, "active_transaction_data");
         return {
             active: (0, utils_1.encodeBase64)(buffer),
         };
@@ -11465,7 +10955,7 @@ class Signer {
     async decodeTransaction(tx) {
         if (!tx.active)
             throw new Error("Active data is not defined");
-        return this.serializer.deserialize(tx.active);
+        return this.serializer.deserialize(tx.active, "active_transaction_data");
     }
 }
 exports.Signer = Signer;