@rosen-bridge/minimum-fee 2.2.3 → 3.0.0

package/CHANGELOG.md

@@ -0,0 +1,86 @@
+# @rosen-bridge/minimum-fee
+
+## 3.0.0
+
+### Major Changes
+
+- Update node version to 22.18
+
+### Patch Changes
+
+- Update dependencies
+  - @rosen-clients/ergo-explorer@2.0.0
+  - @rosen-clients/ergo-node@3.0.0
+  - @rosen-bridge/abstract-logger@3.0.0
+  - @rosen-bridge/json-bigint@1.0.0
+
+## 2.3.0
+
+### Minor Changes
+
+- Update versions of nodejs to 20.11 & typescript to 5.8
+
+### Patch Changes
+
+- Update dependencies
+  - @rosen-bridge/abstract-logger@2.1.0
+  - @rosen-bridge/json-bigint@0.2.0
+
+## 2.2.3
+
+### Patch Changes
+
+- Update ergo node and explorer clients
+
+## 2.2.2
+
+### Patch Changes
+
+- Updated dependencies
+  - @rosen-bridge/abstract-logger@2.0.1
+
+## 2.2.1
+
+### Patch Changes
+
+- Updated dependencies
+  - @rosen-bridge/abstract-logger@2.0.0
+
+## 2.2.0
+
+### Minor Changes
+
+- add `prune` function to remove unused chains (i.e. chains without config)
+
+## 2.1.0
+
+### Minor Changes
+
+- add a function to get fee from MinimumFeeBox
+- add a function to get fee from MinimumFeeBoxBuilder
+- enable MinimumFeeConfig initialization from fee config
+- export fee ratio divisor constant
+- export a function to extract fee config from ErgoBox
+- export a function to convert fee config to register values
+
+## 2.0.1
+
+### Patch Changes
+
+- fix fetching config box for Erg
+
+## 2.0.0
+
+### Major Changes
+
+- Update api calls to use token and remove required address
+
+### Patch Changes
+
+- update ergo explorer and node clients
+
+## 1.0.2
+
+### Patch Changes
+
+- remove previous fetched box in case that no box or multiple boxes is found

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../lib/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,QAAQ,CAAC;AACvC,eAAO,MAAM,iBAAiB,SAAS,CAAC"}

package/dist/constants.js

@@ -0,0 +1,3 @@
+export const ERGO_NATIVE_TOKEN = 'erg';
+export const FEE_RATIO_DIVISOR = 10000n;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vbGliL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxLQUFLLENBQUM7QUFDdkMsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsTUFBTSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IEVSR09fTkFUSVZFX1RPS0VOID0gJ2VyZyc7XG5leHBvcnQgY29uc3QgRkVFX1JBVElPX0RJVklTT1IgPSAxMDAwMG47XG4iXX0=

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../lib/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,GAAG,EAAE,MAAM;CAGxB;AAED,qBAAa,WAAY,SAAQ,KAAK;gBACxB,GAAG,EAAE,MAAM;CAGxB;AAED,qBAAa,YAAa,SAAQ,KAAK;gBACzB,GAAG,EAAE,MAAM;CAGxB;AAED,qBAAa,kBAAmB,SAAQ,KAAK;gBAC/B,GAAG,EAAE,MAAM;CAGxB;AAED,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,GAAG,EAAE,MAAM;CAGxB"}

package/dist/errors.js

