@rabbitio/ui-kit 1.0.0-beta.64 → 1.0.0-beta.66

package/src/robustExteranlApiCallerService/tests/robustExternalAPICallerService/robustExternalAPICallerService/callExternalAPI/callExternalAPI.test.js

@@ -27,38 +27,26 @@ describe("RobustExternalAPICallerService", function () {
                             endpoints === "any" ? "any" : endpoints[i],
                             httpMethods === "any" ? "get" : httpMethods[i],
                             timeouts ? timeouts[i] : null,
-                            RPSes === null
-                                ? new ApiGroup(v4(), 10)
-                                : new ApiGroup(v4(), RPSes[i])
+                            RPSes === null ? new ApiGroup(v4(), 10) : new ApiGroup(v4(), RPSes[i])
                         );
                     }
-                    getDataByResponse(
-                        response,
-                        params = [],
-                        subRequestIndex = 0,
-                        iterationsData = []
-                    ) {
+                    getDataByResponse(response, params = [], subRequestIndex = 0, iterationsData = []) {
                         const func =
                             getDataByResponseFunctions === "any"
                                 ? "any"
                                 : Array.isArray(getDataByResponseFunctions[i])
-                                  ? getDataByResponseFunctions[i][
-                                        subRequestIndex
-                                    ]
+                                  ? getDataByResponseFunctions[i][subRequestIndex]
                                   : getDataByResponseFunctions[i];
                         return func();
                     }
                 }
                 const provider = new TempProvider();
                 providers.push(provider);
-                const composeQueryStringStub = sinon.stub(
-                    provider,
-                    "composeQueryString"
-                );
+                const composeQueryStringStub = sinon.stub(provider, "composeQueryString");
                 composeQueryStringStubs.push(composeQueryStringStub);
             }
             const isRpsExceededStubs = [];
