@hyperlane-xyz/registry 6.10.0 → 6.12.0-http.0

package/dist/registry/FileSystemRegistry.js-e

@@ -0,0 +1,125 @@
+import fs from 'fs';
+import path from 'path';
+import { parse as yamlParse } from 'yaml';
+import { SCHEMA_REF } from '../consts.js';
+import { ChainAddressesSchema } from '../types.js';
+import { toYamlString } from '../utils.js';
+import { CHAIN_FILE_REGEX } from './BaseRegistry.js';
+import { RegistryType, } from './IRegistry.js';
+import { SynchronousRegistry } from './SynchronousRegistry.js';
+import { warpConfigToWarpAddresses } from './warp-utils.js';
+/**
+ * A registry that uses a local file system path as its data source.
+ * Requires file system access so it cannot be used in the browser.
+ */
+export class FileSystemRegistry extends SynchronousRegistry {
+    type = RegistryType.FileSystem;
+    constructor(options) {
+        super(options);
+    }
+    listRegistryContent() {
+        if (this.listContentCache)
+            return this.listContentCache;
+        const chainFileList = this.listFiles(path.join(this.uri, this.getChainsPath()));
+        const chains = {};
+        for (const chainFilePath of chainFileList) {
+            const matches = chainFilePath.match(CHAIN_FILE_REGEX);
+            if (!matches)
+                continue;
+            const [_, chainName, fileName] = matches;
+            chains[chainName] ??= {};
+            // @ts-ignore allow dynamic key assignment
+            chains[chainName][fileName] = chainFilePath;
+        }
+        // TODO add handling for deployment artifact files here too
+        return (this.listContentCache = { chains, deployments: {} });
+    }
+    getMetadata() {
+        if (this.metadataCache)
+            return this.metadataCache;
+        const chainMetadata = {};
+        const repoContents = this.listRegistryContent();
+        for (const [chainName, chainFiles] of Object.entries(repoContents.chains)) {
+            if (!chainFiles.metadata)
+                continue;
+            const data = fs.readFileSync(chainFiles.metadata, 'utf8');
+            chainMetadata[chainName] = yamlParse(data);
+        }
+        return (this.metadataCache = chainMetadata);
+    }
+    getAddresses() {
+        if (this.addressCache)
+            return this.addressCache;
+        const chainAddresses = {};
+        const repoContents = this.listRegistryContent();
+        for (const [chainName, chainFiles] of Object.entries(repoContents.chains)) {
+            if (!chainFiles.addresses)
+                continue;
+            const data = fs.readFileSync(chainFiles.addresses, 'utf8');
+            chainAddresses[chainName] = ChainAddressesSchema.parse(yamlParse(data));
+        }
+        return (this.addressCache = chainAddresses);
+    }
+    removeChain(chainName) {
+        const chainFiles = this.listRegistryContent().chains[chainName];
+        super.removeChain(chainName);
+        this.removeFiles(Object.values(chainFiles));
+    }
+    listFiles(dirPath) {
+        if (!fs.existsSync(dirPath))
+            return [];
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        const filePaths = entries.map((entry) => {
+            const fullPath = path.join(dirPath, entry.name);
+            return entry.isDirectory() ? this.listFiles(fullPath) : fullPath;
+        });
+        return filePaths.flat();
+    }
+    addWarpRoute(config) {
+        let { configPath, addressesPath } = this.getWarpArtifactsPaths(config);
+        configPath = path.join(this.uri, configPath);
+        this.createFile({ filePath: configPath, data: toYamlString(config, SCHEMA_REF) });
+        addressesPath = path.join(this.uri, addressesPath);
+        const addresses = warpConfigToWarpAddresses(config);
+        this.createFile({ filePath: addressesPath, data: toYamlString(addresses) });
+    }
+    createOrUpdateChain(chain) {
+        if (!chain.metadata && !chain.addresses)
+            throw new Error(`Chain ${chain.chainName} must have metadata or addresses, preferably both`);
+        const currentChains = this.listRegistryContent();
+        if (!currentChains.chains[chain.chainName]) {
+            this.logger.debug(`Chain ${chain.chainName} not found in registry, adding it now`);
+        }
+        if (chain.metadata) {
+            this.createChainFile(chain.chainName, 'metadata', chain.metadata, this.getMetadata(), SCHEMA_REF);
+        }
+        if (chain.addresses) {
+            this.createChainFile(chain.chainName, 'addresses', chain.addresses, this.getAddresses());
+        }
+    }
+    createChainFile(chainName, fileName, data, cache, prefix) {
+        const filePath = path.join(this.uri, this.getChainsPath(), chainName, `${fileName}.yaml`);
+        const currentChains = this.listRegistryContent().chains;
+        currentChains[chainName] ||= {};
+        currentChains[chainName][fileName] = filePath;
+        cache[chainName] = data;
+        this.createFile({ filePath, data: toYamlString(data, prefix) });
+    }
+    createFile(file) {
+        const dirPath = path.dirname(file.filePath);
+        if (!fs.existsSync(dirPath))
+            fs.mkdirSync(dirPath, {
+                recursive: true,
+            });
+        fs.writeFileSync(file.filePath, file.data);
+    }
+    removeFiles(filePaths) {
+        for (const filePath of filePaths) {
+            fs.unlinkSync(filePath);
+        }
+        const parentDir = path.dirname(filePaths[0]);
+        if (fs.readdirSync(parentDir).length === 0) {
+            fs.rmdirSync(parentDir);
+        }
+    }
+}

