@rosen-bridge/utils 1.0.0 → 2.0.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @rosen-bridge/utils
 
+## 2.0.1
+
+### Patch Changes
+
+- Fix package-lock and move typescript and types/node into root
+
+## 2.0.0
+
+### Major Changes
+
+- Update node version to 22.18
+
 ## 1.0.0
 
 ### Major Changes

package/dist/downloadRosenAssets.js

@@ -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,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

package/dist/downloadTssBinary.js

@@ -42,4 +42,4 @@ const downloadTssBinary = async (destinationPath, config) => {
     }
 };
 export { downloadTssBinary };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG93bmxvYWRUc3NCaW5hcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvZG93bmxvYWRUc3NCaW5hcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxRQUFRLE1BQU0sVUFBVSxDQUFDO0FBRWhDLE9BQU8sRUFDTCw0QkFBNEIsRUFDNUIsa0NBQWtDLEVBQ2xDLGVBQWUsR0FDaEIsTUFBTSxnQkFBZ0IsQ0FBQztBQUN4QixPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTFDLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUVuRCxNQUFNLElBQUksR0FBRyxnQkFBZ0IsQ0FBQztBQUU5Qjs7OztHQUlHO0FBQ0gsTUFBTSxpQkFBaUIsR0FBRyxLQUFLLEVBQzdCLGVBQXVCLEVBQ3ZCLE1BS0MsRUFDRCxFQUFFO0lBQ0YsTUFBTSxVQUFVLEdBQUcsR0FBRyxFQUFFO1FBQ3RCLElBQUksTUFBTSxDQUFDLEtBQUssRUFBRSxDQUFDO1lBQ2pCLElBQUksTUFBTSxFQUFFLGtCQUFrQjtnQkFDNUIsT0FBTyw0QkFBNEIsQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDOztnQkFDbkQsT0FBTyxrQ0FBa0MsQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ25FLENBQUM7O1lBQU0sT0FBTyxlQUFlLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNsRCxDQUFDLENBQUM7SUFDRixJQUFJLENBQUM7UUFDSCxNQUFNLE9BQU8sR0FBRyxNQUFNLFVBQVUsRUFBRSxDQUFDO1FBRW5DLElBQUksT0FBTyxFQUFFLENBQUM7WUFDWixNQUFNLE9BQU8sQ0FBQyxHQUFHLENBQUM7Z0JBQ2hCLEdBQUcsQ0FBQyxPQUFPO29CQUNULE9BQU8sQ0FBQyxNQUFNO3lCQUNYLE1BQU0sQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUM7eUJBQ3ZELEdBQUcsQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLEVBQUUsQ0FDbkIsUUFBUSxDQUFDLEtBQUssQ0FBQyxvQkFBb0IsRUFBRSxlQUFlLENBQUMsQ0FDdEQsQ0FBQzthQUNQLENBQUMsQ0FBQztRQUNMLENBQUM7YUFBTSxDQUFDO1lBQ04sT0FBTyxDQUFDLEtBQUssQ0FBQyx5QkFBeUIsTUFBTSxDQUFDLE1BQU0sWUFBWSxDQUFDLENBQUM7UUFDcEUsQ0FBQztJQUNILENBQUM7SUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1FBQ2YsT0FBTyxDQUFDLEtBQUssQ0FDWCw4REFBOEQsS0FBSyxFQUFFLENBQ3RFLENBQUM7UUFDRixJQUFJLEtBQUssWUFBWSxLQUFLLEVBQUUsQ0FBQztZQUMzQixPQUFPLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUM3QixDQUFDO1FBQ0QsTUFBTSxJQUFJLHdCQUF3QixDQUFDLEVBQUUsRUFBRSxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQzNELENBQUM7QUFDSCxDQUFDLENBQUM7QUFFRixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBkb3dubG9hZCBmcm9tICdkb3dubG9hZCc7XG5cbmltcG9ydCB7XG4gIGZpbmRMYXRlc3RSZWxlYXNlQnlQcmVmaXhUYWcsXG4gIGZpbmRMYXRlc3RTdGFibGVSZWxlYXNlQnlQcmVmaXhUYWcsXG4gIGdldFJlbGVhc2VCeVRhZyxcbn0gZnJvbSAnLi91dGlscy9naXRodWInO1xuaW1wb3J0IHsgaXNWYWxpZE9TIH0gZnJvbSAnLi91dGlscy9yb3Nlbic7XG5cbmltcG9ydCB7IFJvc2VuQXNzZXRzRG93bmxvYWRFcnJvciB9IGZyb20gJy4vZXJyb3InO1xuXG5jb25zdCByZXBvID0gJ3NpZ24tcHJvdG9jb2xzJztcblxuLyoqXG4gKiBEb3dubG9hZCByZWxlYXNlIGFzc2V0IGJ5IHRhZyB0byBhIHNwZWNpZmljIHBhdGhcbiAqIEBwYXJhbSBkZXN0aW5hdGlvblBhdGggd2hlcmUgd3JpdGVzIGZpbGVzXG4gKiBAcGFyYW0gY29uZmlnIGNvbmZpZ3MgZm9yIGluY2x1ZGluZyBwcmVyZWxlYXNlcywgc2V0IG9zTmFtZSwgZ2V0dGluZyBzcGVjaWZpYyByZWxlYXNlIGJ5IHRhZyBvciBieSByZWdleCB0YWdcbiAqL1xuY29uc3QgZG93bmxvYWRUc3NCaW5hcnkgPSBhc3luYyAoXG4gIGRlc3RpbmF0aW9uUGF0aDogc3RyaW5nLFxuICBjb25maWc6IHtcbiAgICBvc05hbWU6IHN0cmluZztcbiAgICB0YWc6IHN0cmluZztcbiAgICByZWdleDogYm9vbGVhbjtcbiAgICBpbmNsdWRlUHJlcmVsZWFzZXM/OiBib29sZWFuO1xuICB9XG4pID0+IHtcbiAgY29uc3QgZ2V0UmVsZWFzZSA9ICgpID0+IHtcbiAgICBpZiAoY29uZmlnLnJlZ2V4KSB7XG4gICAgICBpZiAoY29uZmlnPy5pbmNsdWRlUHJlcmVsZWFzZXMpXG4gICAgICAgIHJldHVybiBmaW5kTGF0ZXN0UmVsZWFzZUJ5UHJlZml4VGFnKHJlcG8sIGNvbmZpZy50YWcpO1xuICAgICAgZWxzZSByZXR1cm4gZmluZExhdGVzdFN0YWJsZVJlbGVhc2VCeVByZWZpeFRhZyhyZXBvLCBjb25maWcudGFnKTtcbiAgICB9IGVsc2UgcmV0dXJuIGdldFJlbGVhc2VCeVRhZyhyZXBvLCBjb25maWcudGFnKTtcbiAgfTtcbiAgdHJ5IHtcbiAgICBjb25zdCByZWxlYXNlID0gYXdhaXQgZ2V0UmVsZWFzZSgpO1xuXG4gICAgaWYgKHJlbGVhc2UpIHtcbiAgICAgIGF3YWl0IFByb21pc2UuYWxsKFtcbiAgICAgICAgLi4uKHJlbGVhc2UgJiZcbiAgICAgICAgICByZWxlYXNlLmFzc2V0c1xuICAgICAgICAgICAgLmZpbHRlcigoYXNzZXQpID0+IGlzVmFsaWRPUyhjb25maWcub3NOYW1lKShhc3NldC5uYW1lKSlcbiAgICAgICAgICAgIC5tYXAoYXN5bmMgKGFzc2V0KSA9PlxuICAgICAgICAgICAgICBkb3dubG9hZChhc3NldC5icm93c2VyX2Rvd25sb2FkX3VybCwgZGVzdGluYXRpb25QYXRoKVxuICAgICAgICAgICAgKSksXG4gICAgICBdKTtcbiAgICB9IGVsc2Uge1xuICAgICAgY29uc29sZS5lcnJvcihgTm8gcmVsZWFzZSBmb3VuZCBmb3IgWyR7Y29uZmlnLm9zTmFtZX1dIE9TIG5hbWUuYCk7XG4gICAgfVxuICB9IGNhdGNoIChlcnJvcikge1xuICAgIGNvbnNvbGUuZXJyb3IoXG4gICAgICBgQW4gZXJyb3Igb2NjdXJyZWQgd2hpbGUgdHJ5aW5nIHRvIGRvd25sb2FkIHJlbGVhc2UgYXNzZXRzOiAke2Vycm9yfWBcbiAgICApO1xuICAgIGlmIChlcnJvciBpbnN0YW5jZW9mIEVycm9yKSB7XG4gICAgICBjb25zb2xlLmVycm9yKGVycm9yLnN0YWNrKTtcbiAgICB9XG4gICAgdGhyb3cgbmV3IFJvc2VuQXNzZXRzRG93bmxvYWRFcnJvcignJywgeyBjYXVzZTogZXJyb3IgfSk7XG4gIH1cbn07XG5cbmV4cG9ydCB7IGRvd25sb2FkVHNzQmluYXJ5IH07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

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;;;;;;;;;;;;;;;;;YAsJsor0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;oBAjI/gs0B;AAED;;;;;GAKG;AACH,QAAA,MAAM,eAAe,GACnB,UAAU,aAAa,EACvB,YAAW,CAAC,OAAO,EAAE,aAAa,KAAK,OAAoB;;;;;;;;;;;;;;;;;YAuHynr0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;SA3G/gs0B,CAAC;AAEF;;;;GAIG;AACH,QAAA,MAAM,eAAe,GAAU,UAAU,aAAa,EAAE,KAAK,MAAM;;;;;;;;;;;;;;;;;YAoGmnr0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;EA3F/gs0B,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+C2mr0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;SA9Cp9r0B,CAAC;AAE7D;;;;;GAKG;AACH,QAAA,MAAM,uBAAuB,GAC3B,UAAU,aAAa,EACvB,WAAW,MAAM;;;;;;;;;;;;;;;;;YAoCmqr0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;SAnC18r0B,CAAC;AAEvE;;;;GAIG;AACH,QAAA,MAAM,kCAAkC,GACtC,UAAU,aAAa,EACvB,WAAW,MAAM;;;;;;;;;;;;;;;;;YA0Bmqr0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;SAzBv8r0B,CAAC;AAE1E;;;;GAIG;AACH,QAAA,MAAM,4BAA4B,GAChC,UAAU,aAAa,EACvB,WAAW,MAAM;;;;;;;;;;;;;;;;;YAgBmqr0B,sDAAsB;YAA8B,sDAAsB;;;;;gBAA0P,sDAAsB;SAfl9r0B,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":"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"}

