postchain-client 1.22.0 → 2.0.0

package/built/test/unit/blockchainClient/sendTransaction.test.js

@@ -7,693 +7,370 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { createClient } from "../../../src/blockchainClient/blockchainClient";
-import sinon from "sinon";
-import { expect } from "chai";
-import { TxRejectedError, UnexpectedStatusError } from "../../../src/restclient/errors";
+import { TxRejectedError, UnexpectedStatusError } from "../../../src/blockchainClient/errors";
 import { server } from "../../../mocks/servers";
 import { errorHandler } from "../../../mocks/handlers";
-import { clientConfiguredToD1 } from "../ICCF/iccfProofMaterialBuilder.test";
-import * as iccf from "../../../src/ICCF/IccfProofTxMaterialBuilder";
 import { AnchoringStatus, ChainConfirmationLevel, ResponseStatus, TransactionEvent, } from "../../../src/blockchainClient/enums";
-import { AnchoringTransactionSchema } from "../../../src/blockchainClient/validation/anchoringTransaction";
+import { exampleOperation, mockBuffer, mockSignatureProvider, mockUnsignedTx, mockUnsignedMultiOperationTx, mockSignerKeyPair, CONFIGURED_POLL_COUNT, mockTransactionReceipts, mockClusterAnchoringConfirmationResponse, mockSystemAnchoringConfirmationResponse, mockGtx, unsignedNonUniqueTxWithTwoSigners, LOCAL_POOL, } from "../../common/mocks";
+import { ComplexArgumentObject } from "../../common/testData";
+import { getTestsClient, handleTransactionConfirmationMockEvents } from "../../common/setups";
 import * as utils from "../../../src/blockchainClient/utils";
-import { resolveClusterAnchoringTransactionConfirmationWithStubs } from "./helpers/sendTransaction";
-import { CONFIGURED_POLL_COUNT, exampleOperation, mockAnchoringTransaction, mockBuffer, mockConfirmationProof, mockStringBlockchainRid, mockStringDirectoryChainRid, mockThirtyTwoBytesBuffer, mockSignatureProvider, signerPubKey, mockUnsignedTx, signerKeyPair, CONFIGURED_POLL_INTERVAL, } from "../common/mocks";
-import * as gtxTool from "../../../src/gtx/gtx";
-import { randomBytes } from "../../../src/encryption/encryption";
-import { ComplexArgumentObject } from "../../integration/testData";
-import * as handleRequestModule from "../../../src/restclient/httpUtil";
+import * as httpUtils from "../../../src/blockchainClient/httpUtil";
+import { Web3PromiEvent } from "../../../src/promiEvent/promiEvents";
+import { http, HttpResponse } from "msw";
+import { NumberOfSignersAndSignaturesException } from "../../../src/gtx/errors";
 const rejectReason = "[bc-rid=8E:DFB4, chain-id=0] Operation 'news_feed_ch5.news_feed:make_post' failed: Expected at least two operations, make sure that you included auth";
-const invalidFormatRejectReason = "Operation 'news_feed_ch5.news_feed:make_post' failed: Expected at least two operations, make sure that you included auth";
 let client;
