@rosen-bridge/utils 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @rosen-bridge/utils
 
+## 0.2.0
+
+### Minor Changes
+
+- add a method to download tss binary via a prefix tag
+
 ## 0.1.0
 
 ### Minor Changes

package/dist/lib/constants.d.ts

@@ -1,4 +1,3 @@
 export declare const DEFAULT_RELEASES_FETCHING_PAGE_SIZE = 5;
 export declare const ROSEN_BRIDGE_ORGANIZATION = "rosen-bridge";
-export declare const CONTRACT_REPO_NAME = "contract";
 //# sourceMappingURL=constants.d.ts.map

package/dist/lib/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../lib/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mCAAmC,IAAI,CAAC;AACrD,eAAO,MAAM,yBAAyB,iBAAiB,CAAC;AACxD,eAAO,MAAM,kBAAkB,aAAa,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../lib/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mCAAmC,IAAI,CAAC;AACrD,eAAO,MAAM,yBAAyB,iBAAiB,CAAC"}

package/dist/lib/constants.js

@@ -1,4 +1,3 @@
 export const DEFAULT_RELEASES_FETCHING_PAGE_SIZE = 5;
 export const ROSEN_BRIDGE_ORGANIZATION = 'rosen-bridge';
-export const CONTRACT_REPO_NAME = 'contract';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vbGliL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxtQ0FBbUMsR0FBRyxDQUFDLENBQUM7QUFDckQsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQUcsY0FBYyxDQUFDO0FBQ3hELE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLFVBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBERUZBVUxUX1JFTEVBU0VTX0ZFVENISU5HX1BBR0VfU0laRSA9IDU7XG5leHBvcnQgY29uc3QgUk9TRU5fQlJJREdFX09SR0FOSVpBVElPTiA9ICdyb3Nlbi1icmlkZ2UnO1xuZXhwb3J0IGNvbnN0IENPTlRSQUNUX1JFUE9fTkFNRSA9ICdjb250cmFjdCc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vbGliL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxtQ0FBbUMsR0FBRyxDQUFDLENBQUM7QUFDckQsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQUcsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IERFRkFVTFRfUkVMRUFTRVNfRkVUQ0hJTkdfUEFHRV9TSVpFID0gNTtcbmV4cG9ydCBjb25zdCBST1NFTl9CUklER0VfT1JHQU5JWkFUSU9OID0gJ3Jvc2VuLWJyaWRnZSc7XG4iXX0=

package/dist/lib/downloadRosenAssets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"downloadRosenAssets.d.ts","sourceRoot":"","sources":["../../lib/downloadRosenAssets.ts"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,QAAA,MAAM,mBAAmB,cACZ,MAAM,mBACA,MAAM,WACd;IACP,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,kBAsCF,CAAC;AAEF,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"downloadRosenAssets.d.ts","sourceRoot":"","sources":["../../lib/downloadRosenAssets.ts"],"names":[],"mappings":"AAaA;;;;;GAKG;AACH,QAAA,MAAM,mBAAmB,cACZ,MAAM,mBACA,MAAM,WACd;IACP,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,kBAsCF,CAAC;AAEF,eAAe,mBAAmB,CAAC"}

package/dist/lib/downloadRosenAssets.js