package/dist/registry/GithubRegistry.d.ts-e

@@ -0,0 +1,46 @@
+import type { Logger } from 'pino';
+import type { ChainMap, ChainMetadata, ChainName, WarpCoreConfig } from '@hyperlane-xyz/sdk';
+import { ChainAddresses } from '../types.js';
+import { BaseRegistry } from './BaseRegistry.js';
+import { RegistryType, type ChainFiles, type IRegistry, type RegistryContent } from './IRegistry.js';
+export interface GithubRegistryOptions {
+    uri?: string;
+    branch?: string;
+    authToken?: string;
+    logger?: Logger;
+}
+/**
+ * A registry that uses a github repository as its data source.
+ * Reads are performed via the github API and github's raw content URLs.
+ * Writes are not yet supported (TODO)
+ */
+export declare class GithubRegistry extends BaseRegistry implements IRegistry {
+    readonly type = RegistryType.Github;
+    readonly url: URL;
+    readonly branch: string;
+    readonly repoOwner: string;
+    readonly repoName: string;
+    constructor(options?: GithubRegistryOptions);
+    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>;
+    removeChain(_chains: ChainName): Promise<void>;
+    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 fetch(url: string): Promise<Response>;
+}

package/dist/registry/GithubRegistry.js-e

@@ -0,0 +1,129 @@
+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 { RegistryType, } from './IRegistry.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.
+ * Writes are not yet supported (TODO)
+ */
+export class GithubRegistry extends BaseRegistry {
+    type = RegistryType.Github;
+    url;
+    branch;
+    repoOwner;
+    repoName;
+    constructor(options = {}) {
+        super({ uri: options.uri ?? DEFAULT_GITHUB_REGISTRY, logger: options.logger });
+        this.url = new URL(this.uri);
+        this.branch = options.branch ?? 'main';
+        const pathSegments = this.url.pathname.split('/');
+        if (pathSegments.length < 2)
+            throw new Error('Invalid github url');
+        this.repoOwner = pathSegments.at(-2);
+        this.repoName = pathSegments.at(-1);
+    }
+    async listRegistryContent() {
+        if (this.listContentCache)
+            return this.listContentCache;
+        // This uses the tree API instead of the simpler directory list API because it
+        // allows us to get a full view of all files in one request.
+        const apiUrl = `https://api.github.com/repos/${this.repoOwner}/${this.repoName}/git/trees/${this.branch}?recursive=true`;
+        const response = await this.fetch(apiUrl);
+        const result = await response.json();
+        const tree = result.tree;
+        const chainPath = this.getChainsPath();
+        const chains = {};
+        for (const node of tree) {
+            if (CHAIN_FILE_REGEX.test(node.path)) {
+                const [_, chainName, fileName, extension] = node.path.match(CHAIN_FILE_REGEX);
+                chains[chainName] ??= {};
+                // @ts-ignore allow dynamic key assignment
+                chains[chainName][fileName] = this.getRawContentUrl(`${chainPath}/${chainName}/${fileName}.${extension}`);
+            }
+            // TODO add handling for deployment artifact files here too
+        }
+        return (this.listContentCache = { chains, deployments: {} });
+    }
+    async getChains() {
+        const repoContents = await this.listRegistryContent();
+        return Object.keys(repoContents.chains);
+    }
+    async getMetadata() {
+        if (this.metadataCache && this.isMetadataCacheFull)
+            return this.metadataCache;
+        const chainMetadata = await this.fetchChainFiles('metadata');
+        this.isMetadataCacheFull = true;
+        return (this.metadataCache = chainMetadata);
+    }
+    async getChainMetadata(chainName) {
+        if (this.metadataCache?.[chainName])
+            return this.metadataCache[chainName];
+        const data = await this.fetchSingleChainFile('metadata', chainName);
+        if (!data)
+            return null;
+        this.metadataCache = { ...this.metadataCache, [chainName]: data };
+        return data;
+    }
+    async getAddresses() {
+        if (this.addressCache && this.isAddressCacheFull)
+            return this.addressCache;
+        const chainAddresses = await this.fetchChainFiles('addresses');
+        this.isAddressCacheFull = true;
+        return (this.addressCache = chainAddresses);
+    }
+    async getChainAddresses(chainName) {
+        if (this.addressCache?.[chainName])
+            return this.addressCache[chainName];
+        const data = await this.fetchSingleChainFile('addresses', chainName);
+        if (!data)
+            return null;
+        this.addressCache = { ...this.addressCache, [chainName]: data };
+        return data;
+    }
+    async addChain(_chains) {
+        throw new Error('TODO: Implement');
+    }
+    async updateChain(_chains) {
+        throw new Error('TODO: Implement');
+    }
+    async removeChain(_chains) {
+        throw new Error('TODO: Implement');
+    }
+    async addWarpRoute(_config) {
+        throw new Error('TODO: Implement');
+    }
+    getRawContentUrl(path) {
+        return `https://raw.githubusercontent.com/${this.repoOwner}/${this.repoName}/${this.branch}/${path}`;
+    }
+    // Fetches all files of a particular type in parallel
+    // Defaults to all known chains if chainNames is not provided
+    async fetchChainFiles(fileName, chainNames) {
+        const repoContents = await this.listRegistryContent();
+        chainNames ||= Object.keys(repoContents.chains);
+        const fileUrls = chainNames.reduce((acc, chainName) => {
+            const fileUrl = repoContents.chains[chainName][fileName];
+            if (fileUrl)
+                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.fetchChainFiles(fileName, [chainName]);
+        return results[chainName] ?? null;
+    }
+    async fetch(url) {
+        this.logger.debug(`Fetching from github: ${url}`);
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(`Failed to fetch from github: ${response.status} ${response.statusText}`);
+        return response;
+    }
+}

package/dist/registry/HttpClientRegistry.d.ts

@@ -0,0 +1,25 @@
+import { ChainMap, ChainMetadata, ChainName, WarpCoreConfig } from '@hyperlane-xyz/sdk';
+import { ChainAddresses, MaybePromise, WarpRouteConfigMap } from '../types.js';
+import { IRegistry, RegistryContent, RegistryType, UpdateChainParams, WarpRouteFilterParams } from './IRegistry.js';
+export declare class HttpClientRegistry implements IRegistry {
+    private baseUrl;
+    constructor(baseUrl?: string);
+    getChainMetadata(chainName: ChainName): MaybePromise<ChainMetadata>;
+    updateChain(update: UpdateChainParams): MaybePromise<void>;
+    get type(): RegistryType;
+    get uri(): string;
+    getUri(itemPath?: string): string;
+    listRegistryContent(): MaybePromise<RegistryContent>;
+    getChains(): MaybePromise<Array<ChainName>>;
+    getMetadata(): MaybePromise<ChainMap<ChainMetadata>>;
+    getAddresses(): MaybePromise<ChainMap<ChainAddresses>>;
+    getChainAddresses(chainName: ChainName): MaybePromise<ChainAddresses | null>;
+    getChainLogoUri(chainName: ChainName): Promise<string | null>;
+    addChain(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;
+    private fetchJson;
+}

package/dist/registry/HttpClientRegistry.js

@@ -0,0 +1,74 @@
+export class HttpClientRegistry {
+    baseUrl;
+    constructor(baseUrl = 'http://localhost:3000/api') {
+        this.baseUrl = baseUrl;
+    }
+    getChainMetadata(chainName) {
+        return this.fetchJson(`/metadata/${chainName}`);
+    }
+    updateChain(update) {
+        return this.fetchJson(`/metadata/${update.chainName}`, {
+            method: 'POST',
+            body: JSON.stringify(update.metadata),
+        });
+    }
+    get type() {
+        throw new Error('Method not implemented.');
+    }
+    get uri() {
+        throw new Error('Method not implemented.');
+    }
+    getUri(itemPath) {
+        throw new Error('Method not implemented.');
+    }
+    listRegistryContent() {
+        throw new Error('Method not implemented.');
+    }
+    getChains() {
+        throw new Error('Method not implemented.');
+    }
+    getMetadata() {
+        throw new Error('Method not implemented.');
+    }
+    getAddresses() {
+        throw new Error('Method not implemented.');
+    }
+    getChainAddresses(chainName) {
+        throw new Error('Method not implemented.');
+    }
+    getChainLogoUri(chainName) {
+        throw new Error('Method not implemented.');
+    }
+    addChain(chain) {
+        throw new Error('Method not implemented.');
+    }
+    removeChain(chain) {
+        throw new Error('Method not implemented.');
+    }
+    getWarpRoute(routeId) {
+        throw new Error('Method not implemented.');
+    }
+    getWarpRoutes(filter) {
+        throw new Error('Method not implemented.');
+    }
+    addWarpRoute(config) {
+        throw new Error('Method not implemented.');
+    }
+    merge(otherRegistry) {
+        throw new Error('Method not implemented.');
+    }
+    async fetchJson(endpoint, options = {}) {
+        const response = await fetch(`${this.baseUrl}${endpoint}`, {
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(error.error || 'Request failed');
+        }
+        return response.json();
+    }
+}

package/dist/registry/HttpRegistry.d.ts

@@ -0,0 +1,9 @@
+import { Express } from 'express';
+import { IRegistry } from './IRegistry.js';
+export declare class HttpRegistry {
+    app: Express;
+    registry: IRegistry;
+    constructor(registry: IRegistry);
+    serve(registry: IRegistry): void;
+    start(port?: string | number): void;
+}

package/dist/registry/HttpRegistry.js

@@ -0,0 +1,129 @@
+import express, { Router } from 'express';
+export class HttpRegistry {
+    app;
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+        this.app = express();
+        const router = Router();
+        this.app.use(express.json());
+        // Get all registry content
+        router.get('/content', async (req, res) => {
+            try {
+                const content = await registry.listRegistryContent();
+                res.json(content);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+                res.status(500).json({ error: errorMessage });
+            }
+        });
+        // Get all chains
+        router.get('/chains', async (req, res) => {
+            try {
+                const chains = await registry.getChains();
+                res.json(chains);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+                res.status(500).json({ error: errorMessage });
+            }
+        });
+        // Get chain metadata
+        router.get('/metadata/:chain', async (req, res) => {
+            try {
+                const chainName = req.params.chain;
+                const metadata = await registry.getChainMetadata(chainName);
+                if (!metadata) {
+                    return res.status(404).json({ error: 'Chain metadata not found' });
+                }
+                return res.json(metadata);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+                return res.status(500).json({ error: errorMessage });
+            }
+        });
+        // Get chain addresses
+        router.get('/addresses/:chain', async (req, res) => {
+            try {
+                const chainName = req.params.chain;
+                const addresses = await registry.getChainAddresses(chainName);
+                if (!addresses) {
+                    return res.status(404).json({ error: 'Chain addresses not found' });
+                }
+                return res.json(addresses);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+                return res.status(500).json({ error: errorMessage });
+            }
+        });
+        // Get chain logo URI
+        router.get('/logo/:chain', async (req, res) => {
+            try {
+                const chainName = req.params.chain;
+                const logoUri = await registry.getChainLogoUri(chainName);
+                if (!logoUri) {
+                    return res.status(404).json({ error: 'Chain logo not found' });
+                }
+                return res.json({ logoUri });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+                return res.status(500).json({ error: errorMessage });
+            }
+        });
+        // Get warp route
+        router.get('/warp-route/:id', async (req, res) => {
+            try {
+                const routeId = req.params.id;
+                const route = await registry.getWarpRoute(routeId);
+                if (!route) {
+                    return res.status(404).json({ error: 'Warp route not found' });
+                }
+                return res.json(route);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+                return res.status(500).json({ error: errorMessage });
+            }
+        });
+        // Get filtered warp routes
+        router.get('/warp-routes', async (req, res) => {
+            try {
+                const filter = {
+                    symbol: req.query.symbol,
+                    chainName: req.query.chainName,
+                };
+                const routes = await registry.getWarpRoutes(filter);
+                return res.json(routes);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+                return res.status(500).json({ error: errorMessage });
+            }
+        });
+        // Add warp route
+        router.post('/warp-route', async (req, res) => {
+            try {
+                const config = req.body;
+                await registry.addWarpRoute(config);
+                return res.status(201).json({ message: 'Warp route added successfully' });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+                return res.status(500).json({ error: errorMessage });
+            }
+        });
+        this.app.use('/api', router);
+    }
+    serve(registry) {
+        this.registry = registry;
+    }
+    start(port = process.env.PORT || 3000) {
+        this.app.listen(port, () => {
+            console.log(`Server running on port ${port}`);
+        });
+    }
+}

package/dist/registry/HttpServer.d.ts

@@ -0,0 +1,7 @@
+import { Express } from 'express';
+import { IRegistry } from './IRegistry.js';
+export declare class HttpServer {
+    app: Express;
+    constructor(registry: IRegistry);
+    start(port?: string | number): Promise<void>;
+}

package/dist/registry/HttpServer.js

@@ -0,0 +1,50 @@
+import express, { Router } from 'express';
+export class HttpServer {
+    app;
+    constructor(registry) {
+        this.app = express();
+        const router = Router();
+        this.app.use(express.json());
+        // Get chain metadata
+        router.get('/metadata/:chain', async (req, res) => {
+            try {
+                const chainName = req.params.chain;
+                const metadata = await registry.getChainMetadata(chainName);
+                if (!metadata) {
+                    return res.status(404).json({ error: 'Chain metadata not found' });
+                }
+                return res.json(metadata);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+                return res.status(500).json({ error: errorMessage });
+            }
+        });
+        router.post('/metadata/:chain', async (req, res) => {
+            try {
+                const chainName = req.params.chain;
+                const metadata = req.body;
+                await registry.updateChain({
+                    chainName,
+                    metadata,
+                });
+                return res.status(200).json({ message: 'Chain metadata updated successfully' });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+                return res.status(500).json({ error: errorMessage });
+            }
+        });
+    }
+    start(port = process.env.PORT || 3000) {
+        return new Promise((resolve, reject) => {
+            const server = this.app.listen(port, () => {
+                process.stdout.write(`Server running on port ${port}\n`);
+                resolve();
+            });
+            server.on('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+}

package/dist/registry/IRegistry.d.ts-e

@@ -0,0 +1,41 @@
+import type { ChainMap, ChainMetadata, ChainName, WarpCoreConfig } from '@hyperlane-xyz/sdk';
+import type { ChainAddresses, MaybePromise } from '../types.js';
+export interface ChainFiles {
+    metadata?: string;
+    addresses?: string;
+    logo?: string;
+}
+export interface RegistryContent {
+    chains: ChainMap<ChainFiles>;
+    deployments: {};
+}
+export declare enum RegistryType {
+    Github = "github",
+    FileSystem = "filesystem",
+    Merged = "merged",
+    Partial = "partial"
+}
+export interface IRegistry {
+    type: RegistryType;
+    uri: string;
+    listRegistryContent(): MaybePromise<RegistryContent>;
+    getChains(): MaybePromise<Array<ChainName>>;
+    getMetadata(): MaybePromise<ChainMap<ChainMetadata>>;
+    getChainMetadata(chainName: ChainName): MaybePromise<ChainMetadata | null>;
+    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>;
+    removeChain(chain: ChainName): MaybePromise<void>;
+    addWarpRoute(config: WarpCoreConfig): MaybePromise<void>;
+    merge(otherRegistry: IRegistry): IRegistry;
+}

package/dist/registry/IRegistry.js-e

@@ -0,0 +1,7 @@
+export var RegistryType;
+(function (RegistryType) {
+    RegistryType["Github"] = "github";
+    RegistryType["FileSystem"] = "filesystem";
+    RegistryType["Merged"] = "merged";
+    RegistryType["Partial"] = "partial";
+})(RegistryType || (RegistryType = {}));