@rosen-bridge/utils 0.0.1

package/.eslintignore

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

package/README.md

@@ -0,0 +1,25 @@
+# @rosen-bridge/utils
+
+## Table of contents
+
+- [Introduction](#introduction)
+- [Installation](#installation)
+
+## Introduction
+
+`@rosen-bridge/utils` contains some common utility functions and apis that are used
+inside other Rosen bridge projects.
+
+## Installation
+
+npm:
+
+```sh
+npm i @rosen-bridge/utils
+```
+
+yarn:
+
+```sh
+yarn add @rosen-bridge/utils
+```

package/babel.config.json

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

package/dist/lib/constants.d.ts

@@ -0,0 +1,4 @@
+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

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

package/dist/lib/constants.js

@@ -0,0 +1,4 @@
+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=

package/dist/lib/downloadRosenAssets.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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
+ */
+declare const downloadRosenAssets: (chainType: string, destinationPath: string, includePrereleases?: boolean, nameSuffix?: string) => Promise<void>;
+export default downloadRosenAssets;
+//# sourceMappingURL=downloadRosenAssets.d.ts.map

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

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

package/dist/lib/downloadRosenAssets.js

@@ -0,0 +1,43 @@
+import download from 'download';
+import { findLatestRelease, findLatestStableRelease } 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
+ */
+const downloadRosenAssets = async (chainType, destinationPath, includePrereleases = false, nameSuffix) => {
+    try {
+        const release = includePrereleases
+            ? await findLatestRelease(chainType)
+            : await findLatestStableRelease(chainType);
+        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),
+                    }))),
+            ]);
+        }
+        else {
+            console.error(`No release found for [${chainType}] chain type.`);
+            if (!includePrereleases) {
+                console.error('Please note that `includePrereleases` is set to false. There may be some matching releases in prereleases.');
+            }
+        }
+    }
+    catch (error) {
+        console.error(`An error occurred while trying to download Rosen assets: ${error}`);
+        if (error instanceof Error) {
+            console.error(error.stack);
+        }
+        throw new RosenAssetsDownloadError('', { cause: error });
+    }
+};
+export default downloadRosenAssets;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/error.d.ts

@@ -0,0 +1,4 @@
+declare class RosenAssetsDownloadError extends Error {
+}
+export { RosenAssetsDownloadError };
+//# sourceMappingURL=error.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../lib/error.ts"],"names":[],"mappings":"AAAA,cAAM,wBAAyB,SAAQ,KAAK;CAAG;AAE/C,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/lib/error.js

@@ -0,0 +1,4 @@
+class RosenAssetsDownloadError extends Error {
+}
+export { RosenAssetsDownloadError };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvZXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSx3QkFBeUIsU0FBUSxLQUFLO0NBQUc7QUFFL0MsT0FBTyxFQUFFLHdCQUF3QixFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJjbGFzcyBSb3NlbkFzc2V0c0Rvd25sb2FkRXJyb3IgZXh0ZW5kcyBFcnJvciB7fVxuXG5leHBvcnQgeyBSb3NlbkFzc2V0c0Rvd25sb2FkRXJyb3IgfTtcbiJdfQ==

package/dist/lib/index.d.ts

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

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

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

package/dist/lib/index.js

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

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

@@ -0,0 +1,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 {};
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/lib/types/index.js

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

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

@@ -0,0 +1,412 @@
+import { GithubRelease } from '../types';
+/**
+ * Fetch a page of releases from Github Api in each iteration until there are no
+ * more releases.
+ * @param pageSize
+ */
+declare function fetchReleasesPage(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 | 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;
+}[], void, unknown>;
+/**
+ * Find the last release matching the predicate. If all releases are iterated and
+ * no matching release is found, return null.
+ * @param predicate
+ */
+declare const findLastRelease: (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 | 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>;
+/**
+ * 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;
+/**
+ * Find latest release (prerelease or non-prerelease) having some asset matching
+ * a specific chain type
+ * @param chainType
+ */
+declare const findLatestRelease: (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 latest stable (that is, non-prerelease) release having some asset matching
+ * a specific chain type
+ * @param chainType
+ */
+declare const findLatestStableRelease: (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>;
+export { fetchReleasesPage, findLastRelease, findLatestRelease, findLatestStableRelease, hasAssetForChainType, isStableReleaseForChainType, };
+//# sourceMappingURL=github.d.ts.map

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

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

package/dist/lib/utils/github.js

@@ -0,0 +1,69 @@
+import { Octokit } from 'octokit';
+import { isValidAssetName } from './rosen';
+import { CONTRACT_REPO_NAME, 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 pageSize
+ */
+async function* fetchReleasesPage(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,
+            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 predicate
+ */
+const findLastRelease = async (predicate = () => true) => {
+    const releasesPageIterator = fetchReleasesPage();
+    for await (const releasesPage of releasesPageIterator) {
+        const foundRelease = releasesPage.find(predicate);
+        if (foundRelease) {
+            return foundRelease;
+        }
+    }
+    return null;
+};
+/**
+ * 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);
+/**
+ * Find latest release (prerelease or non-prerelease) having some asset matching
+ * a specific chain type
+ * @param chainType
+ */
+const findLatestRelease = async (chainType) => findLastRelease(hasAssetForChainType(chainType));
+/**
+ * Find latest stable (that is, non-prerelease) release having some asset matching
+ * a specific chain type
+ * @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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

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

@@ -0,0 +1,14 @@
+/**
+ * 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;
+/**
+ * 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