@@ -2,6 +2,7 @@ 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.)
@@ -11,10 +12,10 @@ import { RosenAssetsDownloadError } from './error';
 const downloadRosenAssets = async (chainType, destinationPath, config) => {
     const getRelease = () => {
         if (config?.tag)
-            return getReleaseByTag(config.tag);
+            return getReleaseByTag(repo, config.tag);
         if (config?.includePrereleases)
-            return findLatestRelease(chainType);
-        return findLatestStableRelease(chainType);
+            return findLatestRelease(repo, chainType);
+        return findLatestStableRelease(repo, chainType);
     };
     try {
         const release = await getRelease();
@@ -44,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/lib/downloadTssBinary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"downloadTssBinary.d.ts","sourceRoot":"","sources":["../../lib/downloadTssBinary.ts"],"names":[],"mappings":"AAYA;;;;GAIG;AACH,QAAA,MAAM,iBAAiB,oBACJ,MAAM,UACf;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":"AAaA;;;;GAIG;AACH,QAAA,MAAM,iBAAiB,oBACJ,MAAM,UACf;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/lib/downloadTssBinary.js

@@ -1,5 +1,5 @@
 import download from 'download';
-import { findLatestReleaseByPrefixTag, findLatestStableReleaseByPrefixTag, getReleaseByTag } from './utils/github';
+import { findLatestReleaseByPrefixTag, findLatestStableReleaseByPrefixTag, getReleaseByTag, } from './utils/github';
 import { isValidOS } from './utils/rosen';
 import { RosenAssetsDownloadError } from './error';
 const repo = 'sign-protocols';
@@ -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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG93bmxvYWRUc3NCaW5hcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvZG93bmxvYWRUc3NCaW5hcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxRQUFRLE1BQU0sVUFBVSxDQUFDO0FBRWhDLE9BQU8sRUFDTCw0QkFBNEIsRUFDNUIsa0NBQWtDLEVBQ2xDLGVBQWUsR0FDaEIsTUFBTSxnQkFBZ0IsQ0FBQztBQUN4QixPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTFDLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUVuRCxNQUFNLElBQUksR0FBRyxnQkFBZ0IsQ0FBQztBQUU5Qjs7OztHQUlHO0FBQ0gsTUFBTSxpQkFBaUIsR0FBRyxLQUFLLEVBQzdCLGVBQXVCLEVBQ3ZCLE1BS0MsRUFDRCxFQUFFO0lBQ0YsTUFBTSxVQUFVLEdBQUcsR0FBRyxFQUFFO1FBQ3RCLElBQUksTUFBTSxDQUFDLEtBQUssRUFBRTtZQUNoQixJQUFJLE1BQU0sRUFBRSxrQkFBa0I7Z0JBQzVCLE9BQU8sNEJBQTRCLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQzs7Z0JBQ25ELE9BQU8sa0NBQWtDLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztTQUNsRTs7WUFBTSxPQUFPLGVBQWUsQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2xELENBQUMsQ0FBQztJQUNGLElBQUk7UUFDRixNQUFNLE9BQU8sR0FBRyxNQUFNLFVBQVUsRUFBRSxDQUFDO1FBRW5DLElBQUksT0FBTyxFQUFFO1lBQ1gsTUFBTSxPQUFPLENBQUMsR0FBRyxDQUFDO2dCQUNoQixHQUFHLENBQUMsT0FBTztvQkFDVCxPQUFPLENBQUMsTUFBTTt5QkFDWCxNQUFNLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO3lCQUN2RCxHQUFHLENBQUMsS0FBSyxFQUFFLEtBQUssRUFBRSxFQUFFLENBQ25CLFFBQVEsQ0FBQyxLQUFLLENBQUMsb0JBQW9CLEVBQUUsZUFBZSxDQUFDLENBQ3RELENBQUM7YUFDUCxDQUFDLENBQUM7U0FDSjthQUFNO1lBQ0wsT0FBTyxDQUFDLEtBQUssQ0FBQyx5QkFBeUIsTUFBTSxDQUFDLE1BQU0sWUFBWSxDQUFDLENBQUM7U0FDbkU7S0FDRjtJQUFDLE9BQU8sS0FBSyxFQUFFO1FBQ2QsT0FBTyxDQUFDLEtBQUssQ0FDWCw4REFBOEQsS0FBSyxFQUFFLENBQ3RFLENBQUM7UUFDRixJQUFJLEtBQUssWUFBWSxLQUFLLEVBQUU7WUFDMUIsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUM7U0FDNUI7UUFDRCxNQUFNLElBQUksd0JBQXdCLENBQUMsRUFBRSxFQUFFLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUM7S0FDMUQ7QUFDSCxDQUFDLENBQUM7QUFFRixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBkb3dubG9hZCBmcm9tICdkb3dubG9hZCc7XG5cbmltcG9ydCB7XG4gIGZpbmRMYXRlc3RSZWxlYXNlQnlQcmVmaXhUYWcsXG4gIGZpbmRMYXRlc3RTdGFibGVSZWxlYXNlQnlQcmVmaXhUYWcsXG4gIGdldFJlbGVhc2VCeVRhZyxcbn0gZnJvbSAnLi91dGlscy9naXRodWInO1xuaW1wb3J0IHsgaXNWYWxpZE9TIH0gZnJvbSAnLi91dGlscy9yb3Nlbic7XG5cbmltcG9ydCB7IFJvc2VuQXNzZXRzRG93bmxvYWRFcnJvciB9IGZyb20gJy4vZXJyb3InO1xuXG5jb25zdCByZXBvID0gJ3NpZ24tcHJvdG9jb2xzJztcblxuLyoqXG4gKiBEb3dubG9hZCByZWxlYXNlIGFzc2V0IGJ5IHRhZyB0byBhIHNwZWNpZmljIHBhdGhcbiAqIEBwYXJhbSBkZXN0aW5hdGlvblBhdGggd2hlcmUgd3JpdGVzIGZpbGVzXG4gKiBAcGFyYW0gY29uZmlnIGNvbmZpZ3MgZm9yIGluY2x1ZGluZyBwcmVyZWxlYXNlcywgc2V0IG9zTmFtZSwgZ2V0dGluZyBzcGVjaWZpYyByZWxlYXNlIGJ5IHRhZyBvciBieSByZWdleCB0YWdcbiAqL1xuY29uc3QgZG93bmxvYWRUc3NCaW5hcnkgPSBhc3luYyAoXG4gIGRlc3RpbmF0aW9uUGF0aDogc3RyaW5nLFxuICBjb25maWc6IHtcbiAgICBvc05hbWU6IHN0cmluZztcbiAgICB0YWc6IHN0cmluZztcbiAgICByZWdleDogYm9vbGVhbjtcbiAgICBpbmNsdWRlUHJlcmVsZWFzZXM/OiBib29sZWFuO1xuICB9XG4pID0+IHtcbiAgY29uc3QgZ2V0UmVsZWFzZSA9ICgpID0+IHtcbiAgICBpZiAoY29uZmlnLnJlZ2V4KSB7XG4gICAgICBpZiAoY29uZmlnPy5pbmNsdWRlUHJlcmVsZWFzZXMpXG4gICAgICAgIHJldHVybiBmaW5kTGF0ZXN0UmVsZWFzZUJ5UHJlZml4VGFnKHJlcG8sIGNvbmZpZy50YWcpO1xuICAgICAgZWxzZSByZXR1cm4gZmluZExhdGVzdFN0YWJsZVJlbGVhc2VCeVByZWZpeFRhZyhyZXBvLCBjb25maWcudGFnKTtcbiAgICB9IGVsc2UgcmV0dXJuIGdldFJlbGVhc2VCeVRhZyhyZXBvLCBjb25maWcudGFnKTtcbiAgfTtcbiAgdHJ5IHtcbiAgICBjb25zdCByZWxlYXNlID0gYXdhaXQgZ2V0UmVsZWFzZSgpO1xuXG4gICAgaWYgKHJlbGVhc2UpIHtcbiAgICAgIGF3YWl0IFByb21pc2UuYWxsKFtcbiAgICAgICAgLi4uKHJlbGVhc2UgJiZcbiAgICAgICAgICByZWxlYXNlLmFzc2V0c1xuICAgICAgICAgICAgLmZpbHRlcigoYXNzZXQpID0+IGlzVmFsaWRPUyhjb25maWcub3NOYW1lKShhc3NldC5uYW1lKSlcbiAgICAgICAgICAgIC5tYXAoYXN5bmMgKGFzc2V0KSA9PlxuICAgICAgICAgICAgICBkb3dubG9hZChhc3NldC5icm93c2VyX2Rvd25sb2FkX3VybCwgZGVzdGluYXRpb25QYXRoKVxuICAgICAgICAgICAgKSksXG4gICAgICBdKTtcbiAgICB9IGVsc2Uge1xuICAgICAgY29uc29sZS5lcnJvcihgTm8gcmVsZWFzZSBmb3VuZCBmb3IgWyR7Y29uZmlnLm9zTmFtZX1dIE9TIG5hbWUuYCk7XG4gICAgfVxuICB9IGNhdGNoIChlcnJvcikge1xuICAgIGNvbnNvbGUuZXJyb3IoXG4gICAgICBgQW4gZXJyb3Igb2NjdXJyZWQgd2hpbGUgdHJ5aW5nIHRvIGRvd25sb2FkIHJlbGVhc2UgYXNzZXRzOiAke2Vycm9yfWBcbiAgICApO1xuICAgIGlmIChlcnJvciBpbnN0YW5jZW9mIEVycm9yKSB7XG4gICAgICBjb25zb2xlLmVycm9yKGVycm9yLnN0YWNrKTtcbiAgICB9XG4gICAgdGhyb3cgbmV3IFJvc2VuQXNzZXRzRG93bmxvYWRFcnJvcignJywgeyBjYXVzZTogZXJyb3IgfSk7XG4gIH1cbn07XG5cbmV4cG9ydCB7IGRvd25sb2FkVHNzQmluYXJ5IH07XG4iXX0=

package/dist/lib/index.d.ts

@@ -1,3 +1,4 @@
 export { default as downloadRosenAssets } from './downloadRosenAssets';
+export * from './downloadTssBinary';
 export { RosenAssetsDownloadError } from './error';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACvE,cAAc,qBAAqB,CAAC;AAEpC,OAAO,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC"}

package/dist/lib/index.js

@@ -1,3 +1,4 @@
 export { default as downloadRosenAssets } from './downloadRosenAssets';
+export * from './downloadTssBinary';
 export { RosenAssetsDownloadError } from './error';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE9BQU8sSUFBSSxtQkFBbUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXZFLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGRlZmF1bHQgYXMgZG93bmxvYWRSb3NlbkFzc2V0cyB9IGZyb20gJy4vZG93bmxvYWRSb3NlbkFzc2V0cyc7XG5cbmV4cG9ydCB7IFJvc2VuQXNzZXRzRG93bmxvYWRFcnJvciB9IGZyb20gJy4vZXJyb3InO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE9BQU8sSUFBSSxtQkFBbUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3ZFLGNBQWMscUJBQXFCLENBQUM7QUFFcEMsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgZGVmYXVsdCBhcyBkb3dubG9hZFJvc2VuQXNzZXRzIH0gZnJvbSAnLi9kb3dubG9hZFJvc2VuQXNzZXRzJztcbmV4cG9ydCAqIGZyb20gJy4vZG93bmxvYWRUc3NCaW5hcnknO1xuXG5leHBvcnQgeyBSb3NlbkFzc2V0c0Rvd25sb2FkRXJyb3IgfSBmcm9tICcuL2Vycm9yJztcbiJdfQ==

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

@@ -2,5 +2,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 SupportedRepo = 'contract' | 'sign-protocols';
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/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"}
+{"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"}

package/dist/lib/types/index.js

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

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

@@ -1,10 +1,11 @@
-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
  */
-declare function fetchReleasesPage(pageSize?: number): AsyncGenerator<{
+declare function fetchReleasesPage(repoName: SupportedRepo, pageSize?: number): AsyncGenerator<{
     url: string;
     html_url: string;
     assets_url: string;
@@ -101,9 +102,10 @@ declare function fetchReleasesPage(pageSize?: number): AsyncGenerator<{
 /**
  * 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: (predicate?: (release: GithubRelease) => boolean) => Promise<{
+declare const findLastRelease: (repoName: SupportedRepo, predicate?: (release: GithubRelease) => boolean) => Promise<{
     url: string;
     html_url: string;
     assets_url: string;
@@ -199,9 +201,10 @@ declare const findLastRelease: (predicate?: (release: GithubRelease) => boolean)
 } | null>;
 /**
  * get a GitHub release by its tag
+ * @param repoName
  * @param tag
  */
-declare const getReleaseByTag: (tag: string) => Promise<{
+declare const getReleaseByTag: (repoName: SupportedRepo, tag: string) => Promise<{
     url: string;
     html_url: string;
     assets_url: string;
@@ -308,12 +311,24 @@ declare const hasAssetForChainType: (chainType: string) => (release: GithubRelea
  * @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: (chainType: string) => Promise<{
+declare const findLatestRelease: (repoName: SupportedRepo, chainType: string) => Promise<{
     url: string;
     html_url: string;
     assets_url: string;
@@ -410,9 +425,208 @@ declare const findLatestRelease: (chainType: string) => Promise<{
 /**
  * Find latest stable (that is, non-prerelease) release having some asset matching
  * a specific chain type
+ * @param repoName
  * @param chainType
  */
-declare const findLatestStableRelease: (chainType: string) => Promise<{
+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 | undefined;
+    draft: boolean;
+    prerelease: boolean;
+    created_at: string;
+    published_at: string | null;
+    author: {
+        name?: string | null | undefined;
+        email?: string | null | undefined;
+        login: string;
+        id: number;
+        node_id: string;
+        avatar_url: string;
+        gravatar_id: string | null;
+        url: string;
+        html_url: string;
+        followers_url: string;
+        following_url: string;
+        gists_url: string;
+        starred_url: string;
+        subscriptions_url: string;
+        organizations_url: string;
+        repos_url: string;
+        events_url: string;
+        received_events_url: string;
+        type: string;
+        site_admin: boolean;
+        starred_at?: string | undefined;
+    };
+    assets: {
+        url: string;
+        browser_download_url: string;
+        id: number;
+        node_id: string;
+        name: string;
+        label: string | null;
+        state: "uploaded" | "open";
+        content_type: string;
+        size: number;
+        download_count: number;
+        created_at: string;
+        updated_at: string;
+        uploader: {
+            name?: string | null | undefined;
+            email?: string | null | undefined;
+            login: string;
+            id: number;
+            node_id: string;
+            avatar_url: string;
+            gravatar_id: string | null;
+            url: string;
+            html_url: string;
+            followers_url: string;
+            following_url: string;
+            gists_url: string;
+            starred_url: string;
+            subscriptions_url: string;
+            organizations_url: string;
+            repos_url: string;
+            events_url: string;
+            received_events_url: string;
+            type: string;
+            site_admin: boolean;
+            starred_at?: string | undefined;
+        } | null;
+    }[];
+    body_html?: string | undefined;
+    body_text?: string | undefined;
+    mentions_count?: number | undefined;
+    discussion_url?: string | undefined;
+    reactions?: {
+        url: string;
+        total_count: number;
+        "+1": number;
+        "-1": number;
+        laugh: number;
+        confused: number;
+        heart: number;
+        hooray: number;
+        eyes: number;
+        rocket: number;
+    } | undefined;
+} | 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 | undefined;
+    draft: boolean;
+    prerelease: boolean;
+    created_at: string;
+    published_at: string | null;
+    author: {
+        name?: string | null | undefined;
+        email?: string | null | undefined;
+        login: string;
+        id: number;
+        node_id: string;
+        avatar_url: string;
+        gravatar_id: string | null;
+        url: string;
+        html_url: string;
+        followers_url: string;
+        following_url: string;
+        gists_url: string;
+        starred_url: string;
+        subscriptions_url: string;
+        organizations_url: string;
+        repos_url: string;
+        events_url: string;
+        received_events_url: string;
+        type: string;
+        site_admin: boolean;
+        starred_at?: string | undefined;
+    };
+    assets: {
+        url: string;
+        browser_download_url: string;
+        id: number;
+        node_id: string;
+        name: string;
+        label: string | null;
+        state: "uploaded" | "open";
+        content_type: string;
+        size: number;
+        download_count: number;
+        created_at: string;
+        updated_at: string;
+        uploader: {
+            name?: string | null | undefined;
+            email?: string | null | undefined;
+            login: string;
+            id: number;
+            node_id: string;
+            avatar_url: string;
+            gravatar_id: string | null;
+            url: string;
+            html_url: string;
+            followers_url: string;
+            following_url: string;
+            gists_url: string;
+            starred_url: string;
+            subscriptions_url: string;
+            organizations_url: string;
+            repos_url: string;
+            events_url: string;
+            received_events_url: string;
+            type: string;
+            site_admin: boolean;
+            starred_at?: string | undefined;
+        } | null;
+    }[];
+    body_html?: string | undefined;
+    body_text?: string | undefined;
+    mentions_count?: number | undefined;
+    discussion_url?: string | undefined;
+    reactions?: {
+        url: string;
+        total_count: number;
+        "+1": number;
+        "-1": number;
+        laugh: number;
+        confused: number;
+        heart: number;
+        hooray: number;
+        eyes: number;
+        rocket: number;
+    } | undefined;
+} | 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;
@@ -506,5 +720,5 @@ declare const findLatestStableRelease: (chainType: string) => Promise<{
         rocket: number;
     } | undefined;
 } | null>;
-export { fetchReleasesPage, findLastRelease, findLatestRelease, findLatestStableRelease, getReleaseByTag, hasAssetForChainType, isStableReleaseForChainType, };
+export { fetchReleasesPage, findLastRelease, findLatestRelease, findLatestStableRelease, findLatestStableReleaseByPrefixTag, findLatestReleaseByPrefixTag, getReleaseByTag, hasAssetForChainType, isStableReleaseForChainType, isStableReleaseForRegexTagType, hasMatchedTagPrefix, };
 //# sourceMappingURL=github.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"github.d.ts","sourceRoot":"","sources":["../../../lib/utils/github.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC;;;;GAIG;AACH,iBAAgB,iBAAiB,CAC/B,QAAQ,SAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAqB/C;AAED;;;;GAIG;AACH,QAAA,MAAM,eAAe,yBACE,aAAa,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAY/C,CAAC;AAEF;;;GAGG;AACH,QAAA,MAAM,eAAe,QAAe,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASzC,CAAC;AAEF;;;;;GAKG;AACH,QAAA,MAAM,oBAAoB,cAAe,MAAM,eAAe,aAAa,YACE,CAAC;AAE9E;;;;GAIG;AACH,QAAA,MAAM,2BAA2B,cACnB,MAAM,eAAe,aAAa,YACmB,CAAC;AAEpE;;;;GAIG;AACH,QAAA,MAAM,iBAAiB,cAAqB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SACA,CAAC;AAEnD;;;;GAIG;AACH,QAAA,MAAM,uBAAuB,cAAqB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SACC,CAAC;AAE1D,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,uBAAuB,EACvB,eAAe,EACf,oBAAoB,EACpB,2BAA2B,GAC5B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAqB/C;AAED;;;;;GAKG;AACH,QAAA,MAAM,eAAe,aACT,aAAa,wBACF,aAAa,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAY/C,CAAC;AAEF;;;;GAIG;AACH,QAAA,MAAM,eAAe,aAAoB,aAAa,OAAO,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASlE,CAAC;AAEF;;;;;GAKG;AACH,QAAA,MAAM,oBAAoB,cAAe,MAAM,eAAe,aAAa,YACE,CAAC;AAE9E;;;;GAIG;AACH,QAAA,MAAM,2BAA2B,cACnB,MAAM,eAAe,aAAa,YACmB,CAAC;AAEpE;;;GAGG;AACH,QAAA,MAAM,mBAAmB,cAAe,MAAM,eAAe,aAAa,YAGzE,CAAC;AAEF;;;;GAIG;AACH,QAAA,MAAM,8BAA8B,cACtB,MAAM,eAAe,aAAa,YACkB,CAAC;AAEnE;;;;;GAKG;AACH,QAAA,MAAM,iBAAiB,aAAoB,aAAa,aAAa,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SACf,CAAC;AAE7D;;;;;GAKG;AACH,QAAA,MAAM,uBAAuB,aACjB,aAAa,aACZ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SACmD,CAAC;AAEvE;;;;GAIG;AACH,QAAA,MAAM,kCAAkC,aAC5B,aAAa,aACZ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SACsD,CAAC;AAE1E;;;;GAIG;AACH,QAAA,MAAM,4BAA4B,aACtB,aAAa,aACZ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAC2C,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/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":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAElC,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE3C,OAAO,EACL,mCAAmC,EACnC,yBAAyB,GAC1B,MAAM,cAAc,CAAC;AAItB;;;;;GAKG;AACH,KAAK,SAAS,CAAC,CAAC,iBAAiB,CAC/B,QAAuB,EACvB,QAAQ,GAAG,mCAAmC;IAE9C,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;IAE9B,IAAI,WAAW,GAAG,CAAC,CAAC;IAEpB,OAAO,IAAI,EAAE;QACX,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC;YACzD,KAAK,EAAE,yBAAyB;YAChC,IAAI,EAAE,QAAQ;YACd,QAAQ,EAAE,QAAQ;YAClB,IAAI,EAAE,WAAW;SAClB,CAAC,CAAC;QAEH,IAAI,YAAY,CAAC,IAAI,CAAC,MAAM,EAAE;YAC5B,MAAM,YAAY,CAAC,IAAI,CAAC;YACxB,WAAW,IAAI,CAAC,CAAC;SAClB;aAAM;YACL,OAAO;SACR;KACF;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,eAAe,GAAG,KAAK,EAC3B,QAAuB,EACvB,YAAiD,GAAG,EAAE,CAAC,IAAI,EAC3D,EAAE;IACF,MAAM,oBAAoB,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IAEzD,IAAI,KAAK,EAAE,MAAM,YAAY,IAAI,oBAAoB,EAAE;QACrD,MAAM,YAAY,GAAG,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAElD,IAAI,YAAY,EAAE;YAChB,OAAO,YAAY,CAAC;SACrB;KACF;IACD,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,eAAe,GAAG,KAAK,EAAE,QAAuB,EAAE,GAAW,EAAE,EAAE;IACrE,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;IAC9B,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC;QACvD,KAAK,EAAE,yBAAyB;QAChC,IAAI,EAAE,QAAQ;QACd,GAAG;KACJ,CAAC,CAAC;IAEH,OAAO,OAAO,CAAC,IAAI,CAAC;AACtB,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,oBAAoB,GAAG,CAAC,SAAiB,EAAE,EAAE,CAAC,CAAC,OAAsB,EAAE,EAAE,CAC7E,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC;AAE9E;;;;GAIG;AACH,MAAM,2BAA2B,GAC/B,CAAC,SAAiB,EAAE,EAAE,CAAC,CAAC,OAAsB,EAAE,EAAE,CAChD,CAAC,OAAO,CAAC,UAAU,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC;AAEpE;;;GAGG;AACH,MAAM,mBAAmB,GAAG,CAAC,SAAiB,EAAE,EAAE,CAAC,CAAC,OAAsB,EAAE,EAAE;IAC5E,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,IAAI,SAAS,EAAE,CAAC,CAAC;IAC1C,OAAO,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AACtC,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,8BAA8B,GAClC,CAAC,SAAiB,EAAE,EAAE,CAAC,CAAC,OAAsB,EAAE,EAAE,CAChD,CAAC,OAAO,CAAC,UAAU,IAAI,mBAAmB,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC;AAEnE;;;;;GAKG;AACH,MAAM,iBAAiB,GAAG,KAAK,EAAE,QAAuB,EAAE,SAAiB,EAAE,EAAE,CAC7E,eAAe,CAAC,QAAQ,EAAE,oBAAoB,CAAC,SAAS,CAAC,CAAC,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,uBAAuB,GAAG,KAAK,EACnC,QAAuB,EACvB,SAAiB,EACjB,EAAE,CAAC,eAAe,CAAC,QAAQ,EAAE,2BAA2B,CAAC,SAAS,CAAC,CAAC,CAAC;AAEvE;;;;GAIG;AACH,MAAM,kCAAkC,GAAG,KAAK,EAC9C,QAAuB,EACvB,SAAiB,EACjB,EAAE,CAAC,eAAe,CAAC,QAAQ,EAAE,8BAA8B,CAAC,SAAS,CAAC,CAAC,CAAC;AAE1E;;;;GAIG;AACH,MAAM,4BAA4B,GAAG,KAAK,EACxC,QAAuB,EACvB,SAAiB,EACjB,EAAE,CAAC,eAAe,CAAC,QAAQ,EAAE,mBAAmB,CAAC,SAAS,CAAC,CAAC,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","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,cAAe,MAAM,iBAAiB,MAAM,YACI,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,SAAS,WAAY,MAAM,wBAAwB,MAAM,YACJ,CAAC;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,cACjB,MAAM,sBACG,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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