-const mockAnchoringClient = clientConfiguredToD1;
-const mockSystemAnchoringClient = clientConfiguredToD1;
-let getTransactionStatusStub;
-let getConfirmationProofStub;
-let getBlockAnchoringTransactionStub;
-let getSystemAnchoringTransactionConfirmationStub;
-let anchoringTransactionSchemaStub;
-let sendTransactionSentPromiEventDappReceived;
-let sendTransactionSentPromiEventDappConfirmed;
-let sendTransactionSentPromiEventClusterConfirmed;
-let sendTransactionSentPromiEventSystemConfirmed;
-let getDigestToSignStub;
-let handleRequestSpy;
-let handleDappConfirmationsStub;
-let handleSystemConfirmationsStub;
-const mockUnsignedMultiOperationTx = {
-    operations: [exampleOperation, { name: "nop", args: [randomBytes(32)] }],
-    signers: [signerPubKey],
-};
-describe("sendTransaction", () => __awaiter(void 0, void 0, void 0, function* () {
-    before(() => __awaiter(void 0, void 0, void 0, function* () {
+describe("send transactions", () => {
+    beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
         server.listen();
-        client = yield createClient({
-            nodeUrlPool: [`http://localhost`, `http://localhost`],
-            blockchainRid: mockStringBlockchainRid,
-            dappStatusPolling: utils.setStatusPolling({
-                interval: CONFIGURED_POLL_INTERVAL,
-                count: CONFIGURED_POLL_COUNT,
-            }),
-            clusterAnchoringStatusPolling: utils.setStatusPolling(),
-            systemAnchoringStatusPolling: utils.setStatusPolling(),
-            directoryChainRid: mockStringDirectoryChainRid,
-        });
+        client = yield getTestsClient();
     }));
     beforeEach(() => {
-        getConfirmationProofStub = sinon.stub(client, "getConfirmationProof");
-        getSystemAnchoringTransactionConfirmationStub = sinon.stub(client, "getSystemAnchoringTransactionConfirmation");
-        getBlockAnchoringTransactionStub = sinon.stub(iccf, "getBlockAnchoringTransaction");
-        anchoringTransactionSchemaStub = sinon.stub(AnchoringTransactionSchema, "safeParse");
-        sinon.stub(utils, "getAnchoringClientAndSystemChainRid").resolves({
-            anchoringClient: mockAnchoringClient,
-            systemAnchoringChainBridString: mockSystemAnchoringClient.config.blockchainRid,
+        jest.clearAllMocks();
+        jest.spyOn(utils, "getAnchoringClientAndSystemChainRid").mockResolvedValue({
+            anchoringClient: client,
+            systemAnchoringChainBridString: client.config.blockchainRid,
         });
-        getTransactionStatusStub = sinon.stub(client, "getTransactionStatus");
-        getDigestToSignStub = sinon.stub(gtxTool, "getDigestToSign");
-        handleRequestSpy = sinon.spy(handleRequestModule, "default");
-        handleDappConfirmationsStub = sinon.stub(utils, "handleDappConfirmations");
-        handleSystemConfirmationsStub = sinon.stub(utils, "handleSystemConfirmations");
     });
     afterEach(() => {
+        jest.restoreAllMocks();
         server.resetHandlers();
-        sinon.restore();
-        sinon.reset();
     });
-    it("should throw error if endpoint returns 400 status", () => __awaiter(void 0, void 0, void 0, function* () {
-        server.use(errorHandler.txError);
-        try {
-            yield client.sendTransaction(exampleOperation);
-        }
-        catch (error) {
-            expect(error).to.be.instanceOf(UnexpectedStatusError);
-        }
-    })).timeout(4000);
-    it("should throw TxRejectedError with detailed error information if transaction is rejected", () => __awaiter(void 0, void 0, void 0, function* () {
-        getTransactionStatusStub.throws(new TxRejectedError(rejectReason));
-        server.use(errorHandler.statusRejected);
-        try {
-            yield client.sendTransaction(exampleOperation);
-        }
-        catch (error) {
-            expect(error).to.be.instanceOf(TxRejectedError);
-            expect(error.message).to.equal(`Transaction was rejected, ${rejectReason}`);
-            expect(error.fullReason).to.equal(`${rejectReason}`);
-            expect(error.shortReason).to.equal("Expected at least two operations, make sure that you included auth");
-            expect(error.operation).to.equal("news_feed_ch5.news_feed:make_post");
-            expect(error.rellLine).to.equal("bc-rid=8E:DFB4, chain-id=0");
-            expect(getTransactionStatusStub.callCount).to.equal(1);
-        }
-    }));
-    it("throws error if transaction gets rejected, rejectReason is not standard format and error will not containing full reason, short reason, operation and rell line", () => __awaiter(void 0, void 0, void 0, function* () {
-        getTransactionStatusStub.throws(new TxRejectedError(invalidFormatRejectReason));
-        server.use(errorHandler.txStatusInvalidRejectFormat);
-        try {
-            yield client.sendTransaction(exampleOperation);
-        }
-        catch (error) {
-            console.log(error);
-            expect(error).to.be.instanceOf(TxRejectedError);
-            expect(error.message).to.equal(`Transaction was rejected, ${invalidFormatRejectReason}`);
-            expect(error.fullReason).to.equal(`${invalidFormatRejectReason}`);
-            expect(error.shortReason).to.be.undefined;
-            expect(error.operation).to.be.undefined;
-            expect(error.rellLine).to.be.undefined;
-            expect(getTransactionStatusStub.callCount).to.equal(1);
-        }
-    }));
-    it('should return status "Confirmed" when transaction is confirmed', () => __awaiter(void 0, void 0, void 0, function* () {
-        const transactionReceipt = {
-            status: ResponseStatus.Confirmed,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        };
-        getDigestToSignStub.returns(mockBuffer);
-        getTransactionStatusStub.resolves(transactionReceipt);
-        handleDappConfirmationsStub.resolves(transactionReceipt);
-        const status = yield client.sendTransaction(exampleOperation);
-        expect(status).to.deep.equal(transactionReceipt);
-    }));
-    it('should return status "Waiting"', () => __awaiter(void 0, void 0, void 0, function* () {
-        const transactionReceipt = {
-            status: ResponseStatus.Waiting,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        };
-        getDigestToSignStub.returns(mockBuffer);
-        getTransactionStatusStub.resolves(transactionReceipt);
-        handleDappConfirmationsStub.resolves(transactionReceipt);
-        const status = yield client.sendTransaction(exampleOperation);
-        expect(status).to.deep.equal(transactionReceipt);
-    })).timeout(4000);
-    it('should return status "Unknown"', () => __awaiter(void 0, void 0, void 0, function* () {
-        const transactionReceipt = {
-            status: ResponseStatus.Unknown,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        };
-        getDigestToSignStub.returns(mockBuffer);
-        getTransactionStatusStub.resolves(transactionReceipt);
-        handleDappConfirmationsStub.resolves(transactionReceipt);
-        const status = yield client.sendTransaction(exampleOperation);
-        expect(status).to.deep.equal(transactionReceipt);
-    }));
-    it("returns status confirmed after getting status waiting and retries until status is confirmed", () => __awaiter(void 0, void 0, void 0, function* () {
-        const transactionReceipt = {
-            status: ResponseStatus.Confirmed,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        };
-        getTransactionStatusStub.onCall(0).resolves({
-            status: ResponseStatus.Unknown,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        });
-        getDigestToSignStub.returns(mockBuffer);
-        handleDappConfirmationsStub.resolves(transactionReceipt);
-        const status = yield client.sendTransaction(exampleOperation);
-        expect(status).to.deep.equal(transactionReceipt);
-    }));
-    it("should get tx-status when `confirmationLevel` is set to Dapp", () => __awaiter(void 0, void 0, void 0, function* () {
-        const transactionReceipt = {
-            status: ResponseStatus.Waiting,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        };
-        getTransactionStatusStub.resolves(transactionReceipt);
-        handleDappConfirmationsStub.resolves(transactionReceipt);
-        yield client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.Dapp);
-    }));
-    it("should NOT poll for a tx-status when given the flag: `doStatusPolling` set to false", () => __awaiter(void 0, void 0, void 0, function* () {
-        const transactionReceipt = {
-            status: ResponseStatus.Waiting,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        };
-        getDigestToSignStub.returns(mockBuffer);
-        getTransactionStatusStub.resolves(transactionReceipt);
-        handleDappConfirmationsStub.resolves(transactionReceipt);
-        const result = yield client.sendTransaction(exampleOperation, false);
-        expect(result).to.deep.equal(transactionReceipt);
-        expect(getTransactionStatusStub.callCount).to.equal(0);
-    }));
-    it("should throw TxRejectedError with failedAnchoring anchoring status", () => __awaiter(void 0, void 0, void 0, function* () {
-        handleDappConfirmationsStub.resolves({
-            status: ResponseStatus.Confirmed,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        });
-        handleSystemConfirmationsStub.rejects(new TxRejectedError(AnchoringStatus.FailedAnchoring));
-        try {
-            yield client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.ClusterAnchoring);
-        }
-        catch (error) {
-            expect(error).to.be.instanceOf(TxRejectedError);
-            expect(error.message).to.equal(`Transaction was rejected, ${AnchoringStatus.FailedAnchoring}`);
-        }
-    }));
-    it("sends an unsigned transaction", () => __awaiter(void 0, void 0, void 0, function* () {
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-        });
-        const transactionReceipt = yield client.sendTransaction(exampleOperation);
-        expect(transactionReceipt).to.deep.equal({
-            status: ResponseStatus.Confirmed,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        });
-    }));
-    it("signs and sends a transaction", () => __awaiter(void 0, void 0, void 0, function* () {
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-        });
-        const signedTx = yield client.signTransaction(mockUnsignedTx, mockSignatureProvider);
-        const transactionReceipt = yield client.sendTransaction(signedTx, true, undefined, ChainConfirmationLevel.Dapp);
-        expect(transactionReceipt).to.deep.equal({
-            status: ResponseStatus.Confirmed,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        });
-    }));
-    it("sends a transaction with multiple operations", () => __awaiter(void 0, void 0, void 0, function* () {
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-        });
-        const signedMultiOperationTx = yield client.signTransaction(mockUnsignedMultiOperationTx, mockSignatureProvider);
-        const transactionReceipt = yield client.sendTransaction(signedMultiOperationTx);
-        expect(transactionReceipt).to.deep.equal({
-            status: ResponseStatus.Confirmed,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        });
-    }));
-    it("signAndSendUniqueTransaction sends a transaction", () => __awaiter(void 0, void 0, void 0, function* () {
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-        });
-        const transactionReceipt = yield client.signAndSendUniqueTransaction(mockUnsignedTx, mockSignatureProvider);
-        expect(transactionReceipt).to.deep.equal({
-            status: ResponseStatus.Confirmed,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        });
-    }));
-    it("signAndSendUniqueTransaction sends an operation", () => __awaiter(void 0, void 0, void 0, function* () {
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-        });
-        const transactionReceipt = yield client.signAndSendUniqueTransaction(exampleOperation, mockSignatureProvider);
-        expect(transactionReceipt).to.deep.equal({
-            status: ResponseStatus.Confirmed,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        });
-    }));
-    it("signAndSendUniqueTransaction signs if no pubKey was provided", () => __awaiter(void 0, void 0, void 0, function* () {
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-        });
-        const transactionReceipt = yield client.signAndSendUniqueTransaction(exampleOperation, signerKeyPair);
-        expect(transactionReceipt).to.deep.equal({
-            status: ResponseStatus.Confirmed,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        });
-    }));
-    it("signAndSendUniqueTransaction adds a nop", () => __awaiter(void 0, void 0, void 0, function* () {
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-        });
-        const transactionReceipt = yield client.signAndSendUniqueTransaction(exampleOperation, signerKeyPair);
-        const transactionReceiptCopy = yield client.signAndSendUniqueTransaction(exampleOperation, signerKeyPair);
-        const expectedResponse = {
-            status: ResponseStatus.Confirmed,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        };
-        expect(transactionReceipt).to.deep.equal(expectedResponse);
-        expect(transactionReceiptCopy).to.deep.equal(expectedResponse);
-    }));
-    it("signAndSendUniqueTransaction signs and sends a transaction with multiple operations", () => __awaiter(void 0, void 0, void 0, function* () {
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-        });
-        const transactionReceipt = yield client.signAndSendUniqueTransaction(mockUnsignedMultiOperationTx, mockSignatureProvider);
-        expect(transactionReceipt).to.deep.equal({
-            status: ResponseStatus.Confirmed,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        });
-    }));
-    it("signAndSendUniqueTransaction signs and sends an operation with large complex arguments", () => __awaiter(void 0, void 0, void 0, function* () {
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-        });
-        const transactionReceipt = yield client.signAndSendUniqueTransaction({
-            name: "set_globals",
-            args: [
-                ComplexArgumentObject.client_data,
-                ComplexArgumentObject.server_data,
-                ComplexArgumentObject.args,
-            ],
-        }, mockSignatureProvider);
-        expect(transactionReceipt).to.deep.equal({
-            status: ResponseStatus.Confirmed,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        });
-    }));
-    it("should confirm the transaction is added in a block in the cluster anchoring chain with sendTransation", () => __awaiter(void 0, void 0, void 0, function* () {
-        const expectedResponse = {
-            status: AnchoringStatus.ClusterAnchored,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-            clusterAnchoredTx: mockAnchoringTransaction,
-            clusterAnchoringClientBrid: mockAnchoringClient.config.blockchainRid,
-        };
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-            systemConfirmationMockResult: expectedResponse,
-        });
-        const result = yield client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.ClusterAnchoring);
-        expect(result).to.deep.equal(expectedResponse);
-    }));
-    it("should sendTransaction with one sent promiEvent when confirmation level is set to None", () => __awaiter(void 0, void 0, void 0, function* () {
-        const transactionReceipt = {
-            status: ResponseStatus.Waiting,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        };
-        sendTransactionSentPromiEventDappReceived = sinon.spy();
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-            dappConfirmationMockResult: transactionReceipt,
-        });
-        const promiEvent = client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.None);
-        promiEvent.on(TransactionEvent.DappReceived, sendTransactionSentPromiEventDappReceived);
-        const transactionResult = yield promiEvent;
-        expect(transactionResult).to.deep.equal(transactionReceipt);
-    }));
-    it("should sendTransaction with two sent promiEvents when confirmation level is set to Dapp", () => __awaiter(void 0, void 0, void 0, function* () {
-        sendTransactionSentPromiEventDappReceived = sinon.spy();
-        sendTransactionSentPromiEventDappConfirmed = sinon.spy();
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-        });
-        const promiEvent = client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.Dapp);
-        promiEvent.on(TransactionEvent.DappReceived, sendTransactionSentPromiEventDappReceived);
-        promiEvent.on(TransactionEvent.DappConfirmed, sendTransactionSentPromiEventDappConfirmed);
-        const transactionResult = yield promiEvent;
-        const transactionReceipt = {
-            status: ResponseStatus.Confirmed,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        };
-        expect(transactionResult).to.deep.equal(transactionReceipt);
-    }));
-    it("should sendTransaction with three sent promiEvents when confirmation level is set to ClusterAnchoringChain", () => __awaiter(void 0, void 0, void 0, function* () {
-        sendTransactionSentPromiEventDappReceived = sinon.spy();
-        sendTransactionSentPromiEventDappConfirmed = sinon.spy();
-        sendTransactionSentPromiEventClusterConfirmed = sinon.spy();
-        const transactionReceipt = {
-            status: AnchoringStatus.ClusterAnchored,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-            clusterAnchoredTx: mockAnchoringTransaction,
-            clusterAnchoringClientBrid: mockAnchoringClient.config.blockchainRid,
-        };
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-            systemConfirmationMockResult: transactionReceipt,
-        });
-        const promiEvent = client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.ClusterAnchoring);
-        promiEvent.on(TransactionEvent.DappReceived, sendTransactionSentPromiEventDappReceived);
-        promiEvent.on(TransactionEvent.DappConfirmed, sendTransactionSentPromiEventDappConfirmed);
-        promiEvent.on(TransactionEvent.ClusterAnchoringConfirmation, sendTransactionSentPromiEventClusterConfirmed);
-        const transactionResult = yield promiEvent;
-        expect(transactionResult).to.deep.equal(transactionReceipt);
-    }));
-    it("should sendTransaction with four sent promiEvents when confirmation level is set to SystemAnchoring", () => __awaiter(void 0, void 0, void 0, function* () {
-        sendTransactionSentPromiEventDappReceived = sinon.spy();
-        sendTransactionSentPromiEventDappConfirmed = sinon.spy();
-        sendTransactionSentPromiEventClusterConfirmed = sinon.spy();
-        sendTransactionSentPromiEventSystemConfirmed = sinon.spy();
-        const transactionReceipt = {
-            status: AnchoringStatus.SystemAnchored,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-            clusterAnchoredTx: mockAnchoringTransaction,
-            clusterAnchoringClientBrid: mockAnchoringClient.config.blockchainRid,
-            systemAnchoredTx: mockAnchoringTransaction,
-            systemAnchoringClientBrid: mockSystemAnchoringClient.config.blockchainRid,
-        };
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-            systemConfirmationMockResult: transactionReceipt,
-        });
-        const promiEvent = client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.SystemAnchoring);
-        const transactionResult = yield promiEvent;
-        expect(transactionResult).to.deep.equal(transactionReceipt);
-    }));
-    it("should fail to confirm the transaction in the anchoring chain", () => __awaiter(void 0, void 0, void 0, function* () {
-        getTransactionStatusStub.resolves({
-            status: ResponseStatus.Confirmed,
-            statusCode: 200,
-            transactionRid: mockBuffer,
-        });
-        getConfirmationProofStub
-            .withArgs(mockThirtyTwoBytesBuffer)
-            .rejects(new Error("Cluster anchoring chain confirmation failed: fetch failed"));
-        try {
-            yield client.sendTransaction(exampleOperation);
-            throw new Error("Cluster anchoring chain confirmation failed: fetch failed");
-        }
-        catch (error) {
-            expect(error.message).to.equal("Cluster anchoring chain confirmation failed: fetch failed");
-        }
-    }));
-    it("retries default number of times", () => __awaiter(void 0, void 0, void 0, function* () {
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-        });
-        try {
-            yield client.sendTransaction(exampleOperation);
-        }
-        catch (error) {
-            expect(handleRequestSpy.callCount).to.equal(9);
-        }
-    }));
-    it("retries default number of times", () => __awaiter(void 0, void 0, void 0, function* () {
-        resolveClusterAnchoringTransactionConfirmationWithStubs({
-            transactionStatusStub: getTransactionStatusStub,
-            confirmationProofStub: getConfirmationProofStub,
-            blockAnchoringTransactionStub: getBlockAnchoringTransactionStub,
-            anchoringTransactionSchemaStub: anchoringTransactionSchemaStub,
-            systemAnchoringTransactionConfirmationStub: getSystemAnchoringTransactionConfirmationStub,
-            digestToSignStub: getDigestToSignStub,
-            handleDappConfirmationsStub,
-            handleSystemConfirmationsStub,
-        }, {
-            sourceClient: client,
-            anchoringClient: mockAnchoringClient,
-        }, {
-            transactionRid: mockBuffer,
-            confirmationProof: mockConfirmationProof,
-            anchoringTransaction: mockAnchoringTransaction,
-            directoryNodeUrlPool: utils.getUrlsFromEndpoints(client.config.endpointPool),
-        });
-        try {
-            yield client.signAndSendUniqueTransaction(exampleOperation, signerKeyPair);
-        }
-        catch (error) {
-            expect(handleRequestSpy.callCount).to.equal(9);
-        }
-    }));
-}));
+    describe("sendTransaction", () => {
+        it("takes a callback", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockCallback = jest.fn();
+            yield client.sendTransaction(exampleOperation, true, mockCallback);
+            expect(mockCallback).toHaveBeenCalled();
+            expect(mockCallback).toHaveBeenCalledWith(null, mockTransactionReceipts.waiting);
+        }));
+        it("throws an error if endpoint returns 400 status", () => __awaiter(void 0, void 0, void 0, function* () {
+            server.use(errorHandler.txError);
+            yield expect(client.sendTransaction(exampleOperation)).rejects.toThrow(new UnexpectedStatusError(400, '{"error": "Could not parse JSON"}'));
+        }));
+        it("throws TxRejectedError with detailed error information if transaction is rejected", () => __awaiter(void 0, void 0, void 0, function* () {
+            server.use(errorHandler.statusRejected);
+            yield expect(client.sendTransaction(exampleOperation)).rejects.toMatchObject({
+                fullReason: rejectReason,
+                shortReason: "Expected at least two operations, make sure that you included auth",
+                rellLine: "bc-rid=8E:DFB4, chain-id=0",
+                operation: "news_feed_ch5.news_feed:make_post",
+            });
+        }));
+        it("throws error if transaction gets rejected, rejectReason is not standard format and error will not contain full reason, short reason, operation and rell line", () => __awaiter(void 0, void 0, void 0, function* () {
+            server.use(errorHandler.txStatusInvalidRejectFormat);
+            const invalidFormatRejectReason = "Operation 'news_feed_ch5.news_feed:make_post' failed: Expected at least two operations, make sure that you included auth";
+            yield expect(client.sendTransaction(exampleOperation)).rejects.toMatchObject({
+                fullReason: invalidFormatRejectReason,
+                shortReason: undefined,
+                rellLine: undefined,
+                operation: undefined,
+            });
+        }));
+        it("returns status Confirmed when transaction is confirmed in Dapp", () => __awaiter(void 0, void 0, void 0, function* () {
+            const response = yield client.sendTransaction(exampleOperation);
+            expect(response).toEqual(mockTransactionReceipts.confirmed);
+        }));
+        it("returns status Waiting when transaction is waiting and reaches configured poll count", () => __awaiter(void 0, void 0, void 0, function* () {
+            const clientWithConfiguredDappPollCount = yield getTestsClient({
+                dappStatusPolling: utils.setStatusPolling({
+                    count: CONFIGURED_POLL_COUNT,
+                }),
+            });
+            const getTransactionStatusSpy = jest.spyOn(clientWithConfiguredDappPollCount, "getTransactionStatus");
+            server.use(errorHandler.statusWaiting);
+            const response = yield clientWithConfiguredDappPollCount.sendTransaction(exampleOperation);
+            expect(response).toEqual(mockTransactionReceipts.waiting);
+            expect(getTransactionStatusSpy).toHaveBeenCalledTimes(CONFIGURED_POLL_COUNT);
+        }));
+        it("returns status Unknown when transaction status is unknown and reaches configured poll count", () => __awaiter(void 0, void 0, void 0, function* () {
+            const clientWithConfiguredDappPollCount = yield getTestsClient({
+                dappStatusPolling: utils.setStatusPolling({
+                    count: CONFIGURED_POLL_COUNT,
+                }),
+            });
+            const getTransactionStatusSpy = jest.spyOn(clientWithConfiguredDappPollCount, "getTransactionStatus");
+            server.use(errorHandler.statusUnknown);
+            const response = yield clientWithConfiguredDappPollCount.sendTransaction(exampleOperation);
+            expect(response).toEqual(mockTransactionReceipts.unknown);
+            expect(getTransactionStatusSpy).toHaveBeenCalledTimes(CONFIGURED_POLL_COUNT);
+        }));
+        it("get tx-status when ConfirmationLevel is set to Dapp", () => __awaiter(void 0, void 0, void 0, function* () {
+            const response = yield client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.Dapp);
+            expect(response).toEqual(mockTransactionReceipts.confirmed);
+        }));
+        it("does NOT poll for tx-status when doStatusPolling flag is false", () => __awaiter(void 0, void 0, void 0, function* () {
+            const getTransactionStatusSpy = jest.spyOn(client, "getTransactionStatus");
+            const result = yield client.sendTransaction(exampleOperation, false);
+            expect(result).toEqual(mockTransactionReceipts.pending);
+            expect(getTransactionStatusSpy).not.toHaveBeenCalled();
+        }));
+        it("throws TxRejectedError with FailedAnchoring Anchoring Status", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.ClusterAnchoring)).rejects.toThrow(new TxRejectedError(AnchoringStatus.FailedAnchoring));
+        }));
+        it("sends an unsigned transaction and receives dapp confirmed status", () => __awaiter(void 0, void 0, void 0, function* () {
+            const transactionReceipt = yield client.sendTransaction(exampleOperation);
+            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+        }));
+        it("throws a NumberOfSignersAndSignaturesException if signers and signatures array have different size", () => __awaiter(void 0, void 0, void 0, function* () {
+            const signedTransaction = yield client.signTransaction(unsignedNonUniqueTxWithTwoSigners, mockSignatureProvider);
+            yield expect(client.sendTransaction(signedTransaction)).rejects.toThrow(NumberOfSignersAndSignaturesException);
+        }));
+        it("signs and sends a transaction", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockSignedTransaction = mockBuffer;
+            jest.spyOn(client, "signTransaction").mockResolvedValue(mockSignedTransaction);
+            jest.spyOn(utils, "getGTXFromBufferOrTransactionOrOperation").mockReturnValue(mockGtx);
+            jest.spyOn(client, "signTransaction").mockResolvedValue(mockSignedTransaction);
+            jest
+                .spyOn(utils, "handleDappConfirmations")
+                .mockResolvedValue(mockTransactionReceipts.confirmed);
+            const transactionReceipt = yield client.sendTransaction(mockSignedTransaction);
+            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+        }));
+        it("sends a transaction with multiple operations", () => __awaiter(void 0, void 0, void 0, function* () {
+            const signedMultiOperationTx = mockBuffer;
+            jest.spyOn(utils, "getGTXFromBufferOrTransactionOrOperation").mockReturnValue(mockGtx);
+            jest.spyOn(client, "signTransaction").mockResolvedValue(signedMultiOperationTx);
+            jest
+                .spyOn(utils, "handleDappConfirmations")
+                .mockResolvedValue(mockTransactionReceipts.confirmed);
+            const transactionReceipt = yield client.sendTransaction(signedMultiOperationTx);
+            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+        }));
+        it("receives a Cluster Anchoring Confirmation", () => __awaiter(void 0, void 0, void 0, function* () {
+            jest
+                .spyOn(utils, "handleDappConfirmations")
+                .mockResolvedValue(mockTransactionReceipts.confirmed);
+            jest
+                .spyOn(utils, "handleSystemConfirmations")
+                .mockResolvedValue(mockClusterAnchoringConfirmationResponse);
+            const result = yield client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.ClusterAnchoring);
+            expect(result).toEqual(mockClusterAnchoringConfirmationResponse);
+        }));
+        it("receives a System Anchoring Confirmation", () => __awaiter(void 0, void 0, void 0, function* () {
+            jest
+                .spyOn(utils, "handleDappConfirmations")
+                .mockResolvedValue(mockTransactionReceipts.confirmed);
+            jest
+                .spyOn(utils, "handleSystemConfirmations")
+                .mockResolvedValue(mockSystemAnchoringConfirmationResponse);
+            const result = yield client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.SystemAnchoring);
+            expect(result).toEqual(mockSystemAnchoringConfirmationResponse);
+        }));
+        it("triggers DappReceived event when ConfirmationLevel is None", () => __awaiter(void 0, void 0, void 0, function* () {
+            handleTransactionConfirmationMockEvents([
+                {
+                    eventToEmit: TransactionEvent.DappReceived,
+                    eventResolution: mockTransactionReceipts.waiting,
+                },
+            ]);
+            const promiEvent = client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.None);
+            const promiEventSpy = jest.spyOn(promiEvent, "emit");
+            yield expect(promiEvent).resolves.toEqual(mockTransactionReceipts.waiting);
+            expect(promiEventSpy).toHaveBeenCalledTimes(1);
+            expect(promiEventSpy).toHaveBeenCalledWith(TransactionEvent.DappReceived, mockTransactionReceipts.waiting);
+        }));
+        it("triggers DappReceived and DappConfirmed events when Confirmation level is set to Dapp", () => __awaiter(void 0, void 0, void 0, function* () {
+            handleTransactionConfirmationMockEvents([
+                {
+                    eventToEmit: TransactionEvent.DappReceived,
+                    eventResolution: mockTransactionReceipts.waiting,
+                },
+                {
+                    eventToEmit: TransactionEvent.DappConfirmed,
+                    eventResolution: mockTransactionReceipts.confirmed,
+                },
+            ]);
+            const promiEvent = client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.Dapp);
+            const promiEventSpy = jest.spyOn(promiEvent, "emit");
+            yield expect(promiEvent).resolves.toEqual(mockTransactionReceipts.confirmed);
+            expect(promiEventSpy).toHaveBeenCalledTimes(2);
+            expect(promiEventSpy).toHaveBeenCalledWith(TransactionEvent.DappReceived, mockTransactionReceipts.waiting);
+            expect(promiEventSpy).toHaveBeenCalledWith(TransactionEvent.DappConfirmed, mockTransactionReceipts.confirmed);
+        }));
+        it("triggers DappReceived, DappConfirmed and ClusterAnchoringConfirmation events when Confirmation level is set to ClusterAnchoringChain", () => __awaiter(void 0, void 0, void 0, function* () {
+            handleTransactionConfirmationMockEvents([
+                {
+                    eventToEmit: TransactionEvent.DappReceived,
+                    eventResolution: mockTransactionReceipts.waiting,
+                },
+                {
+                    eventToEmit: TransactionEvent.DappConfirmed,
+                    eventResolution: mockTransactionReceipts.confirmed,
+                },
+                {
+                    eventToEmit: TransactionEvent.ClusterAnchoringConfirmation,
+                    eventResolution: mockClusterAnchoringConfirmationResponse,
+                },
+            ]);
+            const promiEvent = client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.ClusterAnchoring);
+            const promiEventSpy = jest.spyOn(promiEvent, "emit");
+            yield expect(promiEvent).resolves.toEqual(mockClusterAnchoringConfirmationResponse);
+            expect(promiEventSpy).toHaveBeenCalledTimes(3);
+            expect(promiEventSpy).toHaveBeenCalledWith(TransactionEvent.DappReceived, mockTransactionReceipts.waiting);
+            expect(promiEventSpy).toHaveBeenCalledWith(TransactionEvent.DappConfirmed, mockTransactionReceipts.confirmed);
+            expect(promiEventSpy).toHaveBeenCalledWith(TransactionEvent.ClusterAnchoringConfirmation, mockClusterAnchoringConfirmationResponse);
+        }));
+        it("triggers DappReceived, DappConfirmed, ClusterAnchoringConfirmation and SystemAnchoringConfirmation events when Confirmation level is set to  SystemAnchoring", () => __awaiter(void 0, void 0, void 0, function* () {
+            handleTransactionConfirmationMockEvents([
+                {
+                    eventToEmit: TransactionEvent.DappReceived,
+                    eventResolution: mockTransactionReceipts.waiting,
+                },
+                {
+                    eventToEmit: TransactionEvent.DappConfirmed,
+                    eventResolution: mockTransactionReceipts.confirmed,
+                },
+                {
+                    eventToEmit: TransactionEvent.ClusterAnchoringConfirmation,
+                    eventResolution: mockClusterAnchoringConfirmationResponse,
+                },
+                {
+                    eventToEmit: TransactionEvent.SystemAnchoringConfirmation,
+                    eventResolution: mockSystemAnchoringConfirmationResponse,
+                },
+            ]);
+            const promiEvent = client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.SystemAnchoring);
+            const promiEventSpy = jest.spyOn(promiEvent, "emit");
+            yield expect(promiEvent).resolves.toEqual(mockSystemAnchoringConfirmationResponse);
+            expect(promiEventSpy).toHaveBeenCalledTimes(4);
+            expect(promiEventSpy).toHaveBeenCalledWith(TransactionEvent.DappReceived, mockTransactionReceipts.waiting);
+            expect(promiEventSpy).toHaveBeenCalledWith(TransactionEvent.DappConfirmed, mockTransactionReceipts.confirmed);
+            expect(promiEventSpy).toHaveBeenCalledWith(TransactionEvent.ClusterAnchoringConfirmation, mockClusterAnchoringConfirmationResponse);
+            expect(promiEventSpy).toHaveBeenCalledWith(TransactionEvent.SystemAnchoringConfirmation, mockSystemAnchoringConfirmationResponse);
+        }));
+        it("throws TxRejectedError with message FailedAnchoring", () => __awaiter(void 0, void 0, void 0, function* () {
+            jest
+                .spyOn(client, "getClusterAnchoringTransactionConfirmation")
+                .mockResolvedValue(AnchoringStatus.FailedAnchoring);
+            yield expect(client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.ClusterAnchoring)).rejects.toThrow(new TxRejectedError(AnchoringStatus.FailedAnchoring));
+        }));
+        it("retries default number of times", () => __awaiter(void 0, void 0, void 0, function* () {
+            const handleRequestSpy = jest.spyOn(httpUtils, "handleRequest");
+            try {
+                yield client.sendTransaction(exampleOperation);
+            }
+            catch (error) {
+                expect(error).not.toBeNull();
+                expect(handleRequestSpy).toHaveBeenCalledTimes(9);
+            }
+        }), 20000);
+        it("returns a PromiEvent", () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(client, "sendTransaction").mockImplementation(() => {
+                return new Web3PromiEvent(() => undefined);
+            });
+            const promiEvent = client.sendTransaction(exampleOperation);
+            expect(promiEvent).toBeInstanceOf(Web3PromiEvent);
+            expect(typeof promiEvent.then).toBe("function");
+            expect(typeof promiEvent.catch).toBe("function");
+            expect(typeof promiEvent.finally).toBe("function");
+            expect(typeof promiEvent.on).toBe("function");
+            expect(typeof promiEvent.once).toBe("function");
+        }));
+    });
+    describe("signAndSendUniqueTransaction", () => {
+        it("takes a callback", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockCallback = jest.fn();
+            jest.spyOn(client, "signTransaction").mockResolvedValue(mockBuffer);
+            const mockPromiEvent = new Web3PromiEvent(resolve => {
+                mockCallback(null, mockTransactionReceipts.waiting);
+                resolve(mockTransactionReceipts.confirmed);
+            });
+            jest.spyOn(client, "sendTransaction").mockImplementation(() => mockPromiEvent);
+            yield client.signAndSendUniqueTransaction(exampleOperation, mockSignatureProvider, true, mockCallback);
+            expect(mockCallback).toHaveBeenCalled();
+            expect(mockCallback).toHaveBeenCalledWith(null, mockTransactionReceipts.waiting);
+        }));
+        it("signs and sends a transaction", () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(client, "signTransaction").mockResolvedValue(mockBuffer);
+            const mockPromiEvent = new Web3PromiEvent(resolve => {
+                resolve(mockTransactionReceipts.confirmed);
+            });
+            jest.spyOn(client, "sendTransaction").mockImplementation(() => mockPromiEvent);
+            const transactionReceipt = yield client.signAndSendUniqueTransaction(mockUnsignedTx, mockSignatureProvider);
+            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+        }));
+        it("sends an operation", () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(client, "signTransaction").mockResolvedValue(mockBuffer);
+            const mockPromiEvent = new Web3PromiEvent(resolve => {
+                resolve(mockTransactionReceipts.confirmed);
+            });
+            jest.spyOn(client, "sendTransaction").mockImplementation(() => mockPromiEvent);
+            const transactionReceipt = yield client.signAndSendUniqueTransaction(exampleOperation, mockSignatureProvider);
+            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+        }));
+        it("signs if no pubKey was provided", () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(client, "signTransaction").mockResolvedValue(mockBuffer);
+            const mockPromiEvent = new Web3PromiEvent(resolve => {
+                resolve(mockTransactionReceipts.confirmed);
+            });
+            jest.spyOn(client, "sendTransaction").mockImplementation(() => mockPromiEvent);
+            const transactionReceipt = yield client.signAndSendUniqueTransaction(exampleOperation, mockSignerKeyPair);
+            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+        }));
+        it("adds a nop", () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(client, "signTransaction").mockResolvedValue(mockBuffer);
+            const mockPromiEvent = new Web3PromiEvent(resolve => {
+                resolve(mockTransactionReceipts.confirmed);
+            });
+            jest.spyOn(client, "sendTransaction").mockImplementation(() => mockPromiEvent);
+            const transactionReceipt = yield client.signAndSendUniqueTransaction(exampleOperation, mockSignerKeyPair);
+            const transactionReceiptCopy = yield client.signAndSendUniqueTransaction(exampleOperation, mockSignerKeyPair);
+            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+            expect(transactionReceiptCopy).toEqual(mockTransactionReceipts.confirmed);
+        }));
+        it("signs and sends a transaction with multiple operations", () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(client, "signTransaction").mockResolvedValue(mockBuffer);
+            const mockPromiEvent = new Web3PromiEvent(resolve => {
+                resolve(mockTransactionReceipts.confirmed);
+            });
+            jest.spyOn(client, "sendTransaction").mockImplementation(() => mockPromiEvent);
+            const transactionReceipt = yield client.signAndSendUniqueTransaction(mockUnsignedMultiOperationTx, mockSignatureProvider);
+            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+        }));
+        it("signs and sends an operation with large complex arguments", () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(client, "signTransaction").mockResolvedValue(mockBuffer);
+            const mockPromiEvent = new Web3PromiEvent(resolve => {
+                resolve(mockTransactionReceipts.confirmed);
+            });
+            jest.spyOn(client, "sendTransaction").mockImplementation(() => mockPromiEvent);
+            const transactionReceipt = yield client.signAndSendUniqueTransaction({
+                name: "set_globals",
+                args: [
+                    ComplexArgumentObject.client_data,
+                    ComplexArgumentObject.server_data,
+                    ComplexArgumentObject.args,
+                ],
+            }, mockSignatureProvider);
+            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+        }));
+        it("retries default number of times", () => __awaiter(void 0, void 0, void 0, function* () {
+            const handleRequestSpy = jest.spyOn(httpUtils, "handleRequest");
+            server.use(http.get(`${LOCAL_POOL}/tx/:blockchainRid/:txHash/status`, () => __awaiter(void 0, void 0, void 0, function* () {
+                return HttpResponse.json({
+                    status: ResponseStatus.Confirmed,
+                });
+            })));
+            try {
+                yield client.signAndSendUniqueTransaction(exampleOperation, mockSignerKeyPair);
+            }
+            catch (error) {
+                expect(error).not.toBeNull();
+                expect(handleRequestSpy).toHaveBeenCalledTimes(9);
+            }
+        }));
+        it("returns a PromiEvent", () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(client, "signAndSendUniqueTransaction").mockImplementation(() => {
+                return new Web3PromiEvent(() => undefined);
+            });
+            const promiEvent = client.signAndSendUniqueTransaction(exampleOperation, mockSignatureProvider);
+            expect(promiEvent).toBeInstanceOf(Web3PromiEvent);
+            expect(typeof promiEvent.then).toBe("function");
+            expect(typeof promiEvent.catch).toBe("function");
+            expect(typeof promiEvent.finally).toBe("function");
+            expect(typeof promiEvent.on).toBe("function");
+            expect(typeof promiEvent.once).toBe("function");
+        }));
+    });
+});
 //# sourceMappingURL=sendTransaction.test.js.map