@hyperlane-xyz/registry 19.1.1 → 19.3.0

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.
  */