@rosen-bridge/utils 2.0.1 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @rosen-bridge/utils
 
+## 3.0.0
+
+### Major Changes
+
+- Remove ArrayElement type to enforce type safety and avoid any
+
+## 2.0.2
+
+### Patch Changes
+
+- Fix asset name regex to support `contracts` and `tokensMap`.
+
 ## 2.0.1
 
 ### Patch Changes

package/dist/downloadRosenAssets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"downloadRosenAssets.d.ts","sourceRoot":"","sources":["../lib/downloadRosenAssets.ts"],"names":[],"mappings":"AAaA;;;;;GAKG;AACH,QAAA,MAAM,mBAAmB,GACvB,WAAW,MAAM,EACjB,iBAAiB,MAAM,EACvB,SAAS;IACP,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,kBA2CF,CAAC;AAEF,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"downloadRosenAssets.d.ts","sourceRoot":"","sources":["../lib/downloadRosenAssets.ts"],"names":[],"mappings":"AAYA;;;;;GAKG;AACH,QAAA,MAAM,mBAAmB,GACvB,WAAW,MAAM,EACjB,iBAAiB,MAAM,EACvB,SAAS;IACP,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,kBA2CF,CAAC;AAEF,eAAe,mBAAmB,CAAC"}

package/dist/downloadRosenAssets.js

@@ -1,7 +1,7 @@
 import download from 'download';
+import { RosenAssetsDownloadError } from './error';
 import { findLatestRelease, findLatestStableRelease, getReleaseByTag, } from './utils/github';
 import { isValidAssetName, truncateAssetName } from './utils/rosen';
