cosmos-connect-core 0.1.0

package/src/adapters/WalletConnectWallet.ts

@@ -0,0 +1,125 @@
+import { WalletConnectV2 } from "./utils/WalletConnectV2.js";
+import { WalletAdapter, Chain, Account } from "../core/types.js";
+import { base64 } from "@goblinhunt/cosmes/codec";
+import { MobileAppDetails } from "./utils/QRCodeModal.js";
+
+export class WalletConnectWallet implements WalletAdapter {
+  id = "walletConnect";
+  name = "Other Wallets";
+  icon =
+    "https://raw.githubusercontent.com/WalletConnect/walletconnect-assets/master/Logo/Blue%20(Default)/Logo.svg";
+
+  private wc: WalletConnectV2;
+  private _uri: string = "";
+  private _connecting: boolean = false;
+  private _updateCallback?: () => void;
+
+  constructor({
+    projectId,
+    id,
+    name,
+    icon,
+    mobileAppDetails,
+  }: {
+    projectId: string;
+    id?: string;
+    name?: string;
+    icon?: string;
+    mobileAppDetails?: MobileAppDetails;
+  }) {
+    if (id) this.id = id;
+    if (name) this.name = name;
+    if (icon) this.icon = icon;
+
+    const details = mobileAppDetails || {
+      name: "Cosmos Connect",
+      description: "Connect to Cosmos app",
+      url: typeof window !== "undefined" ? window.location.origin : "",
+      icons: [
+        "https://raw.githubusercontent.com/WalletConnect/walletconnect-assets/master/Logo/Blue%20(Default)/Logo.svg",
+      ],
+      android:
+        "intent://wcV2#Intent;package=com.chainapsis.keplr;scheme=keplrwallet;end;", // Default to Keplr for android
+      ios: "keplrwallet://wcV2", // Default to Keplr for ios
+    };
+
+    this.wc = new WalletConnectV2(projectId, details);
+
+    this.wc.onUri((uri: string) => {
+      this._uri = uri;
+      this._updateCallback?.();
+    });
+  }
+
+  installed(): boolean {
+    return false;
+  }
+
+  getUri(): string {
+    return this._uri;
+  }
+
+  private _connectPromise: Promise<Account> | null = null;
+
+  async connect(chain: Chain): Promise<Account> {
+    if (this._connectPromise) {
+      console.log(
+        "WalletConnectWallet: connect already in progress, returning existing promise...",
+      );
+      return this._connectPromise;
+    }
+
+    this._connectPromise = (async () => {
+      console.log(
+        "WalletConnectWallet: connect called for chain",
+        chain.chainId,
+      );
+      this._connecting = true;
+      try {
+        // This will trigger our onUri callback
+        console.log("WalletConnectWallet: triggering wc.connect...");
+        await this.wc.connect([chain.chainId]);
+        console.log("WalletConnectWallet: wc.connect settled");
+
+        // After approval, keys are set
+        const accountRes = await this.wc.getAccount(chain.chainId);
+
+        return {
+          address: accountRes.address,
+          pubKey: base64.decode(accountRes.pubkey),
+          algo: accountRes.algo,
+          name: accountRes.name,
+        };
+      } catch (e) {
+        console.error("WalletConnectWallet: Connection failed", e);
+        throw e;
+      } finally {
+        this._connecting = false;
+        this._connectPromise = null;
+      }
+    })();
+
+    return this._connectPromise;
+  }
+
+  async disconnect(): Promise<void> {
+    this.wc.disconnect();
+    this._uri = "";
+    this._connecting = false;
+  }
+
+  async signTx(_bytes: Uint8Array): Promise<Uint8Array> {
+    throw new Error(
+      "signTx not implemented directly on adapter. Use client.signAndBroadcast",
+    );
+  }
+
+  onUpdate(callback: () => void) {
+    this._updateCallback = callback;
+  }
+
+  // Helper for direct access if needed
+  get client() {
+    return this.wc;
+  }
+}

package/src/adapters/utils/QRCodeModal.ts

