Add Cosmos support to Utils and SDK

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

@@ -0,0 +1,35 @@
+import { HexString } from '@hyperlane-xyz/utils';
+
+import { BaseCwAdapter } from '../../app/MultiProtocolApp';
+import { ChainName } from '../../types';
+
+import { ProviderType, TypedTransactionReceipt } from '../../providers/ProviderType';
+import { ICoreAdapter } from './types';
+
+// This adapter just routes to the HyperlaneCore
+// Which implements the needed functionality for Cw chains
+// TODO deprecate HyperlaneCore and replace all Cw-specific classes with adapters
+export class CwCoreAdapter extends BaseCwAdapter implements ICoreAdapter {
+  public readonly contractAddress = this.addresses.mailbox;
+
+  extractMessageIds(
+    sourceTx: TypedTransactionReceipt,
+  ): Array<{ messageId: string; destination: ChainName }> {
+    if (sourceTx.type !== ProviderType.Cosmos) {
+      throw new Error(
+        `Unsupported provider type for CosmosCoreAdapter ${sourceTx.type}`,
+      );
+    }
+    // TODO: parse mailbox logs and extract message ids
+    throw new Error("Method not implemented.");
+  }
+
+  async waitForMessageProcessed(
+    messageId: HexString,
+    destination: ChainName,
+    delayMs?: number,
+    maxAttempts?: number,
+  ): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+}

typescript/sdk/src/router/adapters/CwRouterAdapter.ts

@@ -0,0 +1,100 @@
+import { Address, Domain } from '@hyperlane-xyz/utils';
+
+import { BaseCwAdapter } from '../../app/MultiProtocolApp';
+import { MultiProtocolProvider } from '../../providers/MultiProtocolProvider';
+import { ChainName } from '../../types';
+
+import { IGasRouterAdapter, IRouterAdapter } from './types';
+
+// TODO: import from ts bindings
+type IsmResponse = {
+  ism: Address;
+};
+
+type OwnerResponse = {
+  owner: Address;
+};
+
+type DomainsResponse = {
+  domains: number[];
+};
+
+type DomainRouteSet = {
+  domain: number;
+  route: string;
+};
+
+type RouteResponse = {
+  route: DomainRouteSet;
+};
+
+type RoutesResponse = {
+  routes: DomainRouteSet[];
+};
+
+export class CwRouterAdapter extends BaseCwAdapter implements IRouterAdapter {
+  public readonly contractAddress: Address;
+
+  constructor(
+    public readonly chainName: ChainName,
+    public readonly multiProvider: MultiProtocolProvider<any>,
+    public readonly addresses: { router: Address },
+  ) {
+    super(chainName, multiProvider, addresses);
+    this.contractAddress = addresses.router;
+  }
+
+  async interchainSecurityModule(): Promise<Address> {
+    const ismResponse: IsmResponse =
+      await this.getProvider().queryContractSmart(this.contractAddress, {
+        get_ism: {},
+      });
+    return ismResponse.ism;
+  }
+
+  async owner(): Promise<Address> {
+    const ownerResponse: OwnerResponse =
+      await this.getProvider().queryContractSmart(this.contractAddress, {
+        owner: {},
+      });
+    return ownerResponse.owner;
+  }
+
+  async remoteDomains(): Promise<Domain[]> {
+    const domainsResponse: DomainsResponse =
+      await this.getProvider().queryContractSmart(this.contractAddress, {
+        domains: {},
+      });
+    return domainsResponse.domains;
+  }
+
+  async remoteRouter(remoteDomain: Domain): Promise<Address> {
+    const routeResponse: RouteResponse =
+      await this.getProvider().queryContractSmart(this.contractAddress, {
+        get_route: {
+          domain: remoteDomain,
+        },
+      });
+    return routeResponse.route.route;
+  }
+
+  async remoteRouters(): Promise<Array<{ domain: Domain; address: Address }>> {
+    const routesResponse: RoutesResponse =
+      await this.getProvider().queryContractSmart(this.contractAddress, {
+        list_routes: {},
+      });
+    return routesResponse.routes.map((r) => ({
+      domain: r.domain,
+      address: r.route,
+    }));
+  }
+}
+
+export class CwGasRouterAdapter
+  extends CwRouterAdapter
+  implements IGasRouterAdapter
+{
+  async quoteGasPayment(_: ChainName): Promise<string> {
+    throw new Error('Method not implemented.');
+  }
+}

typescript/sdk/src/token/adapters/ITokenAdapter.ts

@@ -27,10 +27,11 @@ export interface ITokenAdapter {
 }
 
 export interface IHypTokenAdapter extends ITokenAdapter {
-  getDomains(): Promise<Domain[]>;
-  getRouterAddress(domain: Domain): Promise<Buffer>;
-  getAllRouters(): Promise<Array<{ domain: Domain; address: Buffer }>>;
-  quoteGasPayment(destination: Domain): Promise<string>;
+  // TODO: migrate into IRouterAdapter?
+  // getDomains(): Promise<Domain[]>;
+  // getRouterAddress(domain: Domain): Promise<Buffer>;
+  // getAllRouters(): Promise<Array<{ domain: Domain; address: Buffer }>>;
+  // quoteGasPayment(destination: Domain): Promise<string>;
   populateTransferRemoteTx(
     TransferParams: TransferRemoteParams,
   ): unknown | Promise<unknown>;