@hyperlane-xyz/registry 1.3.0 → 2.0.0

package/dist/registry/GithubRegistry.d.ts

@@ -1,8 +1,8 @@
 import type { Logger } from 'pino';
 import type { ChainMap, ChainMetadata, ChainName, WarpCoreConfig } from '@hyperlane-xyz/sdk';
-import { ChainAddresses } from '../types.js';
+import { ChainAddresses, WarpRouteConfigMap } from '../types.js';
 import { BaseRegistry } from './BaseRegistry.js';
-import { RegistryType, type ChainFiles, type IRegistry, type RegistryContent } from './IRegistry.js';
+import { ChainFiles, IRegistry, RegistryContent, RegistryType, UpdateChainParams, WarpRouteFilterParams } from './IRegistry.js';
 export interface GithubRegistryOptions {
     uri?: string;
     branch?: string;
@@ -21,26 +21,23 @@ export declare class GithubRegistry extends BaseRegistry implements IRegistry {
     readonly repoOwner: string;
     readonly repoName: string;
     constructor(options?: GithubRegistryOptions);
+    getUri(itemPath?: string): string;
     listRegistryContent(): Promise<RegistryContent>;
     getChains(): Promise<Array<ChainName>>;
     getMetadata(): Promise<ChainMap<ChainMetadata>>;
     getChainMetadata(chainName: ChainName): Promise<ChainMetadata | null>;
     getAddresses(): Promise<ChainMap<ChainAddresses>>;
     getChainAddresses(chainName: ChainName): Promise<ChainAddresses | null>;
-    addChain(_chains: {
-        chainName: ChainName;
-        metadata?: ChainMetadata;
-        addresses?: ChainAddresses;
-    }): Promise<void>;
-    updateChain(_chains: {
-        chainName: ChainName;
-        metadata?: ChainMetadata;
-        addresses?: ChainAddresses;
-    }): Promise<void>;
+    addChain(_chains: UpdateChainParams): Promise<void>;
+    updateChain(_chains: UpdateChainParams): Promise<void>;
     removeChain(_chains: ChainName): Promise<void>;
+    getWarpRoute(routeId: string): Promise<WarpCoreConfig | null>;
+    getWarpRoutes(filter?: WarpRouteFilterParams): Promise<WarpRouteConfigMap>;
     addWarpRoute(_config: WarpCoreConfig): Promise<void>;
     protected getRawContentUrl(path: string): string;
     protected fetchChainFiles<T>(fileName: keyof ChainFiles, chainNames?: ChainName[]): Promise<ChainMap<T>>;
-    protected fetchSingleChainFile<T>(fileName: keyof ChainFiles, chainName: ChainName): Promise<T | null>;
+    protected fetchChainFile<T>(fileName: keyof ChainFiles, chainName: ChainName): Promise<T | null>;
+    protected fetchYamlFiles<T>(urls: string[]): Promise<T[]>;
+    protected fetchYamlFile<T>(url: string): Promise<T>;
     protected fetch(url: string): Promise<Response>;
 }

package/dist/registry/GithubRegistry.js

@@ -1,8 +1,9 @@
 import { parse as yamlParse } from 'yaml';
-import { DEFAULT_GITHUB_REGISTRY, GITHUB_FETCH_CONCURRENCY_LIMIT } from '../consts.js';
-import { concurrentMap } from '../utils.js';
-import { BaseRegistry, CHAIN_FILE_REGEX } from './BaseRegistry.js';
+import { CHAIN_FILE_REGEX, DEFAULT_GITHUB_REGISTRY, GITHUB_FETCH_CONCURRENCY_LIMIT, WARP_ROUTE_CONFIG_FILE_REGEX, } from '../consts.js';
+import { concurrentMap, stripLeadingSlash } from '../utils.js';
+import { BaseRegistry } from './BaseRegistry.js';
 import { RegistryType, } from './IRegistry.js';
+import { filterWarpRoutesIds, warpRouteConfigPathToId } from './warp-utils.js';
 /**
  * A registry that uses a github repository as its data source.
  * Reads are performed via the github API and github's raw content URLs.
@@ -24,6 +25,11 @@ export class GithubRegistry extends BaseRegistry {
         this.repoOwner = pathSegments.at(-2);
         this.repoName = pathSegments.at(-1);
     }
+    getUri(itemPath) {
+        if (!itemPath)
+            return super.getUri();
+        return this.getRawContentUrl(itemPath);
+    }
     async listRegistryContent() {
         if (this.listContentCache)
             return this.listContentCache;
@@ -35,6 +41,7 @@ export class GithubRegistry extends BaseRegistry {
         const tree = result.tree;
         const chainPath = this.getChainsPath();
         const chains = {};
+        const warpRoutes = {};
         for (const node of tree) {
             if (CHAIN_FILE_REGEX.test(node.path)) {
                 const [_, chainName, fileName, extension] = node.path.match(CHAIN_FILE_REGEX);
@@ -42,9 +49,12 @@ export class GithubRegistry extends BaseRegistry {
                 // @ts-ignore allow dynamic key assignment
                 chains[chainName][fileName] = this.getRawContentUrl(`${chainPath}/${chainName}/${fileName}.${extension}`);
             }
-            // TODO add handling for deployment artifact files here too
+            if (WARP_ROUTE_CONFIG_FILE_REGEX.test(node.path)) {
+                const routeId = warpRouteConfigPathToId(node.path);
+                warpRoutes[routeId] = this.getRawContentUrl(node.path);
+            }
         }
-        return (this.listContentCache = { chains, deployments: {} });
+        return (this.listContentCache = { chains, deployments: { warpRoutes } });
     }
     async getChains() {
         const repoContents = await this.listRegistryContent();
@@ -60,7 +70,7 @@ export class GithubRegistry extends BaseRegistry {
     async getChainMetadata(chainName) {
         if (this.metadataCache?.[chainName])
             return this.metadataCache[chainName];
-        const data = await this.fetchSingleChainFile('metadata', chainName);
+        const data = await this.fetchChainFile('metadata', chainName);
         if (!data)
             return null;
         this.metadataCache = { ...this.metadataCache, [chainName]: data };
@@ -76,7 +86,7 @@ export class GithubRegistry extends BaseRegistry {
     async getChainAddresses(chainName) {
         if (this.addressCache?.[chainName])
             return this.addressCache[chainName];
-        const data = await this.fetchSingleChainFile('addresses', chainName);
+        const data = await this.fetchChainFile('addresses', chainName);
         if (!data)
             return null;
         this.addressCache = { ...this.addressCache, [chainName]: data };
@@ -91,10 +101,25 @@ export class GithubRegistry extends BaseRegistry {
     async removeChain(_chains) {
         throw new Error('TODO: Implement');
     }
+    async getWarpRoute(routeId) {
+        const repoContents = await this.listRegistryContent();
+        const routeConfigUrl = repoContents.deployments.warpRoutes[routeId];
+        if (!routeConfigUrl)
+            return null;
+        return this.fetchYamlFile(routeConfigUrl);
+    }
+    async getWarpRoutes(filter) {
+        const warpRoutes = (await this.listRegistryContent()).deployments.warpRoutes;
+        const { ids: routeIds, values: routeConfigUrls } = filterWarpRoutesIds(warpRoutes, filter);
+        const configs = await this.fetchYamlFiles(routeConfigUrls);
+        const idsWithConfigs = routeIds.map((id, i) => [id, configs[i]]);
+        return Object.fromEntries(idsWithConfigs);
+    }
     async addWarpRoute(_config) {
         throw new Error('TODO: Implement');
     }
     getRawContentUrl(path) {
+        path = stripLeadingSlash(path);
         return `https://raw.githubusercontent.com/${this.repoOwner}/${this.repoName}/${this.branch}/${path}`;
     }
     // Fetches all files of a particular type in parallel
@@ -108,17 +133,25 @@ export class GithubRegistry extends BaseRegistry {
                 acc[chainName] = fileUrl;
             return acc;
         }, {});
-        const results = await concurrentMap(GITHUB_FETCH_CONCURRENCY_LIMIT, Object.entries(fileUrls), async ([chainName, fileUrl]) => {
-            const response = await this.fetch(fileUrl);
-            const data = await response.text();
-            return [chainName, yamlParse(data)];
-        });
-        return Object.fromEntries(results);
-    }
-    async fetchSingleChainFile(fileName, chainName) {
+        const results = await this.fetchYamlFiles(Object.values(fileUrls));
+        const chainNameWithResult = chainNames.map((chainName, i) => [
+            chainName,
+            results[i],
+        ]);
+        return Object.fromEntries(chainNameWithResult);
+    }
+    async fetchChainFile(fileName, chainName) {
         const results = await this.fetchChainFiles(fileName, [chainName]);
         return results[chainName] ?? null;
     }
+    fetchYamlFiles(urls) {
+        return concurrentMap(GITHUB_FETCH_CONCURRENCY_LIMIT, urls, (url) => this.fetchYamlFile(url));
+    }
+    async fetchYamlFile(url) {
+        const response = await this.fetch(url);
+        const data = await response.text();
+        return yamlParse(data);
+    }
     async fetch(url) {
         this.logger.debug(`Fetching from github: ${url}`);
         const response = await fetch(url);

package/dist/registry/IRegistry.d.ts

@@ -1,5 +1,5 @@
 import type { ChainMap, ChainMetadata, ChainName, WarpCoreConfig } from '@hyperlane-xyz/sdk';
-import type { ChainAddresses, MaybePromise } from '../types.js';
+import { ChainAddresses, MaybePromise, WarpRouteConfigMap, WarpRouteId } from '../types.js';
 export interface ChainFiles {
     metadata?: string;
     addresses?: string;
@@ -7,7 +7,18 @@ export interface ChainFiles {
 }
 export interface RegistryContent {
     chains: ChainMap<ChainFiles>;
-    deployments: {};
+    deployments: {
+        warpRoutes: Record<WarpRouteId, string>;
+    };
+}
+export interface UpdateChainParams {
+    chainName: ChainName;
+    metadata?: ChainMetadata;
+    addresses?: ChainAddresses;
+}
+export interface WarpRouteFilterParams {
+    symbol?: string;
+    chainName?: ChainName;
 }
 export declare enum RegistryType {
     Github = "github",
@@ -18,6 +29,7 @@ export declare enum RegistryType {
 export interface IRegistry {
     type: RegistryType;
     uri: string;
+    getUri(itemPath?: string): string;
     listRegistryContent(): MaybePromise<RegistryContent>;
     getChains(): MaybePromise<Array<ChainName>>;
     getMetadata(): MaybePromise<ChainMap<ChainMetadata>>;
@@ -25,17 +37,11 @@ export interface IRegistry {
     getAddresses(): MaybePromise<ChainMap<ChainAddresses>>;
     getChainAddresses(chainName: ChainName): MaybePromise<ChainAddresses | null>;
     getChainLogoUri(chainName: ChainName): Promise<string | null>;
-    addChain(chain: {
-        chainName: ChainName;
-        metadata?: ChainMetadata;
-        addresses?: ChainAddresses;
-    }): MaybePromise<void>;
-    updateChain(chain: {
-        chainName: ChainName;
-        metadata?: ChainMetadata;
-        addresses?: ChainAddresses;
-    }): MaybePromise<void>;
+    addChain(chain: UpdateChainParams): MaybePromise<void>;
+    updateChain(chain: UpdateChainParams): MaybePromise<void>;
     removeChain(chain: ChainName): MaybePromise<void>;
+    getWarpRoute(routeId: string): MaybePromise<WarpCoreConfig | null>;
+    getWarpRoutes(filter?: WarpRouteFilterParams): MaybePromise<WarpRouteConfigMap>;
     addWarpRoute(config: WarpCoreConfig): MaybePromise<void>;
     merge(otherRegistry: IRegistry): IRegistry;
 }

package/dist/registry/MergedRegistry.d.ts

@@ -1,7 +1,7 @@
 import type { Logger } from 'pino';
 import type { ChainMap, ChainMetadata, ChainName, WarpCoreConfig } from '@hyperlane-xyz/sdk';
-import { ChainAddresses } from '../types.js';
-import { IRegistry, RegistryContent, RegistryType } from './IRegistry.js';
+import { ChainAddresses, WarpRouteConfigMap, WarpRouteId } from '../types.js';
+import { IRegistry, RegistryContent, RegistryType, UpdateChainParams, WarpRouteFilterParams } from './IRegistry.js';
 export interface MergedRegistryOptions {
     registries: Array<IRegistry>;
     logger?: Logger;
@@ -18,6 +18,7 @@ export declare class MergedRegistry implements IRegistry {
     readonly registries: Array<IRegistry>;
     protected readonly logger: Logger;
     constructor({ registries, logger }: MergedRegistryOptions);
+    getUri(): string;
     listRegistryContent(): Promise<RegistryContent>;
     getChains(): Promise<Array<ChainName>>;
     getMetadata(): Promise<ChainMap<ChainMetadata>>;
@@ -25,17 +26,11 @@ export declare class MergedRegistry implements IRegistry {
     getAddresses(): Promise<ChainMap<ChainAddresses>>;
     getChainAddresses(chainName: ChainName): Promise<ChainAddresses | null>;
     getChainLogoUri(chainName: ChainName): Promise<string | null>;
-    addChain(chain: {
-        chainName: ChainName;
-        metadata?: ChainMetadata;
-        addresses?: ChainAddresses;
-    }): Promise<void>;
-    updateChain(chain: {
-        chainName: ChainName;
-        metadata?: ChainMetadata;
-        addresses?: ChainAddresses;
-    }): Promise<void>;
+    addChain(chain: UpdateChainParams): Promise<void>;
+    updateChain(chain: UpdateChainParams): Promise<void>;
     removeChain(chain: ChainName): Promise<void>;
+    getWarpRoute(id: WarpRouteId): Promise<WarpCoreConfig | null>;
+    getWarpRoutes(filter?: WarpRouteFilterParams): Promise<WarpRouteConfigMap>;
     addWarpRoute(config: WarpCoreConfig): Promise<void>;
     protected multiRegistryRead<R>(readFn: (registry: IRegistry) => Promise<R> | R): Promise<(Awaited<R> | Awaited<R>)[]>;
     protected multiRegistryWrite(writeFn: (registry: IRegistry) => Promise<void>, logMsg: string): Promise<void>;

package/dist/registry/MergedRegistry.js

@@ -1,5 +1,5 @@
 import { objMerge } from '../utils.js';
-import { RegistryType } from './IRegistry.js';
+import { RegistryType, } from './IRegistry.js';
 /**
  * A registry that accepts multiple sub-registries.
  * Read methods are performed on all sub-registries and the results are merged.
@@ -18,11 +18,16 @@ export class MergedRegistry {
         // @ts-ignore
         this.logger = logger || console;
     }
+    getUri() {
+        throw new Error('getUri method not applicable to MergedRegistry');
+    }
     async listRegistryContent() {
         const results = await this.multiRegistryRead((r) => r.listRegistryContent());
         return results.reduce((acc, content) => objMerge(acc, content), {
             chains: {},
-            deployments: {},
+            deployments: {
+                warpRoutes: {},
+            },
         });
     }
     async getChains() {
@@ -55,6 +60,14 @@ export class MergedRegistry {
     async removeChain(chain) {
         return this.multiRegistryWrite(async (registry) => await registry.removeChain(chain), `removing chain ${chain}`);
     }
+    async getWarpRoute(id) {
+        const results = await this.multiRegistryRead((r) => r.getWarpRoute(id));
+        return results.find((r) => !!r) || null;
+    }
+    async getWarpRoutes(filter) {
+        const results = await this.multiRegistryRead((r) => r.getWarpRoutes(filter));
+        return results.reduce((acc, content) => objMerge(acc, content), {});
+    }
     async addWarpRoute(config) {
         return this.multiRegistryWrite(async (registry) => await registry.addWarpRoute(config), 'adding warp route');
     }

package/dist/registry/PartialRegistry.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from 'pino';
 import type { ChainMap, ChainMetadata, ChainName, WarpCoreConfig } from '@hyperlane-xyz/sdk';
-import { ChainAddresses } from '../types.js';
+import { ChainAddresses, DeepPartial, WarpRouteId } from '../types.js';
 import { IRegistry, RegistryContent, RegistryType } from './IRegistry.js';
 import { SynchronousRegistry } from './SynchronousRegistry.js';
 /**
@@ -8,20 +8,23 @@ import { SynchronousRegistry } from './SynchronousRegistry.js';
  * Useful for merging with other registries force overrides of subsets of data.
  */
 export interface PartialRegistryOptions {
-    chainMetadata?: ChainMap<Partial<ChainMetadata>>;
-    chainAddresses?: ChainMap<Partial<ChainAddresses>>;
+    chainMetadata?: ChainMap<DeepPartial<ChainMetadata>>;
+    chainAddresses?: ChainMap<DeepPartial<ChainAddresses>>;
+    warpRoutes?: Array<DeepPartial<WarpCoreConfig>>;
     logger?: Logger;
 }
 export declare class PartialRegistry extends SynchronousRegistry implements IRegistry {
     readonly type = RegistryType.Partial;
-    chainMetadata: ChainMap<Partial<ChainMetadata>>;
-    chainAddresses: ChainMap<Partial<ChainAddresses>>;
-    constructor({ chainMetadata, chainAddresses, logger }: PartialRegistryOptions);
+    chainMetadata: ChainMap<DeepPartial<ChainMetadata>>;
+    chainAddresses: ChainMap<DeepPartial<ChainAddresses>>;
+    warpRoutes: Array<DeepPartial<WarpCoreConfig>>;
+    constructor({ chainMetadata, chainAddresses, warpRoutes, logger }: PartialRegistryOptions);
     listRegistryContent(): RegistryContent;
     getMetadata(): ChainMap<ChainMetadata>;
     getAddresses(): ChainMap<ChainAddresses>;
     removeChain(chainName: ChainName): void;
     addWarpRoute(_config: WarpCoreConfig): void;
+    protected getWarpRoutesForIds(ids: WarpRouteId[]): WarpCoreConfig[];
     protected createOrUpdateChain(chain: {
         chainName: ChainName;
         metadata?: ChainMetadata;

package/dist/registry/PartialRegistry.js

@@ -1,14 +1,17 @@
 import { RegistryType } from './IRegistry.js';
 import { SynchronousRegistry } from './SynchronousRegistry.js';
+import { warpRouteConfigToId } from './warp-utils.js';
 const PARTIAL_URI_PLACEHOLDER = '__partial_registry__';
 export class PartialRegistry extends SynchronousRegistry {
     type = RegistryType.Partial;
     chainMetadata;
     chainAddresses;
-    constructor({ chainMetadata, chainAddresses, logger }) {
+    warpRoutes;
+    constructor({ chainMetadata, chainAddresses, warpRoutes, logger }) {
         super({ uri: PARTIAL_URI_PLACEHOLDER, logger });
         this.chainMetadata = chainMetadata || {};
         this.chainAddresses = chainAddresses || {};
+        this.warpRoutes = warpRoutes || [];
     }
     listRegistryContent() {
         const chains = {};
@@ -20,9 +23,17 @@ export class PartialRegistry extends SynchronousRegistry {
             chains[c] ||= {};
             chains[c].addresses = PARTIAL_URI_PLACEHOLDER;
         });
+        const warpRoutes = this.warpRoutes.reduce((acc, r) => {
+            // Cast is useful because this handles partials and safe because the fn validates data
+            const id = warpRouteConfigToId(r);
+            acc[id] = PARTIAL_URI_PLACEHOLDER;
+            return acc;
+        }, {});
         return {
             chains,
-            deployments: {},
+            deployments: {
+                warpRoutes,
+            },
         };
     }
     getMetadata() {
@@ -41,6 +52,12 @@ export class PartialRegistry extends SynchronousRegistry {
     addWarpRoute(_config) {
         throw new Error('Method not implemented.');
     }
+    getWarpRoutesForIds(ids) {
+        return this.warpRoutes.filter((r) => {
+            const id = warpRouteConfigToId(r);
+            return ids.includes(id);
+        });
+    }
     createOrUpdateChain(chain) {
         if (chain.metadata)
             this.chainMetadata[chain.chainName] = chain.metadata;

package/dist/registry/SynchronousRegistry.d.ts

@@ -1,7 +1,7 @@
 import type { ChainMap, ChainMetadata, ChainName, WarpCoreConfig } from '@hyperlane-xyz/sdk';
-import { ChainAddresses } from '../types.js';
+import { ChainAddresses, WarpRouteConfigMap, WarpRouteId } from '../types.js';
 import { BaseRegistry } from './BaseRegistry.js';
-import { IRegistry, RegistryContent } from './IRegistry.js';
+import { IRegistry, RegistryContent, UpdateChainParams, WarpRouteFilterParams } from './IRegistry.js';
 /**
  * Shared code for sync registries like the FileSystem and Partial registries.
  * This is required because of the inconsistent sync/async methods across registries.
@@ -14,21 +14,12 @@ export declare abstract class SynchronousRegistry extends BaseRegistry implement
     getChainMetadata(chainName: ChainName): ChainMetadata | null;
     abstract getAddresses(): ChainMap<ChainAddresses>;
     getChainAddresses(chainName: ChainName): ChainAddresses | null;
-    addChain(chain: {
-        chainName: ChainName;
-        metadata?: ChainMetadata;
-        addresses?: ChainAddresses;
-    }): void;
-    updateChain(chain: {
-        chainName: ChainName;
-        metadata?: ChainMetadata;
-        addresses?: ChainAddresses;
-    }): void;
+    addChain(chain: UpdateChainParams): void;
+    updateChain(chain: UpdateChainParams): void;
     removeChain(chainName: ChainName): void;
+    getWarpRoute(routeId: string): WarpCoreConfig | null;
+    getWarpRoutes(filter?: WarpRouteFilterParams): WarpRouteConfigMap;
     abstract addWarpRoute(config: WarpCoreConfig): void;
-    protected abstract createOrUpdateChain(chain: {
-        chainName: ChainName;
-        metadata?: ChainMetadata;
-        addresses?: ChainAddresses;
-    }): void;
+    protected abstract createOrUpdateChain(chain: UpdateChainParams): void;
+    protected abstract getWarpRoutesForIds(ids: WarpRouteId[]): WarpCoreConfig[];
 }

package/dist/registry/SynchronousRegistry.js

@@ -1,4 +1,5 @@
 import { BaseRegistry } from './BaseRegistry.js';
+import { filterWarpRoutesIds } from './warp-utils.js';
 /**
  * Shared code for sync registries like the FileSystem and Partial registries.
  * This is required because of the inconsistent sync/async methods across registries.
@@ -38,4 +39,14 @@ export class SynchronousRegistry extends BaseRegistry {
         if (this.addressCache?.[chainName])
             delete this.addressCache[chainName];
     }
+    getWarpRoute(routeId) {
+        return this.getWarpRoutesForIds([routeId])[0] || null;
+    }
+    getWarpRoutes(filter) {
+        const warpRoutes = this.listRegistryContent().deployments.warpRoutes;
+        const { ids: routeIds } = filterWarpRoutesIds(warpRoutes, filter);
+        const configs = this.getWarpRoutesForIds(routeIds);
+        const idsWithConfigs = routeIds.map((id, i) => [id, configs[i]]);
+        return Object.fromEntries(idsWithConfigs);
+    }
 }

package/dist/registry/warp-utils.d.ts

@@ -1,3 +1,32 @@
-import type { ChainMap, WarpCoreConfig } from '@hyperlane-xyz/sdk';
-import { ChainAddresses } from '../types.js';
+import type { ChainMap, ChainName, WarpCoreConfig } from '@hyperlane-xyz/sdk';
+import { ChainAddresses, WarpRouteId } from '../types.js';
+import { WarpRouteFilterParams } from './IRegistry.js';
+/**
+ * Converts from a full warp config to a map of chain addresses.
+ */
 export declare function warpConfigToWarpAddresses(config: WarpCoreConfig): ChainMap<ChainAddresses>;
+/**
+ * Gets a warp route ID from a warp route config path.
+ * @param configRelativePath A relative path in the deployments dir
+ *    (e.g. `warp_routes/USDC/ethereum-arbitrum-config.yaml`)
+ */
+export declare function warpRouteConfigPathToId(configRelativePath: string): WarpRouteId;
+/**
+ * Gets a warp route ID from a warp route config.
+ * This uses the first symbol in the lift. Situations where a config contains multiple
+ * symbols are not officially supported yet.
+ */
+export declare function warpRouteConfigToId(config: WarpCoreConfig): WarpRouteId;
+export declare function createWarpRouteConfigId(tokenSymbol: string, chains: ChainName[]): WarpRouteId;
+export declare function parseWarpRouteConfigId(routeId: WarpRouteId): {
+    tokenSymbol: string;
+    chainNames: ChainName[];
+};
+/**
+ * Filters a list of warp route IDs based on the provided filter params.
+ */
+export declare function filterWarpRoutesIds<T>(idMap: Record<WarpRouteId, T>, filter?: WarpRouteFilterParams): {
+    ids: WarpRouteId[];
+    values: T[];
+    idMap: Record<WarpRouteId, T>;
+};

package/dist/registry/warp-utils.js

@@ -1,3 +1,7 @@
+import { WARP_ROUTE_CONFIG_FILE_REGEX } from '../consts.js';
+/**
+ * Converts from a full warp config to a map of chain addresses.
+ */
 export function warpConfigToWarpAddresses(config) {
     return config.tokens.reduce((acc, token) => {
         const addressKey = getWarpAddressKey(token.standard);
@@ -20,3 +24,55 @@ function getWarpAddressKey(standard) {
     else
         return null;
 }
+/**
+ * Gets a warp route ID from a warp route config path.
+ * @param configRelativePath A relative path in the deployments dir
+ *    (e.g. `warp_routes/USDC/ethereum-arbitrum-config.yaml`)
+ */
+export function warpRouteConfigPathToId(configRelativePath) {
+    const matches = configRelativePath.match(WARP_ROUTE_CONFIG_FILE_REGEX);
+    if (!matches || matches.length < 3)
+        throw new Error(`Invalid warp route config path: ${configRelativePath}`);
+    const [_, tokenSymbol, chains] = matches;
+    return createWarpRouteConfigId(tokenSymbol, chains.split('-'));
+}
+/**
+ * Gets a warp route ID from a warp route config.
+ * This uses the first symbol in the lift. Situations where a config contains multiple
+ * symbols are not officially supported yet.
+ */
+export function warpRouteConfigToId(config) {
+    if (!config?.tokens?.length)
+        throw new Error('Cannot generate ID for empty warp config');
+    const tokenSymbol = config.tokens[0].symbol;
+    if (!tokenSymbol)
+        throw new Error('Cannot generate warp config ID without a token symbol');
+    const chains = config.tokens.map((token) => token.chainName);
+    return createWarpRouteConfigId(tokenSymbol, chains);
+}
+export function createWarpRouteConfigId(tokenSymbol, chains) {
+    const sortedChains = [...chains].sort();
+    return `${tokenSymbol}/${sortedChains.join('-')}`;
+}
+export function parseWarpRouteConfigId(routeId) {
+    const [tokenSymbol, chains] = routeId.split('/');
+    return { tokenSymbol, chainNames: chains.split('-') };
+}
+/**
+ * Filters a list of warp route IDs based on the provided filter params.
+ */
+export function filterWarpRoutesIds(idMap, filter) {
+    const filterChainName = filter?.chainName?.toLowerCase();
+    const filterSymbol = filter?.symbol?.toLowerCase();
+    const filtered = Object.entries(idMap).filter(([routeId]) => {
+        const { tokenSymbol, chainNames } = parseWarpRouteConfigId(routeId);
+        if (filterSymbol && tokenSymbol.toLowerCase() !== filterSymbol)
+            return false;
+        if (filterChainName && !chainNames.includes(filterChainName))
+            return false;
+        return true;
+    });
+    const ids = filtered.map(([routeId]) => routeId);
+    const values = filtered.map(([, value]) => value);
+    return { ids, values, idMap: Object.fromEntries(filtered) };
+}

package/dist/types.d.ts

@@ -1,4 +1,10 @@
+import type { WarpCoreConfig } from '@hyperlane-xyz/sdk';
 import { z } from 'zod';
 export type MaybePromise<T> = T | Promise<T> | PromiseLike<T>;
 export declare const ChainAddressesSchema: z.ZodRecord<z.ZodString, z.ZodString>;
 export type ChainAddresses = z.infer<typeof ChainAddressesSchema>;
+export type WarpRouteId = string;
+export type WarpRouteConfigMap = Record<WarpRouteId, WarpCoreConfig>;
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;

package/dist/utils.d.ts

@@ -1,4 +1,5 @@
 export declare function toYamlString(data: any, prefix?: string): string;
+export declare function stripLeadingSlash(path: string): string;
 export declare function concurrentMap<A, B>(concurrency: number, xs: A[], mapFn: (val: A, idx: number) => Promise<B>): Promise<B[]>;
 export declare function isObject(item: any): any;
 export declare function objMerge(a: Record<string, any>, b: Record<string, any>, max_depth?: number): any;

package/dist/utils.js

@@ -3,6 +3,9 @@ export function toYamlString(data, prefix) {
     const yamlString = stringify(data);
     return prefix ? `${prefix}\n${yamlString}` : yamlString;
 }
+export function stripLeadingSlash(path) {
+    return path.startsWith('/') || path.startsWith('\\') ? path.slice(1) : path;
+}
 export async function concurrentMap(concurrency, xs, mapFn) {
     let res = [];
     for (let i = 0; i < xs.length; i += concurrency) {

package/dist/warpRouteConfigs.d.ts

@@ -0,0 +1,48 @@
+export declare const warpRouteConfigs: Record<string, {
+    tokens: {
+        symbol: string;
+        name: string;
+        decimals: number;
+        chainName: string;
+        standard: import("@hyperlane-xyz/sdk").TokenStandard;
+        addressOrDenom: string | null;
+        collateralAddressOrDenom?: string | undefined;
+        igpTokenAddressOrDenom?: string | undefined;
+        logoURI?: string | undefined;
+        connections?: ({
+            token: string;
+            type?: import("@hyperlane-xyz/sdk").TokenConnectionType.Hyperlane | undefined;
+        } | {
+            type: import("@hyperlane-xyz/sdk").TokenConnectionType.Ibc;
+            token: string;
+            sourcePort: string;
+            sourceChannel: string;
+        } | {
+            type: import("@hyperlane-xyz/sdk").TokenConnectionType.IbcHyperlane;
+            token: string;
+            sourcePort: string;
+            sourceChannel: string;
+            intermediateChainName: string;
+            intermediateIbcDenom: string;
+            intermediateRouterAddress: string;
+        })[] | undefined;
+    }[];
+    options?: {
+        localFeeConstants?: {
+            amount: string | number | bigint;
+            origin: string;
+            destination: string;
+            addressOrDenom?: string | undefined;
+        }[] | undefined;
+        interchainFeeConstants?: {
+            amount: string | number | bigint;
+            origin: string;
+            destination: string;
+            addressOrDenom?: string | undefined;
+        }[] | undefined;
+        routeBlacklist?: {
+            origin: string;
+            destination: string;
+        }[] | undefined;
+    } | undefined;
+}>;