@rosen-bridge/utils 0.1.0 → 0.3.0

package/dist/lib/utils/github.js

@@ -1,18 +1,19 @@
 import { Octokit } from 'octokit';
 import { isValidAssetName } from './rosen';
-import { CONTRACT_REPO_NAME, DEFAULT_RELEASES_FETCHING_PAGE_SIZE, ROSEN_BRIDGE_ORGANIZATION, } from '../constants';
+import { DEFAULT_RELEASES_FETCHING_PAGE_SIZE, ROSEN_BRIDGE_ORGANIZATION, } from '../constants';
 /**
  * Fetch a page of releases from Github Api in each iteration until there are no
  * more releases.
+ * @param repoName
  * @param pageSize
  */
-async function* fetchReleasesPage(pageSize = DEFAULT_RELEASES_FETCHING_PAGE_SIZE) {
+async function* fetchReleasesPage(repoName, 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: CONTRACT_REPO_NAME,
+            repo: repoName,
             per_page: pageSize,
             page: currentPage,
         });
@@ -28,10 +29,11 @@ async function* fetchReleasesPage(pageSize = DEFAULT_RELEASES_FETCHING_PAGE_SIZE
 /**
  * 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 (predicate = () => true) => {
-    const releasesPageIterator = fetchReleasesPage();
+const findLastRelease = async (repoName, predicate = () => true) => {
+    const releasesPageIterator = fetchReleasesPage(repoName);
     for await (const releasesPage of releasesPageIterator) {
         const foundRelease = releasesPage.find(predicate);
         if (foundRelease) {
@@ -42,13 +44,14 @@ const findLastRelease = async (predicate = () => true) => {
 };
 /**
  * get a GitHub release by its tag
+ * @param repoName
  * @param tag
  */
-const getReleaseByTag = async (tag) => {
+const getReleaseByTag = async (repoName, tag) => {
     const octokit = new Octokit();
     const release = await octokit.rest.repos.getReleaseByTag({
         owner: ROSEN_BRIDGE_ORGANIZATION,
-        repo: CONTRACT_REPO_NAME,
+        repo: repoName,
         tag,
     });
     return release.data;
@@ -66,17 +69,45 @@ const hasAssetForChainType = (chainType) => (release) => release.assets.map((ass
  * @param chainType
  */
 const isStableReleaseForChainType = (chainType) => (release) => !release.prerelease && hasAssetForChainType(chainType)(release);
+/**
+ * Return a function which checks if tagPrefix is matched with release tag_name
+ * @param tagPrefix
+ */
+const hasMatchedTagPrefix = (tagPrefix) => (release) => {
+    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) => (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
  */
-const findLatestRelease = async (chainType) => findLastRelease(hasAssetForChainType(chainType));
+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
  */
-const findLatestStableRelease = async (chainType) => findLastRelease(isStableReleaseForChainType(chainType));
-export { fetchReleasesPage, findLastRelease, findLatestRelease, findLatestStableRelease, getReleaseByTag, hasAssetForChainType, isStableReleaseForChainType, };
-//# sourceMappingURL=data:application/json;base64,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
+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
+ */
+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
+ */
+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"]}

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

@@ -4,6 +4,11 @@
  * @param chainType
  */
 export declare const isValidAssetName: (chainType: string) => (assetName: string) => boolean;
+/**
+ * Check if an OS name is a valid supported tss OS
+ * @param OSName
+ */
+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

package/dist/lib/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,cAAe,MAAM,iBAAiB,MAAM,YACI,CAAC;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,cACjB,MAAM,sBACG,MAAM,WAKzB,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,YACI,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,SAAS,GAAI,QAAQ,MAAM,MAAM,kBAAkB,MAAM,YACJ,CAAC;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,WAAW,MAAM,EACjB,oBAAoB,MAAM,WAKzB,CAAC"}

package/dist/lib/utils/rosen.js

@@ -4,6 +4,11 @@
  * @param chainType
  */
 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
+ */
+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
@@ -11,4 +16,4 @@ export const isValidAssetName = (chainType) => (assetName) => new RegExp(`(contr
  * @param alternativeSuffix a suffix which will be added before `.json` (if provided)
  */
 export const truncateAssetName = (assetName, alternativeSuffix) => assetName.replace(/(contracts-.+?|tokensMap)-.+.json/, alternativeSuffix ? `$1-${alternativeSuffix}.json` : '$1.json');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm9zZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvdXRpbHMvcm9zZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLENBQUMsU0FBaUIsRUFBRSxFQUFFLENBQUMsQ0FBQyxTQUFpQixFQUFFLEVBQUUsQ0FDM0UsSUFBSSxNQUFNLENBQUMsNEJBQTRCLFNBQVMsVUFBVSxDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0FBRTlFOzs7OztHQUtHO0FBQ0gsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsQ0FDL0IsU0FBaUIsRUFDakIsaUJBQTBCLEVBQzFCLEVBQUUsQ0FDRixTQUFTLENBQUMsT0FBTyxDQUNmLG1DQUFtQyxFQUNuQyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsTUFBTSxpQkFBaUIsT0FBTyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQy9ELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENoZWNrIGlmIGFuIGFzc2V0IG5hbWUgaXMgYSB2YWxpZCBSb3NlbiBhc3NldCBuYW1lIGFuZCBtYXRjaGVzIGEgc3BlY2lmaWNcbiAqIGNoYWluIHR5cGVcbiAqIEBwYXJhbSBjaGFpblR5cGVcbiAqL1xuZXhwb3J0IGNvbnN0IGlzVmFsaWRBc3NldE5hbWUgPSAoY2hhaW5UeXBlOiBzdHJpbmcpID0+IChhc3NldE5hbWU6IHN0cmluZykgPT5cbiAgbmV3IFJlZ0V4cChgKGNvbnRyYWN0cy0uK3x0b2tlbnNNYXApLSR7Y2hhaW5UeXBlfS0uKy5qc29uYCkudGVzdChhc3NldE5hbWUpO1xuXG4vKipcbiAqIFJlbW92ZSBjaGFpbiB0eXBlIGFuZCB0YWcgZnJvbSB0aGUgYXNzZXQgbmFtZSBhbmQgb3B0aW9uYWxseSByZXBsYWNlcyB0aGVtXG4gKiB3aXRoIGEgc3VmZml4XG4gKiBAcGFyYW0gYXNzZXROYW1lXG4gKiBAcGFyYW0gYWx0ZXJuYXRpdmVTdWZmaXggYSBzdWZmaXggd2hpY2ggd2lsbCBiZSBhZGRlZCBiZWZvcmUgYC5qc29uYCAoaWYgcHJvdmlkZWQpXG4gKi9cbmV4cG9ydCBjb25zdCB0cnVuY2F0ZUFzc2V0TmFtZSA9IChcbiAgYXNzZXROYW1lOiBzdHJpbmcsXG4gIGFsdGVybmF0aXZlU3VmZml4Pzogc3RyaW5nXG4pID0+XG4gIGFzc2V0TmFtZS5yZXBsYWNlKFxuICAgIC8oY29udHJhY3RzLS4rP3x0b2tlbnNNYXApLS4rLmpzb24vLFxuICAgIGFsdGVybmF0aXZlU3VmZml4ID8gYCQxLSR7YWx0ZXJuYXRpdmVTdWZmaXh9Lmpzb25gIDogJyQxLmpzb24nXG4gICk7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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