@rosen-bridge/extended-minimum-fee 0.0.0

package/CHANGELOG.md

@@ -0,0 +1 @@
+# @rosen-bridge/extended-minimum-fee

package/README.md

@@ -0,0 +1,41 @@
+# @rosen-bridge/extended-minimum-fee
+
+## Table of contents
+
+- [Introduction](#introduction)
+- [Installation](#installation)
+- [Usage](#usage)
+
+## Introduction
+
+`@rosen-bridge/extended-minimum-fee` Typescript package to build and get minimum fee of the bridge for supported tokens from blockchain
+
+## Installation
+
+npm:
+
+```sh
+npm i @rosen-bridge/extended-minimum-fee
+```
+
+yarn:
+
+```sh
+yarn add @rosen-bridge/extended-minimum-fee
+```
+
+## Usage
+
+Here's a basic example of how to use this package:
+
+```typescript
+import {
+  ExtendedMinimumFeeBox,
+  MinimumFeeExplorerNetwork,
+} from '@rosen-bridge/extended-minimum-fee';
+
+const network = new MinimumFeeExplorerNetwork('URL');
+const minimumFeeBox = new ExtendedMinimumFeeBox('TOKEN_ID', 'NFT', network);
+await minimumFeeBox.fetchBox();
+const builder = minimumFeeBox.toBuilder();
+```

package/dist/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class InvalidConfig extends Error {
+    constructor(msg: string);
+}
+//# sourceMappingURL=errors.d.ts.map

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"}

package/dist/errors.js

@@ -0,0 +1,6 @@
+export class InvalidConfig extends Error {
+    constructor(msg) {
+        super('InvalidConfig: ' + msg);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vbGliL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sYUFBYyxTQUFRLEtBQUs7SUFDdEMsWUFBWSxHQUFXO1FBQ3JCLEtBQUssQ0FBQyxpQkFBaUIsR0FBRyxHQUFHLENBQUMsQ0FBQztJQUNqQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgSW52YWxpZENvbmZpZyBleHRlbmRzIEVycm9yIHtcbiAgY29uc3RydWN0b3IobXNnOiBzdHJpbmcpIHtcbiAgICBzdXBlcignSW52YWxpZENvbmZpZzogJyArIG1zZyk7XG4gIH1cbn1cbiJdfQ==

package/dist/extendedMinimumFeeBox.d.ts

@@ -0,0 +1,12 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { AbstractMinimumFeeNetwork, MinimumFeeBox } from '@rosen-bridge/minimum-fee';
+import { MinimumFeeBoxBuilder } from './minimumFeeBoxBuilder';
+export declare class ExtendedMinimumFeeBox extends MinimumFeeBox {
+    constructor(tokenId: string, minimumFeeNFT: string, network: AbstractMinimumFeeNetwork, logger?: AbstractLogger);
+    /**
+     * generates a MinimumFeeBoxBuilder using current box
+     *  note that 'height' parameter of builder won't be set
+     */
+    toBuilder: () => MinimumFeeBoxBuilder;
+}
+//# sourceMappingURL=extendedMinimumFeeBox.d.ts.map

package/dist/extendedMinimumFeeBox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extendedMinimumFeeBox.d.ts","sourceRoot":"","sources":["../lib/extendedMinimumFeeBox.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,OAAO,EACL,yBAAyB,EACzB,aAAa,EAEd,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAG9D,qBAAa,qBAAsB,SAAQ,aAAa;gBAEpD,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,yBAAyB,EAClC,MAAM,CAAC,EAAE,cAAc;IAKzB;;;OAGG;IACH,SAAS,QAAO,oBAAoB,CA+BlC;CACH"}

package/dist/extendedMinimumFeeBox.js

@@ -0,0 +1,34 @@
+import { Address, ErgoTree, NetworkPrefix } from 'ergo-lib-wasm-nodejs';
+import JsonBigInt from '@rosen-bridge/json-bigint';
+import { MinimumFeeBox, MinimumFeeConfig, } from '@rosen-bridge/minimum-fee';
+import { MinimumFeeBoxBuilder } from './minimumFeeBoxBuilder';
+import { decodeRegister } from './utils';
+export class ExtendedMinimumFeeBox extends MinimumFeeBox {
+    constructor(tokenId, minimumFeeNFT, network, logger) {
+        super(tokenId, minimumFeeNFT, network, decodeRegister, logger);
+    }
+    /**
+     * 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(ErgoTree.from_base16_bytes(this.box.ergoTree)).to_base58(NetworkPrefix.Mainnet))
+            .setValue(this.box.value)
+            .setToken(this.tokenId);
+        this.getConfigs().forEach((fee) => {
+            this.logger.debug(`Extracted fee config from box [${this.box.boxId}]: ${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,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

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './errors';
+export { MinimumFeeBoxBuilder } from './minimumFeeBoxBuilder';
+export { ExtendedMinimumFeeBox } from './extendedMinimumFeeBox';
+export * from './utils';
+export * from '@rosen-bridge/minimum-fee';
+//# 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,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,cAAc,SAAS,CAAC;AACxB,cAAc,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from './errors';
+export { MinimumFeeBoxBuilder } from './minimumFeeBoxBuilder';
+export { ExtendedMinimumFeeBox } from './extendedMinimumFeeBox';
+export * from './utils';
+export * from '@rosen-bridge/minimum-fee';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxVQUFVLENBQUM7QUFDekIsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDOUQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDaEUsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZXJyb3JzJztcbmV4cG9ydCB7IE1pbmltdW1GZWVCb3hCdWlsZGVyIH0gZnJvbSAnLi9taW5pbXVtRmVlQm94QnVpbGRlcic7XG5leHBvcnQgeyBFeHRlbmRlZE1pbmltdW1GZWVCb3ggfSBmcm9tICcuL2V4dGVuZGVkTWluaW11bUZlZUJveCc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxzJztcbmV4cG9ydCAqIGZyb20gJ0Byb3Nlbi1icmlkZ2UvbWluaW11bS1mZWUnO1xuIl19

package/dist/minimumFeeBoxBuilder.d.ts

@@ -0,0 +1,54 @@
+import { BoxValue, ErgoBoxCandidate } from 'ergo-lib-wasm-nodejs';
+import { Fee, MinimumFeeConfig } from '@rosen-bridge/minimum-fee';
+export declare class MinimumFeeBoxBuilder {
+    protected fees: Array<Fee>;
+    protected boxValue: BoxValue;
+    protected boxHeight: number;
+    protected tokenId: string;
+    protected minimumFeeNFT: string;
+    protected address: string;
+    constructor(minimumFeeNFT: string, address: string);
+    /**
+     * adds a feeConfig
+     * @param feeConfig
+     */
+    addConfig: (feeConfig: MinimumFeeConfig) => MinimumFeeBoxBuilder;
+    /**
+     * removes a config by index
+     * @param index
+     */
+    removeConfig: (index: number) => MinimumFeeBoxBuilder;
+    /**
+     * gets current feeConfig
+     */
+    getConfigs: () => Array<Fee>;
+    /**
+     * sets ErgoBox Erg value
+     * @param nanoErg
+     * @returns
+     */
+    setValue: (nanoErg: bigint) => MinimumFeeBoxBuilder;
+    /**
+     * sets ErgoBox creationheight
+     * @param currentHeight
+     */
+    setHeight: (currentHeight: number) => MinimumFeeBoxBuilder;
+    /**
+     * sets config token id
+     * @param tokenId
+     */
+    setToken: (tokenId: string) => MinimumFeeBoxBuilder;
+    /**
+     * validates some of specified configs
+     */
+    protected validate: () => void;
+    /**
+     * removes heights and configs of all chains which don't have any configs
+     */
+    prune: () => MinimumFeeBoxBuilder;
+    /**
+     * validates specified configs and builds ErgoBoxCandidate of config box using them
+     */
+    build: () => ErgoBoxCandidate;
+}
+//# 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;AAE9B,OAAO,EACL,GAAG,EACH,gBAAgB,EAEjB,MAAM,2BAA2B,CAAC;AAKnC,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"}

package/dist/minimumFeeBoxBuilder.js

@@ -0,0 +1,138 @@
+import { Address, BoxValue, Contract, ErgoBoxCandidateBuilder, I64, TokenAmount, TokenId, } from 'ergo-lib-wasm-nodejs';
+import { ERGO_NATIVE_TOKEN, } from '@rosen-bridge/minimum-fee';
+import { InvalidConfig } from './errors';
+import { feeToRegisterValues } from './utils';
+export class MinimumFeeBoxBuilder {
+    fees;
+    boxValue;
+    boxHeight;
+    tokenId;
+    minimumFeeNFT;
+    address;
+    constructor(minimumFeeNFT, address) {
+        this.fees = [];
+        this.minimumFeeNFT = minimumFeeNFT;
+        this.address = address;
+    }
+    /**
+     * adds a feeConfig
+     * @param feeConfig
+     */
+    addConfig = (feeConfig) => {
+        this.fees.push(feeConfig.getConfig());
+        return this;
+    };
+    /**
+     * removes a config by index
+     * @param index
+     */
+    removeConfig = (index) => {
+        this.fees.splice(index, 1);
+        return this;
+    };
+    /**
+     * gets current feeConfig
+     */
+    getConfigs = () => {
+        return this.fees;
+    };
+    /**
+     * sets ErgoBox Erg value
+     * @param nanoErg
+     * @returns
+     */
+    setValue = (nanoErg) => {
+        this.boxValue = BoxValue.from_i64(I64.from_str(nanoErg.toString()));
+        return this;
+    };
+    /**
+     * sets ErgoBox creationheight
+     * @param currentHeight
+     */
+    setHeight = (currentHeight) => {
+        this.boxHeight = currentHeight;
+        return this;
+    };
+    /**
+     * sets config token id
+     * @param tokenId
+     */
+    setToken = (tokenId) => {
+        this.tokenId = tokenId;
+        return this;
+    };
+    /**
+     * validates some of specified configs
+     */
+    validate = () => {
+        if (!this.boxValue)
+            throw new InvalidConfig(`Box value argument is not defined`);
+        if (!this.boxHeight)
+            throw new InvalidConfig(`Box creation height argument is not defined`);
+        if (!this.tokenId)
+            throw new InvalidConfig(`Config token id is not defined`);
+        if (this.fees.length === 0)
+            throw new InvalidConfig(`No config added. Please add at least one config`);
+        for (let i = 0; i < this.fees.length - 1; i++) {
+            const chains = Object.keys(this.fees[0].heights);
+            chains.forEach((chain) => {
+                if (!this.fees[i + 1].heights[chain])
+                    throw new InvalidConfig(`Expected chain [${chain}] at index [${i + 1}]`);
+                if (this.fees[i + 1].heights[chain] < this.fees[i].heights[chain])
+                    throw new InvalidConfig(`All heights for a chain should be ascending. Heights of chain [${chain}] at indexes [${i},${i + 1}] are invalid [${this.fees[i + 1].heights[chain]} < ${this.fees[i].heights[chain]}]`);
+            });
+        }
+    };
+    /**
+     * removes heights and configs of all chains which don't have any configs
+     */
+    prune = () => {
+        const activeChains = [];
+        for (let i = 0; i < this.fees.length; i++) {
+            const chains = Object.keys(this.fees[i].heights);
+            chains.forEach((chain) => {
+                const feeConfig = this.fees[i].configs[chain];
+                if (feeConfig &&
+                    (feeConfig.bridgeFee !== -1n ||
+                        feeConfig.networkFee !== -1n ||
+                        feeConfig.rsnRatio !== -1n ||
+                        feeConfig.rsnRatioDivisor !== -1n ||
+                        feeConfig.feeRatio !== -1n))
+                    activeChains.push(chain);
+            });
+        }
+        for (let i = 0; i < this.fees.length; i++) {
+            const chains = Object.keys(this.fees[i].heights);
+            chains.forEach((chain) => {
+                if (!activeChains.includes(chain)) {
+                    delete this.fees[i].heights[chain];
+                    delete this.fees[i].configs[chain];
+                }
+            });
+        }
+        return this;
+    };
+    /**
+     * validates specified configs and builds ErgoBoxCandidate of config box using them
+     */
+    build = () => {
+        this.validate();
+        // add box value, address and creation height
+        const boxBuilder = new ErgoBoxCandidateBuilder(this.boxValue, Contract.new(Address.from_base58(this.address).to_ergo_tree()), this.boxHeight);
+        // add box tokens
+        boxBuilder.add_token(TokenId.from_str(this.minimumFeeNFT), TokenAmount.from_i64(I64.from_str('1')));
+        if (this.tokenId !== ERGO_NATIVE_TOKEN)
+            boxBuilder.add_token(TokenId.from_str(this.tokenId), TokenAmount.from_i64(I64.from_str('1')));
+        // generate register values
+        const registerValues = feeToRegisterValues(this.fees);
+        // add box registers
+        boxBuilder.set_register_value(4, registerValues.R4);
+        boxBuilder.set_register_value(5, registerValues.R5);
+        boxBuilder.set_register_value(6, registerValues.R6);
+        boxBuilder.set_register_value(7, registerValues.R7);
+        boxBuilder.set_register_value(8, registerValues.R8);
+        boxBuilder.set_register_value(9, registerValues.R9);
+        return boxBuilder.build();
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"minimumFeeBoxBuilder.js","sourceRoot":"","sources":["../lib/minimumFeeBoxBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,uBAAuB,EACvB,GAAG,EACH,WAAW,EACX,OAAO,GAER,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAGL,iBAAiB,GAClB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAE9C,MAAM,OAAO,oBAAoB;IACrB,IAAI,CAAa;IACjB,QAAQ,CAAW;IACnB,SAAS,CAAS;IAClB,OAAO,CAAS;IAChB,aAAa,CAAS;IACtB,OAAO,CAAS;IAE1B,YAAY,aAAqB,EAAE,OAAe;QAChD,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;QACf,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED;;;OAGG;IACH,SAAS,GAAG,CAAC,SAA2B,EAAwB,EAAE;QAChE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC;QACtC,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;IAEF;;;OAGG;IACH,YAAY,GAAG,CAAC,KAAa,EAAwB,EAAE;QACrD,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;IAEF;;OAEG;IACH,UAAU,GAAG,GAAe,EAAE;QAC5B,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC,CAAC;IAEF;;;;OAIG;IACH,QAAQ,GAAG,CAAC,OAAe,EAAwB,EAAE;QACnD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QACpE,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;IAEF;;;OAGG;IACH,SAAS,GAAG,CAAC,aAAqB,EAAwB,EAAE;QAC1D,IAAI,CAAC,SAAS,GAAG,aAAa,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;IAEF;;;OAGG;IACH,QAAQ,GAAG,CAAC,OAAe,EAAwB,EAAE;QACnD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;IAEF;;OAEG;IACO,QAAQ,GAAG,GAAS,EAAE;QAC9B,IAAI,CAAC,IAAI,CAAC,QAAQ;YAChB,MAAM,IAAI,aAAa,CAAC,mCAAmC,CAAC,CAAC;QAC/D,IAAI,CAAC,IAAI,CAAC,SAAS;YACjB,MAAM,IAAI,aAAa,CAAC,6CAA6C,CAAC,CAAC;QACzE,IAAI,CAAC,IAAI,CAAC,OAAO;YACf,MAAM,IAAI,aAAa,CAAC,gCAAgC,CAAC,CAAC;QAC5D,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;YACxB,MAAM,IAAI,aAAa,CACrB,iDAAiD,CAClD,CAAC;QAEJ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9C,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YACjD,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;gBACvB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;oBAClC,MAAM,IAAI,aAAa,CACrB,mBAAmB,KAAK,eAAe,CAAC,GAAG,CAAC,GAAG,CAChD,CAAC;gBACJ,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;oBAC/D,MAAM,IAAI,aAAa,CACrB,kEAAkE,KAAK,iBAAiB,CAAC,IACvF,CAAC,GAAG,CACN,kBAAkB,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,MAC/C,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAC5B,GAAG,CACJ,CAAC;YACN,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC;IAEF;;OAEG;IACH,KAAK,GAAG,GAAyB,EAAE;QACjC,MAAM,YAAY,GAAa,EAAE,CAAC;QAElC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC1C,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YACjD,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;gBACvB,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;gBAC9C,IACE,SAAS;oBACT,CAAC,SAAS,CAAC,SAAS,KAAK,CAAC,EAAE;wBAC1B,SAAS,CAAC,UAAU,KAAK,CAAC,EAAE;wBAC5B,SAAS,CAAC,QAAQ,KAAK,CAAC,EAAE;wBAC1B,SAAS,CAAC,eAAe,KAAK,CAAC,EAAE;wBACjC,SAAS,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;oBAE7B,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC7B,CAAC,CAAC,CAAC;QACL,CAAC;QAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC1C,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YACjD,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;gBACvB,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;oBAClC,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;oBACnC,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;gBACrC,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;IAEF;;OAEG;IACH,KAAK,GAAG,GAAqB,EAAE;QAC7B,IAAI,CAAC,QAAQ,EAAE,CAAC;QAEhB,6CAA6C;QAC7C,MAAM,UAAU,GAAG,IAAI,uBAAuB,CAC5C,IAAI,CAAC,QAAQ,EACb,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,YAAY,EAAE,CAAC,EAC9D,IAAI,CAAC,SAAS,CACf,CAAC;QAEF,iBAAiB;QACjB,UAAU,CAAC,SAAS,CAClB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,EACpC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CACxC,CAAC;QACF,IAAI,IAAI,CAAC,OAAO,KAAK,iBAAiB;YACpC,UAAU,CAAC,SAAS,CAClB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAC9B,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CACxC,CAAC;QAEJ,2BAA2B;QAC3B,MAAM,cAAc,GAAG,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEtD,oBAAoB;QACpB,UAAU,CAAC,kBAAkB,CAAC,CAAC,EAAE,cAAc,CAAC,EAAE,CAAC,CAAC;QACpD,UAAU,CAAC,kBAAkB,CAAC,CAAC,EAAE,cAAc,CAAC,EAAE,CAAC,CAAC;QACpD,UAAU,CAAC,kBAAkB,CAAC,CAAC,EAAE,cAAc,CAAC,EAAE,CAAC,CAAC;QACpD,UAAU,CAAC,kBAAkB,CAAC,CAAC,EAAE,cAAc,CAAC,EAAE,CAAC,CAAC;QACpD,UAAU,CAAC,kBAAkB,CAAC,CAAC,EAAE,cAAc,CAAC,EAAE,CAAC,CAAC;QACpD,UAAU,CAAC,kBAAkB,CAAC,CAAC,EAAE,cAAc,CAAC,EAAE,CAAC,CAAC;QAEpD,OAAO,UAAU,CAAC,KAAK,EAAE,CAAC;IAC5B,CAAC,CAAC;CACH","sourcesContent":["import {\n  Address,\n  BoxValue,\n  Contract,\n  ErgoBoxCandidateBuilder,\n  I64,\n  TokenAmount,\n  TokenId,\n  ErgoBoxCandidate,\n} from 'ergo-lib-wasm-nodejs';\n\nimport {\n  Fee,\n  MinimumFeeConfig,\n  ERGO_NATIVE_TOKEN,\n} from '@rosen-bridge/minimum-fee';\n\nimport { InvalidConfig } from './errors';\nimport { feeToRegisterValues } from './utils';\n\nexport class MinimumFeeBoxBuilder {\n  protected fees: Array<Fee>;\n  protected boxValue: BoxValue;\n  protected boxHeight: number;\n  protected tokenId: string;\n  protected minimumFeeNFT: string;\n  protected address: string;\n\n  constructor(minimumFeeNFT: string, address: string) {\n    this.fees = [];\n    this.minimumFeeNFT = minimumFeeNFT;\n    this.address = address;\n  }\n\n  /**\n   * adds a feeConfig\n   * @param feeConfig\n   */\n  addConfig = (feeConfig: MinimumFeeConfig): MinimumFeeBoxBuilder => {\n    this.fees.push(feeConfig.getConfig());\n    return this;\n  };\n\n  /**\n   * removes a config by index\n   * @param index\n   */\n  removeConfig = (index: number): MinimumFeeBoxBuilder => {\n    this.fees.splice(index, 1);\n    return this;\n  };\n\n  /**\n   * gets current feeConfig\n   */\n  getConfigs = (): Array<Fee> => {\n    return this.fees;\n  };\n\n  /**\n   * sets ErgoBox Erg value\n   * @param nanoErg\n   * @returns\n   */\n  setValue = (nanoErg: bigint): MinimumFeeBoxBuilder => {\n    this.boxValue = BoxValue.from_i64(I64.from_str(nanoErg.toString()));\n    return this;\n  };\n\n  /**\n   * sets ErgoBox creationheight\n   * @param currentHeight\n   */\n  setHeight = (currentHeight: number): MinimumFeeBoxBuilder => {\n    this.boxHeight = currentHeight;\n    return this;\n  };\n\n  /**\n   * sets config token id\n   * @param tokenId\n   */\n  setToken = (tokenId: string): MinimumFeeBoxBuilder => {\n    this.tokenId = tokenId;\n    return this;\n  };\n\n  /**\n   * validates some of specified configs\n   */\n  protected validate = (): void => {\n    if (!this.boxValue)\n      throw new InvalidConfig(`Box value argument is not defined`);\n    if (!this.boxHeight)\n      throw new InvalidConfig(`Box creation height argument is not defined`);\n    if (!this.tokenId)\n      throw new InvalidConfig(`Config token id is not defined`);\n    if (this.fees.length === 0)\n      throw new InvalidConfig(\n        `No config added. Please add at least one config`,\n      );\n\n    for (let i = 0; i < this.fees.length - 1; i++) {\n      const chains = Object.keys(this.fees[0].heights);\n      chains.forEach((chain) => {\n        if (!this.fees[i + 1].heights[chain])\n          throw new InvalidConfig(\n            `Expected chain [${chain}] at index [${i + 1}]`,\n          );\n        if (this.fees[i + 1].heights[chain] < this.fees[i].heights[chain])\n          throw new InvalidConfig(\n            `All heights for a chain should be ascending. Heights of chain [${chain}] at indexes [${i},${\n              i + 1\n            }] are invalid [${this.fees[i + 1].heights[chain]} < ${\n              this.fees[i].heights[chain]\n            }]`,\n          );\n      });\n    }\n  };\n\n  /**\n   * removes heights and configs of all chains which don't have any configs\n   */\n  prune = (): MinimumFeeBoxBuilder => {\n    const activeChains: string[] = [];\n\n    for (let i = 0; i < this.fees.length; i++) {\n      const chains = Object.keys(this.fees[i].heights);\n      chains.forEach((chain) => {\n        const feeConfig = this.fees[i].configs[chain];\n        if (\n          feeConfig &&\n          (feeConfig.bridgeFee !== -1n ||\n            feeConfig.networkFee !== -1n ||\n            feeConfig.rsnRatio !== -1n ||\n            feeConfig.rsnRatioDivisor !== -1n ||\n            feeConfig.feeRatio !== -1n)\n        )\n          activeChains.push(chain);\n      });\n    }\n\n    for (let i = 0; i < this.fees.length; i++) {\n      const chains = Object.keys(this.fees[i].heights);\n      chains.forEach((chain) => {\n        if (!activeChains.includes(chain)) {\n          delete this.fees[i].heights[chain];\n          delete this.fees[i].configs[chain];\n        }\n      });\n    }\n\n    return this;\n  };\n\n  /**\n   * validates specified configs and builds ErgoBoxCandidate of config box using them\n   */\n  build = (): ErgoBoxCandidate => {\n    this.validate();\n\n    // add box value, address and creation height\n    const boxBuilder = new ErgoBoxCandidateBuilder(\n      this.boxValue,\n      Contract.new(Address.from_base58(this.address).to_ergo_tree()),\n      this.boxHeight,\n    );\n\n    // add box tokens\n    boxBuilder.add_token(\n      TokenId.from_str(this.minimumFeeNFT),\n      TokenAmount.from_i64(I64.from_str('1')),\n    );\n    if (this.tokenId !== ERGO_NATIVE_TOKEN)\n      boxBuilder.add_token(\n        TokenId.from_str(this.tokenId),\n        TokenAmount.from_i64(I64.from_str('1')),\n      );\n\n    // generate register values\n    const registerValues = feeToRegisterValues(this.fees);\n\n    // add box registers\n    boxBuilder.set_register_value(4, registerValues.R4);\n    boxBuilder.set_register_value(5, registerValues.R5);\n    boxBuilder.set_register_value(6, registerValues.R6);\n    boxBuilder.set_register_value(7, registerValues.R7);\n    boxBuilder.set_register_value(8, registerValues.R8);\n    boxBuilder.set_register_value(9, registerValues.R9);\n\n    return boxBuilder.build();\n  };\n}\n"]}

package/dist/utils.d.ts

@@ -0,0 +1,22 @@
+import { Constant } from 'ergo-lib-wasm-nodejs';
+import { Fee } from '@rosen-bridge/minimum-fee';
+/**
+ * converts fee config to register values
+ * @param fees
+ * @returns
+ */
+export declare const feeToRegisterValues: (fees: Array<Fee>) => {
+    R4: Constant;
+    R5: Constant;
+    R6: Constant;
+    R7: Constant;
+    R8: Constant;
+    R9: Constant;
+};
+/**
+ * decodes register values to its original type
+ * @param register
+ * @returns
+ */
+export declare const decodeRegister: (register: string) => any;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,KAAK,CAAC,GAAG,CAAC;;;;;;;CA0DnD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU,MAAM,QAE9C,CAAC"}

package/dist/utils.js

@@ -0,0 +1,73 @@
+import { Constant } from 'ergo-lib-wasm-nodejs';
+/**
+ * converts fee config to register values
+ * @param fees
+ * @returns
+ */
+export const feeToRegisterValues = (fees) => {
+    //  extract chains
+    const chains = [];
+    fees.forEach((fee) => {
+        Object.keys(fee.heights).forEach((feeChain) => {
+            if (!chains.includes(feeChain))
+                chains.push(feeChain);
+        });
+    });
+    chains.sort();
+    //  extract configs
+    const heights = [];
+    const bridgeFees = [];
+    const networkFees = [];
+    const rsnRatios = [];
+    const feeRatios = [];
+    fees.forEach((fee) => {
+        const heightsConfigs = [];
+        const bridgeFeesConfigs = [];
+        const networkFeesConfigs = [];
+        const rsnRatiosConfigs = [];
+        const feeRatiosConfigs = [];
+        chains.forEach((chain) => {
+            if (Object.hasOwn(fee.heights, chain))
+                heightsConfigs.push(fee.heights[chain]);
+            else
+                heightsConfigs.push(-1);
+            if (Object.hasOwn(fee.configs, chain)) {
+                bridgeFeesConfigs.push(fee.configs[chain].bridgeFee.toString());
+                networkFeesConfigs.push(fee.configs[chain].networkFee.toString());
+                rsnRatiosConfigs.push([
+                    fee.configs[chain].rsnRatio.toString(),
+                    fee.configs[chain].rsnRatioDivisor.toString(),
+                ]);
+                feeRatiosConfigs.push(fee.configs[chain].feeRatio.toString());
+            }
+            else {
+                bridgeFeesConfigs.push('-1');
+                networkFeesConfigs.push('-1');
+                rsnRatiosConfigs.push(['-1', '-1']);
+                feeRatiosConfigs.push('-1');
+            }
+        });
+        heights.push(heightsConfigs);
+        bridgeFees.push(bridgeFeesConfigs);
+        networkFees.push(networkFeesConfigs);
+        rsnRatios.push(rsnRatiosConfigs);
+        feeRatios.push(feeRatiosConfigs);
+    });
+    return {
+        R4: Constant.from_coll_coll_byte(chains.map((chain) => Buffer.from(chain))),
+        R5: Constant.from_js(heights),
+        R6: Constant.from_js(bridgeFees),
+        R7: Constant.from_js(networkFees),
+        R8: Constant.from_js(rsnRatios),
+        R9: Constant.from_js(feeRatios),
+    };
+};
+/**
+ * decodes register values to its original type
+ * @param register
+ * @returns
+ */
+export const decodeRegister = (register) => {
+    return Constant.decode_from_base16(register).to_js();
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBSWhEOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxDQUFDLElBQWdCLEVBQUUsRUFBRTtJQUN0RCxrQkFBa0I7SUFDbEIsTUFBTSxNQUFNLEdBQWtCLEVBQUUsQ0FBQztJQUNqQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUMsR0FBRyxFQUFFLEVBQUU7UUFDbkIsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsUUFBUSxFQUFFLEVBQUU7WUFDNUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDO2dCQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDeEQsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDLENBQUMsQ0FBQztJQUNILE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNkLG1CQUFtQjtJQUNuQixNQUFNLE9BQU8sR0FBeUIsRUFBRSxDQUFDO0lBQ3pDLE1BQU0sVUFBVSxHQUF5QixFQUFFLENBQUM7SUFDNUMsTUFBTSxXQUFXLEdBQXlCLEVBQUUsQ0FBQztJQUM3QyxNQUFNLFNBQVMsR0FBZ0MsRUFBRSxDQUFDO0lBQ2xELE1BQU0sU0FBUyxHQUF5QixFQUFFLENBQUM7SUFDM0MsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFO1FBQ25CLE1BQU0sY0FBYyxHQUFrQixFQUFFLENBQUM7UUFDekMsTUFBTSxpQkFBaUIsR0FBa0IsRUFBRSxDQUFDO1FBQzVDLE1BQU0sa0JBQWtCLEdBQWtCLEVBQUUsQ0FBQztRQUM3QyxNQUFNLGdCQUFnQixHQUF5QixFQUFFLENBQUM7UUFDbEQsTUFBTSxnQkFBZ0IsR0FBa0IsRUFBRSxDQUFDO1FBRTNDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRTtZQUN2QixJQUFJLE1BQU0sQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLE9BQU8sRUFBRSxLQUFLLENBQUM7Z0JBQ25DLGNBQWMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDOztnQkFDckMsY0FBYyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBRTdCLElBQUksTUFBTSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsT0FBTyxFQUFFLEtBQUssQ0FBQyxFQUFFLENBQUM7Z0JBQ3RDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLFNBQVMsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDO2dCQUNoRSxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyxVQUFVLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQztnQkFDbEUsZ0JBQWdCLENBQUMsSUFBSSxDQUFDO29CQUNwQixHQUFHLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLFFBQVEsQ0FBQyxRQUFRLEVBQUU7b0JBQ3RDLEdBQUcsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsZUFBZSxDQUFDLFFBQVEsRUFBRTtpQkFDOUMsQ0FBQyxDQUFDO2dCQUNILGdCQUFnQixDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLFFBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDO1lBQ2hFLENBQUM7aUJBQU0sQ0FBQztnQkFDTixpQkFBaUIsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7Z0JBQzdCLGtCQUFrQixDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFDOUIsZ0JBQWdCLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUM7Z0JBQ3BDLGdCQUFnQixDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUM5QixDQUFDO1FBQ0gsQ0FBQyxDQUFDLENBQUM7UUFFSCxPQUFPLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxDQUFDO1FBQzdCLFVBQVUsQ0FBQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsQ0FBQztRQUNuQyxXQUFXLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLENBQUM7UUFDckMsU0FBUyxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO1FBQ2pDLFNBQVMsQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztJQUNuQyxDQUFDLENBQUMsQ0FBQztJQUVILE9BQU87UUFDTCxFQUFFLEVBQUUsUUFBUSxDQUFDLG1CQUFtQixDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztRQUMzRSxFQUFFLEVBQUUsUUFBUSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUM7UUFDN0IsRUFBRSxFQUFFLFFBQVEsQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDO1FBQ2hDLEVBQUUsRUFBRSxRQUFRLENBQUMsT0FBTyxDQUFDLFdBQVcsQ0FBQztRQUNqQyxFQUFFLEVBQUUsUUFBUSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUM7UUFDL0IsRUFBRSxFQUFFLFFBQVEsQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDO0tBQ2hDLENBQUM7QUFDSixDQUFDLENBQUM7QUFFRjs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHLENBQUMsUUFBZ0IsRUFBRSxFQUFFO0lBQ2pELE9BQU8sUUFBUSxDQUFDLGtCQUFrQixDQUFDLFFBQVEsQ0FBQyxDQUFDLEtBQUssRUFBRSxDQUFDO0FBQ3ZELENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbnN0YW50IH0gZnJvbSAnZXJnby1saWItd2FzbS1ub2RlanMnO1xuXG5pbXBvcnQgeyBGZWUgfSBmcm9tICdAcm9zZW4tYnJpZGdlL21pbmltdW0tZmVlJztcblxuLyoqXG4gKiBjb252ZXJ0cyBmZWUgY29uZmlnIHRvIHJlZ2lzdGVyIHZhbHVlc1xuICogQHBhcmFtIGZlZXNcbiAqIEByZXR1cm5zXG4gKi9cbmV4cG9ydCBjb25zdCBmZWVUb1JlZ2lzdGVyVmFsdWVzID0gKGZlZXM6IEFycmF5PEZlZT4pID0+IHtcbiAgLy8gIGV4dHJhY3QgY2hhaW5zXG4gIGNvbnN0IGNoYWluczogQXJyYXk8c3RyaW5nPiA9IFtdO1xuICBmZWVzLmZvckVhY2goKGZlZSkgPT4ge1xuICAgIE9iamVjdC5rZXlzKGZlZS5oZWlnaHRzKS5mb3JFYWNoKChmZWVDaGFpbikgPT4ge1xuICAgICAgaWYgKCFjaGFpbnMuaW5jbHVkZXMoZmVlQ2hhaW4pKSBjaGFpbnMucHVzaChmZWVDaGFpbik7XG4gICAgfSk7XG4gIH0pO1xuICBjaGFpbnMuc29ydCgpO1xuICAvLyAgZXh0cmFjdCBjb25maWdzXG4gIGNvbnN0IGhlaWdodHM6IEFycmF5PEFycmF5PG51bWJlcj4+ID0gW107XG4gIGNvbnN0IGJyaWRnZUZlZXM6IEFycmF5PEFycmF5PHN0cmluZz4+ID0gW107XG4gIGNvbnN0IG5ldHdvcmtGZWVzOiBBcnJheTxBcnJheTxzdHJpbmc+PiA9IFtdO1xuICBjb25zdCByc25SYXRpb3M6IEFycmF5PEFycmF5PEFycmF5PHN0cmluZz4+PiA9IFtdO1xuICBjb25zdCBmZWVSYXRpb3M6IEFycmF5PEFycmF5PHN0cmluZz4+ID0gW107XG4gIGZlZXMuZm9yRWFjaCgoZmVlKSA9PiB7XG4gICAgY29uc3QgaGVpZ2h0c0NvbmZpZ3M6IEFycmF5PG51bWJlcj4gPSBbXTtcbiAgICBjb25zdCBicmlkZ2VGZWVzQ29uZmlnczogQXJyYXk8c3RyaW5nPiA9IFtdO1xuICAgIGNvbnN0IG5ldHdvcmtGZWVzQ29uZmlnczogQXJyYXk8c3RyaW5nPiA9IFtdO1xuICAgIGNvbnN0IHJzblJhdGlvc0NvbmZpZ3M6IEFycmF5PEFycmF5PHN0cmluZz4+ID0gW107XG4gICAgY29uc3QgZmVlUmF0aW9zQ29uZmlnczogQXJyYXk8c3RyaW5nPiA9IFtdO1xuXG4gICAgY2hhaW5zLmZvckVhY2goKGNoYWluKSA9PiB7XG4gICAgICBpZiAoT2JqZWN0Lmhhc093bihmZWUuaGVpZ2h0cywgY2hhaW4pKVxuICAgICAgICBoZWlnaHRzQ29uZmlncy5wdXNoKGZlZS5oZWlnaHRzW2NoYWluXSk7XG4gICAgICBlbHNlIGhlaWdodHNDb25maWdzLnB1c2goLTEpO1xuXG4gICAgICBpZiAoT2JqZWN0Lmhhc093bihmZWUuY29uZmlncywgY2hhaW4pKSB7XG4gICAgICAgIGJyaWRnZUZlZXNDb25maWdzLnB1c2goZmVlLmNvbmZpZ3NbY2hhaW5dLmJyaWRnZUZlZS50b1N0cmluZygpKTtcbiAgICAgICAgbmV0d29ya0ZlZXNDb25maWdzLnB1c2goZmVlLmNvbmZpZ3NbY2hhaW5dLm5ldHdvcmtGZWUudG9TdHJpbmcoKSk7XG4gICAgICAgIHJzblJhdGlvc0NvbmZpZ3MucHVzaChbXG4gICAgICAgICAgZmVlLmNvbmZpZ3NbY2hhaW5dLnJzblJhdGlvLnRvU3RyaW5nKCksXG4gICAgICAgICAgZmVlLmNvbmZpZ3NbY2hhaW5dLnJzblJhdGlvRGl2aXNvci50b1N0cmluZygpLFxuICAgICAgICBdKTtcbiAgICAgICAgZmVlUmF0aW9zQ29uZmlncy5wdXNoKGZlZS5jb25maWdzW2NoYWluXS5mZWVSYXRpby50b1N0cmluZygpKTtcbiAgICAgIH0gZWxzZSB7XG4gICAgICAgIGJyaWRnZUZlZXNDb25maWdzLnB1c2goJy0xJyk7XG4gICAgICAgIG5ldHdvcmtGZWVzQ29uZmlncy5wdXNoKCctMScpO1xuICAgICAgICByc25SYXRpb3NDb25maWdzLnB1c2goWyctMScsICctMSddKTtcbiAgICAgICAgZmVlUmF0aW9zQ29uZmlncy5wdXNoKCctMScpO1xuICAgICAgfVxuICAgIH0pO1xuXG4gICAgaGVpZ2h0cy5wdXNoKGhlaWdodHNDb25maWdzKTtcbiAgICBicmlkZ2VGZWVzLnB1c2goYnJpZGdlRmVlc0NvbmZpZ3MpO1xuICAgIG5ldHdvcmtGZWVzLnB1c2gobmV0d29ya0ZlZXNDb25maWdzKTtcbiAgICByc25SYXRpb3MucHVzaChyc25SYXRpb3NDb25maWdzKTtcbiAgICBmZWVSYXRpb3MucHVzaChmZWVSYXRpb3NDb25maWdzKTtcbiAgfSk7XG5cbiAgcmV0dXJuIHtcbiAgICBSNDogQ29uc3RhbnQuZnJvbV9jb2xsX2NvbGxfYnl0ZShjaGFpbnMubWFwKChjaGFpbikgPT4gQnVmZmVyLmZyb20oY2hhaW4pKSksXG4gICAgUjU6IENvbnN0YW50LmZyb21fanMoaGVpZ2h0cyksXG4gICAgUjY6IENvbnN0YW50LmZyb21fanMoYnJpZGdlRmVlcyksXG4gICAgUjc6IENvbnN0YW50LmZyb21fanMobmV0d29ya0ZlZXMpLFxuICAgIFI4OiBDb25zdGFudC5mcm9tX2pzKHJzblJhdGlvcyksXG4gICAgUjk6IENvbnN0YW50LmZyb21fanMoZmVlUmF0aW9zKSxcbiAgfTtcbn07XG5cbi8qKlxuICogZGVjb2RlcyByZWdpc3RlciB2YWx1ZXMgdG8gaXRzIG9yaWdpbmFsIHR5cGVcbiAqIEBwYXJhbSByZWdpc3RlclxuICogQHJldHVybnNcbiAqL1xuZXhwb3J0IGNvbnN0IGRlY29kZVJlZ2lzdGVyID0gKHJlZ2lzdGVyOiBzdHJpbmcpID0+IHtcbiAgcmV0dXJuIENvbnN0YW50LmRlY29kZV9mcm9tX2Jhc2UxNihyZWdpc3RlcikudG9fanMoKTtcbn07XG4iXX0=

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@rosen-bridge/extended-minimum-fee",
+  "version": "0.0.0",
+  "description": "this project gets minimum fee of the bridge for supported tokens from blockchain",
+  "keywords": [
+    "rosen"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rosen-bridge/utils.git"
+  },
+  "license": "MIT",
+  "author": "Rosen Team",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "directories": {
+    "lib": "lib",
+    "test": "tests"
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc --build tsconfig.build.json",
+    "coverage": "npm run test -- --coverage",
+    "lint": "eslint --fix . && npm run prettify",
+    "lint:check": "eslint . && npm run prettify:check",
+    "prettify": "prettier --write . --ignore-path ../../../.gitignore",
+    "prettify:check": "prettier --check . --ignore-path ../../../.gitignore",
+    "release": "npm run test && npm run build && npm publish --access public",
+    "test": "NODE_OPTIONS='--import tsx' vitest",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@rosen-bridge/abstract-logger": "^4.0.0",
+    "@rosen-bridge/json-bigint": "^1.1.0",
+    "@rosen-bridge/minimum-fee": "^3.1.2",
+    "ergo-lib-wasm-nodejs": "^0.24.1"
+  },
+  "engines": {
+    "node": ">=22.18.0",
+    "npm": "11.6.2"
+  }
+}