-import { RosenAssetsDownloadError } from './error';
 const repo = 'contract';
 /**
  * Download all required Rosen assets (tokenMap and all chain address files) to a specific path
@@ -45,4 +45,4 @@ const downloadRosenAssets = async (chainType, destinationPath, config) => {
     }
 };
 export default downloadRosenAssets;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG93bmxvYWRSb3NlbkFzc2V0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL2xpYi9kb3dubG9hZFJvc2VuQXNzZXRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sUUFBUSxNQUFNLFVBQVUsQ0FBQztBQUVoQyxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFDbkQsT0FBTyxFQUNMLGlCQUFpQixFQUNqQix1QkFBdUIsRUFDdkIsZUFBZSxHQUNoQixNQUFNLGdCQUFnQixDQUFDO0FBQ3hCLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUVwRSxNQUFNLElBQUksR0FBRyxVQUFVLENBQUM7QUFFeEI7Ozs7O0dBS0c7QUFDSCxNQUFNLG1CQUFtQixHQUFHLEtBQUssRUFDL0IsU0FBaUIsRUFDakIsZUFBdUIsRUFDdkIsTUFJQyxFQUNELEVBQUU7SUFDRixNQUFNLFVBQVUsR0FBRyxHQUFHLEVBQUU7UUFDdEIsSUFBSSxNQUFNLEVBQUUsR0FBRztZQUFFLE9BQU8sZUFBZSxDQUFDLElBQUksRUFBRSxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDMUQsSUFBSSxNQUFNLEVBQUUsa0JBQWtCO1lBQUUsT0FBTyxpQkFBaUIsQ0FBQyxJQUFJLEVBQUUsU0FBUyxDQUFDLENBQUM7UUFDMUUsT0FBTyx1QkFBdUIsQ0FBQyxJQUFJLEVBQUUsU0FBUyxDQUFDLENBQUM7SUFDbEQsQ0FBQyxDQUFDO0lBQ0YsSUFBSSxDQUFDO1FBQ0gsTUFBTSxPQUFPLEdBQUcsTUFBTSxVQUFVLEVBQUUsQ0FBQztRQUVuQyxJQUFJLE9BQU8sRUFBRSxDQUFDO1lBQ1osTUFBTSxPQUFPLENBQUMsR0FBRyxDQUFDO2dCQUNoQixHQUFHLENBQUMsT0FBTztvQkFDVCxPQUFPLENBQUMsTUFBTTt5QkFDWCxNQUFNLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLGdCQUFnQixDQUFDLFNBQVMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQzt5QkFDMUQsR0FBRyxDQUFDLEtBQUssRUFBRSxLQUFLLEVBQUUsRUFBRSxDQUNuQixRQUFRLENBQUMsS0FBSyxDQUFDLG9CQUFvQixFQUFFLGVBQWUsRUFBRTt3QkFDcEQsUUFBUSxFQUFFLGlCQUFpQixDQUN6QixLQUFLLENBQUMsSUFBSSxFQUNWLFNBQVMsRUFDVCxPQUFPLENBQUMsUUFBUSxFQUNoQixNQUFNLEVBQUUsVUFBVSxDQUNuQjtxQkFDRixDQUFDLENBQ0gsQ0FBQzthQUNQLENBQUMsQ0FBQztRQUNMLENBQUM7YUFBTSxDQUFDO1lBQ04sT0FBTyxDQUFDLEtBQUssQ0FBQyx5QkFBeUIsU0FBUyxlQUFlLENBQUMsQ0FBQztZQUNqRSxJQUFJLENBQUMsTUFBTSxFQUFFLGtCQUFrQixFQUFFLENBQUM7Z0JBQ2hDLE9BQU8sQ0FBQyxLQUFLLENBQ1gsNEdBQTRHLENBQzdHLENBQUM7WUFDSixDQUFDO1FBQ0gsQ0FBQztJQUNILENBQUM7SUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1FBQ2YsT0FBTyxDQUFDLEtBQUssQ0FDWCw0REFBNEQsS0FBSyxFQUFFLENBQ3BFLENBQUM7UUFDRixJQUFJLEtBQUssWUFBWSxLQUFLLEVBQUUsQ0FBQztZQUMzQixPQUFPLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUM3QixDQUFDO1FBQ0QsTUFBTSxJQUFJLHdCQUF3QixDQUFDLEVBQUUsRUFBRSxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQzNELENBQUM7QUFDSCxDQUFDLENBQUM7QUFFRixlQUFlLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGRvd25sb2FkIGZyb20gJ2Rvd25sb2FkJztcblxuaW1wb3J0IHsgUm9zZW5Bc3NldHNEb3dubG9hZEVycm9yIH0gZnJvbSAnLi9lcnJvcic7XG5pbXBvcnQge1xuICBmaW5kTGF0ZXN0UmVsZWFzZSxcbiAgZmluZExhdGVzdFN0YWJsZVJlbGVhc2UsXG4gIGdldFJlbGVhc2VCeVRhZyxcbn0gZnJvbSAnLi91dGlscy9naXRodWInO1xuaW1wb3J0IHsgaXNWYWxpZEFzc2V0TmFtZSwgdHJ1bmNhdGVBc3NldE5hbWUgfSBmcm9tICcuL3V0aWxzL3Jvc2VuJztcblxuY29uc3QgcmVwbyA9ICdjb250cmFjdCc7XG5cbi8qKlxuICogRG93bmxvYWQgYWxsIHJlcXVpcmVkIFJvc2VuIGFzc2V0cyAodG9rZW5NYXAgYW5kIGFsbCBjaGFpbiBhZGRyZXNzIGZpbGVzKSB0byBhIHNwZWNpZmljIHBhdGhcbiAqIEBwYXJhbSBjaGFpblR5cGUgY2hhaW4gdHlwZSAoZS5nLiBtYWlubmV0LCB0ZXN0bmV0LCBldGMuKVxuICogQHBhcmFtIGluY2x1ZGVQcmVyZWxlYXNlcyB3ZWF0aGVyIHRvIGluY2x1ZGUgcHJlcmVsZWFzZXMgaW50byBhY2NvdW50IHdoZW4gc2VhcmNoaW5nIGZvciBhIG1hdGNoaW5nIHJlbGVhc2UgaW4gR2l0SHViXG4gKiBAcGFyYW0gY29uZmlnIGNvbmZpZ3MgZm9yIGluY2x1ZGluZyBwcmVyZWxlYXNlcywgYWRkaW5nIG5hbWUgc3VmZml4LCBhbmQgZ2V0dGluZyBzcGVjaWZpYyByZWxlYXNlIGJ5IHRhZ1xuICovXG5jb25zdCBkb3dubG9hZFJvc2VuQXNzZXRzID0gYXN5bmMgKFxuICBjaGFpblR5cGU6IHN0cmluZyxcbiAgZGVzdGluYXRpb25QYXRoOiBzdHJpbmcsXG4gIGNvbmZpZz86IHtcbiAgICBpbmNsdWRlUHJlcmVsZWFzZXM/OiBib29sZWFuO1xuICAgIG5hbWVTdWZmaXg/OiBzdHJpbmc7XG4gICAgdGFnPzogc3RyaW5nO1xuICB9LFxuKSA9PiB7XG4gIGNvbnN0IGdldFJlbGVhc2UgPSAoKSA9PiB7XG4gICAgaWYgKGNvbmZpZz8udGFnKSByZXR1cm4gZ2V0UmVsZWFzZUJ5VGFnKHJlcG8sIGNvbmZpZy50YWcpO1xuICAgIGlmIChjb25maWc/LmluY2x1ZGVQcmVyZWxlYXNlcykgcmV0dXJuIGZpbmRMYXRlc3RSZWxlYXNlKHJlcG8sIGNoYWluVHlwZSk7XG4gICAgcmV0dXJuIGZpbmRMYXRlc3RTdGFibGVSZWxlYXNlKHJlcG8sIGNoYWluVHlwZSk7XG4gIH07XG4gIHRyeSB7XG4gICAgY29uc3QgcmVsZWFzZSA9IGF3YWl0IGdldFJlbGVhc2UoKTtcblxuICAgIGlmIChyZWxlYXNlKSB7XG4gICAgICBhd2FpdCBQcm9taXNlLmFsbChbXG4gICAgICAgIC4uLihyZWxlYXNlICYmXG4gICAgICAgICAgcmVsZWFzZS5hc3NldHNcbiAgICAgICAgICAgIC5maWx0ZXIoKGFzc2V0KSA9PiBpc1ZhbGlkQXNzZXROYW1lKGNoYWluVHlwZSkoYXNzZXQubmFtZSkpXG4gICAgICAgICAgICAubWFwKGFzeW5jIChhc3NldCkgPT5cbiAgICAgICAgICAgICAgZG93bmxvYWQoYXNzZXQuYnJvd3Nlcl9kb3dubG9hZF91cmwsIGRlc3RpbmF0aW9uUGF0aCwge1xuICAgICAgICAgICAgICAgIGZpbGVuYW1lOiB0cnVuY2F0ZUFzc2V0TmFtZShcbiAgICAgICAgICAgICAgICAgIGFzc2V0Lm5hbWUsXG4gICAgICAgICAgICAgICAgICBjaGFpblR5cGUsXG4gICAgICAgICAgICAgICAgICByZWxlYXNlLnRhZ19uYW1lLFxuICAgICAgICAgICAgICAgICAgY29uZmlnPy5uYW1lU3VmZml4LFxuICAgICAgICAgICAgICAgICksXG4gICAgICAgICAgICAgIH0pLFxuICAgICAgICAgICAgKSksXG4gICAgICBdKTtcbiAgICB9IGVsc2Uge1xuICAgICAgY29uc29sZS5lcnJvcihgTm8gcmVsZWFzZSBmb3VuZCBmb3IgWyR7Y2hhaW5UeXBlfV0gY2hhaW4gdHlwZS5gKTtcbiAgICAgIGlmICghY29uZmlnPy5pbmNsdWRlUHJlcmVsZWFzZXMpIHtcbiAgICAgICAgY29uc29sZS5lcnJvcihcbiAgICAgICAgICAnUGxlYXNlIG5vdGUgdGhhdCBgaW5jbHVkZVByZXJlbGVhc2VzYCBpcyBzZXQgdG8gZmFsc2UuIFRoZXJlIG1heSBiZSBzb21lIG1hdGNoaW5nIHJlbGVhc2VzIGluIHByZXJlbGVhc2VzLicsXG4gICAgICAgICk7XG4gICAgICB9XG4gICAgfVxuICB9IGNhdGNoIChlcnJvcikge1xuICAgIGNvbnNvbGUuZXJyb3IoXG4gICAgICBgQW4gZXJyb3Igb2NjdXJyZWQgd2hpbGUgdHJ5aW5nIHRvIGRvd25sb2FkIFJvc2VuIGFzc2V0czogJHtlcnJvcn1gLFxuICAgICk7XG4gICAgaWYgKGVycm9yIGluc3RhbmNlb2YgRXJyb3IpIHtcbiAgICAgIGNvbnNvbGUuZXJyb3IoZXJyb3Iuc3RhY2spO1xuICAgIH1cbiAgICB0aHJvdyBuZXcgUm9zZW5Bc3NldHNEb3dubG9hZEVycm9yKCcnLCB7IGNhdXNlOiBlcnJvciB9KTtcbiAgfVxufTtcblxuZXhwb3J0IGRlZmF1bHQgZG93bmxvYWRSb3NlbkFzc2V0cztcbiJdfQ==

package/dist/downloadTssBinary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"downloadTssBinary.d.ts","sourceRoot":"","sources":["../lib/downloadTssBinary.ts"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,QAAA,MAAM,iBAAiB,GACrB,iBAAiB,MAAM,EACvB,QAAQ;IACN,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;IACf,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,kBAiCF,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"downloadTssBinary.d.ts","sourceRoot":"","sources":["../lib/downloadTssBinary.ts"],"names":[],"mappings":"AAYA;;;;GAIG;AACH,QAAA,MAAM,iBAAiB,GACrB,iBAAiB,MAAM,EACvB,QAAQ;IACN,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;IACf,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,kBAiCF,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/downloadTssBinary.js

@@ -1,7 +1,7 @@
 import download from 'download';
+import { RosenAssetsDownloadError } from './error';
 import { findLatestReleaseByPrefixTag, findLatestStableReleaseByPrefixTag, getReleaseByTag, } from './utils/github';
 import { isValidOS } from './utils/rosen';
-import { RosenAssetsDownloadError } from './error';
 const repo = 'sign-protocols';
 /**
  * Download release asset by tag to a specific path
@@ -42,4 +42,4 @@ const downloadTssBinary = async (destinationPath, config) => {
     }
 };
 export { downloadTssBinary };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types/index.d.ts

@@ -1,7 +1,6 @@
 import { Octokit } from 'octokit';
-export type ArrayElement<T extends any[]> = T extends (infer Element)[] ? Element : never;
 type GithubReleases = Awaited<ReturnType<InstanceType<typeof Octokit>['rest']['repos']['listReleases']>>['data'];
-export type GithubRelease = ArrayElement<GithubReleases>;
+export type GithubRelease = GithubReleases[number];
 export type SupportedRepo = 'contract' | 'sign-protocols';
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/types/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAElC,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,OAAO,CAAC,EAAE,GACnE,OAAO,GACP,KAAK,CAAC;AAEV,KAAK,cAAc,GAAG,OAAO,CAC3B,UAAU,CAAC,YAAY,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,cAAc,CAAC,CAAC,CAC1E,CAAC,MAAM,CAAC,CAAC;AAEV,MAAM,MAAM,aAAa,GAAG,YAAY,CAAC,cAAc,CAAC,CAAC;AAEzD,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/types/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAElC,KAAK,cAAc,GAAG,OAAO,CAC3B,UAAU,CAAC,YAAY,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,cAAc,CAAC,CAAC,CAC1E,CAAC,MAAM,CAAC,CAAC;AAEV,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;AAEnD,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,gBAAgB,CAAC"}

package/dist/types/index.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9jdG9raXQgfSBmcm9tICdvY3Rva2l0JztcblxuZXhwb3J0IHR5cGUgQXJyYXlFbGVtZW50PFQgZXh0ZW5kcyBhbnlbXT4gPSBUIGV4dGVuZHMgKGluZmVyIEVsZW1lbnQpW11cbiAgPyBFbGVtZW50XG4gIDogbmV2ZXI7XG5cbnR5cGUgR2l0aHViUmVsZWFzZXMgPSBBd2FpdGVkPFxuICBSZXR1cm5UeXBlPEluc3RhbmNlVHlwZTx0eXBlb2YgT2N0b2tpdD5bJ3Jlc3QnXVsncmVwb3MnXVsnbGlzdFJlbGVhc2VzJ10+XG4+WydkYXRhJ107XG5cbmV4cG9ydCB0eXBlIEdpdGh1YlJlbGVhc2UgPSBBcnJheUVsZW1lbnQ8R2l0aHViUmVsZWFzZXM+O1xuXG5leHBvcnQgdHlwZSBTdXBwb3J0ZWRSZXBvID0gJ2NvbnRyYWN0JyB8ICdzaWduLXByb3RvY29scyc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9jdG9raXQgfSBmcm9tICdvY3Rva2l0JztcblxudHlwZSBHaXRodWJSZWxlYXNlcyA9IEF3YWl0ZWQ8XG4gIFJldHVyblR5cGU8SW5zdGFuY2VUeXBlPHR5cGVvZiBPY3Rva2l0PlsncmVzdCddWydyZXBvcyddWydsaXN0UmVsZWFzZXMnXT5cbj5bJ2RhdGEnXTtcblxuZXhwb3J0IHR5cGUgR2l0aHViUmVsZWFzZSA9IEdpdGh1YlJlbGVhc2VzW251bWJlcl07XG5cbmV4cG9ydCB0eXBlIFN1cHBvcnRlZFJlcG8gPSAnY29udHJhY3QnIHwgJ3NpZ24tcHJvdG9jb2xzJztcbiJdfQ==

package/dist/utils/github.d.ts

@@ -2,8 +2,8 @@ import { GithubRelease, SupportedRepo } from '../types';
 /**
  * Fetch a page of releases from Github Api in each iteration until there are no
  * more releases.
- * @param repoName
- * @param pageSize
+ * @param repoName GitHub repository name to fetch releases from
+ * @param pageSize number of releases fetched per page
  */
 declare function fetchReleasesPage(repoName: SupportedRepo, pageSize?: number): AsyncGenerator<{
     url: string;
@@ -33,8 +33,8 @@ declare function fetchReleasesPage(repoName: SupportedRepo, pageSize?: number):
 /**
  * Find the last release matching the predicate. If all releases are iterated and
  * no matching release is found, return null.
- * @param repoName
- * @param predicate
+ * @param repoName GitHub repository name to search in
+ * @param predicate custom function to determine release matching
  */
 declare const findLastRelease: (repoName: SupportedRepo, predicate?: (release: GithubRelease) => boolean) => Promise<{
     url: string;
@@ -63,8 +63,8 @@ declare const findLastRelease: (repoName: SupportedRepo, predicate?: (release: G
 } | null>;
 /**
  * get a GitHub release by its tag
- * @param repoName
- * @param tag
+ * @param repoName GitHub repository name
+ * @param tag exact tag of the release to fetch
  */
 declare const getReleaseByTag: (repoName: SupportedRepo, tag: string) => Promise<{
     url: string;
@@ -94,32 +94,32 @@ declare const getReleaseByTag: (repoName: SupportedRepo, tag: string) => Promise
 /**
  * Return a function which checks if a release has at least one asset for a
  * specific chain type
- * @param chainType
- * @param release
+ * @param chainType chain type used to validate asset names
+ * @param release GitHub release whose assets will be checked
  */
 declare const hasAssetForChainType: (chainType: string) => (release: GithubRelease) => boolean;
 /**
  * Return a function which checks if a release is a stable (that is, non-prerelease)
  * and has some asset matching a specific chain type
- * @param chainType
+ * @param chainType chain type to validate assets against
  */
 declare const isStableReleaseForChainType: (chainType: string) => (release: GithubRelease) => boolean;
 /**
  * Return a function which checks if tagPrefix is matched with release tag_name
- * @param tagPrefix
+ * @param tagPrefix prefix used to filter release tags
  */
 declare const hasMatchedTagPrefix: (tagPrefix: string) => (release: GithubRelease) => boolean;
 /**
  * Return a function which checks if a release is a stable (that is, non-prerelease),
  * and tagPrefix is matched with release tag_name
- * @param tagPrefix
+ * @param tagPrefix tag prefix used for matching
  */
 declare const isStableReleaseForRegexTagType: (tagPrefix: string) => (release: GithubRelease) => boolean;
 /**
  * Find latest release (prerelease or non-prerelease) having some asset matching
  * a specific chain type
- * @param repoName
- * @param chainType
+ * @param repoName GitHub repository name
+ * @param chainType chain type to filter by
  */
 declare const findLatestRelease: (repoName: SupportedRepo, chainType: string) => Promise<{
     url: string;
@@ -149,8 +149,8 @@ declare const findLatestRelease: (repoName: SupportedRepo, chainType: string) =>
 /**
  * Find latest stable (that is, non-prerelease) release having some asset matching
  * a specific chain type
- * @param repoName
- * @param chainType
+ * @param repoName GitHub repository name
+ * @param chainType chain type to filter by
  */
 declare const findLatestStableRelease: (repoName: SupportedRepo, chainType: string) => Promise<{
     url: string;
@@ -179,8 +179,8 @@ declare const findLatestStableRelease: (repoName: SupportedRepo, chainType: stri
 } | null>;
 /**
  * Find the latest stable (that is, non-prerelease) release that tagPrefix is matched with release tag_name
- * @param repoName
- * @param tagPrefix
+ * @param repoName GitHub repository name
+ * @param chainType chain type to filter by
  */
 declare const findLatestStableReleaseByPrefixTag: (repoName: SupportedRepo, tagPrefix: string) => Promise<{
     url: string;
@@ -209,8 +209,8 @@ declare const findLatestStableReleaseByPrefixTag: (repoName: SupportedRepo, tagP
 } | null>;
 /**
  * Find the latest release that tagPrefix is matched with release tag_name
- * @param repoName
- * @param tagPrefix
+ * @param repoName GitHub repository name
+ * @param tagPrefix prefix used for matching tag names
  */
 declare const findLatestReleaseByPrefixTag: (repoName: SupportedRepo, tagPrefix: string) => Promise<{
     url: string;

package/dist/utils/github.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"github.d.ts","sourceRoot":"","sources":["../../lib/utils/github.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAExD;;;;;GAKG;AACH,iBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,aAAa,EACvB,QAAQ,SAAsC;;;;;;;;;;;;;;;;;YAuJgor0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;oBAlIzgs0B;AAED;;;;;GAKG;AACH,QAAA,MAAM,eAAe,GACnB,UAAU,aAAa,EAEvB,YAAW,CAAC,OAAO,EAAE,aAAa,KAAK,OAAoB;;;;;;;;;;;;;;;;;YAuHmnr0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;SA3Gzgs0B,CAAC;AAEF;;;;GAIG;AACH,QAAA,MAAM,eAAe,GAAU,UAAU,aAAa,EAAE,KAAK,MAAM;;;;;;;;;;;;;;;;;YAoG6mr0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;EA3Fzgs0B,CAAC;AAEF;;;;;GAKG;AACH,QAAA,MAAM,oBAAoB,GAAI,WAAW,MAAM,MAAM,SAAS,aAAa,YACE,CAAC;AAE9E;;;;GAIG;AACH,QAAA,MAAM,2BAA2B,GAC9B,WAAW,MAAM,MAAM,SAAS,aAAa,YACmB,CAAC;AAEpE;;;GAGG;AACH,QAAA,MAAM,mBAAmB,GAAI,WAAW,MAAM,MAAM,SAAS,aAAa,YAGzE,CAAC;AAEF;;;;GAIG;AACH,QAAA,MAAM,8BAA8B,GACjC,WAAW,MAAM,MAAM,SAAS,aAAa,YACkB,CAAC;AAEnE;;;;;GAKG;AACH,QAAA,MAAM,iBAAiB,GAAU,UAAU,aAAa,EAAE,WAAW,MAAM;;;;;;;;;;;;;;;;;YA+Cqmr0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;SA9C98r0B,CAAC;AAE7D;;;;;GAKG;AACH,QAAA,MAAM,uBAAuB,GAC3B,UAAU,aAAa,EACvB,WAAW,MAAM;;;;;;;;;;;;;;;;;YAoC6pr0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;SAnCp8r0B,CAAC;AAEvE;;;;GAIG;AACH,QAAA,MAAM,kCAAkC,GACtC,UAAU,aAAa,EACvB,WAAW,MAAM;;;;;;;;;;;;;;;;;YA0B6pr0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;SAzBj8r0B,CAAC;AAE1E;;;;GAIG;AACH,QAAA,MAAM,4BAA4B,GAChC,UAAU,aAAa,EACvB,WAAW,MAAM;;;;;;;;;;;;;;;;;YAgB6pr0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;SAf58r0B,CAAC;AAE/D,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,uBAAuB,EACvB,kCAAkC,EAClC,4BAA4B,EAC5B,eAAe,EACf,oBAAoB,EACpB,2BAA2B,EAC3B,8BAA8B,EAC9B,mBAAmB,GACpB,CAAC"}
+{"version":3,"file":"github.d.ts","sourceRoot":"","sources":["../../lib/utils/github.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGxD;;;;;GAKG;AACH,iBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,aAAa,EACvB,QAAQ,SAAsC;;;;;;;;;;;;;;;;;YAuJoiq0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;oBAlI76q0B;AAED;;;;;GAKG;AACH,QAAA,MAAM,eAAe,GACnB,UAAU,aAAa,EAEvB,YAAW,CAAC,OAAO,EAAE,aAAa,KAAK,OAAoB;;;;;;;;;;;;;;;;;YAuHuhq0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;SA3G76q0B,CAAC;AAEF;;;;GAIG;AACH,QAAA,MAAM,eAAe,GAAU,UAAU,aAAa,EAAE,KAAK,MAAM;;;;;;;;;;;;;;;;;YAoGihq0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;EA3F76q0B,CAAC;AAEF;;;;;GAKG;AACH,QAAA,MAAM,oBAAoB,GAAI,WAAW,MAAM,MAAM,SAAS,aAAa,YACE,CAAC;AAE9E;;;;GAIG;AACH,QAAA,MAAM,2BAA2B,GAC9B,WAAW,MAAM,MAAM,SAAS,aAAa,YACmB,CAAC;AAEpE;;;GAGG;AACH,QAAA,MAAM,mBAAmB,GAAI,WAAW,MAAM,MAAM,SAAS,aAAa,YAGzE,CAAC;AAEF;;;;GAIG;AACH,QAAA,MAAM,8BAA8B,GACjC,WAAW,MAAM,MAAM,SAAS,aAAa,YACkB,CAAC;AAEnE;;;;;GAKG;AACH,QAAA,MAAM,iBAAiB,GAAU,UAAU,aAAa,EAAE,WAAW,MAAM;;;;;;;;;;;;;;;;;YA+Cygq0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;SA9Cl3q0B,CAAC;AAE7D;;;;;GAKG;AACH,QAAA,MAAM,uBAAuB,GAC3B,UAAU,aAAa,EACvB,WAAW,MAAM;;;;;;;;;;;;;;;;;YAoCikq0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;SAnCx2q0B,CAAC;AAEvE;;;;GAIG;AACH,QAAA,MAAM,kCAAkC,GACtC,UAAU,aAAa,EACvB,WAAW,MAAM;;;;;;;;;;;;;;;;;YA0Bikq0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;SAzBr2q0B,CAAC;AAE1E;;;;GAIG;AACH,QAAA,MAAM,4BAA4B,GAChC,UAAU,aAAa,EACvB,WAAW,MAAM;;;;;;;;;;;;;;;;;YAgBikq0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;SAfh3q0B,CAAC;AAE/D,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,uBAAuB,EACvB,kCAAkC,EAClC,4BAA4B,EAC5B,eAAe,EACf,oBAAoB,EACpB,2BAA2B,EAC3B,8BAA8B,EAC9B,mBAAmB,GACpB,CAAC"}

package/dist/utils/github.js

@@ -1,11 +1,11 @@
 import { Octokit } from 'octokit';
-import { isValidAssetName } from './rosen';
 import { DEFAULT_RELEASES_FETCHING_PAGE_SIZE, ROSEN_BRIDGE_ORGANIZATION, } from '../constants';
+import { isValidAssetName } from './rosen';
 /**
  * Fetch a page of releases from Github Api in each iteration until there are no
  * more releases.
- * @param repoName
- * @param pageSize
+ * @param repoName GitHub repository name to fetch releases from
+ * @param pageSize number of releases fetched per page
  */
 async function* fetchReleasesPage(repoName, pageSize = DEFAULT_RELEASES_FETCHING_PAGE_SIZE) {
     const octokit = new Octokit();
@@ -29,8 +29,8 @@ async function* fetchReleasesPage(repoName, pageSize = DEFAULT_RELEASES_FETCHING
 /**
  * Find the last release matching the predicate. If all releases are iterated and
  * no matching release is found, return null.
- * @param repoName
- * @param predicate
+ * @param repoName GitHub repository name to search in
+ * @param predicate custom function to determine release matching
  */
 const findLastRelease = async (repoName, predicate = () => true) => {
     const releasesPageIterator = fetchReleasesPage(repoName);
@@ -44,8 +44,8 @@ const findLastRelease = async (repoName, predicate = () => true) => {
 };
 /**
  * get a GitHub release by its tag
- * @param repoName
- * @param tag
+ * @param repoName GitHub repository name
+ * @param tag exact tag of the release to fetch
  */
 const getReleaseByTag = async (repoName, tag) => {
     const octokit = new Octokit();
@@ -59,19 +59,19 @@ const getReleaseByTag = async (repoName, tag) => {
 /**
  * Return a function which checks if a release has at least one asset for a
  * specific chain type
- * @param chainType
- * @param release
+ * @param chainType chain type used to validate asset names
+ * @param release GitHub release whose assets will be checked
  */
 const hasAssetForChainType = (chainType) => (release) => release.assets.map((asset) => asset.name).some(isValidAssetName(chainType));
 /**
  * Return a function which checks if a release is a stable (that is, non-prerelease)
  * and has some asset matching a specific chain type
- * @param chainType
+ * @param chainType chain type to validate assets against
  */
 const isStableReleaseForChainType = (chainType) => (release) => !release.prerelease && hasAssetForChainType(chainType)(release);
 /**
  * Return a function which checks if tagPrefix is matched with release tag_name
- * @param tagPrefix
+ * @param tagPrefix prefix used to filter release tags
  */
 const hasMatchedTagPrefix = (tagPrefix) => (release) => {
     const regex = new RegExp(`^${tagPrefix}`);
@@ -80,34 +80,34 @@ const hasMatchedTagPrefix = (tagPrefix) => (release) => {
 /**
  * Return a function which checks if a release is a stable (that is, non-prerelease),
  * and tagPrefix is matched with release tag_name
- * @param tagPrefix
+ * @param tagPrefix tag prefix used for matching
  */
 const isStableReleaseForRegexTagType = (tagPrefix) => (release) => !release.prerelease && hasMatchedTagPrefix(tagPrefix)(release);
 /**
  * Find latest release (prerelease or non-prerelease) having some asset matching
  * a specific chain type
- * @param repoName
- * @param chainType
+ * @param repoName GitHub repository name
+ * @param chainType chain type to filter by
  */
 const findLatestRelease = async (repoName, chainType) => findLastRelease(repoName, hasAssetForChainType(chainType));
 /**
  * Find latest stable (that is, non-prerelease) release having some asset matching
  * a specific chain type
- * @param repoName
- * @param chainType
+ * @param repoName GitHub repository name
+ * @param chainType chain type to filter by
  */
 const findLatestStableRelease = async (repoName, chainType) => findLastRelease(repoName, isStableReleaseForChainType(chainType));
 /**
  * Find the latest stable (that is, non-prerelease) release that tagPrefix is matched with release tag_name
- * @param repoName
- * @param tagPrefix
+ * @param repoName GitHub repository name
+ * @param chainType chain type to filter by
  */
 const findLatestStableReleaseByPrefixTag = async (repoName, tagPrefix) => findLastRelease(repoName, isStableReleaseForRegexTagType(tagPrefix));
 /**
  * Find the latest release that tagPrefix is matched with release tag_name
- * @param repoName
- * @param tagPrefix
+ * @param repoName GitHub repository name
+ * @param tagPrefix prefix used for matching tag names
  */
 const findLatestReleaseByPrefixTag = async (repoName, tagPrefix) => findLastRelease(repoName, hasMatchedTagPrefix(tagPrefix));
 export { fetchReleasesPage, findLastRelease, findLatestRelease, findLatestStableRelease, findLatestStableReleaseByPrefixTag, findLatestReleaseByPrefixTag, getReleaseByTag, hasAssetForChainType, isStableReleaseForChainType, isStableReleaseForRegexTagType, hasMatchedTagPrefix, };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"github.js","sourceRoot":"","sources":["../../lib/utils/github.ts"],"names":[],"mappings":"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","sourcesContent":["import { Octokit } from 'octokit';\n\nimport { isValidAssetName } from './rosen';\n\nimport {\n  DEFAULT_RELEASES_FETCHING_PAGE_SIZE,\n  ROSEN_BRIDGE_ORGANIZATION,\n} from '../constants';\n\nimport { GithubRelease, SupportedRepo } from '../types';\n\n/**\n * Fetch a page of releases from Github Api in each iteration until there are no\n * more releases.\n * @param repoName\n * @param pageSize\n */\nasync function* fetchReleasesPage(\n  repoName: SupportedRepo,\n  pageSize = DEFAULT_RELEASES_FETCHING_PAGE_SIZE,\n) {\n  const octokit = new Octokit();\n\n  let currentPage = 1;\n\n  while (true) {\n    const releasesPage = await octokit.rest.repos.listReleases({\n      owner: ROSEN_BRIDGE_ORGANIZATION,\n      repo: repoName,\n      per_page: pageSize,\n      page: currentPage,\n    });\n\n    if (releasesPage.data.length) {\n      yield releasesPage.data;\n      currentPage += 1;\n    } else {\n      return;\n    }\n  }\n}\n\n/**\n * Find the last release matching the predicate. If all releases are iterated and\n * no matching release is found, return null.\n * @param repoName\n * @param predicate\n */\nconst findLastRelease = async (\n  repoName: SupportedRepo,\n\n  predicate: (release: GithubRelease) => boolean = () => true,\n) => {\n  const releasesPageIterator = fetchReleasesPage(repoName);\n\n  for await (const releasesPage of releasesPageIterator) {\n    const foundRelease = releasesPage.find(predicate);\n\n    if (foundRelease) {\n      return foundRelease;\n    }\n  }\n  return null;\n};\n\n/**\n * get a GitHub release by its tag\n * @param repoName\n * @param tag\n */\nconst getReleaseByTag = async (repoName: SupportedRepo, tag: string) => {\n  const octokit = new Octokit();\n  const release = await octokit.rest.repos.getReleaseByTag({\n    owner: ROSEN_BRIDGE_ORGANIZATION,\n    repo: repoName,\n    tag,\n  });\n\n  return release.data;\n};\n\n/**\n * Return a function which checks if a release has at least one asset for a\n * specific chain type\n * @param chainType\n * @param release\n */\nconst hasAssetForChainType = (chainType: string) => (release: GithubRelease) =>\n  release.assets.map((asset) => asset.name).some(isValidAssetName(chainType));\n\n/**\n * Return a function which checks if a release is a stable (that is, non-prerelease)\n * and has some asset matching a specific chain type\n * @param chainType\n */\nconst isStableReleaseForChainType =\n  (chainType: string) => (release: GithubRelease) =>\n    !release.prerelease && hasAssetForChainType(chainType)(release);\n\n/**\n * Return a function which checks if tagPrefix is matched with release tag_name\n * @param tagPrefix\n */\nconst hasMatchedTagPrefix = (tagPrefix: string) => (release: GithubRelease) => {\n  const regex = new RegExp(`^${tagPrefix}`);\n  return regex.test(release.tag_name);\n};\n\n/**\n * Return a function which checks if a release is a stable (that is, non-prerelease),\n * and tagPrefix is matched with release tag_name\n * @param tagPrefix\n */\nconst isStableReleaseForRegexTagType =\n  (tagPrefix: string) => (release: GithubRelease) =>\n    !release.prerelease && hasMatchedTagPrefix(tagPrefix)(release);\n\n/**\n * Find latest release (prerelease or non-prerelease) having some asset matching\n * a specific chain type\n * @param repoName\n * @param chainType\n */\nconst findLatestRelease = async (repoName: SupportedRepo, chainType: string) =>\n  findLastRelease(repoName, hasAssetForChainType(chainType));\n\n/**\n * Find latest stable (that is, non-prerelease) release having some asset matching\n * a specific chain type\n * @param repoName\n * @param chainType\n */\nconst findLatestStableRelease = async (\n  repoName: SupportedRepo,\n  chainType: string,\n) => findLastRelease(repoName, isStableReleaseForChainType(chainType));\n\n/**\n * Find the latest stable (that is, non-prerelease) release that tagPrefix is matched with release tag_name\n * @param repoName\n * @param tagPrefix\n */\nconst findLatestStableReleaseByPrefixTag = async (\n  repoName: SupportedRepo,\n  tagPrefix: string,\n) => findLastRelease(repoName, isStableReleaseForRegexTagType(tagPrefix));\n\n/**\n * Find the latest release that tagPrefix is matched with release tag_name\n * @param repoName\n * @param tagPrefix\n */\nconst findLatestReleaseByPrefixTag = async (\n  repoName: SupportedRepo,\n  tagPrefix: string,\n) => findLastRelease(repoName, hasMatchedTagPrefix(tagPrefix));\n\nexport {\n  fetchReleasesPage,\n  findLastRelease,\n  findLatestRelease,\n  findLatestStableRelease,\n  findLatestStableReleaseByPrefixTag,\n  findLatestReleaseByPrefixTag,\n  getReleaseByTag,\n  hasAssetForChainType,\n  isStableReleaseForChainType,\n  isStableReleaseForRegexTagType,\n  hasMatchedTagPrefix,\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"github.js","sourceRoot":"","sources":["../../lib/utils/github.ts"],"names":[],"mappings":"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","sourcesContent":["import { Octokit } from 'octokit';\n\nimport {\n  DEFAULT_RELEASES_FETCHING_PAGE_SIZE,\n  ROSEN_BRIDGE_ORGANIZATION,\n} from '../constants';\nimport { GithubRelease, SupportedRepo } from '../types';\nimport { isValidAssetName } from './rosen';\n\n/**\n * Fetch a page of releases from Github Api in each iteration until there are no\n * more releases.\n * @param repoName GitHub repository name to fetch releases from\n * @param pageSize number of releases fetched per page\n */\nasync function* fetchReleasesPage(\n  repoName: SupportedRepo,\n  pageSize = DEFAULT_RELEASES_FETCHING_PAGE_SIZE,\n) {\n  const octokit = new Octokit();\n\n  let currentPage = 1;\n\n  while (true) {\n    const releasesPage = await octokit.rest.repos.listReleases({\n      owner: ROSEN_BRIDGE_ORGANIZATION,\n      repo: repoName,\n      per_page: pageSize,\n      page: currentPage,\n    });\n\n    if (releasesPage.data.length) {\n      yield releasesPage.data;\n      currentPage += 1;\n    } else {\n      return;\n    }\n  }\n}\n\n/**\n * Find the last release matching the predicate. If all releases are iterated and\n * no matching release is found, return null.\n * @param repoName GitHub repository name to search in\n * @param predicate custom function to determine release matching\n */\nconst findLastRelease = async (\n  repoName: SupportedRepo,\n\n  predicate: (release: GithubRelease) => boolean = () => true,\n) => {\n  const releasesPageIterator = fetchReleasesPage(repoName);\n\n  for await (const releasesPage of releasesPageIterator) {\n    const foundRelease = releasesPage.find(predicate);\n\n    if (foundRelease) {\n      return foundRelease;\n    }\n  }\n  return null;\n};\n\n/**\n * get a GitHub release by its tag\n * @param repoName GitHub repository name\n * @param tag exact tag of the release to fetch\n */\nconst getReleaseByTag = async (repoName: SupportedRepo, tag: string) => {\n  const octokit = new Octokit();\n  const release = await octokit.rest.repos.getReleaseByTag({\n    owner: ROSEN_BRIDGE_ORGANIZATION,\n    repo: repoName,\n    tag,\n  });\n\n  return release.data;\n};\n\n/**\n * Return a function which checks if a release has at least one asset for a\n * specific chain type\n * @param chainType chain type used to validate asset names\n * @param release GitHub release whose assets will be checked\n */\nconst hasAssetForChainType = (chainType: string) => (release: GithubRelease) =>\n  release.assets.map((asset) => asset.name).some(isValidAssetName(chainType));\n\n/**\n * Return a function which checks if a release is a stable (that is, non-prerelease)\n * and has some asset matching a specific chain type\n * @param chainType chain type to validate assets against\n */\nconst isStableReleaseForChainType =\n  (chainType: string) => (release: GithubRelease) =>\n    !release.prerelease && hasAssetForChainType(chainType)(release);\n\n/**\n * Return a function which checks if tagPrefix is matched with release tag_name\n * @param tagPrefix prefix used to filter release tags\n */\nconst hasMatchedTagPrefix = (tagPrefix: string) => (release: GithubRelease) => {\n  const regex = new RegExp(`^${tagPrefix}`);\n  return regex.test(release.tag_name);\n};\n\n/**\n * Return a function which checks if a release is a stable (that is, non-prerelease),\n * and tagPrefix is matched with release tag_name\n * @param tagPrefix tag prefix used for matching\n */\nconst isStableReleaseForRegexTagType =\n  (tagPrefix: string) => (release: GithubRelease) =>\n    !release.prerelease && hasMatchedTagPrefix(tagPrefix)(release);\n\n/**\n * Find latest release (prerelease or non-prerelease) having some asset matching\n * a specific chain type\n * @param repoName GitHub repository name\n * @param chainType chain type to filter by\n */\nconst findLatestRelease = async (repoName: SupportedRepo, chainType: string) =>\n  findLastRelease(repoName, hasAssetForChainType(chainType));\n\n/**\n * Find latest stable (that is, non-prerelease) release having some asset matching\n * a specific chain type\n * @param repoName GitHub repository name\n * @param chainType chain type to filter by\n */\nconst findLatestStableRelease = async (\n  repoName: SupportedRepo,\n  chainType: string,\n) => findLastRelease(repoName, isStableReleaseForChainType(chainType));\n\n/**\n * Find the latest stable (that is, non-prerelease) release that tagPrefix is matched with release tag_name\n * @param repoName GitHub repository name\n * @param chainType chain type to filter by\n */\nconst findLatestStableReleaseByPrefixTag = async (\n  repoName: SupportedRepo,\n  tagPrefix: string,\n) => findLastRelease(repoName, isStableReleaseForRegexTagType(tagPrefix));\n\n/**\n * Find the latest release that tagPrefix is matched with release tag_name\n * @param repoName GitHub repository name\n * @param tagPrefix prefix used for matching tag names\n */\nconst findLatestReleaseByPrefixTag = async (\n  repoName: SupportedRepo,\n  tagPrefix: string,\n) => findLastRelease(repoName, hasMatchedTagPrefix(tagPrefix));\n\nexport {\n  fetchReleasesPage,\n  findLastRelease,\n  findLatestRelease,\n  findLatestStableRelease,\n  findLatestStableReleaseByPrefixTag,\n  findLatestReleaseByPrefixTag,\n  getReleaseByTag,\n  hasAssetForChainType,\n  isStableReleaseForChainType,\n  isStableReleaseForRegexTagType,\n  hasMatchedTagPrefix,\n};\n"]}

package/dist/utils/rosen.d.ts

@@ -1,20 +1,20 @@
 /**
  * Check if an asset name is a valid Rosen asset name and matches a specific
  * chain type
- * @param chainType
+ * @param chainType chain type of the asset (e.g., mainnet, testnet)
  */
 export declare const isValidAssetName: (chainType: string) => (assetName: string) => boolean;
 /**
  * Check if an OS name is a valid supported tss OS
- * @param OSName
+ * @param OSName operating system name to match in release assets (e.g., linux, macOS, windows)
  */
 export declare const isValidOS: (OSName: string) => (releaseAssetName: string) => boolean;
 /**
  * Remove chain type and tag from the asset name and optionally replaces them
  * with a suffix
- * @param assetName
- * @param chainType
- * @param releaseName
+ * @param assetName full asset file name from the release
+ * @param chainType chain type used in the asset file name
+ * @param releaseName release tag used in naming the asset
  * @param alternativeSuffix a suffix which will be added before `.json` (if provided)
  */
 export declare const truncateAssetName: (assetName: string, chainType: string, releaseName: string, alternativeSuffix?: string) => string;

package/dist/utils/rosen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rosen.d.ts","sourceRoot":"","sources":["../../lib/utils/rosen.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,WAAW,MAAM,MAAM,WAAW,MAAM,YACI,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,SAAS,GAAI,QAAQ,MAAM,MAAM,kBAAkB,MAAM,YACJ,CAAC;AAEnE;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,GAC5B,WAAW,MAAM,EACjB,WAAW,MAAM,EACjB,aAAa,MAAM,EACnB,oBAAoB,MAAM,WAM3B,CAAC"}
+{"version":3,"file":"rosen.d.ts","sourceRoot":"","sources":["../../lib/utils/rosen.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,WAAW,MAAM,MAAM,WAAW,MAAM,YACC,CAAC;AAE3E;;;GAGG;AACH,eAAO,MAAM,SAAS,GAAI,QAAQ,MAAM,MAAM,kBAAkB,MAAM,YACJ,CAAC;AAEnE;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,GAC5B,WAAW,MAAM,EACjB,WAAW,MAAM,EACjB,aAAa,MAAM,EACnB,oBAAoB,MAAM,WAM3B,CAAC"}

package/dist/utils/rosen.js

@@ -1,20 +1,20 @@
 /**
  * Check if an asset name is a valid Rosen asset name and matches a specific
  * chain type
- * @param chainType
+ * @param chainType chain type of the asset (e.g., mainnet, testnet)
  */
-export const isValidAssetName = (chainType) => (assetName) => new RegExp(`(contracts-.+|tokensMap)-${chainType}-.+.json`).test(assetName);
+export const isValidAssetName = (chainType) => (assetName) => new RegExp(`(contracts|tokensMap)-${chainType}-.+.json`).test(assetName);
 /**
  * Check if an OS name is a valid supported tss OS
- * @param OSName
+ * @param OSName operating system name to match in release assets (e.g., linux, macOS, windows)
  */
 export const isValidOS = (OSName) => (releaseAssetName) => new RegExp(`(rosenTss-${OSName}-.+).zip`).test(releaseAssetName);
 /**
  * Remove chain type and tag from the asset name and optionally replaces them
  * with a suffix
- * @param assetName
- * @param chainType
- * @param releaseName
+ * @param assetName full asset file name from the release
+ * @param chainType chain type used in the asset file name
+ * @param releaseName release tag used in naming the asset
  * @param alternativeSuffix a suffix which will be added before `.json` (if provided)
  */
 export const truncateAssetName = (assetName, chainType, releaseName, alternativeSuffix) => {
@@ -23,4 +23,4 @@ export const truncateAssetName = (assetName, chainType, releaseName, alternative
         ? `${name}-${alternativeSuffix}.json`
         : `${name}.json`;
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@rosen-bridge/utils",
-  "version": "2.0.1",
+  "version": "3.0.0",
   "description": "Misc utility functions used inside Rosen bridge projects",
+  "keywords": [
+    "rosen"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rosen-bridge/utils.git"
@@ -11,40 +14,34 @@
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "directories": {
+    "lib": "lib",
+    "test": "tests"
+  },
   "files": [
     "dist",
     "CHANGELOG.md"
   ],
   "scripts": {
-    "prettify": "prettier --write . --ignore-path ../../.gitignore",
-    "prettify:check": "prettier --check . --ignore-path ../../.gitignore",
+    "build": "tsc --build tsconfig.build.json",
+    "coverage": "npm run test -- --coverage",
     "lint": "eslint --fix . && npm run prettify",
     "lint:check": "eslint . && npm run prettify:check",
-    "build": "tsc --build tsconfig.build.json",
-    "type-check": "tsc --noEmit",
-    "test": "jest --runInBand",
-    "coverage": "jest --coverage --runInBand",
-    "release": "npm run test && npm run build && npm publish --access public"
-  },
-  "devDependencies": {
-    "@babel/preset-env": "^7.19.0",
-    "@types/download": "^8.0.2",
-    "@types/jest": "^29.1.2",
-    "jest": "^29.2.0",
-    "ts-jest": "^29.0.3"
-  },
-  "directories": {
-    "lib": "lib",
-    "test": "tests"
+    "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"
   },
-  "keywords": [
-    "rosen"
-  ],
   "dependencies": {
     "download": "^8.0.0",
     "octokit": "^2.0.14"
   },
+  "devDependencies": {
+    "@types/download": "^8.0.2"
+  },
   "engines": {
-    "node": ">=22.18.0"
+    "node": ">=22.18.0",
+    "npm": "11.6.2"
   }
 }