postchain-client 2.1.1 → 2.1.3

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

@@ -1,3 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 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) {
@@ -7,24 +41,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { TxRejectedError, UnexpectedStatusError } from "../../../src/blockchainClient/errors";
-import { server } from "../../../mocks/servers";
-import { errorHandler } from "../../../mocks/handlers";
-import { AnchoringStatus, ChainConfirmationLevel, ResponseStatus, TransactionEvent, } from "../../../src/blockchainClient/enums";
-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 * as httpUtils from "../../../src/blockchainClient/httpUtil";
-import { Web3PromiEvent } from "../../../src/promiEvent/promiEvents";
-import { http, HttpResponse } from "msw";
-import { NumberOfSignersAndSignaturesException } from "../../../src/gtx/errors";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../../src/blockchainClient/errors");
+const servers_1 = require("../../../mocks/servers");
+const handlers_1 = require("../../../mocks/handlers");
+const enums_1 = require("../../../src/blockchainClient/enums");
+const mocks_1 = require("../../common/mocks");
+const testData_1 = require("../../common/testData");
+const setups_1 = require("../../common/setups");
+const utils = __importStar(require("../../../src/blockchainClient/utils"));
+const httpUtils = __importStar(require("../../../src/blockchainClient/httpUtil"));
+const promiEvents_1 = require("../../../src/promiEvent/promiEvents");
+const msw_1 = require("msw");
+const errors_2 = require("../../../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";
 let client;
 describe("send transactions", () => {
     beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
-        server.listen();
-        client = yield getTestsClient();
+        servers_1.server.listen();
+        client = yield (0, setups_1.getTestsClient)();
     }));
     beforeEach(() => {
         jest.clearAllMocks();
@@ -35,22 +70,22 @@ describe("send transactions", () => {
     });
     afterEach(() => {
         jest.restoreAllMocks();
-        server.resetHandlers();
+        servers_1.server.resetHandlers();
     });
     describe("sendTransaction", () => {
         it("takes a callback", () => __awaiter(void 0, void 0, void 0, function* () {
             const mockCallback = jest.fn();
-            yield client.sendTransaction(exampleOperation, true, mockCallback);
+            yield client.sendTransaction(mocks_1.exampleOperation, true, mockCallback);
             expect(mockCallback).toHaveBeenCalled();
-            expect(mockCallback).toHaveBeenCalledWith(null, mockTransactionReceipts.waiting);
+            expect(mockCallback).toHaveBeenCalledWith(null, mocks_1.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"}'));
+            servers_1.server.use(handlers_1.errorHandler.txError);
+            yield expect(client.sendTransaction(mocks_1.exampleOperation)).rejects.toThrow(new errors_1.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({
+            servers_1.server.use(handlers_1.errorHandler.statusRejected);
+            yield expect(client.sendTransaction(mocks_1.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",
@@ -58,9 +93,9 @@ describe("send transactions", () => {
             });
         }));
         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);
+            servers_1.server.use(handlers_1.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({
+            yield expect(client.sendTransaction(mocks_1.exampleOperation)).rejects.toMatchObject({
                 fullReason: invalidFormatRejectReason,
                 shortReason: undefined,
                 rellLine: undefined,
@@ -68,193 +103,193 @@ describe("send transactions", () => {
             });
         }));
         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);
+            const response = yield client.sendTransaction(mocks_1.exampleOperation);
+            expect(response).toEqual(mocks_1.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({
+            const clientWithConfiguredDappPollCount = yield (0, setups_1.getTestsClient)({
                 dappStatusPolling: utils.setStatusPolling({
-                    count: CONFIGURED_POLL_COUNT,
+                    count: mocks_1.CONFIGURED_POLL_COUNT,
                 }),
             });
-            server.use(errorHandler.statusWaiting);
+            servers_1.server.use(handlers_1.errorHandler.statusWaiting);
             try {
-                const response = yield clientWithConfiguredDappPollCount.sendTransaction(exampleOperation);
-                expect(response).toEqual(mockTransactionReceipts.waiting);
+                const response = yield clientWithConfiguredDappPollCount.sendTransaction(mocks_1.exampleOperation);
+                expect(response).toEqual(mocks_1.mockTransactionReceipts.waiting);
             }
             catch (error) {
                 expect(error).toEqual(new Error("Retry count exceeded. Confirmation not received. Last transaction status: waiting"));
             }
         }));
         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({
+            const clientWithConfiguredDappPollCount = yield (0, setups_1.getTestsClient)({
                 dappStatusPolling: utils.setStatusPolling({
-                    count: CONFIGURED_POLL_COUNT,
+                    count: mocks_1.CONFIGURED_POLL_COUNT,
                 }),
             });
-            server.use(errorHandler.statusUnknown);
+            servers_1.server.use(handlers_1.errorHandler.statusUnknown);
             try {
-                const response = yield clientWithConfiguredDappPollCount.sendTransaction(exampleOperation);
-                expect(response).toEqual(mockTransactionReceipts.waiting);
+                const response = yield clientWithConfiguredDappPollCount.sendTransaction(mocks_1.exampleOperation);
+                expect(response).toEqual(mocks_1.mockTransactionReceipts.waiting);
             }
             catch (error) {
                 expect(error).toEqual(new Error("Retry count exceeded. Confirmation not received. Last transaction status: unknown"));
             }
         }));
         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);
+            const response = yield client.sendTransaction(mocks_1.exampleOperation, true, undefined, enums_1.ChainConfirmationLevel.Dapp);
+            expect(response).toEqual(mocks_1.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);
+            const result = yield client.sendTransaction(mocks_1.exampleOperation, false);
+            expect(result).toEqual(mocks_1.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));
+            yield expect(client.sendTransaction(mocks_1.exampleOperation, true, undefined, enums_1.ChainConfirmationLevel.ClusterAnchoring)).rejects.toThrow(new errors_1.TxRejectedError(enums_1.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);
+            const transactionReceipt = yield client.sendTransaction(mocks_1.exampleOperation);
+            expect(transactionReceipt).toEqual(mocks_1.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);
+            const signedTransaction = yield client.signTransaction(mocks_1.unsignedNonUniqueTxWithTwoSigners, mocks_1.mockSignatureProvider);
+            yield expect(client.sendTransaction(signedTransaction)).rejects.toThrow(errors_2.NumberOfSignersAndSignaturesException);
         }));
         it("signs and sends a transaction", () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockSignedTransaction = mockBuffer;
+            const mockSignedTransaction = mocks_1.mockBuffer;
             jest.spyOn(client, "signTransaction").mockResolvedValue(mockSignedTransaction);
-            jest.spyOn(utils, "getGTXFromBufferOrTransactionOrOperation").mockReturnValue(mockGtx);
+            jest.spyOn(utils, "getGTXFromBufferOrTransactionOrOperation").mockReturnValue(mocks_1.mockGtx);
             jest.spyOn(client, "signTransaction").mockResolvedValue(mockSignedTransaction);
             jest
                 .spyOn(utils, "handleDappConfirmations")
-                .mockResolvedValue(mockTransactionReceipts.confirmed);
+                .mockResolvedValue(mocks_1.mockTransactionReceipts.confirmed);
             const transactionReceipt = yield client.sendTransaction(mockSignedTransaction);
-            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+            expect(transactionReceipt).toEqual(mocks_1.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);
+            const signedMultiOperationTx = mocks_1.mockBuffer;
+            jest.spyOn(utils, "getGTXFromBufferOrTransactionOrOperation").mockReturnValue(mocks_1.mockGtx);
             jest.spyOn(client, "signTransaction").mockResolvedValue(signedMultiOperationTx);
             jest
                 .spyOn(utils, "handleDappConfirmations")
-                .mockResolvedValue(mockTransactionReceipts.confirmed);
+                .mockResolvedValue(mocks_1.mockTransactionReceipts.confirmed);
             const transactionReceipt = yield client.sendTransaction(signedMultiOperationTx);
-            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+            expect(transactionReceipt).toEqual(mocks_1.mockTransactionReceipts.confirmed);
         }));
         it("receives a Cluster Anchoring Confirmation", () => __awaiter(void 0, void 0, void 0, function* () {
             jest
                 .spyOn(utils, "handleDappConfirmations")
-                .mockResolvedValue(mockTransactionReceipts.confirmed);
+                .mockResolvedValue(mocks_1.mockTransactionReceipts.confirmed);
             jest
                 .spyOn(utils, "handleSystemConfirmations")
-                .mockResolvedValue(mockClusterAnchoringConfirmationResponse);
-            const result = yield client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.ClusterAnchoring);
-            expect(result).toEqual(mockClusterAnchoringConfirmationResponse);
+                .mockResolvedValue(mocks_1.mockClusterAnchoringConfirmationResponse);
+            const result = yield client.sendTransaction(mocks_1.exampleOperation, true, undefined, enums_1.ChainConfirmationLevel.ClusterAnchoring);
+            expect(result).toEqual(mocks_1.mockClusterAnchoringConfirmationResponse);
         }));
         it("receives a System Anchoring Confirmation", () => __awaiter(void 0, void 0, void 0, function* () {
             jest
                 .spyOn(utils, "handleDappConfirmations")
-                .mockResolvedValue(mockTransactionReceipts.confirmed);
+                .mockResolvedValue(mocks_1.mockTransactionReceipts.confirmed);
             jest
                 .spyOn(utils, "handleSystemConfirmations")
-                .mockResolvedValue(mockSystemAnchoringConfirmationResponse);
-            const result = yield client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.SystemAnchoring);
-            expect(result).toEqual(mockSystemAnchoringConfirmationResponse);
+                .mockResolvedValue(mocks_1.mockSystemAnchoringConfirmationResponse);
+            const result = yield client.sendTransaction(mocks_1.exampleOperation, true, undefined, enums_1.ChainConfirmationLevel.SystemAnchoring);
+            expect(result).toEqual(mocks_1.mockSystemAnchoringConfirmationResponse);
         }));
         it("triggers DappReceived event when ConfirmationLevel is None", () => __awaiter(void 0, void 0, void 0, function* () {
-            handleTransactionConfirmationMockEvents([
+            (0, setups_1.handleTransactionConfirmationMockEvents)([
                 {
-                    eventToEmit: TransactionEvent.DappReceived,
-                    eventResolution: mockTransactionReceipts.waiting,
+                    eventToEmit: enums_1.TransactionEvent.DappReceived,
+                    eventResolution: mocks_1.mockTransactionReceipts.waiting,
                 },
             ]);
-            const promiEvent = client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.None);
+            const promiEvent = client.sendTransaction(mocks_1.exampleOperation, true, undefined, enums_1.ChainConfirmationLevel.None);
             const promiEventSpy = jest.spyOn(promiEvent, "emit");
-            yield expect(promiEvent).resolves.toEqual(mockTransactionReceipts.waiting);
+            yield expect(promiEvent).resolves.toEqual(mocks_1.mockTransactionReceipts.waiting);
             expect(promiEventSpy).toHaveBeenCalledTimes(1);
-            expect(promiEventSpy).toHaveBeenCalledWith(TransactionEvent.DappReceived, mockTransactionReceipts.waiting);
+            expect(promiEventSpy).toHaveBeenCalledWith(enums_1.TransactionEvent.DappReceived, mocks_1.mockTransactionReceipts.waiting);
         }));
         it("triggers DappReceived and DappConfirmed events when Confirmation level is set to Dapp", () => __awaiter(void 0, void 0, void 0, function* () {
-            handleTransactionConfirmationMockEvents([
+            (0, setups_1.handleTransactionConfirmationMockEvents)([
                 {
-                    eventToEmit: TransactionEvent.DappReceived,
-                    eventResolution: mockTransactionReceipts.waiting,
+                    eventToEmit: enums_1.TransactionEvent.DappReceived,
+                    eventResolution: mocks_1.mockTransactionReceipts.waiting,
                 },
                 {
-                    eventToEmit: TransactionEvent.DappConfirmed,
-                    eventResolution: mockTransactionReceipts.confirmed,
+                    eventToEmit: enums_1.TransactionEvent.DappConfirmed,
+                    eventResolution: mocks_1.mockTransactionReceipts.confirmed,
                 },
             ]);
-            const promiEvent = client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.Dapp);
+            const promiEvent = client.sendTransaction(mocks_1.exampleOperation, true, undefined, enums_1.ChainConfirmationLevel.Dapp);
             const promiEventSpy = jest.spyOn(promiEvent, "emit");
-            yield expect(promiEvent).resolves.toEqual(mockTransactionReceipts.confirmed);
+            yield expect(promiEvent).resolves.toEqual(mocks_1.mockTransactionReceipts.confirmed);
             expect(promiEventSpy).toHaveBeenCalledTimes(2);
-            expect(promiEventSpy).toHaveBeenCalledWith(TransactionEvent.DappReceived, mockTransactionReceipts.waiting);
-            expect(promiEventSpy).toHaveBeenCalledWith(TransactionEvent.DappConfirmed, mockTransactionReceipts.confirmed);
+            expect(promiEventSpy).toHaveBeenCalledWith(enums_1.TransactionEvent.DappReceived, mocks_1.mockTransactionReceipts.waiting);
+            expect(promiEventSpy).toHaveBeenCalledWith(enums_1.TransactionEvent.DappConfirmed, mocks_1.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([
+            (0, setups_1.handleTransactionConfirmationMockEvents)([
                 {
-                    eventToEmit: TransactionEvent.DappReceived,
-                    eventResolution: mockTransactionReceipts.waiting,
+                    eventToEmit: enums_1.TransactionEvent.DappReceived,
+                    eventResolution: mocks_1.mockTransactionReceipts.waiting,
                 },
                 {
-                    eventToEmit: TransactionEvent.DappConfirmed,
-                    eventResolution: mockTransactionReceipts.confirmed,
+                    eventToEmit: enums_1.TransactionEvent.DappConfirmed,
+                    eventResolution: mocks_1.mockTransactionReceipts.confirmed,
                 },
                 {
-                    eventToEmit: TransactionEvent.ClusterAnchoringConfirmation,
-                    eventResolution: mockClusterAnchoringConfirmationResponse,
+                    eventToEmit: enums_1.TransactionEvent.ClusterAnchoringConfirmation,
+                    eventResolution: mocks_1.mockClusterAnchoringConfirmationResponse,
                 },
             ]);
-            const promiEvent = client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.ClusterAnchoring);
+            const promiEvent = client.sendTransaction(mocks_1.exampleOperation, true, undefined, enums_1.ChainConfirmationLevel.ClusterAnchoring);
             const promiEventSpy = jest.spyOn(promiEvent, "emit");
-            yield expect(promiEvent).resolves.toEqual(mockClusterAnchoringConfirmationResponse);
+            yield expect(promiEvent).resolves.toEqual(mocks_1.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);
+            expect(promiEventSpy).toHaveBeenCalledWith(enums_1.TransactionEvent.DappReceived, mocks_1.mockTransactionReceipts.waiting);
+            expect(promiEventSpy).toHaveBeenCalledWith(enums_1.TransactionEvent.DappConfirmed, mocks_1.mockTransactionReceipts.confirmed);
+            expect(promiEventSpy).toHaveBeenCalledWith(enums_1.TransactionEvent.ClusterAnchoringConfirmation, mocks_1.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([
+            (0, setups_1.handleTransactionConfirmationMockEvents)([
                 {
-                    eventToEmit: TransactionEvent.DappReceived,
-                    eventResolution: mockTransactionReceipts.waiting,
+                    eventToEmit: enums_1.TransactionEvent.DappReceived,
+                    eventResolution: mocks_1.mockTransactionReceipts.waiting,
                 },
                 {
-                    eventToEmit: TransactionEvent.DappConfirmed,
-                    eventResolution: mockTransactionReceipts.confirmed,
+                    eventToEmit: enums_1.TransactionEvent.DappConfirmed,
+                    eventResolution: mocks_1.mockTransactionReceipts.confirmed,
                 },
                 {
-                    eventToEmit: TransactionEvent.ClusterAnchoringConfirmation,
-                    eventResolution: mockClusterAnchoringConfirmationResponse,
+                    eventToEmit: enums_1.TransactionEvent.ClusterAnchoringConfirmation,
+                    eventResolution: mocks_1.mockClusterAnchoringConfirmationResponse,
                 },
                 {
-                    eventToEmit: TransactionEvent.SystemAnchoringConfirmation,
-                    eventResolution: mockSystemAnchoringConfirmationResponse,
+                    eventToEmit: enums_1.TransactionEvent.SystemAnchoringConfirmation,
+                    eventResolution: mocks_1.mockSystemAnchoringConfirmationResponse,
                 },
             ]);
-            const promiEvent = client.sendTransaction(exampleOperation, true, undefined, ChainConfirmationLevel.SystemAnchoring);
+            const promiEvent = client.sendTransaction(mocks_1.exampleOperation, true, undefined, enums_1.ChainConfirmationLevel.SystemAnchoring);
             const promiEventSpy = jest.spyOn(promiEvent, "emit");
-            yield expect(promiEvent).resolves.toEqual(mockSystemAnchoringConfirmationResponse);
+            yield expect(promiEvent).resolves.toEqual(mocks_1.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);
+            expect(promiEventSpy).toHaveBeenCalledWith(enums_1.TransactionEvent.DappReceived, mocks_1.mockTransactionReceipts.waiting);
+            expect(promiEventSpy).toHaveBeenCalledWith(enums_1.TransactionEvent.DappConfirmed, mocks_1.mockTransactionReceipts.confirmed);
+            expect(promiEventSpy).toHaveBeenCalledWith(enums_1.TransactionEvent.ClusterAnchoringConfirmation, mocks_1.mockClusterAnchoringConfirmationResponse);
+            expect(promiEventSpy).toHaveBeenCalledWith(enums_1.TransactionEvent.SystemAnchoringConfirmation, mocks_1.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));
+                .mockResolvedValue(enums_1.AnchoringStatus.FailedAnchoring);
+            yield expect(client.sendTransaction(mocks_1.exampleOperation, true, undefined, enums_1.ChainConfirmationLevel.ClusterAnchoring)).rejects.toThrow(new errors_1.TxRejectedError(enums_1.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);
+                yield client.sendTransaction(mocks_1.exampleOperation);
             }
             catch (error) {
                 expect(error).not.toBeNull();
@@ -263,10 +298,10 @@ describe("send transactions", () => {
         }), 20000);
         it("returns a PromiEvent", () => __awaiter(void 0, void 0, void 0, function* () {
             jest.spyOn(client, "sendTransaction").mockImplementation(() => {
-                return new Web3PromiEvent(() => undefined);
+                return new promiEvents_1.Web3PromiEvent(() => undefined);
             });
-            const promiEvent = client.sendTransaction(exampleOperation);
-            expect(promiEvent).toBeInstanceOf(Web3PromiEvent);
+            const promiEvent = client.sendTransaction(mocks_1.exampleOperation);
+            expect(promiEvent).toBeInstanceOf(promiEvents_1.Web3PromiEvent);
             expect(typeof promiEvent.then).toBe("function");
             expect(typeof promiEvent.catch).toBe("function");
             expect(typeof promiEvent.finally).toBe("function");
@@ -277,88 +312,88 @@ describe("send transactions", () => {
     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, "signTransaction").mockResolvedValue(mocks_1.mockBuffer);
+            const mockPromiEvent = new promiEvents_1.Web3PromiEvent(resolve => {
+                mockCallback(null, mocks_1.mockTransactionReceipts.waiting);
+                resolve(mocks_1.mockTransactionReceipts.confirmed);
             });
             jest.spyOn(client, "sendTransaction").mockImplementation(() => mockPromiEvent);
-            yield client.signAndSendUniqueTransaction(exampleOperation, mockSignatureProvider, true, mockCallback);
+            yield client.signAndSendUniqueTransaction(mocks_1.exampleOperation, mocks_1.mockSignatureProvider, true, mockCallback);
             expect(mockCallback).toHaveBeenCalled();
-            expect(mockCallback).toHaveBeenCalledWith(null, mockTransactionReceipts.waiting);
+            expect(mockCallback).toHaveBeenCalledWith(null, mocks_1.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, "signTransaction").mockResolvedValue(mocks_1.mockBuffer);
+            const mockPromiEvent = new promiEvents_1.Web3PromiEvent(resolve => {
+                resolve(mocks_1.mockTransactionReceipts.confirmed);
             });
             jest.spyOn(client, "sendTransaction").mockImplementation(() => mockPromiEvent);
-            const transactionReceipt = yield client.signAndSendUniqueTransaction(mockUnsignedTx, mockSignatureProvider);
-            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+            const transactionReceipt = yield client.signAndSendUniqueTransaction(mocks_1.mockUnsignedTx, mocks_1.mockSignatureProvider);
+            expect(transactionReceipt).toEqual(mocks_1.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, "signTransaction").mockResolvedValue(mocks_1.mockBuffer);
+            const mockPromiEvent = new promiEvents_1.Web3PromiEvent(resolve => {
+                resolve(mocks_1.mockTransactionReceipts.confirmed);
             });
             jest.spyOn(client, "sendTransaction").mockImplementation(() => mockPromiEvent);
-            const transactionReceipt = yield client.signAndSendUniqueTransaction(exampleOperation, mockSignatureProvider);
-            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+            const transactionReceipt = yield client.signAndSendUniqueTransaction(mocks_1.exampleOperation, mocks_1.mockSignatureProvider);
+            expect(transactionReceipt).toEqual(mocks_1.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, "signTransaction").mockResolvedValue(mocks_1.mockBuffer);
+            const mockPromiEvent = new promiEvents_1.Web3PromiEvent(resolve => {
+                resolve(mocks_1.mockTransactionReceipts.confirmed);
             });
             jest.spyOn(client, "sendTransaction").mockImplementation(() => mockPromiEvent);
-            const transactionReceipt = yield client.signAndSendUniqueTransaction(exampleOperation, mockSignerKeyPair);
-            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+            const transactionReceipt = yield client.signAndSendUniqueTransaction(mocks_1.exampleOperation, mocks_1.mockSignerKeyPair);
+            expect(transactionReceipt).toEqual(mocks_1.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, "signTransaction").mockResolvedValue(mocks_1.mockBuffer);
+            const mockPromiEvent = new promiEvents_1.Web3PromiEvent(resolve => {
+                resolve(mocks_1.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);
+            const transactionReceipt = yield client.signAndSendUniqueTransaction(mocks_1.exampleOperation, mocks_1.mockSignerKeyPair);
+            const transactionReceiptCopy = yield client.signAndSendUniqueTransaction(mocks_1.exampleOperation, mocks_1.mockSignerKeyPair);
+            expect(transactionReceipt).toEqual(mocks_1.mockTransactionReceipts.confirmed);
+            expect(transactionReceiptCopy).toEqual(mocks_1.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, "signTransaction").mockResolvedValue(mocks_1.mockBuffer);
+            const mockPromiEvent = new promiEvents_1.Web3PromiEvent(resolve => {
+                resolve(mocks_1.mockTransactionReceipts.confirmed);
             });
             jest.spyOn(client, "sendTransaction").mockImplementation(() => mockPromiEvent);
-            const transactionReceipt = yield client.signAndSendUniqueTransaction(mockUnsignedMultiOperationTx, mockSignatureProvider);
-            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+            const transactionReceipt = yield client.signAndSendUniqueTransaction(mocks_1.mockUnsignedMultiOperationTx, mocks_1.mockSignatureProvider);
+            expect(transactionReceipt).toEqual(mocks_1.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, "signTransaction").mockResolvedValue(mocks_1.mockBuffer);
+            const mockPromiEvent = new promiEvents_1.Web3PromiEvent(resolve => {
+                resolve(mocks_1.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,
+                    testData_1.ComplexArgumentObject.client_data,
+                    testData_1.ComplexArgumentObject.server_data,
+                    testData_1.ComplexArgumentObject.args,
                 ],
-            }, mockSignatureProvider);
-            expect(transactionReceipt).toEqual(mockTransactionReceipts.confirmed);
+            }, mocks_1.mockSignatureProvider);
+            expect(transactionReceipt).toEqual(mocks_1.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,
+            servers_1.server.use(msw_1.http.get(`${mocks_1.LOCAL_POOL}/tx/:blockchainRid/:txHash/status`, () => __awaiter(void 0, void 0, void 0, function* () {
+                return msw_1.HttpResponse.json({
+                    status: enums_1.ResponseStatus.Confirmed,
                 });
             })));
             try {
-                yield client.signAndSendUniqueTransaction(exampleOperation, mockSignerKeyPair);
+                yield client.signAndSendUniqueTransaction(mocks_1.exampleOperation, mocks_1.mockSignerKeyPair);
             }
             catch (error) {
                 expect(error).not.toBeNull();
@@ -367,10 +402,10 @@ describe("send transactions", () => {
         }));
         it("returns a PromiEvent", () => __awaiter(void 0, void 0, void 0, function* () {
             jest.spyOn(client, "signAndSendUniqueTransaction").mockImplementation(() => {
-                return new Web3PromiEvent(() => undefined);
+                return new promiEvents_1.Web3PromiEvent(() => undefined);
             });
-            const promiEvent = client.signAndSendUniqueTransaction(exampleOperation, mockSignatureProvider);
-            expect(promiEvent).toBeInstanceOf(Web3PromiEvent);
+            const promiEvent = client.signAndSendUniqueTransaction(mocks_1.exampleOperation, mocks_1.mockSignatureProvider);
+            expect(promiEvent).toBeInstanceOf(promiEvents_1.Web3PromiEvent);
             expect(typeof promiEvent.then).toBe("function");
             expect(typeof promiEvent.catch).toBe("function");
             expect(typeof promiEvent.finally).toBe("function");