@rosen-bridge/utils 0.0.1 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @rosen-bridge/utils
+
+## 0.1.0
+
+### Minor Changes
+
+- Add option to `downloadRosenAssets` to download releases by tag

package/dist/lib/downloadRosenAssets.d.ts

@@ -2,9 +2,12 @@
  * 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 destinationPath path to folder in which the files will be saved
- * @param nameSuffix an optional suffix to append to saved files names
+ * @param config configs for including prereleases, adding name suffix, and getting specific release by tag
  */
-declare const downloadRosenAssets: (chainType: string, destinationPath: string, includePrereleases?: boolean, nameSuffix?: string) => Promise<void>;
+declare const downloadRosenAssets: (chainType: string, destinationPath: string, config?: {
+    includePrereleases?: boolean;
+    nameSuffix?: string;
+    tag?: string;
+}) => Promise<void>;
 export default downloadRosenAssets;
 //# sourceMappingURL=downloadRosenAssets.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"downloadRosenAssets.d.ts","sourceRoot":"","sources":["../../lib/downloadRosenAssets.ts"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,QAAA,MAAM,mBAAmB,cACZ,MAAM,mBACA,MAAM,6CAEV,MAAM,kBAmCpB,CAAC;AAEF,eAAe,mBAAmB,CAAC"}
+{"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"}

package/dist/lib/downloadRosenAssets.js

@@ -1,32 +1,36 @@
 import download from 'download';
-import { findLatestRelease, findLatestStableRelease } from './utils/github';
+import { findLatestRelease, findLatestStableRelease, getReleaseByTag, } from './utils/github';
 import { isValidAssetName, truncateAssetName } from './utils/rosen';
 import { RosenAssetsDownloadError } from './error';
 /**
  * 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 destinationPath path to folder in which the files will be saved
- * @param nameSuffix an optional suffix to append to saved files names
+ * @param config configs for including prereleases, adding name suffix, and getting specific release by tag
  */
-const downloadRosenAssets = async (chainType, destinationPath, includePrereleases = false, nameSuffix) => {
+const downloadRosenAssets = async (chainType, destinationPath, config) => {
+    const getRelease = () => {
+        if (config?.tag)
+            return getReleaseByTag(config.tag);
+        if (config?.includePrereleases)
+            return findLatestRelease(chainType);
+        return findLatestStableRelease(chainType);
+    };
     try {
-        const release = includePrereleases
-            ? await findLatestRelease(chainType)
-            : await findLatestStableRelease(chainType);
+        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, nameSuffix),
+                        filename: truncateAssetName(asset.name, config?.nameSuffix),
                     }))),
             ]);
         }
         else {
             console.error(`No release found for [${chainType}] chain type.`);
-            if (!includePrereleases) {
+            if (!config?.includePrereleases) {
                 console.error('Please note that `includePrereleases` is set to false. There may be some matching releases in prereleases.');
             }
         }
@@ -40,4 +44,4 @@ const downloadRosenAssets = async (chainType, destinationPath, includePrerelease
     }
 };
 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

@@ -0,0 +1,13 @@
+/**
+ * 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
+ */
+declare const downloadTssBinary: (destinationPath: string, config: {
+    osName: string;
+    tag: string;
+    regex: boolean;
+    includePrereleases?: boolean;
+}) => Promise<void>;
+export { downloadTssBinary };
+//# sourceMappingURL=downloadTssBinary.d.ts.map

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

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

package/dist/lib/downloadTssBinary.js

@@ -0,0 +1,45 @@
+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, config) => {
+    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 };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -197,6 +197,104 @@ declare const findLastRelease: (predicate?: (release: GithubRelease) => boolean)
         rocket: number;
     } | undefined;
 } | null>;
+/**
+ * get a GitHub release by its tag
+ * @param tag
+ */
+declare const getReleaseByTag: (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 | 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;
+}>;
 /**
  * Return a function which checks if a release has at least one asset for a
  * specific chain type
@@ -408,5 +506,5 @@ declare const findLatestStableRelease: (chainType: string) => Promise<{
         rocket: number;
     } | undefined;
 } | null>;
-export { fetchReleasesPage, findLastRelease, findLatestRelease, findLatestStableRelease, hasAssetForChainType, isStableReleaseForChainType, };
+export { fetchReleasesPage, findLastRelease, findLatestRelease, findLatestStableRelease, getReleaseByTag, hasAssetForChainType, isStableReleaseForChainType, };
 //# 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;;;;;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,oBAAoB,EACpB,2BAA2B,GAC5B,CAAC"}
+{"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"}

package/dist/lib/utils/github.js

@@ -40,6 +40,19 @@ const findLastRelease = async (predicate = () => true) => {
     }
     return null;
 };
+/**
+ * get a GitHub release by its tag
+ * @param tag
+ */
+const getReleaseByTag = async (tag) => {
+    const octokit = new Octokit();
+    const release = await octokit.rest.repos.getReleaseByTag({
+        owner: ROSEN_BRIDGE_ORGANIZATION,
+        repo: CONTRACT_REPO_NAME,
+        tag,
+    });
+    return release.data;
+};
 /**
  * Return a function which checks if a release has at least one asset for a
  * specific chain type
@@ -65,5 +78,5 @@ const findLatestRelease = async (chainType) => findLastRelease(hasAssetForChainT
  * @param chainType
  */
 const findLatestStableRelease = async (chainType) => findLastRelease(isStableReleaseForChainType(chainType));
-export { fetchReleasesPage, findLastRelease, findLatestRelease, findLatestStableRelease, hasAssetForChainType, isStableReleaseForChainType, };
-//# sourceMappingURL=data:application/json;base64,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
+export { fetchReleasesPage, findLastRelease, findLatestRelease, findLatestStableRelease, getReleaseByTag, hasAssetForChainType, isStableReleaseForChainType, };
+//# sourceMappingURL=data:application/json;base64,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