refactor: prune unused graph-first warp surface

paulbalaji · paulbalaji · commit b591ea5df794 · 2026-03-26T18:44:02.000Z
diff --git a/typescript/sdk/src/index.ts b/typescript/sdk/src/index.ts
@@ -924,11 +924,6 @@ export {
   WarpCoreFeeEstimate,
 } from './warp/types.js';
 export { WarpCore, WarpCoreOptions } from './warp/WarpCore.js';
-export {
-  WarpRouteGraph,
-  buildWarpRouteTokens,
-  mapWarpRouteTokens,
-} from './warp/WarpRouteGraph.js';
 export { EvmTimelockReader } from './timelock/evm/EvmTimelockReader.js';
 export { EvmTimelockDeployer } from './timelock/evm/EvmTimelockDeployer.js';
 export {
diff --git a/typescript/sdk/src/providers/ConfiguredMultiProtocolProvider.ts b/typescript/sdk/src/providers/ConfiguredMultiProtocolProvider.ts
@@ -47,6 +47,15 @@ export interface ConfiguredMultiProtocolProviderOptions {
   providerBuilders?: Partial<ProviderBuilderMap>;
 }
 
+export function wrapMultiProviderProviders<MetaExt = {}>(
+  providers: MultiProvider<MetaExt>['providers'],
+): ChainMap<TypedProvider> {
+  return objMap(providers, (_, provider) => ({
+    type: ProviderType.EthersV5,
+    provider,
+  })) as ChainMap<TypedProvider>;
+}
+
 export class ConfiguredMultiProtocolProvider<
   MetaExt = {},
 > extends ChainMetadataManager<MetaExt> {
@@ -77,13 +86,7 @@ export class ConfiguredMultiProtocolProvider<
       mp.metadata,
       options,
     );
-
-    const typedProviders = objMap(mp.providers, (_, provider) => ({
-      type: ProviderType.EthersV5,
-      provider,
-    })) as ChainMap<TypedProvider>;
-
-    newMp.setProviders(typedProviders);
+    newMp.setProviders(wrapMultiProviderProviders(mp.providers));
     return newMp;
   }
 
diff --git a/typescript/sdk/src/providers/MultiProtocolProvider.ts b/typescript/sdk/src/providers/MultiProtocolProvider.ts
@@ -7,6 +7,7 @@ import type { ChainMap, ChainName } from '../types.js';
 import {
   ConfiguredMultiProtocolProvider,
   ConfiguredMultiProtocolProviderOptions,
+  wrapMultiProviderProviders,
 } from './ConfiguredMultiProtocolProvider.js';
 import { MultiProvider } from './MultiProvider.js';
 import { ProviderType, TypedProvider } from './ProviderType.js';
@@ -27,17 +28,7 @@ export class MultiProtocolProvider<
     options: MultiProtocolProviderOptions = {},
   ): MultiProtocolProvider<MetaExt> {
     const newMp = new MultiProtocolProvider<MetaExt>(mp.metadata, options);
-    newMp.setProviders(
-      Object.fromEntries(
-        Object.entries(mp.providers).map(([chain, provider]) => [
-          chain,
-          {
-            type: ProviderType.EthersV5,
-            provider,
-          },
-        ]),
-      ) as ChainMap<TypedProvider>,
-    );
+    newMp.setProviders(wrapMultiProviderProviders(mp.providers));
     return newMp;
   }
 
diff --git a/typescript/sdk/src/warp/WarpCore.test.ts b/typescript/sdk/src/warp/WarpCore.test.ts
@@ -18,13 +18,11 @@ import { MultiProtocolProvider } from '../providers/MultiProtocolProvider.js';
 import { ProviderType } from '../providers/ProviderType.js';
 import { Token } from '../token/Token.js';
 import { TokenAmount } from '../token/TokenAmount.js';
-import { TokenMetadata } from '../token/TokenMetadata.js';
 import { TokenStandard } from '../token/TokenStandard.js';
 import { InterchainGasQuote } from '../token/adapters/ITokenAdapter.js';
 import { ChainName } from '../types.js';
 
 import { WarpCore } from './WarpCore.js';
-import { WarpRouteGraph } from './WarpRouteGraph.js';
 import { WarpTxCategory } from './types.js';
 
 const MOCK_LOCAL_QUOTE = { gasUnits: 2_000n, gasPrice: 100, fee: 200_000n };