-            providers.forEach((provider) => {
+            providers.forEach(provider => {
                 if (
                     provider.httpMethod === "post" ||
                     provider.httpMethod === "put" ||
@@ -96,10 +84,7 @@ describe("RobustExternalAPICallerService", function () {
             );
             const attemptsCount = 6;
             const failingAttemptsCount = Math.floor(attemptsCount * 0.6);
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             for (let i = 0; i < failingAttemptsCount; ++i) {
                 _performCallAttemptStub.onCall(i).resolves({
                     data: null,
@@ -115,16 +100,9 @@ describe("RobustExternalAPICallerService", function () {
                 rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
             });
 
-            await retrieverService.callExternalAPI(
-                [],
-                anyTimeout,
-                null,
-                attemptsCount
-            );
+            await retrieverService.callExternalAPI([], anyTimeout, null, attemptsCount);
 
-            _performCallAttemptStub.callCount.should.be.equal(
-                failingAttemptsCount + 1
-            );
+            _performCallAttemptStub.callCount.should.be.equal(failingAttemptsCount + 1);
         });
 
         it("Should perform max_attempts_count due to null data and shouldBeForceRetried is false for the last call", async function () {
@@ -135,10 +113,7 @@ describe("RobustExternalAPICallerService", function () {
                 console.log
             );
             const attemptsCount = 5;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             for (let i = 0; i < attemptsCount; ++i) {
                 _performCallAttemptStub.onCall(i).resolves({
                     data: null,
@@ -149,12 +124,7 @@ describe("RobustExternalAPICallerService", function () {
             }
 
             try {
-                await retrieverService.callExternalAPI(
-                    [],
-                    anyTimeout,
-                    null,
-                    attemptsCount
-                );
+                await retrieverService.callExternalAPI([], anyTimeout, null, attemptsCount);
             } catch (e) {
                 // We expect an error here
             }
@@ -171,36 +141,20 @@ describe("RobustExternalAPICallerService", function () {
             );
             const attemptsCount = 5;
             const countOfAdditionalRequestsDueToForceRetryNeed = 3;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
-            for (
-                let i = 0;
-                i <
-                attemptsCount + countOfAdditionalRequestsDueToForceRetryNeed;
-                ++i
-            ) {
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
+            for (let i = 0; i < attemptsCount + countOfAdditionalRequestsDueToForceRetryNeed; ++i) {
                 _performCallAttemptStub.onCall(i).resolves({
                     data: null,
                     shouldBeForceRetried:
                         i >= attemptsCount - 1 &&
-                        i !==
-                            attemptsCount +
-                                countOfAdditionalRequestsDueToForceRetryNeed -
-                                1,
+                        i !== attemptsCount + countOfAdditionalRequestsDueToForceRetryNeed - 1,
                     errors: [],
                     rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
                 });
             }
 
             try {
-                await retrieverService.callExternalAPI(
-                    [],
-                    anyTimeout,
-                    null,
-                    attemptsCount
-                );
+                await retrieverService.callExternalAPI([], anyTimeout, null, attemptsCount);
             } catch (e) {
                 // We expect an error here
             }
@@ -218,10 +172,7 @@ describe("RobustExternalAPICallerService", function () {
                 console.log
             );
             const attemptsCount = 5;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             for (let i = 0; i < attemptsCount; ++i) {
                 _performCallAttemptStub.onCall(i).resolves({
                     data: null,
@@ -231,13 +182,7 @@ describe("RobustExternalAPICallerService", function () {
                 });
             }
 
-            const result = await retrieverService.callExternalAPI(
-                [],
-                anyTimeout,
-                null,
-                attemptsCount,
-                true
-            );
+            const result = await retrieverService.callExternalAPI([], anyTimeout, null, attemptsCount, true);
 
             (result == null).should.be.true();
         });
@@ -250,10 +195,7 @@ describe("RobustExternalAPICallerService", function () {
                 console.log
             );
             const attemptsCount = 5;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             for (let i = 0; i < attemptsCount; ++i) {
                 _performCallAttemptStub.onCall(i).resolves({
                     data: null,
@@ -264,16 +206,9 @@ describe("RobustExternalAPICallerService", function () {
             }
 
             try {
-                await retrieverService.callExternalAPI(
-                    [],
-                    anyTimeout,
-                    null,
-                    attemptsCount
-                );
+                await retrieverService.callExternalAPI([], anyTimeout, null, attemptsCount);
             } catch (e) {
-                e.message.should.match(
-                    /.*Failed to retrieve data. It means all attempts have been failed.*/
-                );
+                e.message.should.match(/.*Failed to retrieve data. It means all attempts have been failed.*/);
             }
         });
 
@@ -285,10 +220,7 @@ describe("RobustExternalAPICallerService", function () {
                 console.log
             );
             const attemptsCount = 1;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             _performCallAttemptStub.onCall(0).resolves({
                 data: anyData,
                 shouldBeForceRetried: false,
@@ -296,12 +228,7 @@ describe("RobustExternalAPICallerService", function () {
                 rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
             });
 
-            await retrieverService.callExternalAPI(
-                [],
-                anyTimeout,
-                null,
-                attemptsCount
-            );
+            await retrieverService.callExternalAPI([], anyTimeout, null, attemptsCount);
 
             _performCallAttemptStub.args[0][3].should.be.equal(1);
         });
@@ -317,10 +244,7 @@ describe("RobustExternalAPICallerService", function () {
             global.setTimeout = sinon.stub();
 
             const attemptsCount = 1;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             _performCallAttemptStub.onCall(0).resolves({
                 data: anyData,
                 shouldBeForceRetried: false,
@@ -328,12 +252,7 @@ describe("RobustExternalAPICallerService", function () {
                 rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
             });
 
-            await retrieverService.callExternalAPI(
-                [],
-                anyTimeout,
-                null,
-                attemptsCount
-            );
+            await retrieverService.callExternalAPI([], anyTimeout, null, attemptsCount);
 
             setTimeout.callCount.should.be.equal(0);
         });
@@ -350,10 +269,7 @@ describe("RobustExternalAPICallerService", function () {
 
             const attemptsCount = 4;
             const failingAttemptsCount = 2;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             for (let i = 0; i <= failingAttemptsCount; ++i) {
                 _performCallAttemptStub.onCall(i).resolves({
                     data: i === failingAttemptsCount ? anyData : null,
@@ -363,12 +279,7 @@ describe("RobustExternalAPICallerService", function () {
                 });
             }
 
-            await retrieverService.callExternalAPI(
-                [],
-                anyTimeout,
-                null,
-                attemptsCount
-            );
+            await retrieverService.callExternalAPI([], anyTimeout, null, attemptsCount);
 
             setTimeout.callCount.should.be.equal(failingAttemptsCount);
         });
@@ -386,10 +297,7 @@ describe("RobustExternalAPICallerService", function () {
 
             const attemptsCount = 5;
             const failingAttemptsCount = 3;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             for (let i = 0; i <= failingAttemptsCount; ++i) {
                 _performCallAttemptStub.onCall(i).resolves({
                     data: i === failingAttemptsCount ? anyData : null,
@@ -399,18 +307,11 @@ describe("RobustExternalAPICallerService", function () {
                 });
             }
 
-            await retrieverService.callExternalAPI(
-                [],
-                anyTimeout,
-                null,
-                attemptsCount
-            );
+            await retrieverService.callExternalAPI([], anyTimeout, null, attemptsCount);
 
             for (let j = 0; j < failingAttemptsCount; ++j) {
                 setTimeout.args[j][1].should.be.equal(
-                    1000 /
-                        (Math.max(...RPSes) /
-                            RobustExternalAPICallerService.defaultRPSFactor)
+                    1000 / (Math.max(...RPSes) / RobustExternalAPICallerService.defaultRPSFactor)
                 );
             }
         });
@@ -428,20 +329,10 @@ describe("RobustExternalAPICallerService", function () {
 
             const attemptsCount = 5;
             const failingAttemptsCount = 3;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             const rpsFactors = new Array(4)
                 .fill(RobustExternalAPICallerService.defaultRPSFactor)
-                .map(
-                    (factor, index) =>
-                        factor *
-                        Math.pow(
-                            RobustExternalAPICallerService.rpsMultiplier,
-                            index
-                        )
-                );
+                .map((factor, index) => factor * Math.pow(RobustExternalAPICallerService.rpsMultiplier, index));
 
             for (let i = 0; i <= failingAttemptsCount; ++i) {
                 _performCallAttemptStub.onCall(i).resolves({
@@ -452,12 +343,7 @@ describe("RobustExternalAPICallerService", function () {
                 });
             }
 
-            await retrieverService.callExternalAPI(
-                [],
-                anyTimeout,
-                null,
-                attemptsCount
-            );
+            await retrieverService.callExternalAPI([], anyTimeout, null, attemptsCount);
 
             for (let j = 0; j < failingAttemptsCount; ++j) {
                 setTimeout.args[j][1].should.be.equal(
@@ -468,86 +354,49 @@ describe("RobustExternalAPICallerService", function () {
         });
 
         it("Should log the errors array returned by _performCallAttempt", async function () {
-            const retrieverService = new RobustExternalAPICallerService(
-                "testService",
-                generateProviders(4).providers
-            );
+            const retrieverService = new RobustExternalAPICallerService("testService", generateProviders(4).providers);
 
             const spy = sinon.spy(retrieverService, "_logger");
 
             const attemptsCount = 3;
             const failingAttemptsCount = 2;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             for (let i = 0; i <= failingAttemptsCount; ++i) {
                 _performCallAttemptStub.onCall(i).resolves({
                     data: i === failingAttemptsCount ? anyData : null,
                     shouldBeForceRetried: false,
-                    errors:
-                        i !== failingAttemptsCount
-                            ? [`aaa${i}${i}${i}`, `bbb${i}${i}${i}`]
-                            : [],
+                    errors: i !== failingAttemptsCount ? [`aaa${i}${i}${i}`, `bbb${i}${i}${i}`] : [],
                     rpsFactor: RobustExternalAPICallerService.defaultRPSFactor,
                 });
             }
 
-            await retrieverService.callExternalAPI(
-                [],
-                anyTimeout,
-                null,
-                attemptsCount,
-                true
-            );
+            await retrieverService.callExternalAPI([], anyTimeout, null, attemptsCount, true);
 
             for (let j = 0; j < failingAttemptsCount; ++j) {
-                spy.args[j][0].message
-                    .includes(`aaa${j}${j}${j}`)
-                    .should.be.true();
-                spy.args[j][0].message
-                    .includes(`bbb${j}${j}${j}`)
-                    .should.be.true();
+                spy.args[j][0].message.includes(`aaa${j}${j}${j}`).should.be.true();
+                spy.args[j][0].message.includes(`bbb${j}${j}${j}`).should.be.true();
             }
         });
 
         it("Should log an unexpected error occurred during the _performCallAttempt call", async function () {
-            const retrieverService = new RobustExternalAPICallerService(
-                "testService",
-                generateProviders(4).providers
-            );
+            const retrieverService = new RobustExternalAPICallerService("testService", generateProviders(4).providers);
 
             const spy = sinon.spy(retrieverService, "_logger");
 
             const someError = new Error("Failed ### in tests");
             const attemptsCount = 1;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             _performCallAttemptStub.onCall(0).rejects(someError);
 
-            await retrieverService.callExternalAPI(
-                [],
-                anyTimeout,
-                null,
-                attemptsCount,
-                true
-            );
+            await retrieverService.callExternalAPI([], anyTimeout, null, attemptsCount, true);
             spy.args[0][0].should.be.equal(someError);
         });
 
         it("Should pass correct parameters to _performCallAttempt - case default rpsFactor", async function () {
-            const retrieverService = new RobustExternalAPICallerService(
-                "testService",
-                generateProviders(4).providers
-            );
+            const retrieverService = new RobustExternalAPICallerService("testService", generateProviders(4).providers);
 
             const attemptsCount = 2;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             for (let i = 0; i < attemptsCount; ++i) {
                 _performCallAttemptStub.onCall(i).resolves({
                     data: null,
@@ -559,13 +408,7 @@ describe("RobustExternalAPICallerService", function () {
 
             const someParamsValues = [1, "aaa", { c: "1w2" }];
             const someCancelToken = "some token";
-            await retrieverService.callExternalAPI(
-                someParamsValues,
-                anyTimeout,
-                someCancelToken,
-                attemptsCount,
-                true
-            );
+            await retrieverService.callExternalAPI(someParamsValues, anyTimeout, someCancelToken, attemptsCount, true);
 
             for (let i = 0; i < attemptsCount; ++i) {
                 _performCallAttemptStub.args[i].should.be.deepEqual([
@@ -579,27 +422,14 @@ describe("RobustExternalAPICallerService", function () {
         });
 
         it("Should pass correct parameters to _performCallAttempt - case increasing rpsFactor", async function () {
-            const retrieverService = new RobustExternalAPICallerService(
-                "testService",
-                generateProviders(4).providers
-            );
+            const retrieverService = new RobustExternalAPICallerService("testService", generateProviders(4).providers);
 
             const attemptsCount = 5;
             const failingAttemptsCount = 3;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             const rpsFactors = new Array(failingAttemptsCount + 1)
                 .fill(RobustExternalAPICallerService.defaultRPSFactor)
-                .map(
-                    (factor, index) =>
-                        factor *
-                        Math.pow(
-                            RobustExternalAPICallerService.rpsMultiplier,
-                            index
-                        )
-                );
+                .map((factor, index) => factor * Math.pow(RobustExternalAPICallerService.rpsMultiplier, index));
 
             for (let i = 0; i <= failingAttemptsCount; ++i) {
                 _performCallAttemptStub.onCall(i).resolves({
@@ -611,13 +441,7 @@ describe("RobustExternalAPICallerService", function () {
             }
             const someParamsValues = [1, "aaa", { c: "1w2" }];
             const someCancelToken = "some token";
-            await retrieverService.callExternalAPI(
-                someParamsValues,
-                anyTimeout,
-                someCancelToken,
-                attemptsCount,
-                true
-            );
+            await retrieverService.callExternalAPI(someParamsValues, anyTimeout, someCancelToken, attemptsCount, true);
 
             for (let i = 0; i < failingAttemptsCount + 1; ++i) {
                 _performCallAttemptStub.args[i].should.be.deepEqual(
@@ -625,9 +449,7 @@ describe("RobustExternalAPICallerService", function () {
                         someParamsValues,
                         anyTimeout,
                         someCancelToken,
-                        i === 0
-                            ? RobustExternalAPICallerService.defaultRPSFactor
-                            : rpsFactors[i - 1],
+                        i === 0 ? RobustExternalAPICallerService.defaultRPSFactor : rpsFactors[i - 1],
                         true,
                     ],
                     `Attempt ${i} check`
@@ -636,18 +458,12 @@ describe("RobustExternalAPICallerService", function () {
         });
 
         it("Should log the 'not enough attempts' error when after all attempts data is null and doNotFailForNowData is true", async function () {
-            const retrieverService = new RobustExternalAPICallerService(
-                "testService",
-                generateProviders(4).providers
-            );
+            const retrieverService = new RobustExternalAPICallerService("testService", generateProviders(4).providers);
 
             const spy = sinon.spy(retrieverService, "_logger");
 
             const attemptsCount = 3;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             for (let i = 0; i < attemptsCount; ++i) {
                 _performCallAttemptStub.onCall(i).resolves({
                     data: null,
@@ -657,13 +473,7 @@ describe("RobustExternalAPICallerService", function () {
                 });
             }
 
-            await retrieverService.callExternalAPI(
-                [],
-                anyTimeout,
-                null,
-                attemptsCount,
-                true
-            );
+            await retrieverService.callExternalAPI([], anyTimeout, null, attemptsCount, true);
 
             spy.args[0][0].message.should.be.equal(
                 "Failed to retrieve data. It means all attempts have been failed. DEV: add more attempts to this data retrieval"
@@ -671,18 +481,12 @@ describe("RobustExternalAPICallerService", function () {
         });
 
         it("Should throw the 'not enough attempts' error when after all attempts data is null and doNotFailForNowData is false", async function () {
-            const retrieverService = new RobustExternalAPICallerService(
-                "testService",
-                generateProviders(4).providers
-            );
+            const retrieverService = new RobustExternalAPICallerService("testService", generateProviders(4).providers);
 
             const spy = sinon.spy(retrieverService, "_logger");
 
             const attemptsCount = 3;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             for (let i = 0; i < attemptsCount; ++i) {
                 _performCallAttemptStub.onCall(i).resolves({
                     data: null,
@@ -694,12 +498,7 @@ describe("RobustExternalAPICallerService", function () {
 
             let error = null;
             try {
-                await retrieverService.callExternalAPI(
-                    [],
-                    anyTimeout,
-                    null,
-                    attemptsCount
-                );
+                await retrieverService.callExternalAPI([], anyTimeout, null, attemptsCount);
             } catch (e) {
                 error = e;
             }
@@ -711,17 +510,11 @@ describe("RobustExternalAPICallerService", function () {
         });
 
         it("Should return the not null data returned by the _performCallAttempt", async function () {
-            const retrieverService = new RobustExternalAPICallerService(
-                "testService",
-                generateProviders(4).providers
-            );
+            const retrieverService = new RobustExternalAPICallerService("testService", generateProviders(4).providers);
 
             const attemptsCount = 4;
             const failingAttemptsCount = 2;
-            const _performCallAttemptStub = sinon.stub(
-                retrieverService,
-                "_performCallAttempt"
-            );
+            const _performCallAttemptStub = sinon.stub(retrieverService, "_performCallAttempt");
             for (let i = 0; i <= failingAttemptsCount; ++i) {
                 _performCallAttemptStub.onCall(i).resolves({
                     data: i === failingAttemptsCount ? anyData : null,
@@ -731,13 +524,7 @@ describe("RobustExternalAPICallerService", function () {
                 });
             }
 
-            const result = await retrieverService.callExternalAPI(
-                [],
-                anyTimeout,
-                null,
-                attemptsCount,
-                true
-            );
+            const result = await retrieverService.callExternalAPI([], anyTimeout, null, attemptsCount, true);
 
             result.should.be.deepEqual(anyData);
         });

package/src/robustExteranlApiCallerService/tests/robustExternalAPICallerService/robustExternalAPICallerService/constructor.test.js

@@ -8,24 +8,12 @@ import { ApiGroup } from "../../../../common/external-apis/apiGroups.js";
 
 describe("RobustExternalAPICallerService", function () {
     describe("#constructor", function () {
-        const someProviders = [
-            new ExternalApiProvider(
-                "ggee.com",
-                "get",
-                10000,
-                new ApiGroup("aaa2141r1f", 1)
-            ),
-        ];
+        const someProviders = [new ExternalApiProvider("ggee.com", "get", 10000, new ApiGroup("aaa2141r1f", 1))];
 
         it("Should set niceFactor field to 1 for given providers Array", async function () {
-            const instance = new RobustExternalAPICallerService(
-                "someBio",
-                someProviders
-            );
+            const instance = new RobustExternalAPICallerService("someBio", someProviders);
 
-            instance.providers.forEach((provider) =>
-                provider.niceFactor.should.be.equal(1)
-            );
+            instance.providers.forEach(provider => provider.niceFactor.should.be.equal(1));
         });
     });
 });

package/src/swaps-lib/external-apis/swapProvider.js

@@ -120,13 +120,7 @@ export class SwapProvider {
      *            [rawSwapData]: Object
      *         })>}
      */
-    async getSwapInfo(
-        fromCoin,
-        toCoin,
-        amountCoins,
-        fixed = false,
-        fromCoinToUsdRate = null
-    ) {
+    async getSwapInfo(fromCoin, toCoin, amountCoins, fixed = false, fromCoinToUsdRate = null) {
         throw new Error("Not implemented in base");
     }