Fixes for multi-protocol Kathy

typescript/helloworld/src/app/types.ts

@@ -1,4 +1,4 @@
 export type StatCounts = {
-  sent: number | bigint;
-  received: number | bigint;
+  sent: number;
+  received: number;
 };

typescript/helloworld/src/multiProtocolApp/evmAdapter.ts

@@ -7,7 +7,6 @@ import {
 } from '@hyperlane-xyz/sdk';
 import { Address } from '@hyperlane-xyz/utils';
 
-import { StatCounts } from '../app/types';
 import { HelloWorld, HelloWorld__factory } from '../types';
 
 import { IHelloWorldAdapter } from './types';
@@ -55,22 +54,11 @@ export class EvmHelloWorldAdapter
     return { transaction: tx, type: ProviderType.EthersV5 };
   }
 
-  async channelStats(
-    destination: ChainName,
-    destinationMailbox: Address,
-  ): Promise<StatCounts> {
-    const originDomain = this.multiProvider.getDomainId(this.chainName);
+  async sentStat(destination: ChainName): Promise<number> {
     const destinationDomain = this.multiProvider.getDomainId(destination);
     const originContract = this.getConnectedContract();
     const sent = await originContract.sentTo(destinationDomain);
-    const destinationProvider =
-      this.multiProvider.getEthersV5Provider(destination);
-    const destinationContract = HelloWorld__factory.connect(
-      destinationMailbox,
-      destinationProvider,
-    );
-    const received = await destinationContract.sentTo(originDomain);
-    return { sent: sent.toNumber(), received: received.toNumber() };
+    return sent.toNumber();
   }
 
   override getConnectedContract(): HelloWorld {

typescript/helloworld/src/multiProtocolApp/multiProtocolApp.ts

@@ -38,11 +38,15 @@ export class HelloMultiProtocolApp extends MultiProtocolRouterApp<
     );
   }
 
-  channelStats(origin: ChainName, destination: ChainName): Promise<StatCounts> {
-    return this.adapter(origin).channelStats(
-      destination,
-      this.addresses[destination].mailbox,
-    );
+  async channelStats(
+    origin: ChainName,
+    destination: ChainName,
+  ): Promise<StatCounts> {
+    const [sent, received] = await Promise.all([
+      this.adapter(origin).sentStat(destination),
+      this.adapter(destination).sentStat(origin),
+    ]);
+    return { sent, received };
   }
 
   async stats(): Promise<ChainMap<ChainMap<StatCounts>>> {

typescript/helloworld/src/multiProtocolApp/sealevelAdapter.ts

@@ -24,8 +24,6 @@ import {
 } from '@hyperlane-xyz/sdk';
 import { Address, Domain } from '@hyperlane-xyz/utils';
 
-import { StatCounts } from '../app/types';
-
 import { IHelloWorldAdapter } from './types';
 
 export class SealevelHelloWorldAdapter
@@ -164,21 +162,20 @@ export class SealevelHelloWorldAdapter
     );
   }
 