@@ -64,29 +62,10 @@ describe('WarpCore', () => {
     const exampleConfig = yamlParse(
       fs.readFileSync('./src/warp/test-warp-core-config.yaml', 'utf-8'),
     );
-    const routeGraph = WarpRouteGraph.FromConfig(multiProvider, exampleConfig);
     const fromConfig = WarpCore.FromConfig(multiProvider, exampleConfig);
-    const fromRouteGraph = WarpCore.FromRouteGraph(
-      routeGraph,
-      exampleConfig.options,
-    );
     expect(fromArgs).to.be.instanceOf(WarpCore);
-    expect(routeGraph).to.be.instanceOf(WarpRouteGraph);
     expect(fromConfig).to.be.instanceOf(WarpCore);
-    expect(fromRouteGraph).to.be.instanceOf(WarpCore);
-    expect(routeGraph.tokens[0]).to.be.instanceOf(TokenMetadata);
     expect(fromConfig.tokens.length).to.equal(exampleConfig.tokens.length);
-    expect(fromRouteGraph.tokens.length).to.equal(exampleConfig.tokens.length);
-    expect(fromRouteGraph.tokens[0]).to.be.instanceOf(Token);
-    expect(
-      fromRouteGraph.tokens[0]?.getConnections(),
-    ).to.have.length.greaterThan(0);
-    expect(fromRouteGraph.localFeeConstants).to.deep.equal(
-      fromConfig.localFeeConstants,
-    );
-    expect(fromRouteGraph.interchainFeeConstants).to.deep.equal(
-      fromConfig.interchainFeeConstants,
-    );
 
     warpCore = fromConfig;
     [
diff --git a/typescript/sdk/src/warp/WarpCore.ts b/typescript/sdk/src/warp/WarpCore.ts
@@ -16,7 +16,6 @@ import {
 } from '@hyperlane-xyz/utils';
 import { Keypair } from '@solana/web3.js';
 
-import type { ChainMetadata } from '../metadata/chainMetadataTypes.js';
 import type { ConfiguredMultiProtocolProvider as MultiProtocolProvider } from '../providers/ConfiguredMultiProtocolProvider.js';
 import { ProviderType } from '../providers/ProviderType.js';
 import {
@@ -26,7 +25,7 @@ import {
 import { IToken } from '../token/IToken.js';
 import { Token } from '../token/Token.js';
 import { TokenAmount } from '../token/TokenAmount.js';
-import { TokenMetadata } from '../token/TokenMetadata.js';
+import { parseTokenConnectionId } from '../token/TokenConnection.js';
 import {
   LOCKBOX_STANDARDS,
   MINT_LIMITED_STANDARDS,
@@ -44,7 +43,7 @@ import {
   IHypXERC20Adapter,
   InterchainGasQuote,
 } from '../token/adapters/ITokenAdapter.js';
-import { ChainNameOrId } from '../types.js';
+import { ChainName, ChainNameOrId } from '../types.js';
 
 import {
   FeeConstantConfig,
@@ -54,7 +53,6 @@ import {
   WarpTxCategory,
   WarpTypedTransaction,
 } from './types.js';
-import { WarpRouteGraph, buildWarpRouteTokens } from './WarpRouteGraph.js';
 
 export interface WarpCoreOptions {
   logger?: Logger;
@@ -63,7 +61,9 @@ export interface WarpCoreOptions {
   routeBlacklist?: RouteBlacklist;
 }
 
-export class WarpCore extends WarpRouteGraph<Token> {
+export class WarpCore {
+  public readonly multiProvider: MultiProtocolProvider<{ mailbox?: Address }>;
+  public readonly tokens: Token[];
   public readonly localFeeConstants: FeeConstantConfig;
   public readonly interchainFeeConstants: FeeConstantConfig;
   public readonly routeBlacklist: RouteBlacklist;
@@ -74,7 +74,8 @@ export class WarpCore extends WarpRouteGraph<Token> {
     tokens: Token[],
     options?: WarpCoreOptions,
   ) {
-    super(multiProvider, tokens);
+    this.multiProvider = multiProvider;
+    this.tokens = tokens;
     this.localFeeConstants = options?.localFeeConstants || [];
     this.interchainFeeConstants = options?.interchainFeeConstants || [];
     this.routeBlacklist = options?.routeBlacklist || [];
@@ -95,23 +96,40 @@ export class WarpCore extends WarpRouteGraph<Token> {
     config: unknown,
   ): WarpCore {
     const parsedConfig = WarpCoreConfigSchema.parse(config);
-    const routeGraph = new WarpRouteGraph(
-      multiProvider,
-      buildWarpRouteTokens(parsedConfig, (token) => new TokenMetadata(token)),
+    const tokens = parsedConfig.tokens.map(
+      (token) =>
+        new Token({
+          ...token,
+          addressOrDenom: token.addressOrDenom || '',
+          connections: undefined,
+        }),
     );
-    return WarpCore.FromRouteGraph(routeGraph, parsedConfig.options);
-  }
 
-  static FromRouteGraph(
-    routeGraph: WarpRouteGraph,
-    options?: WarpCoreOptions,
-  ): WarpCore {
-    const tokens = routeGraph.mapTokens((token) => new Token(token)).tokens;
-    return new WarpCore(routeGraph.multiProvider, tokens, options);
-  }
+    parsedConfig.tokens.forEach((config, i) => {
+      for (const connection of config.connections || []) {
+        const token1 = tokens[i];
+        assert(token1, `Token config missing at index ${i}`);
+        const { chainName, addressOrDenom } = parseTokenConnectionId(
+          connection.token,
+        );
+        const token2 = tokens.find(
+          (token) =>
+            token.chainName === chainName &&
+            token.addressOrDenom === addressOrDenom &&
+            (!token1.warpRouteId || token.warpRouteId === token1.warpRouteId),
+        );
+        assert(
+          token2,
+          `Connected token not found: ${chainName} ${addressOrDenom}`,
+        );
+        token1.addConnection({
+          ...connection,
+          token: token2,
+        });
+      }
+    });
 
-  protected override createNativeToken(chainMetadata: ChainMetadata): Token {
-    return Token.FromChainMetadataNativeToken(chainMetadata);
+    return new WarpCore(multiProvider, tokens, parsedConfig.options);
   }
 
   /**
@@ -1253,6 +1271,91 @@ export class WarpCore extends WarpRouteGraph<Token> {
     return null;
   }
 
+  protected resolveDestinationToken({
+    originToken,
+    destination,
+    destinationToken,
+  }: {
+    originToken: IToken;
+    destination: ChainNameOrId;
+    destinationToken?: IToken;
+  }): IToken {
+    const destinationName = this.multiProvider.getChainName(destination);
+    const destinationCandidates = originToken
+      .getConnections()
+      .filter((connection) => connection.token.chainName === destinationName)
+      .map((connection) => connection.token);
+
+    assert(
+      destinationCandidates.length > 0,
+      `No connection found for ${destinationName}`,
+    );
+
+    if (destinationToken) {
+      assert(
+        destinationToken.chainName === destinationName,
+        `Destination token chain mismatch for ${destinationName}`,
+      );
+      const matchedToken = destinationCandidates.find(
+        (candidate) =>
+          candidate.equals(destinationToken) ||
+          candidate.addressOrDenom.toLowerCase() ===
+            destinationToken.addressOrDenom.toLowerCase(),
+      );
+      assert(
+        matchedToken,
+        `Destination token ${destinationToken.addressOrDenom} is not connected from ${originToken.chainName} to ${destinationName}`,
+      );
+      return matchedToken;
+    }
+
+    assert(
+      destinationCandidates.length === 1,
+      `Ambiguous route to ${destinationName}; specify destination token`,
+    );
+    return destinationCandidates[0];
+  }
+
+  findToken(
+    chainName: ChainName,
+    addressOrDenom?: Address | string,
+  ): Token | null {
+    if (!addressOrDenom) return null;
+
+    const results = this.tokens.filter(
+      (token) =>
+        token.chainName === chainName &&
+        token.addressOrDenom.toLowerCase() === addressOrDenom.toLowerCase(),
+    );
+
+    if (results.length === 1) return results[0];
+
+    if (results.length > 1)
+      throw new Error(`Ambiguous token search results for ${addressOrDenom}`);
+
+    const chainMetadata = this.multiProvider.getChainMetadata(chainName);
+    if (chainMetadata.nativeToken?.denom === addressOrDenom) {
+      return Token.FromChainMetadataNativeToken(chainMetadata);
+    }
+
+    return null;
+  }
+
+  getTokenChains(): ChainName[] {
+    return [...new Set(this.tokens.map((token) => token.chainName)).values()];
+  }
+
+  getTokensForChain(chainName: ChainName): Token[] {
+    return this.tokens.filter((token) => token.chainName === chainName);
+  }
+
+  getTokensForRoute(origin: ChainName, destination: ChainName): Token[] {
+    return this.tokens.filter(
+      (token) =>
+        token.chainName === origin && token.getConnectionForChain(destination),
+    );
+  }
+
   /**
    * Ensure the sender has sufficient balances for transfer and interchain gas
    */
diff --git a/typescript/sdk/src/warp/WarpRouteGraph.ts b/typescript/sdk/src/warp/WarpRouteGraph.ts