@@ -0,0 +1,26 @@
+export class InvalidConfig extends Error {
+    constructor(msg) {
+        super('InvalidConfig: ' + msg);
+    }
+}
+export class FailedError extends Error {
+    constructor(msg) {
+        super('FailedError: ' + msg);
+    }
+}
+export class NetworkError extends Error {
+    constructor(msg) {
+        super('NetworkError: ' + msg);
+    }
+}
+export class UnexpectedApiError extends Error {
+    constructor(msg) {
+        super('UnexpectedApiError: ' + msg);
+    }
+}
+export class NotFoundError extends Error {
+    constructor(msg) {
+        super('NotFoundError: ' + msg);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vbGliL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sYUFBYyxTQUFRLEtBQUs7SUFDdEMsWUFBWSxHQUFXO1FBQ3JCLEtBQUssQ0FBQyxpQkFBaUIsR0FBRyxHQUFHLENBQUMsQ0FBQztJQUNqQyxDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8sV0FBWSxTQUFRLEtBQUs7SUFDcEMsWUFBWSxHQUFXO1FBQ3JCLEtBQUssQ0FBQyxlQUFlLEdBQUcsR0FBRyxDQUFDLENBQUM7SUFDL0IsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLFlBQWEsU0FBUSxLQUFLO0lBQ3JDLFlBQVksR0FBVztRQUNyQixLQUFLLENBQUMsZ0JBQWdCLEdBQUcsR0FBRyxDQUFDLENBQUM7SUFDaEMsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLGtCQUFtQixTQUFRLEtBQUs7SUFDM0MsWUFBWSxHQUFXO1FBQ3JCLEtBQUssQ0FBQyxzQkFBc0IsR0FBRyxHQUFHLENBQUMsQ0FBQztJQUN0QyxDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8sYUFBYyxTQUFRLEtBQUs7SUFDdEMsWUFBWSxHQUFXO1FBQ3JCLEtBQUssQ0FBQyxpQkFBaUIsR0FBRyxHQUFHLENBQUMsQ0FBQztJQUNqQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgSW52YWxpZENvbmZpZyBleHRlbmRzIEVycm9yIHtcbiAgY29uc3RydWN0b3IobXNnOiBzdHJpbmcpIHtcbiAgICBzdXBlcignSW52YWxpZENvbmZpZzogJyArIG1zZyk7XG4gIH1cbn1cblxuZXhwb3J0IGNsYXNzIEZhaWxlZEVycm9yIGV4dGVuZHMgRXJyb3Ige1xuICBjb25zdHJ1Y3Rvcihtc2c6IHN0cmluZykge1xuICAgIHN1cGVyKCdGYWlsZWRFcnJvcjogJyArIG1zZyk7XG4gIH1cbn1cblxuZXhwb3J0IGNsYXNzIE5ldHdvcmtFcnJvciBleHRlbmRzIEVycm9yIHtcbiAgY29uc3RydWN0b3IobXNnOiBzdHJpbmcpIHtcbiAgICBzdXBlcignTmV0d29ya0Vycm9yOiAnICsgbXNnKTtcbiAgfVxufVxuXG5leHBvcnQgY2xhc3MgVW5leHBlY3RlZEFwaUVycm9yIGV4dGVuZHMgRXJyb3Ige1xuICBjb25zdHJ1Y3Rvcihtc2c6IHN0cmluZykge1xuICAgIHN1cGVyKCdVbmV4cGVjdGVkQXBpRXJyb3I6ICcgKyBtc2cpO1xuICB9XG59XG5cbmV4cG9ydCBjbGFzcyBOb3RGb3VuZEVycm9yIGV4dGVuZHMgRXJyb3Ige1xuICBjb25zdHJ1Y3Rvcihtc2c6IHN0cmluZykge1xuICAgIHN1cGVyKCdOb3RGb3VuZEVycm9yOiAnICsgbXNnKTtcbiAgfVxufVxuIl19

package/dist/{lib/handleApiError.d.ts → handleApiError.d.ts}

@@ -10,9 +10,9 @@ interface ErrorHandler<HandlerReturnType> {
  * are handled
  */
 declare const handleApiError: <RespondedStateHandlerReturnType = never, NotRespondedStateHandlerReturnType = never, UnknownStateHandlerReturnType = never>(error: any, baseMessage: string, overrideHandlers?: {
-    handleRespondedState?: ErrorHandler<RespondedStateHandlerReturnType> | undefined;
-    handleNotRespondedState?: ErrorHandler<NotRespondedStateHandlerReturnType> | undefined;
-    handleUnknownState?: ErrorHandler<UnknownStateHandlerReturnType> | undefined;
-} | undefined) => RespondedStateHandlerReturnType | NotRespondedStateHandlerReturnType | UnknownStateHandlerReturnType;
+    handleRespondedState?: ErrorHandler<RespondedStateHandlerReturnType>;
+    handleNotRespondedState?: ErrorHandler<NotRespondedStateHandlerReturnType>;
+    handleUnknownState?: ErrorHandler<UnknownStateHandlerReturnType>;
+}) => RespondedStateHandlerReturnType | NotRespondedStateHandlerReturnType | UnknownStateHandlerReturnType;
 export default handleApiError;
 //# sourceMappingURL=handleApiError.d.ts.map

package/dist/handleApiError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleApiError.d.ts","sourceRoot":"","sources":["../lib/handleApiError.ts"],"names":[],"mappings":"AAEA,UAAU,YAAY,CAAC,iBAAiB;IACtC,CAAC,KAAK,EAAE,GAAG,GAAG,iBAAiB,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,QAAA,MAAM,cAAc,GAClB,+BAA+B,GAAG,KAAK,EACvC,kCAAkC,GAAG,KAAK,EAC1C,6BAA6B,GAAG,KAAK,EAErC,OAAO,GAAG,EACV,aAAa,MAAM,EACnB,mBAAmB;IACjB,oBAAoB,CAAC,EAAE,YAAY,CAAC,+BAA+B,CAAC,CAAC;IACrE,uBAAuB,CAAC,EAAE,YAAY,CAAC,kCAAkC,CAAC,CAAC;IAC3E,kBAAkB,CAAC,EAAE,YAAY,CAAC,6BAA6B,CAAC,CAAC;CAClE,KAEC,+BAA+B,GAC/B,kCAAkC,GAClC,6BA2BH,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/dist/handleApiError.js

@@ -0,0 +1,35 @@
+import { FailedError, NetworkError, UnexpectedApiError } from './errors';
+/**
+ * handle an axios api error, considering different kinds of events which may
+ * cause it
+ * @param error the error object
+ * @param baseMessage string to prepend the actual error message
+ * @param overrideHandlers an object for overriding how different kinds of error
+ * are handled
+ */
+const handleApiError = (error, baseMessage, overrideHandlers) => {
+    const generateErrorMessage = (partialMessage) => `${baseMessage} ${partialMessage}`;
+    const handleRespondedState = overrideHandlers?.handleRespondedState ??
+        (() => {
+            throw new FailedError(generateErrorMessage(error.response.data.reason));
+        });
+    const handleNotRespondedState = overrideHandlers?.handleNotRespondedState ??
+        (() => {
+            throw new NetworkError(generateErrorMessage(error.message));
+        });
+    const handleUnknownState = overrideHandlers?.handleUnknownState ??
+        (() => {
+            throw new UnexpectedApiError(generateErrorMessage(error.message));
+        });
+    if (error.response) {
+        return handleRespondedState(error);
+    }
+    else if (error.request) {
+        return handleNotRespondedState(error);
+    }
+    else {
+        return handleUnknownState(error);
+    }
+};
+export default handleApiError;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { FEE_RATIO_DIVISOR } from './constants';
+export * from './types';
+export * from './errors';
+export { MinimumFeeConfig } from './minimumFeeConfig';
+export { MinimumFeeBoxBuilder } from './minimumFeeBoxBuilder';
+export { MinimumFeeBox } from './minimumFeeBox';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export { FEE_RATIO_DIVISOR } from './constants';
+export * from './types';
+export * from './errors';
+export { MinimumFeeConfig } from './minimumFeeConfig';
+export { MinimumFeeBoxBuilder } from './minimumFeeBoxBuilder';
+export { MinimumFeeBox } from './minimumFeeBox';
+export * from './utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ2hELGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzlELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUNoRCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IEZFRV9SQVRJT19ESVZJU09SIH0gZnJvbSAnLi9jb25zdGFudHMnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL2Vycm9ycyc7XG5leHBvcnQgeyBNaW5pbXVtRmVlQ29uZmlnIH0gZnJvbSAnLi9taW5pbXVtRmVlQ29uZmlnJztcbmV4cG9ydCB7IE1pbmltdW1GZWVCb3hCdWlsZGVyIH0gZnJvbSAnLi9taW5pbXVtRmVlQm94QnVpbGRlcic7XG5leHBvcnQgeyBNaW5pbXVtRmVlQm94IH0gZnJvbSAnLi9taW5pbXVtRmVlQm94JztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbHMnO1xuIl19

package/dist/{lib/MinimumFeeBox.d.ts → minimumFeeBox.d.ts}

@@ -3,7 +3,7 @@ import { ChainMinimumFee, ErgoNetworkType, Fee } from './types';
 import ergoExplorerClientFactory from '@rosen-clients/ergo-explorer';
 import ergoNodeClientFactory from '@rosen-clients/ergo-node';
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
-import { MinimumFeeBoxBuilder } from './MinimumFeeBoxBuilder';
+import { MinimumFeeBoxBuilder } from './minimumFeeBoxBuilder';
 export declare class MinimumFeeBox {
     protected readonly BOX_FETCHING_PAGE_SIZE = 50;
     protected logger: AbstractLogger;
@@ -52,4 +52,4 @@ export declare class MinimumFeeBox {
      */
     toBuilder: () => MinimumFeeBoxBuilder;
 }
-//# sourceMappingURL=MinimumFeeBox.d.ts.map
+//# sourceMappingURL=minimumFeeBox.d.ts.map

package/dist/minimumFeeBox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimumFeeBox.d.ts","sourceRoot":"","sources":["../lib/minimumFeeBox.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,OAAO,EAAiB,MAAM,sBAAsB,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC;AAEhE,OAAO,yBAAyB,MAAM,8BAA8B,CAAC;AACrE,OAAO,qBAAqB,MAAM,0BAA0B,CAAC;AAG7D,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAK9D,qBAAa,aAAa;IACxB,SAAS,CAAC,QAAQ,CAAC,sBAAsB,MAAM;IAC/C,SAAS,CAAC,MAAM,EAAE,cAAc,CAAC;IACjC,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,CAAC;IACnC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,aAAa,EAAE,MAAM,CAAC;IAChC,SAAS,CAAC,cAAc,EAAE,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC;IACvE,SAAS,CAAC,UAAU,EAAE,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;gBAG7D,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,eAAe,EAC5B,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,cAAc;IAUzB;;;OAGG;IACH,QAAQ,QAAa,OAAO,CAAC,OAAO,CAAC,CAoCnC;IAEF;;;OAGG;IACH,SAAS,CAAC,iBAAiB,GAAI,eAAe,KAAK,CAAC,OAAO,CAAC,KAAG,OAAO,CAyBpE;IAEF;;OAEG;IACH,SAAS,CAAC,uBAAuB,QAAa,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CA8CnE;IAEF;;OAEG;IACH,SAAS,CAAC,mBAAmB,QAAa,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAiD/D;IAEF;;OAEG;IACH,MAAM,QAAO,OAAO,GAAG,SAAS,CAAa;IAE7C;;OAEG;IACH,UAAU,QAAO,KAAK,CAAC,GAAG,CAAC,CASzB;IAEF;;;;;OAKG;IACH,MAAM,GACJ,WAAW,MAAM,EACjB,QAAQ,MAAM,EACd,SAAS,MAAM,KACd,eAAe,CA4BhB;IAEF;;;OAGG;IACH,SAAS,QAAO,oBAAoB,CA+BlC;CACH"}

package/dist/minimumFeeBox.js

@@ -0,0 +1,219 @@
+import { Address, ErgoBox, NetworkPrefix } from 'ergo-lib-wasm-nodejs';
+import { ChainMinimumFee, ErgoNetworkType } from './types';
+import { FailedError, NotFoundError } from './errors';
+import ergoExplorerClientFactory from '@rosen-clients/ergo-explorer';
+import ergoNodeClientFactory from '@rosen-clients/ergo-node';
+import JsonBigInt from '@rosen-bridge/json-bigint';
+import handleApiError from './handleApiError';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { MinimumFeeBoxBuilder } from './minimumFeeBoxBuilder';
+import { MinimumFeeConfig } from './minimumFeeConfig';
+import { ERGO_NATIVE_TOKEN } from './constants';
+import { extractFeeFromBox } from './utils';
+export class MinimumFeeBox {
+    BOX_FETCHING_PAGE_SIZE = 50;
+    logger;
+    box;
+    tokenId;
+    minimumFeeNFT;
+    explorerClient;
+    nodeClient;
+    constructor(tokenId, minimumFeeNFT, networkType, networkUrl, logger) {
+        this.tokenId = tokenId;
+        this.minimumFeeNFT = minimumFeeNFT;
+        if (networkType === ErgoNetworkType.explorer)
+            this.explorerClient = ergoExplorerClientFactory(networkUrl);
+        else
+            this.nodeClient = ergoNodeClientFactory(networkUrl);
+        this.logger = logger ? logger : new DummyLogger();
+    }
+    /**
+     * fetches the box from the blockchain
+     * @returns true if action was successful, otherwise false
+     */
+    fetchBox = async () => {
+        const boxHasAppropriateTokens = (box) => {
+            const tokenLen = box.tokens().len();
+            let hasMinimumFeeNFT = false;
+            let hasTargetToken = this.tokenId === ERGO_NATIVE_TOKEN ? true : false;
+            const hasCorrectTokens = this.tokenId === ERGO_NATIVE_TOKEN ? tokenLen === 1 : tokenLen === 2;
+            for (let i = 0; i < tokenLen; i++) {
+                const id = box.tokens().get(i).id().to_str();
+                if (id === this.minimumFeeNFT)
+                    hasMinimumFeeNFT = true;
+                else if (id === this.tokenId)
+                    hasTargetToken = true;
+            }
+            return hasCorrectTokens && hasMinimumFeeNFT && hasTargetToken;
+        };
+        try {
+            const boxes = this.explorerClient
+                ? await this.fetchBoxesUsingExplorer()
+                : await this.fetchBoxesUsingNode();
+            this.box = this.selectEligibleBox(boxes.filter((box) => boxHasAppropriateTokens(box)));
+            return true;
+        }
+        catch (e) {
+            if (e instanceof NotFoundError || e instanceof FailedError) {
+                this.logger.warn(`No valid minimum-fee box. reason: ${e}`);
+                this.box = undefined;
+            }
+            else {
+                this.logger.warn(`An error occurred while updating minimum-fee box for token [${this.tokenId}]: ${e}`);
+                if (e instanceof Error && e.stack)
+                    this.logger.warn(e.stack);
+            }
+            return false;
+        }
+    };
+    /**
+     * returns fetched box or throws appropriate error if found more or none
+     * @param eligibleBoxes
+     */
+    selectEligibleBox = (eligibleBoxes) => {
+        this.logger.debug(`Found [${eligibleBoxes.length}] minimum-fee boxes: ${JsonBigInt.stringify(eligibleBoxes.map((box) => box.to_json()))}`);
+        if (eligibleBoxes.length === 0) {
+            throw new NotFoundError(`Found no minimum-fee box for token [${this.tokenId}]`);
+        }
+        else if (eligibleBoxes.length > 1) {
+            throw new FailedError(`Found [${eligibleBoxes.length}] minimum-fee boxes for token [${this.tokenId}]`);
+        }
+        else {
+            this.logger.debug(`Found minimum-fee box [${eligibleBoxes[0]
+                .box_id()
+                .to_str()}] for token [${this.tokenId}]`);
+            return eligibleBoxes[0];
+        }
+    };
+    /**
+     * fetches box from the blockchain using explorer client
+     */
+    fetchBoxesUsingExplorer = async () => {
+        const boxes = [];
+        try {
+            let currentPage = 0;
+            let boxesPage = await this.explorerClient.v1.getApiV1BoxesUnspentBytokenidP1(this.minimumFeeNFT, {
+                offset: currentPage * this.BOX_FETCHING_PAGE_SIZE,
+                limit: this.BOX_FETCHING_PAGE_SIZE,
+            });
+            this.logger.debug(`requested 'explorerClient.getApiV1BoxesUnspentBytokenidP1' for token [${this.minimumFeeNFT}]. res: ${JsonBigInt.stringify(boxesPage)}`);
+            while (boxesPage.items?.length) {
+                boxes.push(...boxesPage.items.map((box) => ErgoBox.from_json(JsonBigInt.stringify(box))));
+                currentPage++;
+                boxesPage =
+                    await this.explorerClient.v1.getApiV1BoxesUnspentBytokenidP1(this.minimumFeeNFT, {
+                        offset: currentPage * this.BOX_FETCHING_PAGE_SIZE,
+                        limit: this.BOX_FETCHING_PAGE_SIZE,
+                    });
+                this.logger.debug(`requested 'explorerClient.getApiV1BoxesUnspentBytokenidP1' for token [${this.minimumFeeNFT}]. res: ${JsonBigInt.stringify(boxesPage)}`);
+            }
+        }
+        catch (error) {
+            return handleApiError(error, 'Failed to get boxes by token id from Ergo Explorer:');
+        }
+        return boxes;
+    };
+    /**
+     * fetches the box from the blockchain using node client
+     */
+    fetchBoxesUsingNode = async () => {
+        const boxes = [];
+        try {
+            let currentPage = 0;
+            let boxesPage = await this.nodeClient.getBoxesByTokenIdUnspent(this.minimumFeeNFT, {
+                offset: currentPage * this.BOX_FETCHING_PAGE_SIZE,
+                limit: this.BOX_FETCHING_PAGE_SIZE,
+            });
+            this.logger.debug(`requested 'nodeClient.getBoxesByTokenIdUnspent' for token [${this.minimumFeeNFT}]. res: ${JsonBigInt.stringify(boxesPage)}`);
+            while (boxesPage.length !== 0) {
+                boxes.push(...boxesPage.map((box) => ErgoBox.from_json(JsonBigInt.stringify(box))));
+                currentPage++;
+                boxesPage = await this.nodeClient.getBoxesByTokenIdUnspent(this.minimumFeeNFT, {
+                    offset: currentPage * this.BOX_FETCHING_PAGE_SIZE,
+                    limit: this.BOX_FETCHING_PAGE_SIZE,
+                });
+                this.logger.debug(`requested 'nodeClient.getBoxesByTokenIdUnspent' for token [${this.minimumFeeNFT}]. res: ${JsonBigInt.stringify(boxesPage)}`);
+            }
+        }
+        catch (error) {
+            const baseError = 'Failed to get boxes by token id from Ergo Node:';
+            handleApiError(error, baseError, {
+                handleRespondedState: (error) => {
+                    if (error.response.status === 400)
+                        return;
+                    throw new FailedError(`${baseError} [${error.response.status}] ${error.response.data.reason}`);
+                },
+            });
+        }
+        return boxes;
+    };
+    /**
+     * returns fetched config box
+     */
+    getBox = () => this.box;
+    /**
+     * gets current feeConfig
+     */
+    getConfigs = () => {
+        if (!this.box)
+            throw Error(`Box is not fetched yet`);
+        const fee = extractFeeFromBox(this.box);
+        this.logger.debug(`Extracted fee config from box [${this.box
+            .box_id()
+            .to_str()}]: ${JsonBigInt.stringify(fee)}`);
+        return fee;
+    };
+    /**
+     * gets corresponding config for two chains and height
+     * @param fromChain
+     * @param height blockchain height for fromChain
+     * @param toChain
+     */
+    getFee = (fromChain, height, toChain) => {
+        if (!this.box)
+            throw Error(`Box is not fetched yet`);
+        const fees = this.getConfigs().reverse();
+        for (const fee of fees) {
+            if (!Object.hasOwn(fee.heights, fromChain))
+                throw new NotFoundError(`No fee found for chain [${fromChain}] in box [${this.box
+                    .box_id()
+                    .to_str()}]`);
+            if (fee.heights[fromChain] < height) {
+                const chainFee = fee.configs[toChain];
+                if (chainFee)
+                    return new ChainMinimumFee(chainFee);
+                else
+                    throw new Error(`Chain [${toChain}] is not supported at given height of fromChain [${height} of ${fromChain}] in box [${this.box
+                        .box_id()
+                        .to_str()}]`);
+            }
+        }
+        throw new NotFoundError(`Config does not support height [${height}] for chain [${fromChain}] in box [${this.box
+            .box_id()
+            .to_str()}]`);
+    };
+    /**
+     * generates a MinimumFeeBoxBuilder using current box
+     *  note that 'height' parameter of builder won't be set
+     */
+    toBuilder = () => {
+        if (!this.box)
+            throw Error(`Box is not fetched yet`);
+        const builder = new MinimumFeeBoxBuilder(this.minimumFeeNFT, Address.recreate_from_ergo_tree(this.box.ergo_tree()).to_base58(NetworkPrefix.Mainnet))
+            .setValue(BigInt(this.box.value().as_i64().to_str()))
+            .setToken(this.tokenId);
+        this.getConfigs().forEach((fee) => {
+            this.logger.debug(`Extracted fee config from box [${this.box.box_id().to_str()}]: ${JsonBigInt.stringify(fee)}`);
+            const chainFee = new MinimumFeeConfig();
+            Object.keys(fee.heights).forEach((chain) => {
+                if (Object.hasOwn(fee.configs, chain))
+                    chainFee.setChainConfig(chain, fee.heights[chain], fee.configs[chain]);
+                else
+                    chainFee.setChainConfig(chain, fee.heights[chain], undefined);
+            });
+            builder.addConfig(chainFee);
+        });
+        return builder;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"minimumFeeBox.js","sourceRoot":"","sources":["../lib/minimumFeeBox.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,eAAe,EAAO,MAAM,SAAS,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,yBAAyB,MAAM,8BAA8B,CAAC;AACrE,OAAO,qBAAqB,MAAM,0BAA0B,CAAC;AAC7D,OAAO,UAAU,MAAM,2BAA2B,CAAC;AACnD,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAkB,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE5C,MAAM,OAAO,aAAa;IACL,sBAAsB,GAAG,EAAE,CAAC;IACrC,MAAM,CAAiB;IACvB,GAAG,CAAsB;IACzB,OAAO,CAAS;IAChB,aAAa,CAAS;IACtB,cAAc,CAA+C;IAC7D,UAAU,CAA2C;IAE/D,YACE,OAAe,EACf,aAAqB,EACrB,WAA4B,EAC5B,UAAkB,EAClB,MAAuB;QAEvB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,WAAW,KAAK,eAAe,CAAC,QAAQ;YAC1C,IAAI,CAAC,cAAc,GAAG,yBAAyB,CAAC,UAAU,CAAC,CAAC;;YACzD,IAAI,CAAC,UAAU,GAAG,qBAAqB,CAAC,UAAU,CAAC,CAAC;QACzD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC;IACpD,CAAC;IAED;;;OAGG;IACH,QAAQ,GAAG,KAAK,IAAsB,EAAE;QACtC,MAAM,uBAAuB,GAAG,CAAC,GAAY,EAAE,EAAE;YAC/C,MAAM,QAAQ,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC;YACpC,IAAI,gBAAgB,GAAG,KAAK,CAAC;YAC7B,IAAI,cAAc,GAAG,IAAI,CAAC,OAAO,KAAK,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;YACvE,MAAM,gBAAgB,GACpB,IAAI,CAAC,OAAO,KAAK,iBAAiB,CAAC,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC;YACvE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC;gBAClC,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC;gBAC7C,IAAI,EAAE,KAAK,IAAI,CAAC,aAAa;oBAAE,gBAAgB,GAAG,IAAI,CAAC;qBAClD,IAAI,EAAE,KAAK,IAAI,CAAC,OAAO;oBAAE,cAAc,GAAG,IAAI,CAAC;YACtD,CAAC;YACD,OAAO,gBAAgB,IAAI,gBAAgB,IAAI,cAAc,CAAC;QAChE,CAAC,CAAC;QAEF,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc;gBAC/B,CAAC,CAAC,MAAM,IAAI,CAAC,uBAAuB,EAAE;gBACtC,CAAC,CAAC,MAAM,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAErC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,iBAAiB,CAC/B,KAAK,CAAC,MAAM,CAAC,CAAC,GAAY,EAAE,EAAE,CAAC,uBAAuB,CAAC,GAAG,CAAC,CAAC,CAC7D,CAAC;YACF,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,CAAC,YAAY,aAAa,IAAI,CAAC,YAAY,WAAW,EAAE,CAAC;gBAC3D,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,qCAAqC,CAAC,EAAE,CAAC,CAAC;gBAC3D,IAAI,CAAC,GAAG,GAAG,SAAS,CAAC;YACvB,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,+DAA+D,IAAI,CAAC,OAAO,MAAM,CAAC,EAAE,CACrF,CAAC;gBACF,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,KAAK;oBAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;YAC/D,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC,CAAC;IAEF;;;OAGG;IACO,iBAAiB,GAAG,CAAC,aAA6B,EAAW,EAAE;QACvE,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,UACE,aAAa,CAAC,MAChB,wBAAwB,UAAU,CAAC,SAAS,CAC1C,aAAa,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAC1C,EAAE,CACJ,CAAC;QAEF,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,aAAa,CACrB,uCAAuC,IAAI,CAAC,OAAO,GAAG,CACvD,CAAC;QACJ,CAAC;aAAM,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpC,MAAM,IAAI,WAAW,CACnB,UAAU,aAAa,CAAC,MAAM,kCAAkC,IAAI,CAAC,OAAO,GAAG,CAChF,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,0BAA0B,aAAa,CAAC,CAAC,CAAC;iBACvC,MAAM,EAAE;iBACR,MAAM,EAAE,gBAAgB,IAAI,CAAC,OAAO,GAAG,CAC3C,CAAC;YACF,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC;QAC1B,CAAC;IACH,CAAC,CAAC;IAEF;;OAEG;IACO,uBAAuB,GAAG,KAAK,IAA6B,EAAE;QACtE,MAAM,KAAK,GAAmB,EAAE,CAAC;QACjC,IAAI,CAAC;YACH,IAAI,WAAW,GAAG,CAAC,CAAC;YACpB,IAAI,SAAS,GACX,MAAM,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,+BAA+B,CAC1D,IAAI,CAAC,aAAa,EAClB;gBACE,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC,sBAAsB;gBACjD,KAAK,EAAE,IAAI,CAAC,sBAAsB;aACnC,CACF,CAAC;YACJ,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,yEACE,IAAI,CAAC,aACP,WAAW,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAC7C,CAAC;YACF,OAAO,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;gBAC/B,KAAK,CAAC,IAAI,CACR,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAC7B,OAAO,CAAC,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAC7C,CACF,CAAC;gBACF,WAAW,EAAE,CAAC;gBACd,SAAS;oBACP,MAAM,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,+BAA+B,CAC1D,IAAI,CAAC,aAAa,EAClB;wBACE,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC,sBAAsB;wBACjD,KAAK,EAAE,IAAI,CAAC,sBAAsB;qBACnC,CACF,CAAC;gBACJ,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,yEACE,IAAI,CAAC,aACP,WAAW,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAC7C,CAAC;YACJ,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,cAAc,CACnB,KAAK,EACL,qDAAqD,CACtD,CAAC;QACJ,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF;;OAEG;IACO,mBAAmB,GAAG,KAAK,IAA6B,EAAE;QAClE,MAAM,KAAK,GAAmB,EAAE,CAAC;QACjC,IAAI,CAAC;YACH,IAAI,WAAW,GAAG,CAAC,CAAC;YACpB,IAAI,SAAS,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,wBAAwB,CAC5D,IAAI,CAAC,aAAa,EAClB;gBACE,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC,sBAAsB;gBACjD,KAAK,EAAE,IAAI,CAAC,sBAAsB;aACnC,CACF,CAAC;YACF,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,8DACE,IAAI,CAAC,aACP,WAAW,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAC7C,CAAC;YACF,OAAO,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC9B,KAAK,CAAC,IAAI,CACR,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CACvB,OAAO,CAAC,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAC7C,CACF,CAAC;gBACF,WAAW,EAAE,CAAC;gBACd,SAAS,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,wBAAwB,CACxD,IAAI,CAAC,aAAa,EAClB;oBACE,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC,sBAAsB;oBACjD,KAAK,EAAE,IAAI,CAAC,sBAAsB;iBACnC,CACF,CAAC;gBACF,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,8DACE,IAAI,CAAC,aACP,WAAW,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAC7C,CAAC;YACJ,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,SAAS,GAAG,iDAAiD,CAAC;YACpE,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE;gBAC/B,oBAAoB,EAAE,CAAC,KAAK,EAAE,EAAE;oBAC9B,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM,KAAK,GAAG;wBAAE,OAAO;oBAC1C,MAAM,IAAI,WAAW,CACnB,GAAG,SAAS,KAAK,KAAK,CAAC,QAAQ,CAAC,MAAM,KAAK,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,CACxE,CAAC;gBACJ,CAAC;aACF,CAAC,CAAC;QACL,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF;;OAEG;IACH,MAAM,GAAG,GAAwB,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;IAE7C;;OAEG;IACH,UAAU,GAAG,GAAe,EAAE;QAC5B,IAAI,CAAC,IAAI,CAAC,GAAG;YAAE,MAAM,KAAK,CAAC,wBAAwB,CAAC,CAAC;QACrD,MAAM,GAAG,GAAG,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACxC,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,kCAAkC,IAAI,CAAC,GAAG;aACvC,MAAM,EAAE;aACR,MAAM,EAAE,MAAM,UAAU,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAC7C,CAAC;QACF,OAAO,GAAG,CAAC;IACb,CAAC,CAAC;IAEF;;;;;OAKG;IACH,MAAM,GAAG,CACP,SAAiB,EACjB,MAAc,EACd,OAAe,EACE,EAAE;QACnB,IAAI,CAAC,IAAI,CAAC,GAAG;YAAE,MAAM,KAAK,CAAC,wBAAwB,CAAC,CAAC;QAErD,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,OAAO,EAAE,CAAC;QACzC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,SAAS,CAAC;gBACxC,MAAM,IAAI,aAAa,CACrB,2BAA2B,SAAS,aAAa,IAAI,CAAC,GAAG;qBACtD,MAAM,EAAE;qBACR,MAAM,EAAE,GAAG,CACf,CAAC;YACJ,IAAI,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,MAAM,EAAE,CAAC;gBACpC,MAAM,QAAQ,GAAG,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;gBACtC,IAAI,QAAQ;oBAAE,OAAO,IAAI,eAAe,CAAC,QAAQ,CAAC,CAAC;;oBAEjD,MAAM,IAAI,KAAK,CACb,UAAU,OAAO,oDAAoD,MAAM,OAAO,SAAS,aAAa,IAAI,CAAC,GAAG;yBAC7G,MAAM,EAAE;yBACR,MAAM,EAAE,GAAG,CACf,CAAC;YACN,CAAC;QACH,CAAC;QAED,MAAM,IAAI,aAAa,CACrB,mCAAmC,MAAM,gBAAgB,SAAS,aAAa,IAAI,CAAC,GAAG;aACpF,MAAM,EAAE;aACR,MAAM,EAAE,GAAG,CACf,CAAC;IACJ,CAAC,CAAC;IAEF;;;OAGG;IACH,SAAS,GAAG,GAAyB,EAAE;QACrC,IAAI,CAAC,IAAI,CAAC,GAAG;YAAE,MAAM,KAAK,CAAC,wBAAwB,CAAC,CAAC;QAErD,MAAM,OAAO,GAAG,IAAI,oBAAoB,CACtC,IAAI,CAAC,aAAa,EAClB,OAAO,CAAC,uBAAuB,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,CAC7D,aAAa,CAAC,OAAO,CACtB,CACF;aACE,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC;aACpD,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE1B,IAAI,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YAChC,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,kCAAkC,IAAI,CAAC,GAAI,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,UAAU,CAAC,SAAS,CACrF,GAAG,CACJ,EAAE,CACJ,CAAC;YACF,MAAM,QAAQ,GAAG,IAAI,gBAAgB,EAAE,CAAC;YACxC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;gBACzC,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC;oBACnC,QAAQ,CAAC,cAAc,CACrB,KAAK,EACL,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,EAClB,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CACnB,CAAC;;oBACC,QAAQ,CAAC,cAAc,CAAC,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;YACrE,CAAC,CAAC,CAAC;YACH,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QAC9B,CAAC,CAAC,CAAC;QACH,OAAO,OAAO,CAAC;IACjB,CAAC,CAAC;CACH","sourcesContent":["import { Address, ErgoBox, NetworkPrefix } from 'ergo-lib-wasm-nodejs';\nimport { ChainMinimumFee, ErgoNetworkType, Fee } from './types';\nimport { FailedError, NotFoundError } from './errors';\nimport ergoExplorerClientFactory from '@rosen-clients/ergo-explorer';\nimport ergoNodeClientFactory from '@rosen-clients/ergo-node';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport handleApiError from './handleApiError';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport { MinimumFeeBoxBuilder } from './minimumFeeBoxBuilder';\nimport { MinimumFeeConfig } from './minimumFeeConfig';\nimport { ERGO_NATIVE_TOKEN } from './constants';\nimport { extractFeeFromBox } from './utils';\n\nexport class MinimumFeeBox {\n  protected readonly BOX_FETCHING_PAGE_SIZE = 50;\n  protected logger: AbstractLogger;\n  protected box: ErgoBox | undefined;\n  protected tokenId: string;\n  protected minimumFeeNFT: string;\n  protected explorerClient: ReturnType<typeof ergoExplorerClientFactory>;\n  protected nodeClient: ReturnType<typeof ergoNodeClientFactory>;\n\n  constructor(\n    tokenId: string,\n    minimumFeeNFT: string,\n    networkType: ErgoNetworkType,\n    networkUrl: string,\n    logger?: AbstractLogger,\n  ) {\n    this.tokenId = tokenId;\n    this.minimumFeeNFT = minimumFeeNFT;\n    if (networkType === ErgoNetworkType.explorer)\n      this.explorerClient = ergoExplorerClientFactory(networkUrl);\n    else this.nodeClient = ergoNodeClientFactory(networkUrl);\n    this.logger = logger ? logger : new DummyLogger();\n  }\n\n  /**\n   * fetches the box from the blockchain\n   * @returns true if action was successful, otherwise false\n   */\n  fetchBox = async (): Promise<boolean> => {\n    const boxHasAppropriateTokens = (box: ErgoBox) => {\n      const tokenLen = box.tokens().len();\n      let hasMinimumFeeNFT = false;\n      let hasTargetToken = this.tokenId === ERGO_NATIVE_TOKEN ? true : false;\n      const hasCorrectTokens =\n        this.tokenId === ERGO_NATIVE_TOKEN ? tokenLen === 1 : tokenLen === 2;\n      for (let i = 0; i < tokenLen; i++) {\n        const id = box.tokens().get(i).id().to_str();\n        if (id === this.minimumFeeNFT) hasMinimumFeeNFT = true;\n        else if (id === this.tokenId) hasTargetToken = true;\n      }\n      return hasCorrectTokens && hasMinimumFeeNFT && hasTargetToken;\n    };\n\n    try {\n      const boxes = this.explorerClient\n        ? await this.fetchBoxesUsingExplorer()\n        : await this.fetchBoxesUsingNode();\n\n      this.box = this.selectEligibleBox(\n        boxes.filter((box: ErgoBox) => boxHasAppropriateTokens(box)),\n      );\n      return true;\n    } catch (e) {\n      if (e instanceof NotFoundError || e instanceof FailedError) {\n        this.logger.warn(`No valid minimum-fee box. reason: ${e}`);\n        this.box = undefined;\n      } else {\n        this.logger.warn(\n          `An error occurred while updating minimum-fee box for token [${this.tokenId}]: ${e}`,\n        );\n        if (e instanceof Error && e.stack) this.logger.warn(e.stack);\n      }\n      return false;\n    }\n  };\n\n  /**\n   * returns fetched box or throws appropriate error if found more or none\n   * @param eligibleBoxes\n   */\n  protected selectEligibleBox = (eligibleBoxes: Array<ErgoBox>): ErgoBox => {\n    this.logger.debug(\n      `Found [${\n        eligibleBoxes.length\n      }] minimum-fee boxes: ${JsonBigInt.stringify(\n        eligibleBoxes.map((box) => box.to_json()),\n      )}`,\n    );\n\n    if (eligibleBoxes.length === 0) {\n      throw new NotFoundError(\n        `Found no minimum-fee box for token [${this.tokenId}]`,\n      );\n    } else if (eligibleBoxes.length > 1) {\n      throw new FailedError(\n        `Found [${eligibleBoxes.length}] minimum-fee boxes for token [${this.tokenId}]`,\n      );\n    } else {\n      this.logger.debug(\n        `Found minimum-fee box [${eligibleBoxes[0]\n          .box_id()\n          .to_str()}] for token [${this.tokenId}]`,\n      );\n      return eligibleBoxes[0];\n    }\n  };\n\n  /**\n   * fetches box from the blockchain using explorer client\n   */\n  protected fetchBoxesUsingExplorer = async (): Promise<Array<ErgoBox>> => {\n    const boxes: Array<ErgoBox> = [];\n    try {\n      let currentPage = 0;\n      let boxesPage =\n        await this.explorerClient.v1.getApiV1BoxesUnspentBytokenidP1(\n          this.minimumFeeNFT,\n          {\n            offset: currentPage * this.BOX_FETCHING_PAGE_SIZE,\n            limit: this.BOX_FETCHING_PAGE_SIZE,\n          },\n        );\n      this.logger.debug(\n        `requested 'explorerClient.getApiV1BoxesUnspentBytokenidP1' for token [${\n          this.minimumFeeNFT\n        }]. res: ${JsonBigInt.stringify(boxesPage)}`,\n      );\n      while (boxesPage.items?.length) {\n        boxes.push(\n          ...boxesPage.items.map((box) =>\n            ErgoBox.from_json(JsonBigInt.stringify(box)),\n          ),\n        );\n        currentPage++;\n        boxesPage =\n          await this.explorerClient.v1.getApiV1BoxesUnspentBytokenidP1(\n            this.minimumFeeNFT,\n            {\n              offset: currentPage * this.BOX_FETCHING_PAGE_SIZE,\n              limit: this.BOX_FETCHING_PAGE_SIZE,\n            },\n          );\n        this.logger.debug(\n          `requested 'explorerClient.getApiV1BoxesUnspentBytokenidP1' for token [${\n            this.minimumFeeNFT\n          }]. res: ${JsonBigInt.stringify(boxesPage)}`,\n        );\n      }\n    } catch (error) {\n      return handleApiError(\n        error,\n        'Failed to get boxes by token id from Ergo Explorer:',\n      );\n    }\n\n    return boxes;\n  };\n\n  /**\n   * fetches the box from the blockchain using node client\n   */\n  protected fetchBoxesUsingNode = async (): Promise<Array<ErgoBox>> => {\n    const boxes: Array<ErgoBox> = [];\n    try {\n      let currentPage = 0;\n      let boxesPage = await this.nodeClient.getBoxesByTokenIdUnspent(\n        this.minimumFeeNFT,\n        {\n          offset: currentPage * this.BOX_FETCHING_PAGE_SIZE,\n          limit: this.BOX_FETCHING_PAGE_SIZE,\n        },\n      );\n      this.logger.debug(\n        `requested 'nodeClient.getBoxesByTokenIdUnspent' for token [${\n          this.minimumFeeNFT\n        }]. res: ${JsonBigInt.stringify(boxesPage)}`,\n      );\n      while (boxesPage.length !== 0) {\n        boxes.push(\n          ...boxesPage.map((box) =>\n            ErgoBox.from_json(JsonBigInt.stringify(box)),\n          ),\n        );\n        currentPage++;\n        boxesPage = await this.nodeClient.getBoxesByTokenIdUnspent(\n          this.minimumFeeNFT,\n          {\n            offset: currentPage * this.BOX_FETCHING_PAGE_SIZE,\n            limit: this.BOX_FETCHING_PAGE_SIZE,\n          },\n        );\n        this.logger.debug(\n          `requested 'nodeClient.getBoxesByTokenIdUnspent' for token [${\n            this.minimumFeeNFT\n          }]. res: ${JsonBigInt.stringify(boxesPage)}`,\n        );\n      }\n    } catch (error) {\n      const baseError = 'Failed to get boxes by token id from Ergo Node:';\n      handleApiError(error, baseError, {\n        handleRespondedState: (error) => {\n          if (error.response.status === 400) return;\n          throw new FailedError(\n            `${baseError} [${error.response.status}] ${error.response.data.reason}`,\n          );\n        },\n      });\n    }\n\n    return boxes;\n  };\n\n  /**\n   * returns fetched config box\n   */\n  getBox = (): ErgoBox | undefined => this.box;\n\n  /**\n   * gets current feeConfig\n   */\n  getConfigs = (): Array<Fee> => {\n    if (!this.box) throw Error(`Box is not fetched yet`);\n    const fee = extractFeeFromBox(this.box);\n    this.logger.debug(\n      `Extracted fee config from box [${this.box\n        .box_id()\n        .to_str()}]: ${JsonBigInt.stringify(fee)}`,\n    );\n    return fee;\n  };\n\n  /**\n   * gets corresponding config for two chains and height\n   * @param fromChain\n   * @param height blockchain height for fromChain\n   * @param toChain\n   */\n  getFee = (\n    fromChain: string,\n    height: number,\n    toChain: string,\n  ): ChainMinimumFee => {\n    if (!this.box) throw Error(`Box is not fetched yet`);\n\n    const fees = this.getConfigs().reverse();\n    for (const fee of fees) {\n      if (!Object.hasOwn(fee.heights, fromChain))\n        throw new NotFoundError(\n          `No fee found for chain [${fromChain}] in box [${this.box\n            .box_id()\n            .to_str()}]`,\n        );\n      if (fee.heights[fromChain] < height) {\n        const chainFee = fee.configs[toChain];\n        if (chainFee) return new ChainMinimumFee(chainFee);\n        else\n          throw new Error(\n            `Chain [${toChain}] is not supported at given height of fromChain [${height} of ${fromChain}] in box [${this.box\n              .box_id()\n              .to_str()}]`,\n          );\n      }\n    }\n\n    throw new NotFoundError(\n      `Config does not support height [${height}] for chain [${fromChain}] in box [${this.box\n        .box_id()\n        .to_str()}]`,\n    );\n  };\n\n  /**\n   * generates a MinimumFeeBoxBuilder using current box\n   *  note that 'height' parameter of builder won't be set\n   */\n  toBuilder = (): MinimumFeeBoxBuilder => {\n    if (!this.box) throw Error(`Box is not fetched yet`);\n\n    const builder = new MinimumFeeBoxBuilder(\n      this.minimumFeeNFT,\n      Address.recreate_from_ergo_tree(this.box.ergo_tree()).to_base58(\n        NetworkPrefix.Mainnet,\n      ),\n    )\n      .setValue(BigInt(this.box.value().as_i64().to_str()))\n      .setToken(this.tokenId);\n\n    this.getConfigs().forEach((fee) => {\n      this.logger.debug(\n        `Extracted fee config from box [${this.box!.box_id().to_str()}]: ${JsonBigInt.stringify(\n          fee,\n        )}`,\n      );\n      const chainFee = new MinimumFeeConfig();\n      Object.keys(fee.heights).forEach((chain) => {\n        if (Object.hasOwn(fee.configs, chain))\n          chainFee.setChainConfig(\n            chain,\n            fee.heights[chain],\n            fee.configs[chain],\n          );\n        else chainFee.setChainConfig(chain, fee.heights[chain], undefined);\n      });\n      builder.addConfig(chainFee);\n    });\n    return builder;\n  };\n}\n"]}

package/dist/{lib/MinimumFeeBoxBuilder.d.ts → minimumFeeBoxBuilder.d.ts}

@@ -1,5 +1,5 @@
 import { BoxValue, ErgoBoxCandidate } from 'ergo-lib-wasm-nodejs';
-import { MinimumFeeConfig } from './MinimumFeeConfig';
+import { MinimumFeeConfig } from './minimumFeeConfig';
 import { Fee } from './types';
 export declare class MinimumFeeBoxBuilder {
     protected fees: Array<Fee>;
@@ -52,4 +52,4 @@ export declare class MinimumFeeBoxBuilder {
      */
     build: () => ErgoBoxCandidate;
 }
-//# sourceMappingURL=MinimumFeeBoxBuilder.d.ts.map
+//# sourceMappingURL=minimumFeeBoxBuilder.d.ts.map

package/dist/minimumFeeBoxBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimumFeeBoxBuilder.d.ts","sourceRoot":"","sources":["../lib/minimumFeeBoxBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAMR,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC;AAK9B,qBAAa,oBAAoB;IAC/B,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IAC3B,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC7B,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;IAC5B,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,aAAa,EAAE,MAAM,CAAC;IAChC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEd,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAMlD;;;OAGG;IACH,SAAS,GAAI,WAAW,gBAAgB,KAAG,oBAAoB,CAG7D;IAEF;;;OAGG;IACH,YAAY,GAAI,OAAO,MAAM,KAAG,oBAAoB,CAGlD;IAEF;;OAEG;IACH,UAAU,QAAO,KAAK,CAAC,GAAG,CAAC,CAEzB;IAEF;;;;OAIG;IACH,QAAQ,GAAI,SAAS,MAAM,KAAG,oBAAoB,CAGhD;IAEF;;;OAGG;IACH,SAAS,GAAI,eAAe,MAAM,KAAG,oBAAoB,CAGvD;IAEF;;;OAGG;IACH,QAAQ,GAAI,SAAS,MAAM,KAAG,oBAAoB,CAGhD;IAEF;;OAEG;IACH,SAAS,CAAC,QAAQ,QAAO,IAAI,CA6B3B;IAEF;;OAEG;IACH,KAAK,QAAO,oBAAoB,CA8B9B;IAEF;;OAEG;IACH,KAAK,QAAO,gBAAgB,CAiC1B;CACH"}