package/dist/utils/github.js

@@ -110,4 +110,4 @@ const findLatestStableReleaseByPrefixTag = async (repoName, tagPrefix) => findLa
  */
 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  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 { 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"]}

package/dist/utils/rosen.js

@@ -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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm9zZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvdXRpbHMvcm9zZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLENBQUMsU0FBaUIsRUFBRSxFQUFFLENBQUMsQ0FBQyxTQUFpQixFQUFFLEVBQUUsQ0FDM0UsSUFBSSxNQUFNLENBQUMsNEJBQTRCLFNBQVMsVUFBVSxDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0FBRTlFOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxDQUFDLE1BQWMsRUFBRSxFQUFFLENBQUMsQ0FBQyxnQkFBd0IsRUFBRSxFQUFFLENBQ3hFLElBQUksTUFBTSxDQUFDLGFBQWEsTUFBTSxVQUFVLENBQUMsQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztBQUVuRTs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsQ0FDL0IsU0FBaUIsRUFDakIsU0FBaUIsRUFDakIsV0FBbUIsRUFDbkIsaUJBQTBCLEVBQzFCLEVBQUU7SUFDRixNQUFNLElBQUksR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFDLElBQUksU0FBUyxJQUFJLFdBQVcsT0FBTyxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQ3hFLE9BQU8saUJBQWlCO1FBQ3RCLENBQUMsQ0FBQyxHQUFHLElBQUksSUFBSSxpQkFBaUIsT0FBTztRQUNyQyxDQUFDLENBQUMsR0FBRyxJQUFJLE9BQU8sQ0FBQztBQUNyQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENoZWNrIGlmIGFuIGFzc2V0IG5hbWUgaXMgYSB2YWxpZCBSb3NlbiBhc3NldCBuYW1lIGFuZCBtYXRjaGVzIGEgc3BlY2lmaWNcbiAqIGNoYWluIHR5cGVcbiAqIEBwYXJhbSBjaGFpblR5cGVcbiAqL1xuZXhwb3J0IGNvbnN0IGlzVmFsaWRBc3NldE5hbWUgPSAoY2hhaW5UeXBlOiBzdHJpbmcpID0+IChhc3NldE5hbWU6IHN0cmluZykgPT5cbiAgbmV3IFJlZ0V4cChgKGNvbnRyYWN0cy0uK3x0b2tlbnNNYXApLSR7Y2hhaW5UeXBlfS0uKy5qc29uYCkudGVzdChhc3NldE5hbWUpO1xuXG4vKipcbiAqIENoZWNrIGlmIGFuIE9TIG5hbWUgaXMgYSB2YWxpZCBzdXBwb3J0ZWQgdHNzIE9TXG4gKiBAcGFyYW0gT1NOYW1lXG4gKi9cbmV4cG9ydCBjb25zdCBpc1ZhbGlkT1MgPSAoT1NOYW1lOiBzdHJpbmcpID0+IChyZWxlYXNlQXNzZXROYW1lOiBzdHJpbmcpID0+XG4gIG5ldyBSZWdFeHAoYChyb3NlblRzcy0ke09TTmFtZX0tLispLnppcGApLnRlc3QocmVsZWFzZUFzc2V0TmFtZSk7XG5cbi8qKlxuICogUmVtb3ZlIGNoYWluIHR5cGUgYW5kIHRhZyBmcm9tIHRoZSBhc3NldCBuYW1lIGFuZCBvcHRpb25hbGx5IHJlcGxhY2VzIHRoZW1cbiAqIHdpdGggYSBzdWZmaXhcbiAqIEBwYXJhbSBhc3NldE5hbWVcbiAqIEBwYXJhbSBjaGFpblR5cGVcbiAqIEBwYXJhbSByZWxlYXNlTmFtZVxuICogQHBhcmFtIGFsdGVybmF0aXZlU3VmZml4IGEgc3VmZml4IHdoaWNoIHdpbGwgYmUgYWRkZWQgYmVmb3JlIGAuanNvbmAgKGlmIHByb3ZpZGVkKVxuICovXG5leHBvcnQgY29uc3QgdHJ1bmNhdGVBc3NldE5hbWUgPSAoXG4gIGFzc2V0TmFtZTogc3RyaW5nLFxuICBjaGFpblR5cGU6IHN0cmluZyxcbiAgcmVsZWFzZU5hbWU6IHN0cmluZyxcbiAgYWx0ZXJuYXRpdmVTdWZmaXg/OiBzdHJpbmcsXG4pID0+IHtcbiAgY29uc3QgbmFtZSA9IGFzc2V0TmFtZS5yZXBsYWNlKGAtJHtjaGFpblR5cGV9LSR7cmVsZWFzZU5hbWV9Lmpzb25gLCAnJyk7XG4gIHJldHVybiBhbHRlcm5hdGl2ZVN1ZmZpeFxuICAgID8gYCR7bmFtZX0tJHthbHRlcm5hdGl2ZVN1ZmZpeH0uanNvbmBcbiAgICA6IGAke25hbWV9Lmpzb25gO1xufTtcbiJdfQ==

package/package.json

@@ -1,32 +1,37 @@
 {
   "name": "@rosen-bridge/utils",
-  "version": "1.0.0",
+  "version": "2.0.1",
   "description": "Misc utility functions used inside Rosen bridge projects",
+  "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",
-  "type": "module",
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
   "scripts": {
-    "prettify": "prettier --write . --ignore-path .gitignore",
+    "prettify": "prettier --write . --ignore-path ../../.gitignore",
+    "prettify:check": "prettier --check . --ignore-path ../../.gitignore",
     "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"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/rosen-bridge/utils.git"
-  },
-  "license": "MIT",
   "devDependencies": {
     "@babel/preset-env": "^7.19.0",
     "@types/download": "^8.0.2",
     "@types/jest": "^29.1.2",
-    "@types/node": "^20.11.0",
     "jest": "^29.2.0",
-    "ts-jest": "^29.0.3",
-    "typescript": "^5.8.3"
+    "ts-jest": "^29.0.3"
   },
   "directories": {
     "lib": "lib",
@@ -38,5 +43,8 @@
   "dependencies": {
     "download": "^8.0.0",
     "octokit": "^2.0.14"
+  },
+  "engines": {
+    "node": ">=22.18.0"
   }
 }

package/.eslintignore

@@ -1 +0,0 @@
-dist

package/babel.config.json

@@ -1,3 +0,0 @@
-{
-  "extends": "../../babel.config.base.json"
-}

package/jest.config.json

@@ -1,7 +0,0 @@
-{
-  "coverageReporters": ["lcov", "cobertura", "text", "text-summary"],
-  "preset": "ts-jest/presets/js-with-babel",
-  "setupFiles": ["./tests/setup.ts"],
-  "testEnvironment": "node",
-  "verbose": true
-}

package/lib/constants.ts

@@ -1,2 +0,0 @@
-export const DEFAULT_RELEASES_FETCHING_PAGE_SIZE = 5;
-export const ROSEN_BRIDGE_ORGANIZATION = 'rosen-bridge';

package/lib/downloadRosenAssets.ts

@@ -1,72 +0,0 @@
-import download from 'download';
-
-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
- * @param chainType chain type (e.g. mainnet, testnet, etc.)
- * @param includePrereleases weather to include prereleases into account when searching for a matching release in GitHub
- * @param config configs for including prereleases, adding name suffix, and getting specific release by tag
- */
-const downloadRosenAssets = async (
-  chainType: string,
-  destinationPath: string,
-  config?: {
-    includePrereleases?: boolean;
-    nameSuffix?: string;
-    tag?: string;
-  }
-) => {
-  const getRelease = () => {
-    if (config?.tag) return getReleaseByTag(repo, config.tag);
-    if (config?.includePrereleases) return findLatestRelease(repo, chainType);
-    return findLatestStableRelease(repo, chainType);
-  };
-  try {
-    const release = await getRelease();
-
-    if (release) {
-      await Promise.all([
-        ...(release &&
-          release.assets
-            .filter((asset) => isValidAssetName(chainType)(asset.name))
-            .map(async (asset) =>
-              download(asset.browser_download_url, destinationPath, {
-                filename: truncateAssetName(
-                  asset.name,
-                  chainType,
-                  release.tag_name,
-                  config?.nameSuffix
-                ),
-              })
-            )),
-      ]);
-    } else {
-      console.error(`No release found for [${chainType}] chain type.`);
-      if (!config?.includePrereleases) {
-        console.error(
-          'Please note that `includePrereleases` is set to false. There may be some matching releases in prereleases.'
-        );
-      }
-    }
-  } catch (error) {
-    console.error(
-      `An error occurred while trying to download Rosen assets: ${error}`
-    );
-    if (error instanceof Error) {
-      console.error(error.stack);
-    }
-    throw new RosenAssetsDownloadError('', { cause: error });
-  }
-};
-
-export default downloadRosenAssets;

package/lib/downloadTssBinary.ts

@@ -1,61 +0,0 @@
-import download from 'download';
-
-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
- * @param destinationPath where writes files
- * @param config configs for including prereleases, set osName, getting specific release by tag or by regex tag
- */
-const downloadTssBinary = async (
-  destinationPath: string,
-  config: {
-    osName: string;
-    tag: string;
-    regex: boolean;
-    includePrereleases?: boolean;
-  }
-) => {
-  const getRelease = () => {
-    if (config.regex) {
-      if (config?.includePrereleases)
-        return findLatestReleaseByPrefixTag(repo, config.tag);
-      else return findLatestStableReleaseByPrefixTag(repo, config.tag);
-    } else return getReleaseByTag(repo, config.tag);
-  };
-  try {
-    const release = await getRelease();
-
-    if (release) {
-      await Promise.all([
-        ...(release &&
-          release.assets
-            .filter((asset) => isValidOS(config.osName)(asset.name))
-            .map(async (asset) =>
-              download(asset.browser_download_url, destinationPath)
-            )),
-      ]);
-    } else {
-      console.error(`No release found for [${config.osName}] OS name.`);
-    }
-  } catch (error) {
-    console.error(
-      `An error occurred while trying to download release assets: ${error}`
-    );
-    if (error instanceof Error) {
-      console.error(error.stack);
-    }
-    throw new RosenAssetsDownloadError('', { cause: error });
-  }
-};
-
-export { downloadTssBinary };

package/lib/error.ts

@@ -1,3 +0,0 @@
-class RosenAssetsDownloadError extends Error {}
-
-export { RosenAssetsDownloadError };

package/lib/index.ts

@@ -1,4 +0,0 @@
-export { default as downloadRosenAssets } from './downloadRosenAssets';
-export * from './downloadTssBinary';
-
-export { RosenAssetsDownloadError } from './error';

package/lib/types/index.ts

@@ -1,13 +0,0 @@
-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 SupportedRepo = 'contract' | 'sign-protocols';

package/lib/utils/github.ts

@@ -1,169 +0,0 @@
-import { Octokit } from 'octokit';
-
-import { isValidAssetName } from './rosen';
-
-import {
-  DEFAULT_RELEASES_FETCHING_PAGE_SIZE,
-  ROSEN_BRIDGE_ORGANIZATION,
-} from '../constants';
-
-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
- */
-async function* fetchReleasesPage(
-  repoName: SupportedRepo,
-  pageSize = DEFAULT_RELEASES_FETCHING_PAGE_SIZE
-) {
-  const octokit = new Octokit();
-
-  let currentPage = 1;
-
-  while (true) {
-    const releasesPage = await octokit.rest.repos.listReleases({
-      owner: ROSEN_BRIDGE_ORGANIZATION,
-      repo: repoName,
-      per_page: pageSize,
-      page: currentPage,
-    });
-
-    if (releasesPage.data.length) {
-      yield releasesPage.data;
-      currentPage += 1;
-    } else {
-      return;
-    }
-  }
-}
-
-/**
- * Find the last release matching the predicate. If all releases are iterated and
- * no matching release is found, return null.
- * @param repoName
- * @param predicate
- */
-const findLastRelease = async (
-  repoName: SupportedRepo,
-  predicate: (release: GithubRelease) => boolean = () => true
-) => {
-  const releasesPageIterator = fetchReleasesPage(repoName);
-
-  for await (const releasesPage of releasesPageIterator) {
-    const foundRelease = releasesPage.find(predicate);
-
-    if (foundRelease) {
-      return foundRelease;
-    }
-  }
-  return null;
-};
-
-/**
- * get a GitHub release by its tag
- * @param repoName
- * @param tag
- */
-const getReleaseByTag = async (repoName: SupportedRepo, tag: string) => {
-  const octokit = new Octokit();
-  const release = await octokit.rest.repos.getReleaseByTag({
-    owner: ROSEN_BRIDGE_ORGANIZATION,
-    repo: repoName,
-    tag,
-  });
-
-  return release.data;
-};
-
-/**
- * Return a function which checks if a release has at least one asset for a
- * specific chain type
- * @param chainType
- * @param release
- */
-const hasAssetForChainType = (chainType: string) => (release: GithubRelease) =>
-  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
- */
-const isStableReleaseForChainType =
-  (chainType: string) => (release: GithubRelease) =>
-    !release.prerelease && hasAssetForChainType(chainType)(release);
-
-/**
- * Return a function which checks if tagPrefix is matched with release tag_name
- * @param tagPrefix
- */
-const hasMatchedTagPrefix = (tagPrefix: string) => (release: GithubRelease) => {
-  const regex = new RegExp(`^${tagPrefix}`);
-  return regex.test(release.tag_name);
-};
-
-/**
- * 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
- */
-const isStableReleaseForRegexTagType =
-  (tagPrefix: string) => (release: GithubRelease) =>
-    !release.prerelease && hasMatchedTagPrefix(tagPrefix)(release);
-
-/**
- * Find latest release (prerelease or non-prerelease) having some asset matching
- * a specific chain type
- * @param repoName
- * @param chainType
- */
-const findLatestRelease = async (repoName: SupportedRepo, chainType: string) =>
-  findLastRelease(repoName, hasAssetForChainType(chainType));
-
-/**
- * Find latest stable (that is, non-prerelease) release having some asset matching
- * a specific chain type
- * @param repoName
- * @param chainType
- */
-const findLatestStableRelease = async (
-  repoName: SupportedRepo,
-  chainType: string
-) => 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
- */
-const findLatestStableReleaseByPrefixTag = async (
-  repoName: SupportedRepo,
-  tagPrefix: string
-) => findLastRelease(repoName, isStableReleaseForRegexTagType(tagPrefix));
-
-/**
- * Find the latest release that tagPrefix is matched with release tag_name
- * @param repoName
- * @param tagPrefix
- */
-const findLatestReleaseByPrefixTag = async (
-  repoName: SupportedRepo,
-  tagPrefix: string
-) => findLastRelease(repoName, hasMatchedTagPrefix(tagPrefix));
-
-export {
-  fetchReleasesPage,
-  findLastRelease,
-  findLatestRelease,
-  findLatestStableRelease,
-  findLatestStableReleaseByPrefixTag,
-  findLatestReleaseByPrefixTag,
-  getReleaseByTag,
-  hasAssetForChainType,
-  isStableReleaseForChainType,
-  isStableReleaseForRegexTagType,
-  hasMatchedTagPrefix,
-};

package/lib/utils/rosen.ts

@@ -1,34 +0,0 @@
-/**
- * Check if an asset name is a valid Rosen asset name and matches a specific
- * chain type
- * @param chainType
- */
-export const isValidAssetName = (chainType: string) => (assetName: string) =>
-  new RegExp(`(contracts-.+|tokensMap)-${chainType}-.+.json`).test(assetName);
-
-/**
- * Check if an OS name is a valid supported tss OS
- * @param OSName
- */
-export const isValidOS = (OSName: string) => (releaseAssetName: string) =>
-  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 alternativeSuffix a suffix which will be added before `.json` (if provided)
- */
-export const truncateAssetName = (
-  assetName: string,
-  chainType: string,
-  releaseName: string,
-  alternativeSuffix?: string
-) => {
-  const name = assetName.replace(`-${chainType}-${releaseName}.json`, '');
-  return alternativeSuffix
-    ? `${name}-${alternativeSuffix}.json`
-    : `${name}.json`;
-};