@rosen-bridge/utils 0.1.0 → 0.3.0

package/dist/utils/github.d.ts

@@ -0,0 +1,241 @@
+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
+ */
+declare function fetchReleasesPage(repoName: SupportedRepo, pageSize?: number): AsyncGenerator<{
+    url: string;
+    html_url: string;
+    assets_url: string;
+    upload_url: string;
+    tarball_url: string | null;
+    zipball_url: string | null;
+    id: number;
+    node_id: string;
+    tag_name: string;
+    target_commitish: string;
+    name: string | null;
+    body?: string | null;
+    draft: boolean;
+    prerelease: boolean;
+    created_at: string;
+    published_at: string | null;
+    author: import("@octokit/openapi-types").components["schemas"]["simple-user"];
+    assets: import("@octokit/openapi-types").components["schemas"]["release-asset"][];
+    body_html?: string;
+    body_text?: string;
+    mentions_count?: number;
+    discussion_url?: string;
+    reactions?: import("@octokit/openapi-types").components["schemas"]["reaction-rollup"];
+}[], void, unknown>;
+/**
+ * Find the last release matching the predicate. If all releases are iterated and
+ * no matching release is found, return null.
+ * @param repoName
+ * @param predicate
+ */
+declare const findLastRelease: (repoName: SupportedRepo, predicate?: (release: GithubRelease) => boolean) => Promise<{
+    url: string;
+    html_url: string;
+    assets_url: string;
+    upload_url: string;
+    tarball_url: string | null;
+    zipball_url: string | null;
+    id: number;
+    node_id: string;
+    tag_name: string;
+    target_commitish: string;
+    name: string | null;
+    body?: string | null;
+    draft: boolean;
+    prerelease: boolean;
+    created_at: string;
+    published_at: string | null;
+    author: import("@octokit/openapi-types").components["schemas"]["simple-user"];
+    assets: import("@octokit/openapi-types").components["schemas"]["release-asset"][];
+    body_html?: string;
+    body_text?: string;
+    mentions_count?: number;
+    discussion_url?: string;
+    reactions?: import("@octokit/openapi-types").components["schemas"]["reaction-rollup"];
+} | null>;
+/**
+ * get a GitHub release by its tag
+ * @param repoName
+ * @param tag
+ */
+declare const getReleaseByTag: (repoName: SupportedRepo, tag: string) => Promise<{
+    url: string;
+    html_url: string;
+    assets_url: string;
+    upload_url: string;
+    tarball_url: string | null;
+    zipball_url: string | null;
+    id: number;
+    node_id: string;
+    tag_name: string;
+    target_commitish: string;
+    name: string | null;
+    body?: string | null;
+    draft: boolean;
+    prerelease: boolean;
+    created_at: string;
+    published_at: string | null;
+    author: import("@octokit/openapi-types").components["schemas"]["simple-user"];
+    assets: import("@octokit/openapi-types").components["schemas"]["release-asset"][];
+    body_html?: string;
+    body_text?: string;
+    mentions_count?: number;
+    discussion_url?: string;
+    reactions?: import("@octokit/openapi-types").components["schemas"]["reaction-rollup"];
+}>;
+/**
+ * Return a function which checks if a release has at least one asset for a
+ * specific chain type
+ * @param chainType
+ * @param release
+ */
+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
+ */
+declare const isStableReleaseForChainType: (chainType: string) => (release: GithubRelease) => boolean;
+/**
+ * Return a function which checks if tagPrefix is matched with release tag_name
+ * @param tagPrefix
+ */
+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
+ */
+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
+ */
+declare const findLatestRelease: (repoName: SupportedRepo, chainType: string) => Promise<{
+    url: string;
+    html_url: string;
+    assets_url: string;
+    upload_url: string;
+    tarball_url: string | null;
+    zipball_url: string | null;
+    id: number;
+    node_id: string;
+    tag_name: string;
+    target_commitish: string;
+    name: string | null;
+    body?: string | null;
+    draft: boolean;
+    prerelease: boolean;
+    created_at: string;
+    published_at: string | null;
+    author: import("@octokit/openapi-types").components["schemas"]["simple-user"];
+    assets: import("@octokit/openapi-types").components["schemas"]["release-asset"][];
+    body_html?: string;
+    body_text?: string;
+    mentions_count?: number;
+    discussion_url?: string;
+    reactions?: import("@octokit/openapi-types").components["schemas"]["reaction-rollup"];
+} | null>;
+/**
+ * Find latest stable (that is, non-prerelease) release having some asset matching
+ * a specific chain type
+ * @param repoName
+ * @param chainType
+ */
+declare const findLatestStableRelease: (repoName: SupportedRepo, chainType: string) => Promise<{
+    url: string;
+    html_url: string;
+    assets_url: string;
+    upload_url: string;
+    tarball_url: string | null;
+    zipball_url: string | null;
+    id: number;
+    node_id: string;
+    tag_name: string;
+    target_commitish: string;
+    name: string | null;
+    body?: string | null;
+    draft: boolean;
+    prerelease: boolean;
+    created_at: string;
+    published_at: string | null;
+    author: import("@octokit/openapi-types").components["schemas"]["simple-user"];
+    assets: import("@octokit/openapi-types").components["schemas"]["release-asset"][];
+    body_html?: string;
+    body_text?: string;
+    mentions_count?: number;
+    discussion_url?: string;
+    reactions?: import("@octokit/openapi-types").components["schemas"]["reaction-rollup"];
+} | null>;
+/**
+ * Find the latest stable (that is, non-prerelease) release that tagPrefix is matched with release tag_name
+ * @param repoName
+ * @param tagPrefix
+ */
+declare const findLatestStableReleaseByPrefixTag: (repoName: SupportedRepo, tagPrefix: string) => Promise<{
+    url: string;
+    html_url: string;
+    assets_url: string;
+    upload_url: string;
+    tarball_url: string | null;
+    zipball_url: string | null;
+    id: number;
+    node_id: string;
+    tag_name: string;
+    target_commitish: string;
+    name: string | null;
+    body?: string | null;
+    draft: boolean;
+    prerelease: boolean;
+    created_at: string;
+    published_at: string | null;
+    author: import("@octokit/openapi-types").components["schemas"]["simple-user"];
+    assets: import("@octokit/openapi-types").components["schemas"]["release-asset"][];
+    body_html?: string;
+    body_text?: string;
+    mentions_count?: number;
+    discussion_url?: string;
+    reactions?: import("@octokit/openapi-types").components["schemas"]["reaction-rollup"];
+} | null>;
+/**
+ * Find the latest release that tagPrefix is matched with release tag_name
+ * @param repoName
+ * @param tagPrefix
+ */
+declare const findLatestReleaseByPrefixTag: (repoName: SupportedRepo, tagPrefix: string) => Promise<{
+    url: string;
+    html_url: string;
+    assets_url: string;
+    upload_url: string;
+    tarball_url: string | null;
+    zipball_url: string | null;
+    id: number;
+    node_id: string;
+    tag_name: string;
+    target_commitish: string;
+    name: string | null;
+    body?: string | null;
+    draft: boolean;
+    prerelease: boolean;
+    created_at: string;
+    published_at: string | null;
+    author: import("@octokit/openapi-types").components["schemas"]["simple-user"];
+    assets: import("@octokit/openapi-types").components["schemas"]["release-asset"][];
+    body_html?: string;
+    body_text?: string;
+    mentions_count?: number;
+    discussion_url?: string;
+    reactions?: import("@octokit/openapi-types").components["schemas"]["reaction-rollup"];
+} | null>;
+export { fetchReleasesPage, findLastRelease, findLatestRelease, findLatestStableRelease, findLatestStableReleaseByPrefixTag, findLatestReleaseByPrefixTag, getReleaseByTag, hasAssetForChainType, isStableReleaseForChainType, isStableReleaseForRegexTagType, hasMatchedTagPrefix, };
+//# sourceMappingURL=github.d.ts.map

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