@@ -0,0 +1,73 @@
+import { isAndroid, isMobile } from "./os.js";
+
+export type MobileAppDetails = {
+  name: string;
+  android: string;
+  ios: string;
+  isStation?: boolean;
+  isLuncDash?: boolean;
+  description?: string;
+  url?: string;
+  icons?: string[];
+  projectId?: string;
+};
+
+export class QRCodeModal {
+  private details: MobileAppDetails;
+
+  // Expose URI for external access (monkey-patch hook)
+  // Static or instance property? WalletConnectV2 creates a NEW instance each time.
+  // So we need a way to extract it.
+  // The official QRCodeModal renders to DOM.
+  // The WalletConnectWallet adapter will PATCH the prototype or instance.
+
+  constructor(details: MobileAppDetails) {
+    this.details = details;
+  }
+
+  open(uri: string) {
+    console.log("QRCodeModalStub open called with:", uri);
+    // Default behavior is to redirect on mobile
+    if (isMobile() && typeof window !== "undefined") {
+      const schemeUri = this.getSchemeUri(uri);
+      if (this.details.isStation) {
+        window.location.href = schemeUri;
+      } else if (isAndroid()) {
+        window.location.href = this.generateAndroidIntent(uri);
+      } else {
+        window.location.href = this.generateIosIntent(uri);
+      }
+    }
+  }
+
+  close() {
+    console.log("QRCodeModalStub close called");
+  }
+
+  private getSchemeUri(uri: string): string {
+    return this.details.isStation
+      ? this.details.isLuncDash
+        ? `luncdash://wallet_connect?${encodeURIComponent(
+            `payload=${encodeURIComponent(uri)}`,
+          )}`
+        : `https://terrastation.page.link/?link=https://terra.money?${encodeURIComponent(
+            `action=wallet_connect&payload=${encodeURIComponent(uri)}`,
+          )}&apn=money.terra.station&ibi=money.terra.station&isi=1548434735`
+      : uri;
+  }
+
+  private generateAndroidIntent(uri: string): string {
+    const hashIndex = this.details.android.indexOf("#");
+    if (hashIndex === -1) return this.details.android;
+    return (
+      this.details.android.slice(0, hashIndex) +
+      "?" +
+      encodeURIComponent(uri) +
+      this.details.android.slice(hashIndex)
+    );
+  }
+
+  private generateIosIntent(uri: string): string {
+    return this.details.ios + "?" + encodeURIComponent(uri);
+  }
+}

package/src/adapters/utils/WalletConnectV2.ts

