postchain-client 1.22.0 → 2.0.1

package/built/test/integration/blockchainClientIntegration.test.js

@@ -1,1075 +0,0 @@
-var __awaiter = (this && this.__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 __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import chai from "chai";
-import chaiAsPromised from "chai-as-promised";
-import * as secp256k1 from "secp256k1";
-import { randomInt } from "crypto";
-import * as sinon from "sinon";
-import { Buffer } from "buffer";
-import { createClient } from "../../src/blockchainClient/blockchainClient";
-import { signDigest } from "../../src/encryption/encryption";
-import { getDigestToSign } from "../../src/gtx/gtx";
-import * as gtxTool from "../../src/gtx/gtx";
-import * as handleRequestModule from "../../src/restclient/httpUtil";
-import { ComplexArgumentObject } from "./testData";
-import { toBuffer } from "../../src/formatter";
-import { MissingBlockchainIdentifierError } from "../../src/blockchainClient/errors";
-import { ChainConfirmationLevel, ResponseStatus, TransactionEvent, } from "../../src/blockchainClient/enums";
-import { CONFIGURED_POLL_COUNT, mockStringDirectoryChainRid, mockThirtyTwoBytesBuffer, } from "../unit/common/mocks";
-import { setStatusPolling } from "../../src/blockchainClient/utils";
-import { LOCAL_POOL } from "../../src/constants";
-const expect = chai.expect;
-chai.use(chaiAsPromised);
-const invalidEndpointPool = [
-    "http://localhost1:7740",
-    "http://localhost2:7740",
-    "http://localhost3:7740",
-];
-const signerPrivKeyA = Buffer.alloc(32, "a");
-const signerPubKeyA = Buffer.from(secp256k1.publicKeyCreate(signerPrivKeyA));
-const signerKeyPairA = {
-    privKey: signerPrivKeyA,
-    pubKey: signerPubKeyA,
-};
-const sigProvA = {
-    pubKey: signerPubKeyA,
-    sign: (rawGtxBody) => __awaiter(void 0, void 0, void 0, function* () {
-        const digest = gtxTool.getDigestToSignFromRawGtxBody(rawGtxBody, 1);
-        return signDigest(digest, signerPrivKeyA);
-    }),
-};
-const signerPrivKeyB = Buffer.alloc(32, "b");
-const signerPubKeyB = Buffer.from(secp256k1.publicKeyCreate(signerPrivKeyB));
-const signerKeyPairB = {
-    privKey: signerPrivKeyB,
-    pubKey: signerPubKeyB,
-};
-const unsignedNonUniqueTx = {
-    operations: [
-        {
-            name: "setInteger",
-            args: [1],
-        },
-    ],
-    signers: [signerPubKeyA],
-};
-const unsignedNonUniqueTxWithTwoSigners = {
-    operations: [
-        {
-            name: "setInteger",
-            args: [1],
-        },
-    ],
-    signers: [signerPubKeyA, signerPubKeyB],
-};
-const signedNonUniqueTxHex = "a581bb3081b8a56e306ca1220420bfb34abea1045bb97ed18a5dbb2b8dce84cb181585d55abb3" +
-    "21a33133dba0595a51d301ba5193017a20c0c0a736574496e7465676572a5073005a303020101" +
-    "a5273025a123042102e5a018b3a2e155316109d9cdc5eab739759c0e07e0c00bf9fccb8237fe4" +
-    "d7f02a5463044a1420440eb6c468bc2693a218a71e7b50465ba08343780d0829ec0132337cf8b" +
-    "293d841e09ac203ef0200ac7641a359a98ba1b37baace48fd96c21f7870e197f3246de0b";
-const unsignedTx = {
-    operations: [
-        {
-            name: "setInteger",
-            args: [randomInt(99999)],
-        },
-    ],
-    signers: [signerPubKeyA],
-};
-const getTxWithGTXAndTxRID = (client, signers = []) => {
-    const operation = {
-        name: "setInteger",
-        args: [randomInt(99999)],
-    };
-    const gtxBody = {
-        blockchainRid: toBuffer(client.config.blockchainRid),
-        operations: [
-            {
-                opName: operation.name,
-                args: operation.args,
-            },
-        ],
-        signers,
-    };
-    const gtx = Object.assign(Object.assign({}, gtxBody), { signatures: [] });
-    const tx = {
-        operations: [operation],
-        signers,
-    };
-    const txRID = getDigestToSign(gtx, 2);
-    return { operation, gtx, txRID, tx };
-};
-describe("Blockchain client", () => {
-    let client;
-    let faultyClient;
-    let stableConfigClient;
-    let handleRequestSpy;
-    before(done => {
-        faultyClient = createClient({
-            nodeUrlPool: invalidEndpointPool,
-            blockchainRid: process.env.BLOCKCHAIN_RID,
-            failOverConfig: {
-                attemptInterval: 1,
-            },
-            directoryChainRid: mockStringDirectoryChainRid,
-            merkleHashVersion: 1,
-        });
-        stableConfigClient = createClient({
-            nodeUrlPool: LOCAL_POOL,
-            blockchainRid: "BFB34ABEA1045BB97ED18A5DBB2B8DCE84CB181585D55ABB321A33133DBA0595",
-            merkleHashVersion: 1,
-        });
-        client = createClient({
-            nodeUrlPool: LOCAL_POOL,
-            blockchainIid: 0,
-            merkleHashVersion: 1,
-        }).finally(() => {
-            done();
-        });
-        handleRequestSpy = sinon.spy(handleRequestModule, "default");
-    });
-    beforeEach(() => {
-        handleRequestSpy.resetHistory();
-    });
-    after(() => {
-        handleRequestSpy.restore();
-    });
-    // TODO: Clean up after tests? E.g. wipe database?
-    describe("Init client", () => {
-        it("inits client", () => __awaiter(void 0, void 0, void 0, function* () {
-            const client = yield createClient({
-                nodeUrlPool: "https://localhost:7740",
-                blockchainRid: process.env.BLOCKCHAIN_RID,
-                directoryChainRid: mockStringDirectoryChainRid,
-                merkleHashVersion: 1,
-            });
-            const _a = client.config, { nodeManager } = _a, restClientConfig = __rest(_a, ["nodeManager"]);
-            expect(restClientConfig).to.deep.equal({
-                endpointPool: [{ url: "https://localhost:7740", whenAvailable: 0 }],
-                blockchainRid: process.env.BLOCKCHAIN_RID,
-                failoverStrategy: "abortOnError",
-                merkleHashVersion: 1,
-                attemptsPerEndpoint: 3,
-                attemptInterval: 500,
-                unreachableDuration: 30000,
-                directoryChainRid: mockStringDirectoryChainRid,
-                dappStatusPolling: {
-                    interval: 500,
-                    count: 20,
-                },
-                clusterAnchoringStatusPolling: {
-                    interval: 500,
-                    count: 20,
-                },
-                systemAnchoringStatusPolling: {
-                    interval: 500,
-                    count: 20,
-                },
-            });
-            expect(nodeManager).to.have.property("nodes");
-            expect(nodeManager).to.have.property("getAvailableNodes");
-            expect(nodeManager).to.have.property("getNode");
-            expect(nodeManager).to.have.property("setStickyNode");
-            expect(nodeManager).to.have.property("makeNodeUnavailable");
-            expect(nodeManager.stickedNode).to.be.null;
-            expect(nodeManager.nodes).to.have.deep.members([
-                {
-                    url: "https://localhost:7740",
-                    whenAvailable: 0,
-                    isAvailable: true,
-                },
-            ]);
-        }));
-        it("fails to init client if no blockchainRID or blockchainIID is provided", () => __awaiter(void 0, void 0, void 0, function* () {
-            const promise = createClient({
-                nodeUrlPool: "localhost:7740",
-            });
-            yield expect(promise).to.be.rejectedWith(new MissingBlockchainIdentifierError().message);
-        }));
-        it("fails to init client if no nodeUrlPool or directoryNodeUrlPool was provided", () => __awaiter(void 0, void 0, void 0, function* () {
-            const promise = createClient({});
-            yield expect(promise).to.be.rejectedWith(new MissingBlockchainIdentifierError().message);
-        }));
-        it.skip("inits client with node discovery");
-        it("inits client with Blockchain IID", () => __awaiter(void 0, void 0, void 0, function* () {
-            const client = yield createClient({
-                nodeUrlPool: [LOCAL_POOL],
-                blockchainIid: 0,
-                directoryChainRid: mockStringDirectoryChainRid,
-            });
-            const _b = client.config, { nodeManager } = _b, restClientConfig = __rest(_b, ["nodeManager"]);
-            expect(restClientConfig).to.deep.equal({
-                endpointPool: [{ url: LOCAL_POOL, whenAvailable: 0 }],
-                blockchainRid: process.env.BLOCKCHAIN_RID,
-                failoverStrategy: "abortOnError",
-                merkleHashVersion: 1,
-                attemptsPerEndpoint: 3,
-                attemptInterval: 500,
-                unreachableDuration: 30000,
-                directoryChainRid: mockStringDirectoryChainRid,
-                dappStatusPolling: {
-                    interval: 500,
-                    count: 20,
-                },
-                clusterAnchoringStatusPolling: {
-                    interval: 500,
-                    count: 20,
-                },
-                systemAnchoringStatusPolling: {
-                    interval: 500,
-                    count: 20,
-                },
-            });
-            expect(nodeManager).to.have.property("nodes");
-            expect(nodeManager).to.have.property("getAvailableNodes");
-            expect(nodeManager).to.have.property("getNode");
-            expect(nodeManager).to.have.property("setStickyNode");
-            expect(nodeManager).to.have.property("makeNodeUnavailable");
-            expect(nodeManager.stickedNode).to.deep.equal({
-                url: LOCAL_POOL,
-                whenAvailable: 0,
-                isAvailable: true,
-            });
-            expect(nodeManager.nodes).to.have.deep.members([
-                {
-                    url: LOCAL_POOL,
-                    whenAvailable: 0,
-                    isAvailable: true,
-                },
-            ]);
-        }));
-    });
-    describe("query", () => {
-        it("returns a value", () => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield (yield client).query("test_boolean", {
-                arg1: true,
-            });
-            expect(result).to.equal(1);
-        }));
-        it("takes a query object as argument", () => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield (yield client).query({
-                name: "test_boolean",
-                args: {
-                    arg1: true,
-                },
-            });
-            expect(result).to.equal(1);
-        }));
-        it("works with large complex object as argument", () => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield (yield client).query({
-                name: "test_complex_object",
-                args: ComplexArgumentObject,
-            });
-            expect(result).to.equal("");
-        }));
-        it("takes a query object without arguments as argument", () => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield (yield client).query({ name: "test_without_args" });
-            expect(result).to.equal(1);
-        }));
-        it("returns a promise", () => __awaiter(void 0, void 0, void 0, function* () {
-            const promise = (yield client).query("test_boolean", {
-                arg1: true,
-            });
-            expect(promise.then).to.be.a("function");
-        }));
-        // TODO: Results in a timeout error if expect statements fails. Fix this.
-        it("takes a callback", done => {
-            client.then(_client => {
-                _client.query("test_boolean", {
-                    arg1: true,
-                }, (err, result) => {
-                    expect(result).to.equal(1);
-                    done();
-                });
-            });
-        });
-        // TODO: Results in a timeout error if expect statements fails. Fix this.
-        it("takes a callback when using query object as argument", done => {
-            client.then(_client => {
-                _client.query({
-                    name: "test_boolean",
-                    args: {
-                        arg1: true,
-                    },
-                }, undefined, (err, result) => {
-                    expect(result).to.equal(1);
-                    done();
-                });
-            });
-        });
-        // Attempt at testing typescript generics. Will make the test suite fail
-        // if the query function doesn't take these generics
-        it("takes a typed argument", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const result = yield _client.query("test_boolean", {
-                arg1: true,
-            });
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const resultQueryObject = yield _client.query({
-                name: "test_boolean",
-                args: {
-                    arg1: true,
-                },
-            });
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const resultNoArgs = yield _client.query("test_without_args");
-            _client.query("test_boolean", {
-                arg1: true,
-            }, (err, response) => {
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                const numberResponse = response;
-            });
-        }));
-        it("takes a nullable argument", () => __awaiter(void 0, void 0, void 0, function* () {
-            const nullableStructQueryObject = {
-                name: "test_nullable_struct",
-                args: {
-                    arg1: [null],
-                },
-            };
-            const result = yield (yield client).query(nullableStructQueryObject);
-            expect(result).to.deep.equal({ int: null });
-        }));
-        it("rejects promise on error", () => __awaiter(void 0, void 0, void 0, function* () {
-            const promise = (yield client).query("does_not_exist");
-            yield expect(promise).to.be.rejected;
-        }));
-        // TODO: Results in a timeout error if expect statements fails. Fix this.
-        it("propagates errors when using a callback", done => {
-            client.then(_client => {
-                _client.query("does_not_exist", {}, (err, result) => {
-                    expect(result).to.be.null;
-                    expect(err).to.be.an("error");
-                    done();
-                });
-            });
-        });
-        it("works without arguments", () => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield (yield client).query("test_without_args");
-            expect(result).to.equal(1);
-        }));
-        it("returns string key map", () => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield (yield client).query("test_map");
-            expect(result["sample_key"]).to.equal("sample_value");
-        }));
-        it("returns byte array key map as an array with buffers", () => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield (yield client).query("test_map_with_bytearray_key");
-            expect(Array.isArray(result)).to.be.true;
-            expect(Buffer.isBuffer(result[0][0])).to.be.true;
-            expect(result[0][1]).to.equal("sample_value");
-        }));
-        // TODO:  make generic test that takes query name and arguments
-        // same as gtxClientIntegrationTest.ts
-        it.skip("works with basic types as arguments");
-        it.skip("retries default number of times", () => __awaiter(void 0, void 0, void 0, function* () {
-            try {
-                yield (yield faultyClient).query("test_without_arguments");
-            }
-            catch (err) {
-                expect(handleRequestSpy.callCount).to.equal(9);
-            }
-        }));
-        it.skip("retries configured number of times", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield createClient({
-                nodeUrlPool: invalidEndpointPool,
-                blockchainRid: process.env.BLOCKCHAIN_RID,
-                failOverConfig: {
-                    attemptsPerEndpoint: 1,
-                    attemptInterval: 1,
-                },
-                merkleHashVersion: 1,
-                directoryChainRid: mockStringDirectoryChainRid,
-            });
-            try {
-                yield _client.query("test_without_arguments");
-            }
-            catch (err) {
-                expect(handleRequestSpy.callCount).to.equal(3);
-            }
-        }));
-        // TODO: Mock backend and use fake timers to make this more robust
-        it.skip("uses default attemptInterval of 500", () => __awaiter(void 0, void 0, void 0, function* () {
-            const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-            const _client = yield createClient({
-                nodeUrlPool: invalidEndpointPool,
-                blockchainRid: process.env.BLOCKCHAIN_RID,
-                failOverConfig: {
-                    attemptsPerEndpoint: 1,
-                },
-                merkleHashVersion: 1,
-                directoryChainRid: mockStringDirectoryChainRid,
-            });
-            _client.query("test_without_arguments");
-            expect(handleRequestSpy.callCount).to.equal(1);
-            yield sleep(250);
-            expect(handleRequestSpy.callCount).to.equal(1);
-            yield sleep(500);
-            expect(handleRequestSpy.callCount).to.equal(2);
-            yield sleep(500);
-            expect(handleRequestSpy.callCount).to.equal(3);
-            yield sleep(500);
-            expect(handleRequestSpy.callCount).to.equal(3);
-        }));
-        // TODO: Mock backend and use fake timers to make this more robust
-        it("uses configured attemptInterval", () => __awaiter(void 0, void 0, void 0, function* () {
-            const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-            const _client = yield createClient({
-                nodeUrlPool: invalidEndpointPool,
-                blockchainRid: process.env.BLOCKCHAIN_RID,
-                failOverConfig: {
-                    attemptsPerEndpoint: 1,
-                    attemptInterval: 100,
-                },
-                merkleHashVersion: 1,
-                directoryChainRid: mockStringDirectoryChainRid,
-            });
-            _client.query("test_without_arguments");
-            //TODO: test not working locally (all values have to be 1)
-            expect(handleRequestSpy.callCount).to.equal(1);
-            yield sleep(50);
-            expect(handleRequestSpy.callCount).to.equal(1);
-            yield sleep(100);
-            expect(handleRequestSpy.callCount).to.equal(2);
-            yield sleep(100);
-            expect(handleRequestSpy.callCount).to.equal(3);
-            yield sleep(100);
-            expect(handleRequestSpy.callCount).to.equal(3);
-        }));
-        it("inits client with Blockchain IID and send query", () => __awaiter(void 0, void 0, void 0, function* () {
-            const client = yield createClient({
-                nodeUrlPool: [LOCAL_POOL],
-                blockchainIid: 0,
-            });
-            const result = yield client.query("test_boolean", {
-                arg1: true,
-            });
-            expect(result).to.equal(1);
-        }));
-    });
-    describe("signTransaction", () => {
-        it("returns transaction with a signature when using signature provider", () => __awaiter(void 0, void 0, void 0, function* () {
-            const client = yield stableConfigClient;
-            const signedTx = yield client.signTransaction(unsignedNonUniqueTx, sigProvA);
-            expect(signedTx.toString("hex")).to.equal(signedNonUniqueTxHex);
-        }));
-        it("returns transaction with a signature when using key pair", () => __awaiter(void 0, void 0, void 0, function* () {
-            const signedTx = yield (yield stableConfigClient).signTransaction(unsignedNonUniqueTx, {
-                privKey: signerPrivKeyA,
-                pubKey: signerPubKeyA,
-            });
-            expect(signedTx.toString("hex")).to.equal(signedNonUniqueTxHex);
-        }));
-        it("adds signature to an already signed transaction", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield stableConfigClient;
-            const signedTxA = yield _client.signTransaction(unsignedNonUniqueTxWithTwoSigners, signerKeyPairA);
-            const signedTx = yield _client.signTransaction(signedTxA, signerKeyPairB);
-            const deserialized = gtxTool.deserialize(signedTx);
-            expect(deserialized.signatures).to.have.length(2);
-            expect(signedTx.toString("hex")).to.equal("a582012930820125a58194308191a1220420bfb34abea1045bb97ed18a5dbb2b8dce84" +
-                "cb181585d55abb321a33133dba0595a51d301ba5193017a20c0c0a736574496e746567" +
-                "6572a5073005a303020101a54c304aa123042102e5a018b3a2e155316109d9cdc5eab7" +
-                "39759c0e07e0c00bf9fccb8237fe4d7f02a123042103cb144659ef300200912762786a" +
-                "173663150592d78f4408390c47e9956d9a6c31a5818b308188a1420440c6d576625143" +
-                "eb97c783efc56a4fef7fa9f76dff775e65222c3217aef96c93be43a4d3d96f8f9c301f" +
-                "da9d9577c86f0dd400f803988bb7b97107c7d61e27b99fa1420440817ef63a1c3bc642" +
-                "6d9c23521ece05ad1b9e6607f68d25c699e4380865e00a82044d3ad31f422bdd9e39d2" +
-                "3769680fcb97bec393b3505de8743709dd3f373487");
-        }));
-        it.skip("returns error if signers does not match signMethod");
-        it("takes a callback, transaction with a signature when using signature provider", () => __awaiter(void 0, void 0, void 0, function* () {
-            const client = yield stableConfigClient;
-            yield client.signTransaction(unsignedNonUniqueTx, sigProvA, (err, signedTx) => {
-                expect(signedTx === null || signedTx === void 0 ? void 0 : signedTx.toString("hex")).to.equal(signedNonUniqueTxHex);
-            });
-        }));
-        it("takes a callback, transaction with a signature when using key pair", done => {
-            stableConfigClient.then(_client => {
-                _client.signTransaction(unsignedNonUniqueTx, { privKey: signerPrivKeyA, pubKey: signerPubKeyA }, (err, signedTx) => {
-                    expect(signedTx === null || signedTx === void 0 ? void 0 : signedTx.toString("hex")).to.equal(signedNonUniqueTxHex);
-                    done();
-                });
-            });
-        });
-        it("rejects promise if signer does not exist", () => __awaiter(void 0, void 0, void 0, function* () {
-            const promise = (yield stableConfigClient).signTransaction(unsignedTx, {
-                privKey: signerPrivKeyB,
-                pubKey: signerPubKeyB,
-            });
-            yield expect(promise).to.be.rejectedWith("No such signer, remember to add signer to transaction before" + " adding a signature");
-        }));
-        it("propagates errors when using a callback if signer does not exist", done => {
-            stableConfigClient.then(_client => {
-                _client.signTransaction(unsignedTx, { privKey: signerPrivKeyB, pubKey: signerPubKeyB }, (err, result) => {
-                    expect(result).to.be.null;
-                    expect(err).to.be.be.an("error");
-                    done();
-                });
-            });
-        });
-    });
-    describe("sendTransaction", () => {
-        it("returns a PromiEvent", () => __awaiter(void 0, void 0, void 0, function* () {
-            const promiEvent = (yield client).sendTransaction({
-                name: "setInteger",
-                args: [randomInt(99999)],
-            });
-            expect(promiEvent.then).to.be.a("function");
-            expect(promiEvent.on).to.be.a("function");
-            expect(promiEvent.once).to.be.a("function");
-        }));
-        // TODO: Results in a timeout error if expect statements fails. Fix this.
-        it("takes a callback", done => {
-            client.then(_client => {
-                _client.sendTransaction({
-                    name: "setInteger",
-                    args: [randomInt(99999)],
-                }, true, (err, receipt) => {
-                    const transactionReceipt = receipt;
-                    expect(transactionReceipt === null || transactionReceipt === void 0 ? void 0 : transactionReceipt.status).to.equal(ResponseStatus.Waiting);
-                    expect(transactionReceipt === null || transactionReceipt === void 0 ? void 0 : transactionReceipt.statusCode).to.equal(200);
-                    expect(transactionReceipt === null || transactionReceipt === void 0 ? void 0 : transactionReceipt.transactionRid).to.not.be.null;
-                    done();
-                });
-            });
-        });
-        it("rejects promise on error", () => __awaiter(void 0, void 0, void 0, function* () {
-            const promise = (yield client).sendTransaction({
-                name: "doesNotExist",
-            });
-            yield expect(promise).to.be.rejected;
-        }));
-        it.skip("rejects promise if transaction is rejected by network");
-        it("rejects promise if signers and signatures array have different size", () => __awaiter(void 0, void 0, void 0, function* () {
-            const signedTx = yield (yield client).signTransaction(unsignedNonUniqueTxWithTwoSigners, sigProvA);
-            const deserializedSignedTx = gtxTool.deserialize(signedTx);
-            expect(deserializedSignedTx.signers.length).to.not.equal(deserializedSignedTx.signatures.length);
-            const promise = (yield client).sendTransaction(signedTx);
-            yield expect(promise).to.be.rejectedWith("Not matching number of signers and signatures");
-        }));
-        it("propagates errors when using a callback", done => {
-            client.then(_client => {
-                _client.sendTransaction({
-                    name: "doesNotExist",
-                }, true, (err, receipt) => {
-                    expect(receipt).to.be.null;
-                    expect(err).to.be.be.an("error");
-                    done();
-                });
-            });
-        });
-        it.skip("resolves promise once the transaction is accepted");
-        // TODO: Results in a timeout error if expect statements fails. Fix this.
-        it("emits PromiEvent 'sent' once transaction is sent", () => __awaiter(void 0, void 0, void 0, function* () {
-            const client = yield createClient({
-                nodeUrlPool: LOCAL_POOL,
-                blockchainIid: 0,
-            });
-            const promiEvent = client.sendTransaction({
-                name: "setInteger",
-                args: [randomInt(99999)],
-            }, true, undefined, ChainConfirmationLevel.None);
-            promiEvent.on(TransactionEvent.DappReceived, (receipt) => {
-                expect(receipt.status).to.equal(ResponseStatus.Waiting);
-                expect(receipt.statusCode).to.equal(200);
-                expect(receipt.transactionRid).to.not.be.null;
-            });
-        }));
-        it.skip("resolves to a TransactionReceipt");
-        // TODO: Test fails when running entire test suite. Make it more robust
-        // by mocking the backend or writing unit tests
-        it.skip("uses default attemptInterval of 500", () => __awaiter(void 0, void 0, void 0, function* () {
-            const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-            const _client = yield createClient({
-                nodeUrlPool: invalidEndpointPool,
-                blockchainRid: process.env.BLOCKCHAIN_RID,
-                failOverConfig: {
-                    attemptsPerEndpoint: 1,
-                },
-            });
-            _client.sendTransaction({
-                name: "setInteger",
-                args: [randomInt(99999)],
-            });
-            expect(handleRequestSpy.callCount).to.equal(1);
-            yield sleep(250);
-            expect(handleRequestSpy.callCount).to.equal(1);
-            yield sleep(500);
-            expect(handleRequestSpy.callCount).to.equal(2);
-            yield sleep(500);
-            expect(handleRequestSpy.callCount).to.equal(3);
-            yield sleep(500);
-            expect(handleRequestSpy.callCount).to.equal(3);
-        }));
-        // TODO: Test fails when running entire test suite. Make it more robust
-        // by mocking the backend or writing unit tests
-        it.skip("uses default pollingInterval of 500", () => __awaiter(void 0, void 0, void 0, function* () {
-            const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-            (yield client).sendTransaction({
-                name: "setInteger",
-                args: [randomInt(99999)],
-            });
-            expect(handleRequestSpy.callCount).to.equal(1);
-            yield sleep(250);
-            // will have sent the transaction and polled for status once
-            expect(handleRequestSpy.callCount).to.equal(2);
-            yield sleep(500);
-            expect(handleRequestSpy.callCount).to.equal(3);
-            yield sleep(500);
-            expect(handleRequestSpy.callCount).to.equal(4);
-        }));
-        // TODO: Test fails when running entire test suite. Make it more robust
-        // by mocking the backend or writing unit tests
-        it.skip("uses configured pollingInterval of 100", () => __awaiter(void 0, void 0, void 0, function* () {
-            const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-            const _client = yield createClient({
-                nodeUrlPool: LOCAL_POOL,
-                blockchainRid: process.env.BLOCKCHAIN_RID,
-                dappStatusPolling: setStatusPolling({ interval: 100, count: CONFIGURED_POLL_COUNT }),
-                clusterAnchoringStatusPolling: setStatusPolling(),
-                systemAnchoringStatusPolling: setStatusPolling(),
-            });
-            _client.sendTransaction({
-                name: "setInteger",
-                args: [randomInt(99999)],
-            });
-            expect(handleRequestSpy.callCount).to.equal(1);
-            yield sleep(100);
-            expect(handleRequestSpy.callCount).to.equal(2);
-            yield sleep(100);
-            expect(handleRequestSpy.callCount).to.equal(3);
-            yield sleep(100);
-            expect(handleRequestSpy.callCount).to.equal(4);
-        }));
-    });
-    describe("addNop", () => {
-        it("adds nop to transaction object", () => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            const transaction = (yield client).addNop(unsignedTx);
-            const nopOperation = transaction.operations[1];
-            expect(nopOperation).to.include({ name: "nop" });
-            expect(nopOperation.args).to.have.lengthOf(1);
-            expect((_a = nopOperation.args) === null || _a === void 0 ? void 0 : _a[0]).to.be.instanceof(Buffer);
-            // TODO changed nop to add randomBytes instead of randomInt because if failed in the browser
-            //expect((nopOperation.args?.[0] as number) % 1).to.equal(0); // Is integer
-        }));
-        it("adds nop with a unique argument", () => __awaiter(void 0, void 0, void 0, function* () {
-            const transactionOne = (yield client).addNop({
-                operations: [
-                    {
-                        name: "setInteger",
-                        args: [1],
-                    },
-                ],
-                signers: [signerPubKeyA],
-            });
-            const transactionTwo = (yield client).addNop({
-                operations: [
-                    {
-                        name: "setInteger",
-                        args: [1],
-                    },
-                ],
-                signers: [signerPubKeyA],
-            });
-            const nopOperationOne = transactionOne.operations[1];
-            const nopOperationTwo = transactionTwo.operations[1];
-            expect(nopOperationOne).to.not.equal(nopOperationTwo);
-        }));
-    });
-    describe("signAndSendUniqueTransaction", () => {
-        it("returns a PromiEvent", () => __awaiter(void 0, void 0, void 0, function* () {
-            const promiEvent = (yield client).signAndSendUniqueTransaction({
-                name: "setInteger",
-                args: [randomInt(99999)],
-            }, sigProvA);
-            expect(promiEvent.then).to.be.a("function");
-            expect(promiEvent.on).to.be.a("function");
-            expect(promiEvent.once).to.be.a("function");
-        }));
-        // TODO: Results in a timeout error if expect statements fails. Fix this.
-        it("takes a callback", done => {
-            client.then(_client => {
-                _client.signAndSendUniqueTransaction({
-                    name: "setInteger",
-                    args: [randomInt(99999)],
-                }, sigProvA, true, (err, receipt) => {
-                    const transactionReceipt = receipt;
-                    expect(transactionReceipt === null || transactionReceipt === void 0 ? void 0 : transactionReceipt.status).to.equal(ResponseStatus.Waiting);
-                    expect(transactionReceipt === null || transactionReceipt === void 0 ? void 0 : transactionReceipt.statusCode).to.equal(200);
-                    expect(transactionReceipt === null || transactionReceipt === void 0 ? void 0 : transactionReceipt.transactionRid).to.not.be.null;
-                    done();
-                });
-            });
-        });
-        it.skip("rejects promise if send failed");
-        it("rejects promise if transaction has empty list of signers", () => __awaiter(void 0, void 0, void 0, function* () {
-            const promise = (yield client).signAndSendUniqueTransaction({
-                operations: [
-                    {
-                        name: "setInteger",
-                        args: [randomInt(99999)],
-                    },
-                ],
-                signers: [],
-            }, sigProvA);
-            yield expect(promise).to.be.rejectedWith("No such signer, remember to add signer to transaction before adding a signature");
-        }));
-        it("rejects promise if transaction has signers that do not match signMethod", () => __awaiter(void 0, void 0, void 0, function* () {
-            const promise = (yield client).signAndSendUniqueTransaction({
-                operations: [
-                    {
-                        name: "setInteger",
-                        args: [randomInt(99999)],
-                    },
-                ],
-                signers: [signerPubKeyB],
-            }, sigProvA);
-            yield expect(promise).to.be.rejectedWith("No such signer, remember to add signer to transaction before adding a signature");
-        }));
-        it.skip("rejects promise if transaction is rejected by network");
-        it("propagates errors when using a callback", done => {
-            client.then(_client => {
-                _client.signAndSendUniqueTransaction({
-                    name: "doesNotExist",
-                }, sigProvA, true, (err, receipt) => {
-                    expect(receipt).to.be.null;
-                    expect(err).to.be.be.an("error");
-                    done();
-                });
-            });
-        });
-        // TODO: Results in a timeout error if expect statements fails. Fix this.
-        it("emits PromiEvent 'sent' once transaction is sent", () => __awaiter(void 0, void 0, void 0, function* () {
-            const client = yield createClient({
-                nodeUrlPool: LOCAL_POOL,
-                blockchainIid: 0,
-            });
-            const promiEvent = client.signAndSendUniqueTransaction({
-                name: "setInteger",
-                args: [randomInt(99999)],
-            }, sigProvA, true, undefined, ChainConfirmationLevel.None);
-            promiEvent.on(TransactionEvent.DappReceived, (receipt) => {
-                expect(receipt.status).to.equal(ResponseStatus.Waiting);
-                expect(receipt.statusCode).to.equal(200);
-                expect(receipt.transactionRid).to.not.be.null;
-            });
-        }));
-        it.skip("resolves promise once the transaction is accepted");
-        it.skip("resolves to a TransactionReceipt");
-        // TODO: Test fails when running entire test suite. Make it more robust
-        // by mocking the backend or writing unit tests
-        it.skip("uses default attemptInterval of 500", () => __awaiter(void 0, void 0, void 0, function* () {
-            const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-            const _client = yield createClient({
-                nodeUrlPool: invalidEndpointPool,
-                blockchainRid: process.env.BLOCKCHAIN_RID,
-                failOverConfig: {
-                    attemptsPerEndpoint: 1,
-                },
-            });
-            _client.signAndSendUniqueTransaction({
-                name: "setInteger",
-                args: [randomInt(99999)],
-            }, signerKeyPairA);
-            yield sleep(10);
-            expect(handleRequestSpy.callCount).to.equal(1);
-            yield sleep(440);
-            expect(handleRequestSpy.callCount).to.equal(1);
-            yield sleep(500);
-            expect(handleRequestSpy.callCount).to.equal(2);
-            yield sleep(500);
-            expect(handleRequestSpy.callCount).to.equal(3);
-            yield sleep(500);
-            expect(handleRequestSpy.callCount).to.equal(3);
-        })).timeout(5000);
-    });
-    describe("getTransaction", () => {
-        it("rejects promise if a specific txRID does not exist in blockchain", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const promise = _client.getTransaction(Buffer.alloc(32, "a"));
-            yield expect(promise).to.be.rejectedWith(`{"error":"Can't find transaction with RID: 6161616161616161616161616161616161616161616161616161616161616161"}`);
-        }));
-        it("returns a promise", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const { txRID } = getTxWithGTXAndTxRID(_client);
-            const promise = _client.getTransaction(txRID);
-            expect(promise.then).to.be.a("function");
-        }));
-        it("rejects promise if transaction RID is invalid", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const promise = _client.getTransaction(Buffer.from("invalid"));
-            yield expect(promise).to.be.rejectedWith("expected length 32 of txRID, but got 7");
-        }));
-        it("propagates errors when using a callback", done => {
-            client.then(_client => {
-                _client.getTransaction(Buffer.from("invalid"), (err, serializedMessage) => {
-                    expect(err === null || err === void 0 ? void 0 : err.message).to.equal("expected length 32 of txRID, but got 7");
-                    expect(serializedMessage).to.be.null;
-                    done();
-                });
-            });
-        });
-    });
-    describe("getTransactionStatus", () => {
-        it("gets status of an unknown transaction", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const { txRID } = getTxWithGTXAndTxRID(_client);
-            const { status } = yield _client.getTransactionStatus(txRID);
-            expect(status).to.equal(ResponseStatus.Unknown);
-        }));
-        it.skip("gets status of a rejected transaction");
-        it("returns a promise", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const { txRID } = getTxWithGTXAndTxRID(_client);
-            const promise = _client.getTransactionStatus(txRID);
-            expect(promise.then).to.be.a("function");
-        }));
-        it("rejects promise if transaction RID is invalid", () => __awaiter(void 0, void 0, void 0, function* () {
-            const promise = (yield client).getTransactionStatus(Buffer.from("invalid"));
-            yield expect(promise).to.be.rejectedWith("expected length 32 of txRID, but got 7");
-        }));
-        it("propagates errors when using a callback", done => {
-            const callback = (err, statusObj) => {
-                expect(err === null || err === void 0 ? void 0 : err.message).to.equal("expected length 32 of txRID, but got 7");
-                expect(statusObj).to.be.null;
-                done();
-            };
-            client.then(_client => {
-                _client.getTransactionStatus(Buffer.from("invalid"), callback);
-            });
-        });
-        it.skip("retries default number of times", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _faultyClient = yield faultyClient;
-            try {
-                const { txRID } = getTxWithGTXAndTxRID(_faultyClient);
-                yield _faultyClient.getTransactionStatus(txRID);
-            }
-            catch (err) {
-                expect(handleRequestSpy.callCount).to.equal(9);
-            }
-        }));
-        it("uses default attemptInterval of 500", () => __awaiter(void 0, void 0, void 0, function* () {
-            const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-            const _client = yield createClient({
-                nodeUrlPool: invalidEndpointPool,
-                blockchainRid: process.env.BLOCKCHAIN_RID,
-                failOverConfig: {
-                    attemptsPerEndpoint: 1,
-                },
-                directoryChainRid: mockStringDirectoryChainRid,
-            });
-            try {
-                const { txRID } = getTxWithGTXAndTxRID(_client);
-                _client.getTransactionStatus(txRID);
-                expect(handleRequestSpy.callCount).to.equal(1);
-                yield sleep(500);
-                expect(handleRequestSpy.callCount).to.equal(1);
-                yield sleep(500);
-                expect(handleRequestSpy.callCount).to.equal(2);
-                yield sleep(500);
-                expect(handleRequestSpy.callCount).to.equal(3);
-                yield sleep(500);
-                expect(handleRequestSpy.callCount).to.equal(3);
-            }
-            catch (error) {
-                expect(error).to.not.be.null;
-            }
-        })).timeout(4000);
-    });
-    describe("getTransactionRID", () => {
-        it("takes a transaction object", () => __awaiter(void 0, void 0, void 0, function* () {
-            const txRID = (yield stableConfigClient).getTransactionRid({
-                operations: [
-                    {
-                        name: "setInteger",
-                        args: [1],
-                    },
-                ],
-                signers: [],
-            });
-            expect(txRID.toString("hex")).to.equal("9f8966574214d987ddcc918c09eb7f1b6a1a75855d8e03bbffb07ef2cb949534");
-        }));
-        it("takes an operation", () => __awaiter(void 0, void 0, void 0, function* () {
-            const txRID = (yield stableConfigClient).getTransactionRid({
-                name: "setInteger",
-                args: [1],
-            });
-            expect(txRID.toString("hex")).to.equal("9f8966574214d987ddcc918c09eb7f1b6a1a75855d8e03bbffb07ef2cb949534");
-        }));
-        it("takes a signed transaction buffer", () => __awaiter(void 0, void 0, void 0, function* () {
-            const signedTx = Buffer.from(signedNonUniqueTxHex, "hex");
-            const txRID = (yield stableConfigClient).getTransactionRid(signedTx);
-            expect(txRID.toString("hex")).to.equal("33754eb08c2a7c6be69821608378ef315399f3113de6ea229023ccad2b7ea7a7");
-        }));
-    });
-    describe("getTransactionsInfo", () => {
-        it("returns empty array when limit is invalid", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const transactions = yield _client.getTransactionsInfo(-1);
-            expect(transactions).to.be.instanceOf(Array).and.lengthOf(0);
-        }));
-        it.skip("returns empty array when before-time is invalid", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const transactions = yield _client.getTransactionsInfo(undefined, new Date(-1));
-            expect(transactions).to.be.instanceOf(Array).and.lengthOf(0);
-        }));
-    });
-    describe("getTransactionInfo", () => {
-        it("should throw 404 error when transaction rid is not found", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const invalidTxRid = "8FB7809B264587F165771FDE89471F8C81838785FB9DAC65E3DFFD1B41B7EFFC";
-            const transactionInfoPromise = _client.getTransactionInfo(toBuffer(invalidTxRid));
-            yield expect(transactionInfoPromise).to.be.rejectedWith(`{"error":"Can't find transaction with RID: ${invalidTxRid}"}`);
-        }));
-    });
-    describe("getBlockInfo", () => {
-        it("should return an error when provided with a block identifier of the wrong type.", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const rejectedPromise = _client.getBlockInfo(["test"]);
-            yield expect(rejectedPromise).to.be.rejectedWith(`Invalid "blockIdentifier" type. Expected string or number, but received object.`);
-        }));
-        it("should return an error when provided with a block identifier string of a wrong format.", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const rejectedPromise = _client.getBlockInfo("123213asdsad");
-            yield expect(rejectedPromise).to.be.rejectedWith("Parameter 'blockIdentifier' does not have the correct format (64-character hexadecimal string).");
-        }));
-        it("should return null when given a non-existing block RID.", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const block = yield _client.getBlockInfo("B640E5935B54E9CB2029C56EF33F89D0A3C1041E2C1B38389F2930DFC1179657");
-            expect(block).to.be.null;
-        }));
-        it("should return null when given a non-existing block height.", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const block = yield _client.getBlockInfo(999999999999);
-            expect(block).to.be.null;
-        }));
-        it("should fetch a block when provided with a block height", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const block = yield _client.getBlockInfo(1);
-            expect(block).to.have.keys([
-                "rid",
-                "prevBlockRid",
-                "header",
-                "height",
-                "transactions",
-                "witness",
-                "witnesses",
-                "timestamp",
-            ]);
-        }));
-        it("should fetch a block when provided with a block RID.", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const blockFromHeight = yield _client.getBlockInfo(1);
-            const block = yield _client.getBlockInfo(blockFromHeight.rid.toString("hex"));
-            expect(block).to.have.keys([
-                "rid",
-                "prevBlockRid",
-                "header",
-                "height",
-                "transactions",
-                "witness",
-                "witnesses",
-                "timestamp",
-            ]);
-        }));
-    });
-    describe("getLatestBlock", () => {
-        it("get latest block", () => __awaiter(void 0, void 0, void 0, function* () {
-            const blockInfo = yield (yield client).getLatestBlock();
-            expect(blockInfo).to.have.keys([
-                "rid",
-                "prevBlockRid",
-                "header",
-                "height",
-                "transactions",
-                "witness",
-                "witnesses",
-                "timestamp",
-            ]);
-        }));
-    });
-    describe("getBlocksInfo", () => {
-        it("fetches all blocks for a chain", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const blocks = yield _client.getBlocksInfo();
-            expect(blocks).to.not.be.empty;
-        }));
-        it("fetches all blocks before a block height", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const blocks = yield _client.getBlocksInfo(undefined, undefined, 2);
-            expect(blocks).to.have.length(2);
-        }));
-    });
-    describe("getClientNodeURLPool", () => {
-        it("gets list of url from the client config", () => __awaiter(void 0, void 0, void 0, function* () {
-            const nodeUrlPool = (yield client).getClientNodeUrlPool();
-            expect(nodeUrlPool).to.deep.equal([LOCAL_POOL]);
-        }));
-    });
-    describe("getConfirmationProof", () => {
-        it("returns error", () => __awaiter(void 0, void 0, void 0, function* () {
-            const _client = yield client;
-            const promise = _client.getConfirmationProof(mockThirtyTwoBytesBuffer);
-            yield expect(promise).to.be.rejectedWith(`{"error":"Can't find transaction with RID: 0000000000000000000000000000000000000000000000000000000000000000"}`);
-        }));
-    });
-    describe("createClient", () => {
-        it("initializes with default status polling configurations", () => __awaiter(void 0, void 0, void 0, function* () {
-            const client = yield createClient({
-                nodeUrlPool: LOCAL_POOL,
-                blockchainRid: "BFB34ABEA1045BB97ED18A5DBB2B8DCE84CB181585D55ABB321A33133DBA0595",
-            });
-            const defaultStatusPollingConfig = {
-                interval: 500,
-                count: 20,
-            };
-            expect(client.config.dappStatusPolling).to.deep.equal(defaultStatusPollingConfig);
-            expect(client.config.clusterAnchoringStatusPolling).to.deep.equal(defaultStatusPollingConfig);
-            expect(client.config.systemAnchoringStatusPolling).to.deep.equal(defaultStatusPollingConfig);
-        }));
-        it("initializes with 3 different status polling configurations", () => __awaiter(void 0, void 0, void 0, function* () {
-            const dappStatusPollingConfig = {
-                interval: 100,
-                count: 5,
-            };
-            const clusterAnchoringStatusPollingConfig = {
-                interval: 200,
-                count: 10,
-            };
-            const systemAnchoringStatusPollingConfig = {
-                interval: 500,
-                count: 20,
-            };
-            const client = yield createClient({
-                nodeUrlPool: LOCAL_POOL,
-                blockchainRid: "BFB34ABEA1045BB97ED18A5DBB2B8DCE84CB181585D55ABB321A33133DBA0595",
-                dappStatusPolling: dappStatusPollingConfig,
-                clusterAnchoringStatusPolling: clusterAnchoringStatusPollingConfig,
-                systemAnchoringStatusPolling: systemAnchoringStatusPollingConfig,
-            });
-            expect(client.config.dappStatusPolling).to.deep.equal(dappStatusPollingConfig);
-            expect(client.config.clusterAnchoringStatusPolling).to.deep.equal(clusterAnchoringStatusPollingConfig);
-            expect(client.config.systemAnchoringStatusPolling).to.deep.equal(systemAnchoringStatusPollingConfig);
-        }));
-    });
-});
-//# sourceMappingURL=blockchainClientIntegration.test.js.map