postchain-client 1.3.2 → 1.5.0

package/built/cjs/index.js

@@ -3,6 +3,8 @@
 var bn_js = require('bn.js');
 var crypto = require('crypto');
 var secp256k1 = require('secp256k1');
+var _ = require('lodash');
+var events = require('events');
 
 function _interopNamespaceDefault(e) {
 	var n = Object.create(null);
@@ -53,7 +55,7 @@ function getAugmentedNamespace(n) {
 }
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
-const asn = require("asn1.js/lib/asn1");
+const asn = require("@chromia/asn1/lib/asn1");
 const ASNDictPair = asn.define("DictPair", function () {
     this.seq().obj(this.key("name").utf8str(), this.key("value").use(rawGTV));
 });
@@ -94,7 +96,7 @@ class NumberOfSignersAndSignaturesException extends Error {
 }
 class MissingSignerException extends Error {
     constructor() {
-        super(`No such signer, remember to call addSignerToGtx() before adding a signature`);
+        super(`No such signer, remember to add signer to transaction before adding a signature`);
     }
 }
 
@@ -1636,7 +1638,7 @@ var index = /*#__PURE__*/Object.freeze({
 const encode = encodeValueGtx;
 const decode = decodeValueGtx;
 
-var __awaiter$5 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter$8 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -1688,16 +1690,16 @@ function gtvTxBody(gtx) {
     ];
 }
 function sign(gtx, privOrSigProv, pubKey) {
-    return __awaiter$5(this, void 0, void 0, function* () {
+    return __awaiter$8(this, void 0, void 0, function* () {
         if (privOrSigProv instanceof Buffer) {
             const digestToSign = getDigestToSign(gtx);
             const signature = signDigest(digestToSign, privOrSigProv);
-            addSignature(pubKey || makeKeyPair(privOrSigProv).pubKey, signature, gtx);
+            return addSignature(pubKey || makeKeyPair(privOrSigProv).pubKey, signature, gtx);
         }
         else {
             const digestToSign = getDigestToSign(gtx);
             const signature = yield privOrSigProv.sign(digestToSign);
-            addSignature(privOrSigProv.pubKey, signature, gtx);
+            return addSignature(privOrSigProv.pubKey, signature, gtx);
         }
     });
 }
@@ -1713,16 +1715,14 @@ function signRawTransaction(_keyPair, _rawTransaction) {
  */
 function addSignature(pubKeyBuffer, signatureBuffer, gtx) {
     if (!gtx.signatures) {
-        gtx.signatures = Array(gtx.signers.length).fill(Buffer.alloc(64));
-    }
-    if (gtx.signers.length !== gtx.signatures.length) {
-        throw new NumberOfSignersAndSignaturesException();
+        gtx.signatures = Array(gtx.signers.length);
     }
     const signerIndex = gtx.signers.findIndex((signer) => pubKeyBuffer.equals(signer));
     if (signerIndex === -1) {
         throw new MissingSignerException();
     }
     gtx.signatures[signerIndex] = signatureBuffer;
+    return gtx;
 }
 function serialize(gtx) {
     if (!gtx.signatures) {
@@ -1760,6 +1760,16 @@ function checkGTXSignatures(txHash, gtx) {
     }
     return true;
 }
+function checkExistingGTXSignatures(txHash, gtx) {
+    for (const i in gtx.signers) {
+        if (gtx.signatures[i]) {
+            const signValid = checkDigestSignature(txHash, gtx.signers[i], gtx.signatures[i]);
+            if (!signValid)
+                return signValid;
+        }
+    }
+    return true;
+}
 function newSignatureProvider(keyPair) {
     let pub, priv;
     if (keyPair) {
@@ -1771,7 +1781,7 @@ function newSignatureProvider(keyPair) {
     }
     return {
         pubKey: pub,
-        sign: (digest) => __awaiter$5(this, void 0, void 0, function* () { return signDigest(digest, priv); })
+        sign: (digest) => __awaiter$8(this, void 0, void 0, function* () { return signDigest(digest, priv); }),
     };
 }
 
@@ -1780,6 +1790,7 @@ var gtx = /*#__PURE__*/Object.freeze({
 	addSignature: addSignature,
 	addSignerToGtx: addSignerToGtx,
 	addTransactionToGtx: addTransactionToGtx,
+	checkExistingGTXSignatures: checkExistingGTXSignatures,
 	checkGTXSignatures: checkGTXSignatures,
 	deserialize: deserialize,
 	emptyGtx: emptyGtx,
@@ -1853,7 +1864,7 @@ var logger = /*#__PURE__*/Object.freeze({
 	warning: warning
 });
 
-var __awaiter$4 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter$7 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -1862,13 +1873,13 @@ var __awaiter$4 = (undefined && undefined.__awaiter) || function (thisArg, _argu
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-function createClient(restApiClient, blockchainRID, functionNames) {
+function createClient$1(restApiClient, blockchainRID, functionNames) {
     functionNames.push("message");
     function transaction(gtx$1) {
         return {
             gtx: gtx$1,
             sign: function (privOrSigProv, pubKey) {
-                return __awaiter$4(this, void 0, void 0, function* () {
+                return __awaiter$7(this, void 0, void 0, function* () {
                     debug(`signing transaction with ${privOrSigProv instanceof Buffer
                         ? "privkey: " + privOrSigProv.toString("hex")
                         : "signature provider [pubkey: " + privOrSigProv.pubKey + "]"}`);
@@ -1944,16 +1955,16 @@ function createClient(restApiClient, blockchainRID, functionNames) {
 
 var gtxclient = /*#__PURE__*/Object.freeze({
 	__proto__: null,
-	createClient: createClient
+	createClient: createClient$1
 });
 
-var ResponseStatus;
+var ResponseStatus$1;
 (function (ResponseStatus) {
     ResponseStatus["Confirmed"] = "confirmed";
     ResponseStatus["Rejected"] = "rejected";
     ResponseStatus["Unknown"] = "unknown";
     ResponseStatus["Waiting"] = "waiting";
-})(ResponseStatus || (ResponseStatus = {}));
+})(ResponseStatus$1 || (ResponseStatus$1 = {}));
 var Method;
 (function (Method) {
     Method["GET"] = "get";
@@ -1974,8 +1985,12 @@ class TxRejectedError extends Error {
     }
 }
 class UnexpectedStatusError extends Error {
-    constructor(status) {
-        super(`Unexpected status code from server: ${status}`);
+    constructor(status, error) {
+        let errorMessage = `Unexpected status code from server. Code: ${status}.`;
+        if (error) {
+            errorMessage += ` Message: ${error}.`;
+        }
+        super(errorMessage);
     }
 }
 class LostMessageError extends Error {
@@ -2009,7 +2024,7 @@ class EmptyListOfUrlsException extends Error {
     }
 }
 
-var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter$6 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -2019,7 +2034,7 @@ var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _argu
     });
 };
 function handleRequest(method, path, endpoint, postObject) {
-    return __awaiter$3(this, void 0, void 0, function* () {
+    return __awaiter$6(this, void 0, void 0, function* () {
         if (method == Method.GET) {
             return yield get(path, endpoint);
         }
@@ -2034,7 +2049,7 @@ function handleRequest(method, path, endpoint, postObject) {
  * @param endpoint
  */
 function get(path, endpoint) {
-    return __awaiter$3(this, void 0, void 0, function* () {
+    return __awaiter$6(this, void 0, void 0, function* () {
         debug("GET URL " + new URL(path, endpoint).href);
         try {
             const response = yield fetch(new URL(path, endpoint).href);
@@ -2057,7 +2072,7 @@ function get(path, endpoint) {
  * @param requestBody request body
  */
 function post(path, endpoint, requestBody) {
-    return __awaiter$3(this, void 0, void 0, function* () {
+    return __awaiter$6(this, void 0, void 0, function* () {
         debug("POST URL " + new URL(path, endpoint).href);
         debug("POST body " + JSON.stringify(requestBody));
         if (Buffer.isBuffer(requestBody)) {
@@ -2096,7 +2111,7 @@ function post(path, endpoint, requestBody) {
     });
 }
 
-var __awaiter$2 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter$5 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -2126,7 +2141,7 @@ function getBrid(urlBase, chainId) {
     }
 }
 function requestWithRetry(method, path, config, postObject) {
-    return __awaiter$2(this, void 0, void 0, function* () {
+    return __awaiter$5(this, void 0, void 0, function* () {
         let statusCode, rspBody, error;
         const noRetryStatusCodes = [200, 400, 409, 500];
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -2172,7 +2187,7 @@ var restclientutil = /*#__PURE__*/Object.freeze({
 	sleep: sleep
 });
 
-var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter$4 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -2192,8 +2207,8 @@ function createRestClient(endpointPool, blockchainRID, maxSockets = 10, pollingI
             attemptInterval: (failOverConfig === null || failOverConfig === void 0 ? void 0 : failOverConfig.attemptInterval) || 500,
         },
         getTransaction: function (txRID, callback) {
-            return __awaiter$1(this, void 0, void 0, function* () {
-                if (!validTxRID(txRID)) {
+            return __awaiter$4(this, void 0, void 0, function* () {
+                if (!validTxRID$1(txRID)) {
                     callback(new UnvalidTxRidException(txRID), null);
                 }
                 else {
@@ -2203,7 +2218,7 @@ function createRestClient(endpointPool, blockchainRID, maxSockets = 10, pollingI
             });
         },
         postTransaction: function (serializedTransaction, callback) {
-            return __awaiter$1(this, void 0, void 0, function* () {
+            return __awaiter$4(this, void 0, void 0, function* () {
                 if (!Buffer.isBuffer(serializedTransaction)) {
                     throw new SerializedTransactionFormatException();
                 }
@@ -2215,8 +2230,8 @@ function createRestClient(endpointPool, blockchainRID, maxSockets = 10, pollingI
             });
         },
         status: function (txRID, callback) {
-            return __awaiter$1(this, void 0, void 0, function* () {
-                if (!validTxRID(txRID)) {
+            return __awaiter$4(this, void 0, void 0, function* () {
+                if (!validTxRID$1(txRID)) {
                     callback(new UnvalidTxRidException(txRID), null);
                 }
                 else {
@@ -2226,9 +2241,9 @@ function createRestClient(endpointPool, blockchainRID, maxSockets = 10, pollingI
             });
         },
         query: function (nameOrQueryObject, queryArguments) {
-            return __awaiter$1(this, void 0, void 0, function* () {
+            return __awaiter$4(this, void 0, void 0, function* () {
                 // eslint-disable-next-line no-async-promise-executor
-                return new Promise((resolve, reject) => __awaiter$1(this, void 0, void 0, function* () {
+                return new Promise((resolve, reject) => __awaiter$4(this, void 0, void 0, function* () {
                     const callback = (error, result) => {
                         if (error) {
                             reject(error);
@@ -2251,16 +2266,16 @@ function createRestClient(endpointPool, blockchainRID, maxSockets = 10, pollingI
                     else {
                         const status = result.status;
                         switch (status) {
-                            case ResponseStatus.Confirmed:
+                            case ResponseStatus$1.Confirmed:
                                 resolve(null);
                                 break;
-                            case ResponseStatus.Rejected:
+                            case ResponseStatus$1.Rejected:
                                 reject(new TxRejectedError(result.rejectReason));
                                 break;
-                            case ResponseStatus.Unknown:
+                            case ResponseStatus$1.Unknown:
                                 reject(new LostMessageError());
                                 break;
-                            case ResponseStatus.Waiting:
+                            case ResponseStatus$1.Waiting:
                                 setTimeout(() => this.waitConfirmation(txRID).then(resolve, reject), this.config.pollingInterval);
                                 break;
                             default:
@@ -2294,7 +2309,7 @@ function createRestClient(endpointPool, blockchainRID, maxSockets = 10, pollingI
  * Validates that txRID is a Buffer of 32 bytes.
  * @param txRID A buffer of 32 bytes
  */
-function validTxRID(txRID) {
+function validTxRID$1(txRID) {
     if (txRID.length != 32) {
         const error$1 = new UnvalidTxRidException(txRID);
         error(error$1.toString());
@@ -2330,14 +2345,14 @@ function handleGetResponse(error$1, statusCode, responseObject, callback) {
             callback(null, null);
         }
         else if (statusCode !== 200) {
-            callback(new UnexpectedStatusError(statusCode), responseObject);
+            callback(new UnexpectedStatusError(statusCode, responseObjectPrintable), responseObject);
         }
         else {
             callback(null, responseObject);
         }
     }
     catch (error$1) {
-        error("restclient.handleGetResponse(): Failed to call callback function " +
+        error("restclient.handleGetResponse(): Failed to call the callback function. " +
             error$1);
     }
 }
@@ -2356,8 +2371,12 @@ function handlePostResponse(error$1, statusCode, responseObject, callback) {
             callback(error$1);
         }
         else if (statusCode != 200) {
-            error(`Unexpected status code from server: ${statusCode}`);
-            callback(new UnexpectedStatusError(statusCode), responseObject);
+            let errorMessage = `Unexpected status code from server. Code: ${statusCode}.`;
+            if (responseObjectPrintable) {
+                errorMessage += ` Message: ${responseObjectPrintable}.`;
+            }
+            error(errorMessage);
+            callback(new UnexpectedStatusError(statusCode, responseObjectPrintable), responseObject);
         }
         else {
             info(`Calling responseCallback with responseObject: ${responseObjectPrintable}`);
@@ -2372,7 +2391,9 @@ function handlePostResponse(error$1, statusCode, responseObject, callback) {
 
 var restclient = /*#__PURE__*/Object.freeze({
 	__proto__: null,
-	createRestClient: createRestClient
+	createRestClient: createRestClient,
+	handleGetResponse: handleGetResponse,
+	handlePostResponse: handlePostResponse
 });
 
 var internalNodePrefix = Buffer.alloc(1, 0);
@@ -2495,7 +2516,7 @@ class BlockchainUrlUndefinedException extends Error {
     }
 }
 
-var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -2510,10 +2531,10 @@ var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _argume
  * @param rest rest client configured to node running chain0
  */
 function chromiaClientProvider(chain0BRID, rest) {
-    const chain0Client = createClient(rest, chain0BRID, []);
+    const chain0Client = createClient$1(rest, chain0BRID, []);
     return {
         blockchainConnection: function (dappBRID) {
-            return __awaiter(this, void 0, void 0, function* () {
+            return __awaiter$3(this, void 0, void 0, function* () {
                 const queryObject = {
                     type: "cm_get_blockchain_api_urls",
                     blockchain_rid: dappBRID,
@@ -2533,7 +2554,528 @@ var chromiaClientProvider$1 = /*#__PURE__*/Object.freeze({
 	chromiaClientProvider: chromiaClientProvider
 });
 
+var ResponseStatus;
+(function (ResponseStatus) {
+    ResponseStatus["Confirmed"] = "confirmed";
+    ResponseStatus["Rejected"] = "rejected";
+    ResponseStatus["Unknown"] = "unknown";
+    ResponseStatus["Waiting"] = "waiting";
+})(ResponseStatus || (ResponseStatus = {}));
+
+class MissingBlockchainError extends Error {
+    constructor() {
+        super(`No target blockchain was provided`);
+    }
+}
+class MissingNodeUrlError extends Error {
+    constructor() {
+        super(`No node url or directory node url was provided`);
+    }
+}
+class InvalidTransactionFormatException extends Error {
+    constructor() {
+        super(`The transaction is not in the right format`);
+    }
+}
+class getTransactionRIDException extends Error {
+    constructor(error) {
+        super(`"Error occurred while getting transaction RID:", ${error}`);
+    }
+}
+
+var __awaiter$2 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+require("web3-core-promievent");
+function getConfig(settings) {
+    var _a, _b;
+    return __awaiter$2(this, void 0, void 0, function* () {
+        if (!settings.nodeURLPool && !settings.directoryNodeURLPool) {
+            throw new MissingNodeUrlError();
+        }
+        if (!settings.blockchainRID &&
+            typeof settings.blockchainIID === "undefined") {
+            throw new MissingBlockchainError();
+        }
+        const nodeUrlPool = settings.directoryNodeURLPool
+            ? yield getNodeUrls(settings)
+            : typeof settings.nodeURLPool === "string"
+                ? [settings.nodeURLPool]
+                : Array.isArray(settings.nodeURLPool)
+                    ? settings.nodeURLPool
+                    : [];
+        return {
+            endpointPool: nodeUrlPool,
+            blockchainRID: settings.blockchainRID
+                ? toBuffer(settings.blockchainRID)
+                : toBuffer(yield getBrid(nodeUrlPool[0], settings.blockchainIID)),
+            pollingInterval: settings.pollingInterval || 500,
+            attemptsPerEndpoint: ((_a = settings.failOverConfig) === null || _a === void 0 ? void 0 : _a.attemptsPerEndpoint) || 3,
+            attemptInterval: ((_b = settings.failOverConfig) === null || _b === void 0 ? void 0 : _b.attemptInterval) || 500,
+        };
+    });
+}
+function validTxRID(txRID) {
+    if (txRID.length != 32) {
+        const error$1 = new UnvalidTxRidException(txRID);
+        error(error$1.toString());
+        return false;
+    }
+    return true;
+}
+function getNodeUrls(settings) {
+    return __awaiter$2(this, void 0, void 0, function* () {
+        if (!settings.blockchainRID) {
+            throw new MissingBlockchainError();
+        }
+        const nodeUrlPool = Array.isArray(settings.directoryNodeURLPool)
+            ? settings.directoryNodeURLPool
+            : typeof settings.directoryNodeURLPool === "string"
+                ? [settings.directoryNodeURLPool]
+                : [];
+        const directoryBRID = yield getBrid(nodeUrlPool[0], 0);
+        const queryObject = {
+            type: "cm_get_blockchain_api_urls",
+            blockchain_rid: settings.blockchainRID
+                ? settings.blockchainRID
+                : yield getBrid(nodeUrlPool[0], settings.blockchainIID),
+        };
+        const rest = createRestClient(nodeUrlPool, directoryBRID);
+        const baseUrls = yield rest.query(queryObject);
+        if (!baseUrls.length) {
+            throw new BlockchainUrlUndefinedException(directoryBRID);
+        }
+        return baseUrls;
+    });
+}
+function convertToRellOperation(operations) {
+    return operations.map((operation) => {
+        var _a;
+        return {
+            opName: operation.name,
+            args: (_a = operation.args) !== null && _a !== void 0 ? _a : [],
+        };
+    });
+}
+function getSerializedGTX(gtx$1) {
+    const gtxBytes = serialize(gtx$1);
+    if (!Buffer.isBuffer(gtxBytes)) {
+        throw new SerializedTransactionFormatException();
+    }
+    return gtxBytes;
+}
+function getGTXFromBufferOrTransactionOrOperation(transaction, blockchainRID) {
+    if (Buffer.isBuffer(transaction)) {
+        return deserialize(transaction);
+    }
+    else if ("operations" in transaction) {
+        return {
+            blockchainRID,
+            operations: convertToRellOperation(transaction.operations),
+            signers: transaction.signers,
+            signatures: [],
+        };
+    }
+    else if ("name" in transaction) {
+        return {
+            blockchainRID,
+            operations: convertToRellOperation([transaction]),
+            signers: [],
+            signatures: [],
+        };
+    }
+    else {
+        throw new InvalidTransactionFormatException();
+    }
+}
+const callbackPromiseBuilder = (reject, resolve, callback) => {
+    return (error, result) => {
+        if (error) {
+            if (typeof callback === "function") {
+                callback(error, null);
+            }
+            reject(error);
+        }
+        else {
+            if (typeof callback === "function") {
+                callback(null, result);
+            }
+            resolve(result);
+        }
+    };
+};
+const handlePostResponsePromisified = (error, statusCode, rspBody) => {
+    return new Promise((resolve, reject) => {
+        handlePostResponse(error, statusCode, rspBody, (_error) => {
+            if (_error) {
+                reject(_error);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+};
+
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+class Web3EventEmitter {
+    constructor() {
+        this._emitter = new events.EventEmitter();
+    }
+    on(eventName, fn) {
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        this._emitter.on(eventName, fn);
+    }
+    once(eventName, fn) {
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        this._emitter.once(eventName, fn);
+    }
+    off(eventName, fn) {
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        this._emitter.off(eventName, fn);
+    }
+    emit(eventName, params) {
+        this._emitter.emit(eventName, params);
+    }
+    listenerCount(eventName) {
+        return this._emitter.listenerCount(eventName);
+    }
+    listeners(eventName) {
+        return this._emitter.listeners(eventName);
+    }
+    eventNames() {
+        return this._emitter.eventNames();
+    }
+    removeAllListeners() {
+        return this._emitter.removeAllListeners();
+    }
+    setMaxListenerWarningThreshold(maxListenersWarningThreshold) {
+        this._emitter.setMaxListeners(maxListenersWarningThreshold);
+    }
+    getMaxListeners() {
+        return this._emitter.getMaxListeners();
+    }
+}
+
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a;
+class Web3PromiEvent extends Web3EventEmitter {
+    constructor(executor) {
+        super();
+        // public tag to treat object as promise by different libs
+        // eslint-disable-next-line @typescript-eslint/prefer-as-const
+        this[_a] = "Promise";
+        this._promise = new Promise(executor);
+    }
+    then(onfulfilled, onrejected) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            return this._promise.then(onfulfilled, onrejected);
+        });
+    }
+    catch(onrejected) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            return this._promise.catch(onrejected);
+        });
+    }
+    finally(onfinally) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            return this._promise.finally(onfinally);
+        });
+    }
+    on(eventName, fn) {
+        super.on(eventName, fn);
+        return this;
+    }
+    once(eventName, fn) {
+        super.once(eventName, fn);
+        return this;
+    }
+}
+_a = Symbol.toStringTag;
+
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+function createClient(settings) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const blockchainRID = settings.blockchainRID;
+        return {
+            config: yield getConfig(settings),
+            query(nameOrQueryObject, args, callback) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    let _name, _args;
+                    if (typeof nameOrQueryObject === "string") {
+                        _name = nameOrQueryObject;
+                        _args = args;
+                    }
+                    else {
+                        _name = nameOrQueryObject === null || nameOrQueryObject === void 0 ? void 0 : nameOrQueryObject.name;
+                        _args = nameOrQueryObject === null || nameOrQueryObject === void 0 ? void 0 : nameOrQueryObject.args;
+                    }
+                    const { error, statusCode, rspBody } = yield requestWithRetry(Method.POST, `query_gtv/${blockchainRID}`, this.config, encodeValue(toQueryObjectGTV(_name, _args)));
+                    return new Promise((resolve, reject) => {
+                        handlePostResponse(error, statusCode, rspBody, callbackPromiseBuilder(reject, resolve, callback));
+                    });
+                });
+            },
+            signTransaction(transaction, signMethod, callback) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const signMethodIsPrivKey = "privKey" in signMethod;
+                    debug(`signing transaction with ${signMethodIsPrivKey
+                        ? "privkey: " + signMethod.privKey.toString("hex")
+                        : "signature provider [pubkey: " + toString(signMethod.pubKey) + "]"}`);
+                    const gtx$1 = getGTXFromBufferOrTransactionOrOperation(transaction, this.config.blockchainRID);
+                    try {
+                        const signedTx = yield (signMethodIsPrivKey
+                            ? sign(gtx$1, signMethod.privKey, signMethod.pubKey)
+                            : sign(gtx$1, signMethod));
+                        const gtxBytes = getSerializedGTX(signedTx);
+                        if (typeof callback === "function") {
+                            callback(null, gtxBytes);
+                        }
+                        return gtxBytes;
+                    }
+                    catch (error) {
+                        if (typeof callback === "function") {
+                            callback(error, null);
+                        }
+                        throw new Error(error);
+                    }
+                });
+            },
+            sendTransaction(transaction, callback) {
+                const promiEvent = new Web3PromiEvent((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                    const gtx$1 = getGTXFromBufferOrTransactionOrOperation(transaction, this.config.blockchainRID);
+                    if (gtx$1.signers.length !== gtx$1.signatures.length) {
+                        reject(new NumberOfSignersAndSignaturesException());
+                    }
+                    const gtxBytes = getSerializedGTX(gtx$1);
+                    const transactionObject = {
+                        tx: gtxBytes.toString("hex"),
+                    };
+                    const { error: error$1, statusCode, rspBody } = yield requestWithRetry(Method.POST, "tx/" + blockchainRID, this.config, transactionObject);
+                    const transactionRID = getDigestToSign(gtx$1);
+                    try {
+                        yield handlePostResponsePromisified(error$1, statusCode, rspBody);
+                        if (typeof callback === "function") {
+                            callback(null, {
+                                status: ResponseStatus.Waiting,
+                                statusCode,
+                                transactionRID,
+                            });
+                        }
+                    }
+                    catch (_error) {
+                        if (typeof callback === "function") {
+                            callback(_error, null);
+                        }
+                        return reject(_error);
+                    }
+                    promiEvent.emit("sent", {
+                        status: ResponseStatus.Waiting,
+                        statusCode: statusCode,
+                        transactionRID,
+                    });
+                    const waitConfirmation = (txRID) => {
+                        return new Promise((resolve, reject) => {
+                            this.getTransactionStatus(txRID, (error$1, result) => {
+                                if (error$1) {
+                                    reject(error$1);
+                                }
+                                else {
+                                    const status = result.status;
+                                    switch (status) {
+                                        case ResponseStatus.Confirmed:
+                                            resolve(ResponseStatus.Confirmed);
+                                            break;
+                                        case ResponseStatus.Rejected:
+                                            reject(new TxRejectedError(result.rejectReason));
+                                            break;
+                                        case ResponseStatus.Unknown:
+                                            reject(new LostMessageError());
+                                            break;
+                                        case ResponseStatus.Waiting:
+                                            setTimeout(() => waitConfirmation(txRID).then(resolve, reject), this.config.pollingInterval);
+                                            break;
+                                        default:
+                                            error(status);
+                                            reject(new UnexpectedResponseError());
+                                    }
+                                }
+                            });
+                        });
+                    };
+                    try {
+                        waitConfirmation(getDigestToSign(gtx$1)).then((confirmationStatus) => {
+                            resolve({
+                                status: confirmationStatus,
+                                statusCode: statusCode,
+                                transactionRID,
+                            });
+                        });
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                }));
+                return promiEvent;
+            },
+            signAndSendUniqueTransaction(transactionOrOperation, signMethod, callback) {
+                const promiEvent = new Web3PromiEvent((resolve, reject) => {
+                    const signMethodIsPrivKey = "privKey" in signMethod;
+                    let _pubKey;
+                    if (signMethodIsPrivKey) {
+                        _pubKey = !signMethod.pubKey
+                            ? makeKeyPair(signMethod.privKey).pubKey
+                            : signMethod.pubKey;
+                    }
+                    const transaction = "name" in transactionOrOperation
+                        ? {
+                            operations: [transactionOrOperation],
+                            signers: [signMethod.pubKey || _pubKey],
+                        }
+                        : transactionOrOperation;
+                    const hasNop = transaction.operations.some((operation) => {
+                        return operation.name === "nop";
+                    });
+                    const transactionWithNop = hasNop
+                        ? transaction
+                        : this.addNop(transaction);
+                    this.signTransaction(transactionWithNop, signMethod)
+                        .then((signedTx) => {
+                        const sendTransactionPromiEvent = this.sendTransaction(signedTx, callback);
+                        sendTransactionPromiEvent.on("sent", (receipt) => {
+                            promiEvent.emit("sent", receipt);
+                        });
+                        resolve(sendTransactionPromiEvent);
+                    })
+                        .catch((error) => {
+                        reject(error);
+                    });
+                });
+                return promiEvent;
+            },
+            getTransaction(transactionRID, callback) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (!validTxRID(transactionRID)) {
+                        if (typeof callback === "function") {
+                            callback(new UnvalidTxRidException(transactionRID), null);
+                        }
+                        throw new UnvalidTxRidException(transactionRID);
+                    }
+                    const { error, statusCode, rspBody } = yield requestWithRetry(Method.GET, "tx/" + blockchainRID + "/" + transactionRID.toString("hex"), this.config);
+                    return new Promise((resolve, reject) => {
+                        handleGetResponse(error, statusCode, statusCode === 200 ? toBuffer(rspBody.tx) : rspBody, callbackPromiseBuilder(reject, resolve, callback));
+                    });
+                });
+            },
+            getTransactionStatus(transactionRID, callback) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (!validTxRID(transactionRID)) {
+                        const error = new UnvalidTxRidException(transactionRID);
+                        if (typeof callback === "function") {
+                            callback(error, null);
+                        }
+                        throw error;
+                    }
+                    const { error, statusCode, rspBody } = yield requestWithRetry(Method.GET, "tx/" +
+                        blockchainRID +
+                        "/" +
+                        transactionRID.toString("hex") +
+                        "/status", this.config);
+                    return new Promise((resolve, reject) => {
+                        handleGetResponse(error, statusCode, rspBody, callbackPromiseBuilder(reject, resolve, callback));
+                    });
+                });
+            },
+            addNop(transaction) {
+                const _transaction = _.cloneDeep(transaction);
+                const noOperation = {
+                    name: "nop",
+                    args: [crypto.randomBytes(32)],
+                };
+                _transaction.operations = [..._transaction.operations, noOperation];
+                return _transaction;
+            },
+            getTransactionRID(transaction) {
+                try {
+                    const gtx$1 = getGTXFromBufferOrTransactionOrOperation(transaction, this.config.blockchainRID);
+                    return getDigestToSign(gtx$1);
+                }
+                catch (e) {
+                    throw new getTransactionRIDException(e);
+                }
+            },
+            encodeTransaction(transaction) {
+                const gtx$1 = getGTXFromBufferOrTransactionOrOperation(transaction, this.config.blockchainRID);
+                return serialize(gtx$1);
+            },
+            decodeTransactionToGTX(encodedTransaction) {
+                const gtx$1 = deserialize(encodedTransaction);
+                debug(`Output from deserializing a raw transaction: ${JSON.stringify(gtx$1)}`);
+                return gtx$1;
+            },
+            getClientNodeURLPool() {
+                return this.config.endpointPool;
+            },
+        };
+    });
+}
+
 exports.chromiaClient = chromiaClientProvider$1;
+exports.createClient = createClient;
 exports.encryption = encryption$1;
 exports.formatter = formatter;
 exports.gtv = index;
@@ -2541,6 +3083,7 @@ exports.gtx = gtx;
 exports.gtxClient = gtxclient;
 exports.logger = logger;
 exports.merkle = merkleHelper;
+exports.newSignatureProvider = newSignatureProvider;
 exports.restClient = restclient;
 exports.restClientutil = restclientutil;
 //# sourceMappingURL=index.js.map