@@ -0,0 +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"}

package/dist/utils/github.js

@@ -0,0 +1,113 @@
+import { Octokit } from 'octokit';
+import { isValidAssetName } from './rosen';
+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(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: 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, predicate = () => 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, tag) => {
+    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) => (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
+ */
+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 (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 (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/utils/rosen.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Check if an asset name is a valid Rosen asset name and matches a specific
+ * chain type
+ * @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
+ * @param assetName
+ * @param alternativeSuffix a suffix which will be added before `.json` (if provided)
+ */
+export declare const truncateAssetName: (assetName: string, alternativeSuffix?: string) => string;
+//# sourceMappingURL=rosen.d.ts.map

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

@@ -0,0 +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;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,WAAW,MAAM,EACjB,oBAAoB,MAAM,WAKzB,CAAC"}

package/dist/utils/rosen.js

@@ -0,0 +1,19 @@
+/**
+ * Check if an asset name is a valid Rosen asset name and matches a specific
+ * chain type
+ * @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
+ * @param assetName
+ * @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,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

package/lib/constants.ts

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

package/lib/downloadRosenAssets.ts

@@ -9,6 +9,8 @@ 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.)
@@ -25,9 +27,9 @@ const downloadRosenAssets = async (
   }
 ) => {
   const getRelease = () => {
-    if (config?.tag) return getReleaseByTag(config.tag);
-    if (config?.includePrereleases) return findLatestRelease(chainType);
-    return findLatestStableRelease(chainType);
+    if (config?.tag) return getReleaseByTag(repo, config.tag);
+    if (config?.includePrereleases) return findLatestRelease(repo, chainType);
+    return findLatestStableRelease(repo, chainType);
   };
   try {
     const release = await getRelease();

package/lib/downloadTssBinary.ts

@@ -0,0 +1,61 @@
+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/index.ts

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

package/lib/types/index.ts

@@ -9,3 +9,5 @@ type GithubReleases = Awaited<
 >['data'];
 
 export type GithubRelease = ArrayElement<GithubReleases>;
+
+export type SupportedRepo = 'contract' | 'sign-protocols';

package/lib/utils/github.ts

@@ -3,19 +3,20 @@ import { Octokit } from 'octokit';
 import { isValidAssetName } from './rosen';
 
 import {
-  CONTRACT_REPO_NAME,
   DEFAULT_RELEASES_FETCHING_PAGE_SIZE,
   ROSEN_BRIDGE_ORGANIZATION,
 } from '../constants';
 
-import { GithubRelease } from '../types';
+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();
@@ -25,7 +26,7 @@ async function* fetchReleasesPage(
   while (true) {
     const releasesPage = await octokit.rest.repos.listReleases({
       owner: ROSEN_BRIDGE_ORGANIZATION,
-      repo: CONTRACT_REPO_NAME,
+      repo: repoName,
       per_page: pageSize,
       page: currentPage,
     });
@@ -42,12 +43,14 @@ async function* fetchReleasesPage(
 /**
  * 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();
+  const releasesPageIterator = fetchReleasesPage(repoName);
 
   for await (const releasesPage of releasesPageIterator) {
     const foundRelease = releasesPage.find(predicate);
@@ -61,13 +64,14 @@ const findLastRelease = async (
 
 /**
  * get a GitHub release by its tag
+ * @param repoName
  * @param tag
  */
-const getReleaseByTag = async (tag: string) => {
+const getReleaseByTag = async (repoName: SupportedRepo, tag: string) => {
   const octokit = new Octokit();
   const release = await octokit.rest.repos.getReleaseByTag({
     owner: ROSEN_BRIDGE_ORGANIZATION,
-    repo: CONTRACT_REPO_NAME,
+    repo: repoName,
     tag,
   });
 
@@ -92,28 +96,74 @@ 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 (chainType: string) =>
-  findLastRelease(hasAssetForChainType(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 (chainType: string) =>
-  findLastRelease(isStableReleaseForChainType(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,
 };