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

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

@@ -0,0 +1,43 @@
+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';
+export interface MergedRegistryOptions {
+    registries: Array<IRegistry>;
+    logger?: Logger;
+}
+/**
+ * A registry that accepts multiple sub-registries.
+ * Read methods are performed on all sub-registries and the results are merged.
+ * Write methods are performed on all sub-registries.
+ * Can be created manually or by calling `.merge()` on an existing registry.
+ */
+export declare class MergedRegistry implements IRegistry {
+    readonly type = RegistryType.Merged;
+    readonly uri = "__merged_registry__";
+    readonly registries: Array<IRegistry>;
+    protected readonly logger: Logger;
+    constructor({ registries, logger }: MergedRegistryOptions);
+    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>;
+    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>;
+    removeChain(chain: ChainName): Promise<void>;
+    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>;
+    merge(otherRegistry: IRegistry): IRegistry;
+}

package/dist/registry/MergedRegistry.js-e

@@ -0,0 +1,88 @@
+import { objMerge } from '../utils.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.
+ * Write methods are performed on all sub-registries.
+ * Can be created manually or by calling `.merge()` on an existing registry.
+ */
+export class MergedRegistry {
+    type = RegistryType.Merged;
+    uri = '__merged_registry__';
+    registries;
+    logger;
+    constructor({ registries, logger }) {
+        if (!registries.length)
+            throw new Error('At least one registry URI is required');
+        this.registries = registries;
+        // @ts-ignore
+        this.logger = logger || console;
+    }
+    async listRegistryContent() {
+        const results = await this.multiRegistryRead((r) => r.listRegistryContent());
+        return results.reduce((acc, content) => objMerge(acc, content), {
+            chains: {},
+            deployments: {},
+        });
+    }
+    async getChains() {
+        return Object.keys(await this.getMetadata());
+    }
+    async getMetadata() {
+        const results = await this.multiRegistryRead((r) => r.getMetadata());
+        return results.reduce((acc, content) => objMerge(acc, content), {});
+    }
+    async getChainMetadata(chainName) {
+        return (await this.getMetadata())[chainName] || null;
+    }
+    async getAddresses() {
+        const results = await this.multiRegistryRead((r) => r.getAddresses());
+        return results.reduce((acc, content) => objMerge(acc, content), {});
+    }
+    async getChainAddresses(chainName) {
+        return (await this.getAddresses())[chainName] || null;
+    }
+    async getChainLogoUri(chainName) {
+        const results = await this.multiRegistryRead((r) => r.getChainLogoUri(chainName));
+        return results.find((uri) => !!uri) || null;
+    }
+    async addChain(chain) {
+        return this.multiRegistryWrite(async (registry) => await registry.addChain(chain), `adding chain ${chain.chainName}`);
+    }
+    async updateChain(chain) {
+        return this.multiRegistryWrite(async (registry) => await registry.updateChain(chain), `updating chain ${chain.chainName}`);
+    }
+    async removeChain(chain) {
+        return this.multiRegistryWrite(async (registry) => await registry.removeChain(chain), `removing chain ${chain}`);
+    }
+    async addWarpRoute(config) {
+        return this.multiRegistryWrite(async (registry) => await registry.addWarpRoute(config), 'adding warp route');
+    }
+    multiRegistryRead(readFn) {
+        return Promise.all(this.registries.map(readFn));
+    }
+    async multiRegistryWrite(writeFn, 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`);
+                continue;
+            }
+            try {
+                this.logger.info(`Now ${logMsg} at ${registry.type} registry at ${registry.uri}`);
+                await writeFn(registry);
+                this.logger.info(`Done ${logMsg} at ${registry.type} registry`);
+            }
+            catch (error) {
+                // To prevent loss of artifacts, MergedRegistry write methods are failure tolerant
+                this.logger.error(`Failure ${logMsg} at ${registry.type} registry`, error);
+            }
+        }
+    }
+    merge(otherRegistry) {
+        return new MergedRegistry({
+            registries: [...this.registries, otherRegistry],
+            logger: this.logger,
+        });
+    }
+}

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

@@ -0,0 +1,30 @@
+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 { SynchronousRegistry } from './SynchronousRegistry.js';
+/**
+ * A registry that accepts partial data, such as incomplete chain metadata or addresses.
+ * Useful for merging with other registries force overrides of subsets of data.
+ */
+export interface PartialRegistryOptions {
+    chainMetadata?: ChainMap<Partial<ChainMetadata>>;
+    chainAddresses?: ChainMap<Partial<ChainAddresses>>;
+    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);
+    listRegistryContent(): RegistryContent;
+    getMetadata(): ChainMap<ChainMetadata>;
+    getAddresses(): ChainMap<ChainAddresses>;
+    removeChain(chainName: ChainName): void;
+    addWarpRoute(_config: WarpCoreConfig): void;
+    protected createOrUpdateChain(chain: {
+        chainName: ChainName;
+        metadata?: ChainMetadata;
+        addresses?: ChainAddresses;
+    }): void;
+}

package/dist/registry/PartialRegistry.js-e

@@ -0,0 +1,50 @@
+import { RegistryType } from './IRegistry.js';
+import { SynchronousRegistry } from './SynchronousRegistry.js';
+const PARTIAL_URI_PLACEHOLDER = '__partial_registry__';
+export class PartialRegistry extends SynchronousRegistry {
+    type = RegistryType.Partial;
+    chainMetadata;
+    chainAddresses;
+    constructor({ chainMetadata, chainAddresses, logger }) {
+        super({ uri: PARTIAL_URI_PLACEHOLDER, logger });
+        this.chainMetadata = chainMetadata || {};
+        this.chainAddresses = chainAddresses || {};
+    }
+    listRegistryContent() {
+        const chains = {};
+        Object.keys(this.chainMetadata).forEach((c) => {
+            chains[c] ||= {};
+            chains[c].metadata = PARTIAL_URI_PLACEHOLDER;
+        });
+        Object.keys(this.chainAddresses).forEach((c) => {
+            chains[c] ||= {};
+            chains[c].addresses = PARTIAL_URI_PLACEHOLDER;
+        });
+        return {
+            chains,
+            deployments: {},
+        };
+    }
+    getMetadata() {
+        return this.chainMetadata;
+    }
+    getAddresses() {
+        return this.chainAddresses;
+    }
+    removeChain(chainName) {
+        super.removeChain(chainName);
+        if (this.chainMetadata?.[chainName])
+            delete this.chainMetadata[chainName];
+        if (this.chainAddresses?.[chainName])
+            delete this.chainAddresses[chainName];
+    }
+    addWarpRoute(_config) {
+        throw new Error('Method not implemented.');
+    }
+    createOrUpdateChain(chain) {
+        if (chain.metadata)
+            this.chainMetadata[chain.chainName] = chain.metadata;
+        if (chain.addresses)
+            this.chainAddresses[chain.chainName] = chain.addresses;
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { ChainMap, ChainMetadata, ChainName, WarpCoreConfig } from '@hyperlane-xyz/sdk';
+import { ChainAddresses } from '../types.js';
+import { BaseRegistry } from './BaseRegistry.js';
+import { 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.
+ * If the Infra package can be updated to work with async-only methods, this code can be moved to the BaseRegistry class.
+ */
+export declare abstract class SynchronousRegistry extends BaseRegistry implements IRegistry {
+    abstract listRegistryContent(): RegistryContent;
+    getChains(): Array<ChainName>;
+    abstract getMetadata(): ChainMap<ChainMetadata>;
+    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;
+    removeChain(chainName: ChainName): void;
+    abstract addWarpRoute(config: WarpCoreConfig): void;
+    protected abstract createOrUpdateChain(chain: {
+        chainName: ChainName;
+        metadata?: ChainMetadata;
+        addresses?: ChainAddresses;
+    }): void;
+}

package/dist/registry/SynchronousRegistry.js-e

@@ -0,0 +1,41 @@
+import { BaseRegistry } from './BaseRegistry.js';
+/**
+ * Shared code for sync registries like the FileSystem and Partial registries.
+ * This is required because of the inconsistent sync/async methods across registries.
+ * If the Infra package can be updated to work with async-only methods, this code can be moved to the BaseRegistry class.
+ */
+export class SynchronousRegistry extends BaseRegistry {
+    getChains() {
+        return Object.keys(this.listRegistryContent().chains);
+    }
+    getChainMetadata(chainName) {
+        return this.getMetadata()[chainName] || null;
+    }
+    getChainAddresses(chainName) {
+        return this.getAddresses()[chainName] || null;
+    }
+    addChain(chain) {
+        const currentChains = this.listRegistryContent().chains;
+        if (currentChains[chain.chainName])
+            throw new Error(`Chain ${chain.chainName} already exists in registry`);
+        this.createOrUpdateChain(chain);
+    }
+    updateChain(chain) {
+        const currentChains = this.listRegistryContent();
+        if (!currentChains.chains[chain.chainName]) {
+            this.logger.debug(`Chain ${chain.chainName} not found in registry, adding it now`);
+        }
+        this.createOrUpdateChain(chain);
+    }
+    removeChain(chainName) {
+        const currentChains = this.listRegistryContent().chains;
+        if (!currentChains[chainName])
+            throw new Error(`Chain ${chainName} does not exist in registry`);
+        if (this.listContentCache?.chains[chainName])
+            delete this.listContentCache.chains[chainName];
+        if (this.metadataCache?.[chainName])
+            delete this.metadataCache[chainName];
+        if (this.addressCache?.[chainName])
+            delete this.addressCache[chainName];
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { ChainMap, WarpCoreConfig } from '@hyperlane-xyz/sdk';
+import { ChainAddresses } from '../types.js';
+export declare function warpConfigToWarpAddresses(config: WarpCoreConfig): ChainMap<ChainAddresses>;

package/dist/registry/warp-utils.js-e

@@ -0,0 +1,22 @@
+export function warpConfigToWarpAddresses(config) {
+    return config.tokens.reduce((acc, token) => {
+        const addressKey = getWarpAddressKey(token.standard);
+        if (!addressKey || !token.addressOrDenom)
+            return acc;
+        acc[token.chainName] = {
+            [addressKey]: token.addressOrDenom,
+        };
+        return acc;
+    }, {});
+}
+function getWarpAddressKey(standard) {
+    const standardValue = standard.toLowerCase();
+    if (standardValue.includes('collateral'))
+        return 'collateral';
+    if (standardValue.includes('synthetic'))
+        return 'synthetic';
+    if (standardValue.includes('native'))
+        return 'native';
+    else
+        return null;
+}

package/dist/types.d.ts-e

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

package/dist/types.js-e

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export const ChainAddressesSchema = z.record(z.string());

package/dist/utils.d.ts-e

@@ -0,0 +1,4 @@
+export declare function toYamlString(data: any, prefix?: 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-e

@@ -0,0 +1,46 @@
+import { stringify } from 'yaml';
+export function toYamlString(data, prefix) {
+    const yamlString = stringify(data);
+    return prefix ? `${prefix}\n${yamlString}` : yamlString;
+}
+export async function concurrentMap(concurrency, xs, mapFn) {
+    let res = [];
+    for (let i = 0; i < xs.length; i += concurrency) {
+        const remaining = xs.length - i;
+        const sliceSize = Math.min(remaining, concurrency);
+        const slice = xs.slice(i, i + sliceSize);
+        res = res.concat(await Promise.all(slice.map((elem, index) => mapFn(elem, i + index))));
+    }
+    return res;
+}
+export function isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+}
+// Recursively merges b into a
+// Where there are conflicts, b takes priority over a
+export function objMerge(a, b, max_depth = 10) {
+    if (max_depth === 0) {
+        throw new Error('objMerge tried to go too deep');
+    }
+    if (isObject(a) && isObject(b)) {
+        const ret = {};
+        const aKeys = new Set(Object.keys(a));
+        const bKeys = new Set(Object.keys(b));
+        const allKeys = new Set([...aKeys, ...bKeys]);
+        for (const key of allKeys.values()) {
+            if (aKeys.has(key) && bKeys.has(key)) {
+                ret[key] = objMerge(a[key], b[key], max_depth - 1);
+            }
+            else if (aKeys.has(key)) {
+                ret[key] = a[key];
+            }
+            else {
+                ret[key] = b[key];
+            }
+        }
+        return ret;
+    }
+    else {
+        return b ? b : a;
+    }
+}

package/dist/warpRouteConfigs.js

@@ -2618,6 +2618,60 @@ export const warpRouteConfigs = {
             }
         ]
     },
+    "PNDR/bsc-ethereum-lumiaprism": {
+        "tokens": [
+            {
+                "addressOrDenom": "0xC868Ea07031eE67dCE475D535F1AA0e5571Ba92a",
+                "chainName": "ethereum",
+                "coinGeckoId": "ponder-one",
+                "collateralAddressOrDenom": "0x73624d2dEF952C77a1f3B5AD995eef53E49639EC",
+                "connections": [
+                    {
+                        "token": "ethereum|bsc|0xDcE63e8cc7f1E2Ed25a226166abE3217c19d0BF1"
+                    },
+                    {
+                        "token": "ethereum|lumiaprism|0x1fdfD1486b8339638C6b92f8a96D698D8182D2b1"
+                    }
+                ],
+                "decimals": 18,
+                "name": "Ponder",
+                "standard": "EvmHypCollateral",
+                "symbol": "PNDR"
+            },
+            {
+                "addressOrDenom": "0xDcE63e8cc7f1E2Ed25a226166abE3217c19d0BF1",
+                "chainName": "bsc",
+                "connections": [
+                    {
+                        "token": "ethereum|ethereum|0xC868Ea07031eE67dCE475D535F1AA0e5571Ba92a"
+                    },
+                    {
+                        "token": "ethereum|lumiaprism|0x1fdfD1486b8339638C6b92f8a96D698D8182D2b1"
+                    }
+                ],
+                "decimals": 18,
+                "name": "Ponder",
+                "standard": "EvmHypSynthetic",
+                "symbol": "PNDR"
+            },
+            {
+                "addressOrDenom": "0x1fdfD1486b8339638C6b92f8a96D698D8182D2b1",
+                "chainName": "lumiaprism",
+                "connections": [
+                    {
+                        "token": "ethereum|ethereum|0xC868Ea07031eE67dCE475D535F1AA0e5571Ba92a"
+                    },
+                    {
+                        "token": "ethereum|bsc|0xDcE63e8cc7f1E2Ed25a226166abE3217c19d0BF1"
+                    }
+                ],
+                "decimals": 18,
+                "name": "Ponder",
+                "standard": "EvmHypSynthetic",
+                "symbol": "PNDR"
+            }
+        ]
+    },
     "POL/kalychain-polygon": {
         "tokens": [
             {
@@ -3379,6 +3433,40 @@ export const warpRouteConfigs = {
             }
         ]
     },
+    "USDC/ancient8-ethereum": {
+        "tokens": [
+            {
+                "addressOrDenom": "0x8b4192B9Ad1fCa440A5808641261e5289e6de95D",
+                "chainName": "ethereum",
+                "coinGeckoId": "usd-coin",
+                "collateralAddressOrDenom": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+                "connections": [
+                    {
+                        "token": "ethereum|ancient8|0x97423A68BAe94b5De52d767a17aBCc54c157c0E5"
+                    }
+                ],
+                "decimals": 6,
+                "logoURI": "/deployments/warp_routes/USDC/logo.svg",
+                "name": "USD Coin",
+                "standard": "EvmHypCollateral",
+                "symbol": "USDC"
+            },
+            {
+                "addressOrDenom": "0x97423A68BAe94b5De52d767a17aBCc54c157c0E5",
+                "chainName": "ancient8",
+                "connections": [
+                    {
+                        "token": "ethereum|ethereum|0x8b4192B9Ad1fCa440A5808641261e5289e6de95D"
+                    }
+                ],
+                "decimals": 6,
+                "logoURI": "/deployments/warp_routes/USDC/logo.svg",
+                "name": "USD Coin",
+                "standard": "EvmHypSynthetic",
+                "symbol": "USDC"
+            }
+        ]
+    },
     "USDC/appchain-base": {
         "tokens": [
             {
@@ -3863,6 +3951,7 @@ export const warpRouteConfigs = {
                     }
                 ],
                 "decimals": 6,
+                "logoURI": "/deployments/warp_routes/USDC/logo.svg",
                 "name": "USD Coin",
                 "standard": "EvmHypCollateral",
                 "symbol": "USDC"
@@ -3964,6 +4053,7 @@ export const warpRouteConfigs = {
                     }
                 ],
                 "decimals": 18,
+                "logoURI": "/deployments/warp_routes/USDC/logo.svg",
                 "name": "USD Coin",
                 "standard": "EvmHypCollateral",
                 "symbol": "USDC"
@@ -3980,6 +4070,7 @@ export const warpRouteConfigs = {
                     }
                 ],
                 "decimals": 18,
+                "logoURI": "/deployments/warp_routes/USDC/logo.svg",
                 "name": "USD Coin",
                 "standard": "EvmHypSynthetic",
                 "symbol": "USDC"
@@ -4037,40 +4128,6 @@ export const warpRouteConfigs = {
             }
         ]
     },
-    "USDC/ancient8-ethereum": {
-        "tokens": [
-            {
-                "addressOrDenom": "0x8b4192B9Ad1fCa440A5808641261e5289e6de95D",
-                "chainName": "ethereum",
-                "coinGeckoId": "usd-coin",
-                "collateralAddressOrDenom": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-                "connections": [
-                    {
-                        "token": "ethereum|ancient8|0x97423A68BAe94b5De52d767a17aBCc54c157c0E5"
-                    }
-                ],
-                "decimals": 6,
-                "logoURI": "/deployments/warp_routes/USDC/logo.svg",
-                "name": "USD Coin",
-                "standard": "EvmHypCollateral",
-                "symbol": "USDC"
-            },
-            {
-                "addressOrDenom": "0x97423A68BAe94b5De52d767a17aBCc54c157c0E5",
-                "chainName": "ancient8",
-                "connections": [
-                    {
-                        "token": "ethereum|ethereum|0x8b4192B9Ad1fCa440A5808641261e5289e6de95D"
-                    }
-                ],
-                "decimals": 6,
-                "logoURI": "/deployments/warp_routes/USDC/logo.svg",
-                "name": "USD Coin",
-                "standard": "EvmHypSynthetic",
-                "symbol": "USDC"
-            }
-        ]
-    },
     "USDC/eclipsemainnet-ethereum-solanamainnet": {
         "tokens": [
             {
@@ -4667,6 +4724,7 @@ export const warpRouteConfigs = {
                     }
                 ],
                 "decimals": 18,
+                "logoURI": "/deployments/warp_routes/USDT/logo.svg",
                 "name": "Tether USD",
                 "standard": "EvmHypCollateral",
                 "symbol": "USDT"
@@ -4683,6 +4741,7 @@ export const warpRouteConfigs = {
                     }
                 ],
                 "decimals": 18,
+                "logoURI": "/deployments/warp_routes/USDT/logo.svg",
                 "name": "Tether USD",
                 "standard": "EvmHypSynthetic",
                 "symbol": "USDT"

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@hyperlane-xyz/registry",
   "description": "A collection of configs, artifacts, and schemas for Hyperlane",
-  "version": "6.10.0",
+  "version": "6.12.0-http.0",
   "dependencies": {
+    "express": "^4.21.2",
     "yaml": "2.4.5",
     "zod": "^3.21.2"
   },
@@ -10,6 +11,7 @@
     "@changesets/cli": "^2.26.2",
     "@eslint/js": "^9.1.1",
     "@hyperlane-xyz/sdk": "7.0.0",
+    "@types/express": "^4",
     "@types/mocha": "^10.0.1",
     "@types/node": "^16.9.1",
     "@typescript-eslint/parser": "^7.7.0",
@@ -22,6 +24,7 @@
     "mocha": "^10.2.0",
     "prettier": "^2.8.8",
     "sinon": "^18.0.0",
+    "svgo": "3.3.2",
     "tsx": "^4.7.1",
     "typescript": "5.5.2",
     "typescript-eslint": "^7.7.0",
@@ -71,5 +74,5 @@
     "version:prepare": "yarn changeset version && yarn install --no-immutable",
     "version:check": "yarn changeset status"
   },
-  "packageManager": "yarn@4.0.2"
+  "packageManager": "yarn@4.5.1"
 }