@@ -0,0 +1,388 @@
+// @ts-nocheck
+import SignClient from "@walletconnect/sign-client";
+import { isAndroid, isMobile } from "./os.js";
+import { MobileAppDetails } from "./QRCodeModal.js";
+import { debounce } from "lodash-es";
+
+// Re-defining internal types as they are not exported
+export type GetAccountResponse = {
+  name?: string | undefined;
+  address: string;
+  algo: string;
+  pubkey: string;
+};
+
+export type WcSignAminoResponse = {
+  signature: {
+    signature: string;
+  };
+  signed?: any | undefined;
+};
+
+export type SignAminoResponse = Required<WcSignAminoResponse>;
+
+export type WcSignDirectResponse = {
+  signature: {
+    signature: string;
+  };
+  signed?: any | undefined;
+};
+export type SignDirectResponse = Required<WcSignDirectResponse>;
+
+export type WalletConnectV2Config = {
+  disableConnectionCheck?: boolean;
+};
+
+const Method = {
+  GET_ACCOUNTS: "cosmos_getAccounts",
+  SIGN_AMINO: "cosmos_signAmino",
+  SIGN_DIRECT: "cosmos_signDirect",
+  SIGN_ARBITRARY: "keplr_signArbitrary",
+  ADD_CHAIN: "keplr_experimentalSuggestChain",
+} as const;
+
+const Event = {
+  CHAIN_CHANGED: "chainChanged",
+  ACCOUNTS_CHANGED: "accountsChanged",
+} as const;
+
+const DEFAULT_SIGN_OPTIONS = {
+  preferNoSetFee: true,
+  preferNoSetMemo: true,
+};
+
+export class WalletConnectV2 {
+  private readonly projectId: string;
+  private readonly mobileAppDetails: MobileAppDetails;
+  private readonly sessionStorageKey: string;
+  private readonly accountStorageKey: string;
+  private readonly onDisconnectCbs: Set<() => unknown>;
+  private readonly onAccountChangeCbs: Set<() => unknown>;
+  private readonly onUriCbs: Set<(uri: string) => unknown>;
+  private signClient: any | null;
+  private config?: WalletConnectV2Config;
+
+  constructor(
+    projectId: string,
+    mobileAppDetails: MobileAppDetails,
+    config?: WalletConnectV2Config,
+  ) {
+    this.projectId = projectId;
+    this.mobileAppDetails = mobileAppDetails;
+    this.sessionStorageKey = `cosmes.wallet.${mobileAppDetails.name.toLowerCase()}.wcSession`;
+    this.accountStorageKey = `cosmes.wallet.${mobileAppDetails.name.toLowerCase()}.lastAccount`;
+    this.onDisconnectCbs = new Set();
+    this.onAccountChangeCbs = new Set();
+    this.onUriCbs = new Set();
+    this.signClient = null;
+    this.config = config;
+  }
+
+  onUri(cb: (uri: string) => unknown): () => void {
+    this.onUriCbs.add(cb);
+    return () => {
+      this.onUriCbs.delete(cb);
+    };
+  }
+
+  async addChain(chainId: string, chainInfo: any): Promise<void> {
+    if (!this.signClient) {
+      throw new Error("SignClient is not initialized");
+    }
+    await this.request(chainId, Method.ADD_CHAIN, {
+      chainInfo,
+    });
+  }
+
+  async connect(chainIds: string[]): Promise<void> {
+    // Initialise the sign client and event listeners if they don't already exist
+    if (!this.signClient) {
+      console.log("WalletConnectV2: Initializing SignClient...");
+      try {
+        this.signClient = await (SignClient as any).init({
+          projectId: this.projectId,
+          relayUrl: "wss://relay.walletconnect.com",
+          metadata: {
+            name: this.mobileAppDetails.name,
+            description: this.mobileAppDetails.description || "Cosmos App",
+            url:
+              this.mobileAppDetails.url ||
+              (typeof window !== "undefined" ? window.location.origin : ""),
+            icons: this.mobileAppDetails.icons || [],
+          },
+        });
+        console.log("WalletConnectV2: SignClient initialized");
+      } catch (err) {
+        console.error("WalletConnectV2: Failed to initialize SignClient", err);
+        throw err;
+      }
+      // Disconnect if the session is disconnected or expired
+      this.signClient.on("session_delete", ({ topic }: { topic: string }) =>
+        this._disconnect(topic),
+      );
+      this.signClient.on("session_expire", ({ topic }: { topic: string }) =>
+        this._disconnect(topic),
+      );
+      // Handle the `accountsChanged` event
+      const handleAccountChange = debounce(
+        // Handler is debounced as the `accountsChanged` event is fired once for
+        // each connected chain, but we only want to trigger the callback once.
+        () => this.onAccountChangeCbs.forEach((cb) => cb()),
+        300,
+        { leading: true, trailing: false },
+      );
+      this.signClient.on("session_event", ({ params }: { params: any }) => {
+        if (params.event.name === Event.ACCOUNTS_CHANGED) {
+          handleAccountChange();
+        }
+      });
+    }
+    // Check if a valid session already exists
+    const oldSession = localStorage.getItem(this.sessionStorageKey);
+    const chainIdsSet = new Set(chainIds);
+
+    if (oldSession) {
+      const { topic, chainIds: storedIds } = JSON.parse(oldSession);
+      const storedIdsSet = new Set<string>(storedIds);
+      if (chainIds.every((id) => storedIdsSet.has(id))) {
+        // Assume we want a fresh session for the UI to show the QR code
+        // unless explicitly disabled.
+        if (this.config?.disableConnectionCheck) {
+          return;
+        }
+        // Force disconnect old session to ensure a new URI is generated
+        this._disconnect(topic);
+      } else {
+        // Otherwise, we need to merge the stored IDs with the requested IDs
+        for (const id of storedIds) {
+          chainIdsSet.add(id);
+        }
+      }
+    }
+    // Initialise a new session
+    const { uri, approval } = await this.signClient!.connect({
+      optionalNamespaces: {
+        cosmos: {
+          chains: [...chainIdsSet].map((id) => this.toCosmosNamespace(id)),
+          methods: Object.values(Method),
+          events: Object.values(Event),
+        },
+      },
+    });
+    if (uri) {
+      console.log("WalletConnectV2: URI generated", uri);
+      this._uri = uri; // Store it locally too
+      this.onUriCbs.forEach((cb) => cb(uri));
+      console.log("WalletConnectV2: Waiting for approval...");
+      const approvalPromise = approval();
+      const timeoutPromise = new Promise((_, reject) =>
+        setTimeout(
+          () => reject(new Error("Connection approval timed out")),
+          60000,
+        ),
+      );
+
+      const { topic } = await (Promise.race([
+        approvalPromise,
+        timeoutPromise,
+      ]) as Promise<{ topic: string }>);
+
+      console.log("WalletConnectV2: Approved session topic", topic);
+      // Save this new session to local storage
+      const newSession = {
+        topic,
+        chainIds: [...chainIdsSet],
+      };
+      localStorage.setItem(this.sessionStorageKey, JSON.stringify(newSession));
+    }
+  }
+
+  disconnect() {
+    const session = localStorage.getItem(this.sessionStorageKey);
+    if (session) {
+      const { topic } = JSON.parse(session);
+      this._disconnect(topic);
+    }
+  }
+
+  onDisconnect(cb: () => unknown): () => void {
+    this.onDisconnectCbs.add(cb);
+    return () => {
+      this.onDisconnectCbs.delete(cb);
+    };
+  }
+
+  onAccountChange(cb: () => unknown): () => void {
+    this.onAccountChangeCbs.add(cb);
+    return () => {
+      this.onAccountChangeCbs.delete(cb);
+    };
+  }
+
+  async getAccount(chainId: string): Promise<GetAccountResponse> {
+    if (!this.config?.disableConnectionCheck) {
+      const res = await this.request(chainId, Method.GET_ACCOUNTS, {});
+      // result might be array or single object depending on wallet impl, usually array
+      return Array.isArray(res) ? res[0] : res;
+    }
+    try {
+      const timeout = new Promise((_, reject) =>
+        setTimeout(() => reject(new Error("Request timed out")), 3000),
+      );
+      const resArray: any = await Promise.race([
+        this.request(chainId, Method.GET_ACCOUNTS, {}),
+        timeout,
+      ]);
+      const res = Array.isArray(resArray) ? resArray[0] : resArray;
+      // Store successful response
+      this.onDisconnect(() => {
+        localStorage.removeItem(this.accountStorageKey);
+      });
+      localStorage.setItem(this.accountStorageKey, JSON.stringify(res));
+      return res;
+    } catch (e) {
+      // Try to get stored account data
+      const stored = localStorage.getItem(this.accountStorageKey);
+      if (stored) {
+        const account = JSON.parse(stored);
+        // Try to refresh in background
+        this.request(chainId, Method.GET_ACCOUNTS, {})
+          .then((res: any) => {
+            const accountData = Array.isArray(res) ? res[0] : res;
+            localStorage.setItem(
+              this.accountStorageKey,
+              JSON.stringify(accountData),
+            );
+          })
+          .catch(() => {});
+        this.onDisconnect(() => {
+          localStorage.removeItem(this.accountStorageKey);
+        });
+        return account;
+      }
+      throw e;
+    }
+  }
+
+  async signArbitrary(
+    chainId: string,
+    signerAddress: string,
+    data: string,
+  ): Promise<{ signature: string }> {
+    return this.request(chainId, Method.SIGN_ARBITRARY, {
+      chainId,
+      signer: signerAddress,
+      type: "string",
+      data,
+    });
+  }
+
+  async signAmino(
+    chainId: string,
+    signerAddress: string,
+    stdSignDoc: any,
+  ): Promise<SignAminoResponse> {
+    const { signature, signed } = await this.request(
+      chainId,
+      Method.SIGN_AMINO,
+      {
+        signerAddress,
+        signDoc: stdSignDoc,
+        signOptions: DEFAULT_SIGN_OPTIONS,
+      },
+    );
+    return {
+      signature: signature,
+      signed: signed ?? stdSignDoc,
+    };
+  }
+
+  async signDirect(
+    chainId: string,
+    signerAddress: string,
+    signDoc: any,
+  ): Promise<SignDirectResponse> {
+    const { signature, signed } = await this.request(
+      chainId,
+      Method.SIGN_DIRECT,
+      {
+        signerAddress,
+        signDoc,
+        signOptions: DEFAULT_SIGN_OPTIONS,
+      },
+    );
+    return {
+      signature: signature,
+      signed: signed ?? signDoc,
+    };
+  }
+
+  private isConnected(
+    signClient: any,
+    topic: string,
+    timeoutSeconds: number,
+  ): Promise<boolean> {
+    const tryPing = async () =>
+      signClient
+        .ping({ topic })
+        .then(() => true)
+        .catch(() => false);
+    const waitDisconnect = async () =>
+      new Promise<boolean>((resolve) => {
+        // @ts-ignore
+        signClient.on("session_delete", (res) => {
+          if (topic === res.topic) {
+            resolve(false);
+          }
+        });
+        // @ts-ignore
+        signClient.on("session_expire", (res) => {
+          if (topic === res.topic) {
+            resolve(false);
+          }
+        });
+      });
+    const timeout = async () =>
+      new Promise<boolean>((resolve) =>
+        setTimeout(() => resolve(false), timeoutSeconds * 1000),
+      );
+    return Promise.race([tryPing(), waitDisconnect(), timeout()]);
+  }
+
+  private _disconnect(topic: string) {
+    const session = localStorage.getItem(this.sessionStorageKey);
+    if (!session || session.includes(topic)) {
+      localStorage.removeItem(this.sessionStorageKey);
+      this.onDisconnectCbs.forEach((cb) => cb());
+    }
+  }
+
+  private async request(
+    chainId: string,
+    method: string,
+    params: any,
+  ): Promise<any> {
+    const session = localStorage.getItem(this.sessionStorageKey);
+    if (!session || !this.signClient) {
+      throw new Error("Session not found for " + chainId);
+    }
+    const { topic } = JSON.parse(session);
+    if (isMobile() && method !== Method.GET_ACCOUNTS) {
+      window.location.href = isAndroid()
+        ? this.mobileAppDetails.android
+        : this.mobileAppDetails.ios;
+    }
+    return this.signClient!.request({
+      topic,
+      chainId: this.toCosmosNamespace(chainId),
+      request: {
+        method,
+        params,
+      },
+    });
+  }
+
+  private toCosmosNamespace(chainId: string): string {
+    return "cosmos:" + chainId;
+  }
+}

package/src/adapters/utils/os.ts

@@ -0,0 +1 @@
+export { isAndroid, isIOS, isMobile } from "@goblinhunt/cosmes/wallet";

package/src/core/account.ts

@@ -0,0 +1,7 @@
+// import { Account } from "./types.js";
+
+// Currently just a placeholder for potential account-related utilities
+export function formatShortAddress(address: string, prefixLen = 8, suffixLen = 4): string {
+  if (!address) return "";
+  return `${address.slice(0, prefixLen)}...${address.slice(-suffixLen)}`;
+}

package/src/core/chain.ts

@@ -0,0 +1,15 @@
+import { Chain } from "./types.js";
+
+export const TERRA_CLASSIC: Chain = {
+  chainId: "columbus-5",
+  rpc: "https://rpc-columbus-5.garuda-defi.org/",
+  rest: "https://lcd-columbus-5.garuda-defi.org/",
+  bech32Prefix: "terra",
+  gasPrice: "28.325uluna", // Approximate gas price for LUNC
+};
+
+export const DEFAULT_CHAINS: Chain[] = [TERRA_CLASSIC];
+
+export function findChain(chains: Chain[], chainId: string): Chain | undefined {
+  return chains.find((c) => c.chainId === chainId);
+}