-  async channelStats(_destination: ChainName): Promise<StatCounts> {
+  async sentStat(destination: ChainName): Promise<number> {
+    const destinationDomain = this.multiProvider.getDomainId(destination);
     const data = await this.getAccountInfo();
-    return { sent: data.sent, received: data.received };
+    return Number(data.sent_to.get(destinationDomain) || 0);
   }
 
   async getAccountInfo(): Promise<HelloWorldData> {
     const address = this.addresses.router;
     const connection = this.getProvider();
 
-    const msgRecipientPda = this.deriveMessageRecipientPda(address);
-    const accountInfo = await connection.getAccountInfo(msgRecipientPda);
+    const pda = this.deriveProgramStoragePDA(address);
+    const accountInfo = await connection.getAccountInfo(pda);
     if (!accountInfo)
-      throw new Error(
-        `No account info found for ${msgRecipientPda.toBase58()}}`,
-      );
+      throw new Error(`No account info found for ${pda.toBase58()}}`);
 
     const accountData = deserializeUnchecked(
       HelloWorldDataSchema,

typescript/helloworld/src/multiProtocolApp/types.ts

@@ -5,8 +5,6 @@ import {
 } from '@hyperlane-xyz/sdk';
 import { Address } from '@hyperlane-xyz/utils';
 
-import { StatCounts } from '../app/types';
-
 export interface IHelloWorldAdapter extends IRouterAdapter {
   populateSendHelloTx: (
     destination: ChainName,
@@ -15,10 +13,5 @@ export interface IHelloWorldAdapter extends IRouterAdapter {
     sender: Address,
   ) => Promise<TypedTransaction>;
 
-  // TODO break apart into separate origin + destination methods to
-  // handle case where origin/dest protocols differ
-  channelStats: (
-    destination: ChainName,
-    destinationMailbox: Address,
-  ) => Promise<StatCounts>;
+  sentStat: (destination: ChainName) => Promise<number>;
 }

typescript/infra/config/environments/testnet3/helloworld/hyperlane/addresses.json

@@ -25,5 +25,8 @@
   },
   "sepolia": {
     "router": "0x5d56B8a669F50193b54319442c6EEE5edD662381"
+  },
+  "solanadevnet": {
+    "router": "CXQX54kdkU5GqdRJjCmHpwHfEMgFb5SeBmMWntP2Ds7J"
   }
 }

typescript/infra/scripts/helloworld/kathy.ts

@@ -37,7 +37,12 @@ import { DeployEnvironment } from '../../src/config/environment';
 import { Role } from '../../src/roles';
 import { startMetricsServer } from '../../src/utils/metrics';
 import { assertChain, diagonalize, sleep } from '../../src/utils/utils';
-import { getAddressesForKey, getArgs, withContext } from '../utils';
+import {
+  getAddressesForKey,
+  getArgs,
+  getEnvironmentConfig,
+  withContext,
+} from '../utils';
 
 import { getHelloWorldMultiProtocolApp } from './utils';
 
@@ -160,9 +165,8 @@ async function main(): Promise<boolean> {
   startMetricsServer(metricsRegister);
   debug('Starting up', { environment });
 
-  // TODO (Rossy) remove getCoreConfigStub and re-enable getEnvironmentConfig
-  // const coreConfig = getEnvironmentConfig(environment);
-  const coreConfig = getCoreConfigStub(environment);
+  const coreConfig = getEnvironmentConfig(environment);
+  // const coreConfig = getCoreConfigStub(environment);
 
   const { app, core, igp, multiProvider, keys } =
     await getHelloWorldMultiProtocolApp(

typescript/infra/scripts/helloworld/utils.ts

@@ -14,10 +14,10 @@ import {
   chainMetadata,
   filterAddressesToProtocol,
   hyperlaneEnvironments,
+  hyperlaneEnvironmentsWithSealevel,
   igpFactories,
 } from '@hyperlane-xyz/sdk';
-import { hyperlaneEnvironmentsWithSealevel } from '@hyperlane-xyz/sdk/src';
-import { ProtocolType, objMerge } from '@hyperlane-xyz/utils';
+import { ProtocolType, objMap } from '@hyperlane-xyz/utils';
 
 import { Contexts } from '../../config/contexts';
 import { EnvironmentConfig } from '../../src/config';
@@ -62,6 +62,9 @@ export async function getHelloWorldMultiProtocolApp(
     connectionType,
   );
   const sdkEnvName = deployEnvToSdkEnv[coreConfig.environment];
+  const envAddresses = hyperlaneEnvironments[sdkEnvName];
+  const envAddressesWithSealevel =
+    hyperlaneEnvironmentsWithSealevel[sdkEnvName];
   const keys = await coreConfig.getKeys(keyContext, keyRole);
 
   const helloworldConfig = getHelloWorldConfig(coreConfig, context);
@@ -76,13 +79,17 @@ export async function getHelloWorldMultiProtocolApp(
   }
 
   const core = MultiProtocolCore.fromAddressesMap(
-    hyperlaneEnvironmentsWithSealevel[sdkEnvName],
+    envAddressesWithSealevel,
     multiProtocolProvider,
   );
 
-  const routersAndMailboxes = objMerge(
-    core.chainMap,
+  const routersAndMailboxes = objMap(
     helloworldConfig.addresses,
+    (chain, addresses) => ({
+      router: addresses.router,
+      // @ts-ignore allow loosely typed chain name to index env addresses
+      mailbox: envAddressesWithSealevel[chain].mailbox,
+    }),
   );
   const app = new HelloMultiProtocolApp(
     multiProtocolProvider,
@@ -92,7 +99,6 @@ export async function getHelloWorldMultiProtocolApp(
   // TODO we need a MultiProtocolIgp
   // Using an standard IGP for just evm chains for now
   // Unfortunately this requires hacking surgically around certain addresses
-  const envAddresses = hyperlaneEnvironments[sdkEnvName];
   const filteredAddresses = filterAddressesToProtocol(
     envAddresses,
     ProtocolType.Ethereum,

typescript/sdk/src/core/adapters/SealevelCoreAdapter.ts

@@ -1,6 +1,12 @@
 import { PublicKey } from '@solana/web3.js';
 
-import { Address, HexString, pollAsync } from '@hyperlane-xyz/utils';
+import {
+  Address,
+  HexString,
+  ensure0x,
+  pollAsync,
+  strip0x,
+} from '@hyperlane-xyz/utils';
 
 import { BaseSealevelAdapter } from '../../app/MultiProtocolApp';
 import { MultiProtocolProvider } from '../../providers/MultiProtocolProvider';
@@ -35,14 +41,13 @@ export class SealevelCoreAdapter
         `Unsupported provider type for SealevelCoreAdapter ${sourceTx.type}`,
       );
     }
-    const receipt = sourceTx.receipt;
-    const logs = receipt.meta?.logMessages;
+    const logs = sourceTx.receipt.meta?.logMessages;
     if (!logs)
       throw new Error('Transaction logs required to check message delivery');
     const parsedLogs = SealevelCoreAdapter.parseMessageDispatchLogs(logs);
     if (!parsedLogs.length) throw new Error('Message dispatch log not found');
     return parsedLogs.map(({ destination, messageId }) => ({
-      messageId: Buffer.from(messageId, 'hex').toString('hex'),
+      messageId: ensure0x(messageId),
       destination: this.multiProvider.getChainName(destination),
     }));
   }
@@ -144,10 +149,16 @@ export class SealevelCoreAdapter
 
   static deriveMailboxMessageProcessedPda(
     mailboxProgramId: string | PublicKey,
-    messageId: string,
+    messageId: HexString,
   ): PublicKey {
     return super.derivePda(
-      ['hyperlane', '-', 'processed_message', Buffer.from(messageId, 'hex')],
+      [
+        'hyperlane',
+        '-',
+        'processed_message',
+        '-',
+        Buffer.from(strip0x(messageId), 'hex'),
+      ],
       mailboxProgramId,
     );
   }

typescript/utils/src/addresses.ts

@@ -135,14 +135,14 @@ export function isValidTransactionHashSealevel(input: string) {
   return SEALEVEL_TX_HASH_REGEX.test(input);
 }
 
-export function isValidTransactionHash(input: string, protocol?: ProtocolType) {
-  return routeAddressUtil(
-    isValidTransactionHashEvm,
-    isValidTransactionHashSealevel,
-    false,
-    input,
-    protocol,
-  );
+export function isValidTransactionHash(input: string, protocol: ProtocolType) {
+  if (protocol === ProtocolType.Ethereum) {
+    return isValidTransactionHashEvm(input);
+  } else if (protocol === ProtocolType.Sealevel) {
+    return isValidTransactionHashSealevel(input);
+  } else {
+    return false;
+  }
 }
 
 export function isZeroishAddress(address: Address) {