@hyperlane-xyz/registry 19.1.1 → 19.2.0

package/dist/fs/FileSystemRegistry.d.ts

@@ -1,7 +1,7 @@
 import type { Logger } from 'pino';
 import type { ChainMap, ChainMetadata, ChainName, WarpCoreConfig, WarpRouteDeployConfig } from '@hyperlane-xyz/sdk';
-import { ChainAddresses, WarpRouteId } from '../types.js';
-import { AddWarpRouteConfigOptions, RegistryType, UpdateChainParams, type ChainFiles, type IRegistry, type RegistryContent } from '../registry/IRegistry.js';
+import { ChainAddresses, UpdateChainParams, WarpRouteId } from '../types.js';
+import { AddWarpRouteConfigOptions, RegistryType, type ChainFiles, type IRegistry, type RegistryContent } from '../registry/IRegistry.js';
 import { SynchronousRegistry } from '../registry/SynchronousRegistry.js';
 export interface FileSystemRegistryOptions {
     uri: string;

package/dist/fs/registry-utils.js

@@ -2,12 +2,13 @@ import { GithubRegistry } from '../registry/GithubRegistry.js';
 import { FileSystemRegistry } from './FileSystemRegistry.js';
 import { PROXY_DEPLOYED_URL } from '../consts.js';
 import { MergedRegistry } from '../registry/MergedRegistry.js';
-const isHttpsUrl = (value) => {
+import { HttpClientRegistry } from '../registry/HttpClientRegistry.js';
+const isProtocolUrl = (value, protocols) => {
     try {
         if (!value)
             return false;
         const url = new URL(value);
-        return url.protocol === 'https:';
+        return protocols.includes(url.protocol);
     }
     catch {
         return false;
@@ -57,7 +58,7 @@ export function getRegistry({ registryUris, enableProxy, branch, logger, authTok
         .filter((uri) => !!uri)
         .map((uri, index) => {
         const childLogger = registryLogger?.child({ uri, index });
-        if (isHttpsUrl(uri)) {
+        if (isProtocolUrl(uri, ['https:']) && uri.includes('github')) {
             return new GithubRegistry({
                 uri,
                 branch,
@@ -66,6 +67,9 @@ export function getRegistry({ registryUris, enableProxy, branch, logger, authTok
                 authToken,
             });
         }
+        else if (isProtocolUrl(uri, ['http:', 'https:'])) {
+            return new HttpClientRegistry(uri);
+        }
         else {
             if (!isValidFilePath(uri)) {
                 throw new Error(`Invalid file system path: ${uri}`);

package/dist/index.d.ts

@@ -4,8 +4,9 @@ export { GithubRegistry, GithubRegistryOptions } from './registry/GithubRegistry
 export { AddWarpRouteConfigOptions, ChainFiles, IRegistry, RegistryContent, RegistryType, } from './registry/IRegistry.js';
 export { MergedRegistry, MergedRegistryOptions } from './registry/MergedRegistry.js';
 export { PartialRegistry, PartialRegistryOptions } from './registry/PartialRegistry.js';
+export { HttpClientRegistry } from './registry/HttpClientRegistry.js';
 export { filterWarpRoutesIds, warpConfigToWarpAddresses, warpRouteConfigPathToId, createWarpRouteConfigId, } from './registry/warp-utils.js';
-export { ChainAddresses, ChainAddressesSchema } from './types.js';
+export { ChainAddresses, ChainAddressesSchema, WarpRouteId, WarpRouteConfigMap, WarpRouteFilterParams, WarpRouteFilterSchema, UpdateChainParams, UpdateChainSchema, } from './types.js';
 export { isAbacusWorksChain } from './utils.js';
 export { chainMetadata } from './chainMetadata.js';
 export { chainAddresses } from './chainAddresses.js';

package/dist/index.js

@@ -4,8 +4,9 @@ export { GithubRegistry } from './registry/GithubRegistry.js';
 export { RegistryType, } from './registry/IRegistry.js';
 export { MergedRegistry } from './registry/MergedRegistry.js';
 export { PartialRegistry } from './registry/PartialRegistry.js';
+export { HttpClientRegistry } from './registry/HttpClientRegistry.js';
 export { filterWarpRoutesIds, warpConfigToWarpAddresses, warpRouteConfigPathToId, createWarpRouteConfigId, } from './registry/warp-utils.js';
-export { ChainAddressesSchema } from './types.js';
+export { ChainAddressesSchema, WarpRouteFilterSchema, UpdateChainSchema, } from './types.js';
 export { isAbacusWorksChain } from './utils.js';
 export { chainMetadata } from './chainMetadata.js';
 export { chainAddresses } from './chainAddresses.js';

package/dist/registry/BaseRegistry.d.ts

@@ -1,8 +1,8 @@
 import type { Logger } from 'pino';
 import { ChainMap, ChainMetadata, ChainName, WarpCoreConfig, WarpRouteDeployConfig } from '@hyperlane-xyz/sdk';
-import type { ChainAddresses, MaybePromise, WarpDeployConfigMap, WarpRouteId } from '../types.js';
+import type { ChainAddresses, MaybePromise, WarpDeployConfigMap, WarpRouteFilterParams, WarpRouteId, UpdateChainParams } from '../types.js';
 import { WarpRouteConfigMap } from '../types.js';
-import type { AddWarpRouteConfigOptions, IRegistry, RegistryContent, RegistryType, UpdateChainParams, WarpRouteFilterParams } from './IRegistry.js';
+import type { AddWarpRouteConfigOptions, IRegistry, RegistryContent, RegistryType } from './IRegistry.js';
 export declare abstract class BaseRegistry implements IRegistry {
     abstract type: RegistryType;
     readonly uri: string;

package/dist/registry/GithubRegistry.d.ts

@@ -1,8 +1,8 @@
 import type { Logger } from 'pino';
 import type { ChainMap, ChainMetadata, ChainName, WarpCoreConfig, WarpRouteDeployConfig } from '@hyperlane-xyz/sdk';
-import { ChainAddresses, WarpDeployConfigMap, WarpRouteConfigMap } from '../types.js';
+import { ChainAddresses, UpdateChainParams, WarpDeployConfigMap, WarpRouteConfigMap, WarpRouteFilterParams } from '../types.js';
 import { BaseRegistry } from './BaseRegistry.js';
-import { AddWarpRouteConfigOptions, ChainFiles, IRegistry, RegistryContent, RegistryType, UpdateChainParams, WarpRouteFilterParams } from './IRegistry.js';
+import { AddWarpRouteConfigOptions, ChainFiles, IRegistry, IRegistryMethods, RegistryContent, RegistryType } from './IRegistry.js';
 export interface GithubRegistryOptions {
     uri?: string;
     proxyUrl?: string;
@@ -48,6 +48,7 @@ export declare class GithubRegistry extends BaseRegistry implements IRegistry {
     private readonly isBrowser;
     private archiveEntries?;
     private archiveEntriesPromise?;
+    readonly unimplementedMethods: Set<IRegistryMethods>;
     private readonly baseApiHeaders;
     constructor(options?: GithubRegistryOptions);
     getUri(itemPath?: string): string;

package/dist/registry/GithubRegistry.js

@@ -37,6 +37,13 @@ export class GithubRegistry extends BaseRegistry {
     archiveEntries;
     // Promise tracking an in-flight archive download/unpack to dedupe parallel calls
     archiveEntriesPromise;
+    unimplementedMethods = new Set([
+        'addChain',
+        'updateChain',
+        'removeChain',
+        'addWarpRoute',
+        'addWarpRouteConfig',
+    ]);
     baseApiHeaders = {
         'X-GitHub-Api-Version': GITHUB_API_VERSION,
     };

package/dist/registry/HttpClientRegistry.d.ts

@@ -0,0 +1,34 @@
+import { ChainMap, ChainMetadata, ChainName, WarpCoreConfig, WarpRouteDeployConfig } from '@hyperlane-xyz/sdk';
+import { ChainAddresses, MaybePromise, UpdateChainParams, WarpDeployConfigMap, WarpRouteConfigMap, WarpRouteFilterParams } from '../types.js';
+import { IRegistry, RegistryContent, RegistryType, AddWarpRouteConfigOptions, IRegistryMethods } from './IRegistry.js';
+export declare class HttpError extends Error {
+    status: number;
+    body: any;
+    constructor(message: string, status: number, body?: any);
+}
+export declare class HttpClientRegistry implements IRegistry {
+    private baseUrl;
+    readonly type = RegistryType.Http;
+    readonly uri: string;
+    readonly unimplementedMethods: Set<IRegistryMethods>;
+    constructor(baseUrl?: string);
+    getMetadata(): MaybePromise<ChainMap<ChainMetadata>>;
+    getAddresses(): MaybePromise<ChainMap<ChainAddresses>>;
+    getUri(_itemPath?: string): string;
+    listRegistryContent(): MaybePromise<RegistryContent>;
+    getChains(): MaybePromise<Array<ChainName>>;
+    getChainMetadata(chainName: ChainName): Promise<ChainMetadata | null>;
+    getChainAddresses(chainName: ChainName): Promise<ChainAddresses | null>;
+    updateChain(update: UpdateChainParams): Promise<void>;
+    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>;
+    getWarpDeployConfig(_routeId: string): MaybePromise<WarpRouteDeployConfig | null>;
+    getWarpDeployConfigs(): MaybePromise<WarpDeployConfigMap>;
+    addWarpRouteConfig(_config: WarpRouteDeployConfig, _options: AddWarpRouteConfigOptions): MaybePromise<void>;
+    merge(_otherRegistry: IRegistry): IRegistry;
+    private fetchJson;
+}

package/dist/registry/HttpClientRegistry.js

@@ -0,0 +1,149 @@
+import { RegistryType, } from './IRegistry.js';
+export class HttpError extends Error {
+    status;
+    body;
+    constructor(message, status, body = null) {
+        super(message);
+        this.name = 'HttpError';
+        this.status = status;
+        this.body = body;
+    }
+}
+export class HttpClientRegistry {
+    baseUrl;
+    type = RegistryType.Http;
+    uri;
+    unimplementedMethods = new Set([
+        'getUri',
+        'getChainLogoUri',
+        'addChain',
+        'removeChain',
+        'addWarpRoute',
+        'getWarpDeployConfig',
+        'getWarpDeployConfigs',
+        'addWarpRouteConfig',
+        'merge',
+    ]);
+    constructor(baseUrl = 'http://localhost:3001') {
+        this.baseUrl = baseUrl;
+        this.uri = baseUrl;
+    }
+    getMetadata() {
+        return this.fetchJson('/metadata');
+    }
+    getAddresses() {
+        return this.fetchJson('/addresses');
+    }
+    getUri(_itemPath) {
+        throw new Error('Method not implemented.');
+    }
+    listRegistryContent() {
+        return this.fetchJson('/list-registry-content');
+    }
+    getChains() {
+        return this.fetchJson('/chains');
+    }
+    async getChainMetadata(chainName) {
+        try {
+            return await this.fetchJson(`/chain/${chainName}/metadata`);
+        }
+        catch (e) {
+            if (e instanceof HttpError && e.status === 404) {
+                return null;
+            }
+            throw e;
+        }
+    }
+    async getChainAddresses(chainName) {
+        try {
+            return await this.fetchJson(`/chain/${chainName}/addresses`);
+        }
+        catch (e) {
+            if (e instanceof HttpError && e.status === 404) {
+                return null;
+            }
+            throw e;
+        }
+    }
+    async updateChain(update) {
+        await this.fetchJson(`/chain/${update.chainName}`, {
+            method: 'POST',
+            body: JSON.stringify({
+                metadata: update.metadata,
+                addresses: update.addresses,
+            }),
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    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) {
+        return this.fetchJson(`/warp-route/${routeId}`);
+    }
+    getWarpRoutes(filter) {
+        const queryParams = new URLSearchParams();
+        if (filter?.symbol) {
+            queryParams.set('symbol', filter.symbol);
+        }
+        if (filter?.label) {
+            queryParams.set('label', filter.label);
+        }
+        return this.fetchJson(`/warp-routes?${queryParams.toString()}`);
+    }
+    addWarpRoute(_config) {
+        throw new Error('Method not implemented.');
+    }
+    getWarpDeployConfig(_routeId) {
+        throw new Error('Method not implemented.');
+    }
+    getWarpDeployConfigs() {
+        throw new Error('Method not implemented.');
+    }
+    addWarpRouteConfig(_config, _options) {
+        throw new Error('Method not implemented.');
+    }
+    merge(_otherRegistry) {
+        throw new Error('Method not implemented.');
+    }
+    async fetchJson(endpoint, options = {}) {
+        const requestOptions = { ...options };
+        // Only add JSON content-type header if there's a body
+        if (options.body) {
+            requestOptions.headers = {
+                'Content-Type': 'application/json',
+                ...options.headers,
+            };
+        }
+        const response = await fetch(`${this.baseUrl}${endpoint}`, requestOptions);
+        // Handle successful requests that have no content to parse.
+        if (response.status === 204) {
+            return null;
+        }
+        if (!response.ok) {
+            let errorBody = null;
+            let errorMessage = `HTTP Error: ${response.status} ${response.statusText}`;
+            try {
+                errorBody = await response.json();
+                // Use the server's detailed error message if available
+                if (errorBody?.message) {
+                    errorMessage = errorBody.message;
+                }
+            }
+            catch (e) {
+                // Ignore if error body isn't valid JSON, use statusText instead.
+            }
+            // Throw the structured error
+            throw new HttpError(errorMessage, response.status, errorBody);
+        }
+        return response.json();
+    }
+}

package/dist/registry/IRegistry.d.ts

@@ -1,5 +1,14 @@
 import type { ChainMap, ChainMetadata, ChainName, WarpCoreConfig, WarpRouteDeployConfig } from '@hyperlane-xyz/sdk';
-import { ChainAddresses, MaybePromise, WarpDeployConfigMap, WarpRouteConfigMap, WarpRouteId } from '../types.js';
+import { ChainAddresses, MaybePromise, WarpDeployConfigMap, WarpRouteConfigMap, WarpRouteId, WarpRouteFilterParams, UpdateChainParams } from '../types.js';
+type MethodsOf<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+/**
+ * A type listing all method names on IRegistry.
+ * It is derived from IRegistry to ensure it's always in sync.
+ * Omit is used to avoid a circular reference with the `unimplementedMethods` property.
+ */
+export type IRegistryMethods = MethodsOf<Omit<IRegistry, 'unimplementedMethods'>>;
 export interface ChainFiles {
     metadata?: string;
     addresses?: string;
@@ -12,20 +21,12 @@ export interface RegistryContent {
         warpDeployConfig: Record<WarpRouteId, string>;
     };
 }
-export interface UpdateChainParams {
-    chainName: ChainName;
-    metadata?: ChainMetadata;
-    addresses?: ChainAddresses;
-}
-export interface WarpRouteFilterParams {
-    symbol?: string;
-    label?: string;
-}
 export declare enum RegistryType {
     Github = "github",
     FileSystem = "filesystem",
     Merged = "merged",
-    Partial = "partial"
+    Partial = "partial",
+    Http = "http"
 }
 export type AddWarpRouteConfigOptions = {
     symbol: string;
@@ -35,6 +36,12 @@ export type AddWarpRouteConfigOptions = {
 export interface IRegistry {
     type: RegistryType;
     uri: string;
+    /**
+     * An optional set of method names that are not implemented by the registry.
+     * If a method is in this set, it should not be called.
+     * If this property is undefined, all methods are assumed to be implemented.
+     */
+    readonly unimplementedMethods?: Set<IRegistryMethods>;
     getUri(itemPath?: string): string;
     listRegistryContent(): MaybePromise<RegistryContent>;
     getChains(): MaybePromise<Array<ChainName>>;
@@ -54,3 +61,4 @@ export interface IRegistry {
     getWarpDeployConfigs(filter?: WarpRouteFilterParams): MaybePromise<WarpDeployConfigMap>;
     merge(otherRegistry: IRegistry): IRegistry;
 }
+export {};

package/dist/registry/IRegistry.js

@@ -4,4 +4,5 @@ export var RegistryType;
     RegistryType["FileSystem"] = "filesystem";
     RegistryType["Merged"] = "merged";
     RegistryType["Partial"] = "partial";
+    RegistryType["Http"] = "http";
 })(RegistryType || (RegistryType = {}));

package/dist/registry/MergedRegistry.d.ts

@@ -1,7 +1,7 @@
 import type { Logger } from 'pino';
 import type { ChainMap, ChainMetadata, ChainName, WarpCoreConfig, WarpRouteDeployConfig } from '@hyperlane-xyz/sdk';
-import { ChainAddresses, WarpDeployConfigMap, WarpRouteConfigMap, WarpRouteId } from '../types.js';
-import { AddWarpRouteConfigOptions, IRegistry, RegistryContent, RegistryType, UpdateChainParams, WarpRouteFilterParams } from './IRegistry.js';
+import { ChainAddresses, UpdateChainParams, WarpDeployConfigMap, WarpRouteConfigMap, WarpRouteFilterParams, WarpRouteId } from '../types.js';
+import { AddWarpRouteConfigOptions, IRegistry, IRegistryMethods, RegistryContent, RegistryType } from './IRegistry.js';
 export interface MergedRegistryOptions {
     registries: Array<IRegistry>;
     logger?: Logger;
@@ -36,6 +36,6 @@ export declare class MergedRegistry implements IRegistry {
     addWarpRoute(config: WarpCoreConfig, options?: AddWarpRouteConfigOptions): Promise<void>;
     addWarpRouteConfig(config: WarpRouteDeployConfig, options: AddWarpRouteConfigOptions): 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>;
+    protected multiRegistryWrite(writeFn: (registry: IRegistry) => Promise<void>, methodName: IRegistryMethods, logMsg: string): Promise<void>;
     merge(otherRegistry: IRegistry): IRegistry;
 }

package/dist/registry/MergedRegistry.js

@@ -53,13 +53,13 @@ export class MergedRegistry {
         return results.find((uri) => !!uri) || null;
     }
     async addChain(chain) {
-        return this.multiRegistryWrite(async (registry) => await registry.addChain(chain), `adding chain ${chain.chainName}`);
+        return this.multiRegistryWrite(async (registry) => await registry.addChain(chain), 'addChain', `adding chain ${chain.chainName}`);
     }
     async updateChain(chain) {
-        return this.multiRegistryWrite(async (registry) => await registry.updateChain(chain), `updating chain ${chain.chainName}`);
+        return this.multiRegistryWrite(async (registry) => await registry.updateChain(chain), 'updateChain', `updating chain ${chain.chainName}`);
     }
     async removeChain(chain) {
-        return this.multiRegistryWrite(async (registry) => await registry.removeChain(chain), `removing chain ${chain}`);
+        return this.multiRegistryWrite(async (registry) => await registry.removeChain(chain), 'removeChain', `removing chain ${chain}`);
     }
     async getWarpRoute(id) {
         const results = await this.multiRegistryRead((r) => r.getWarpRoute(id));
@@ -78,19 +78,18 @@ export class MergedRegistry {
         return results.reduce((acc, content) => objMerge(acc, content), {});
     }
     async addWarpRoute(config, options) {
-        return this.multiRegistryWrite(async (registry) => await registry.addWarpRoute(config, options), 'adding warp route');
+        return this.multiRegistryWrite(async (registry) => await registry.addWarpRoute(config, options), 'addWarpRoute', 'adding warp route');
     }
     async addWarpRouteConfig(config, options) {
-        return this.multiRegistryWrite(async (registry) => await registry.addWarpRouteConfig(config, options), 'adding warp route deploy config');
+        return this.multiRegistryWrite(async (registry) => await registry.addWarpRouteConfig(config, options), 'addWarpRouteConfig', 'adding warp route deploy config');
     }
     multiRegistryRead(readFn) {
         return Promise.all(this.registries.map(readFn));
     }
-    async multiRegistryWrite(writeFn, logMsg) {
+    async multiRegistryWrite(writeFn, methodName, logMsg) {
         for (const registry of this.registries) {
-            // TODO remove this when GithubRegistry supports write methods
-            if (registry.type === RegistryType.Github) {
-                this.logger.warn(`Skipping ${logMsg} at ${registry.type} registry`);
+            if (registry.unimplementedMethods?.has(methodName)) {
+                this.logger.warn(`Skipping ${logMsg} at ${registry.type} registry (not supported)`);
                 continue;
             }
             try {

package/dist/registry/SynchronousRegistry.d.ts

@@ -1,7 +1,7 @@
 import type { ChainMap, ChainMetadata, ChainName, WarpCoreConfig, WarpRouteDeployConfig } from '@hyperlane-xyz/sdk';
-import { ChainAddresses, WarpDeployConfigMap, WarpRouteConfigMap, WarpRouteId } from '../types.js';
+import { ChainAddresses, UpdateChainParams, WarpDeployConfigMap, WarpRouteConfigMap, WarpRouteFilterParams, WarpRouteId } from '../types.js';
 import { BaseRegistry } from './BaseRegistry.js';
-import { AddWarpRouteConfigOptions, IRegistry, RegistryContent, UpdateChainParams, WarpRouteFilterParams } from './IRegistry.js';
+import { AddWarpRouteConfigOptions, IRegistry, RegistryContent } 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.

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

@@ -1,6 +1,5 @@
 import { TokenStandard, type ChainMap, type WarpCoreConfig } from '@hyperlane-xyz/sdk';
-import { ChainAddresses, WarpRouteId } from '../types.js';
-import { WarpRouteFilterParams } from './IRegistry.js';
+import { ChainAddresses, WarpRouteFilterParams, WarpRouteId } from '../types.js';
 /**
  * Converts from a full warp config to a map of chain addresses.
  */