@keplr-wallet/wc-client 0.12.21-rc.2 → 0.12.22-rc.0

package/src/index.ts

@@ -1,263 +1,295 @@
 import {
-  IConnector,
-  IJsonRpcRequest,
-  IRequestOptions,
-} from "@walletconnect/types";
-import {
+  AminoSignResponse,
+  BroadcastMode,
   ChainInfo,
+  ChainInfoWithoutEndpoints,
+  DirectSignResponse,
   EthSignType,
+  ICNSAdr36Signatures,
   Keplr,
   KeplrIntereactionOptions,
   KeplrMode,
   KeplrSignOptions,
   Key,
-  DirectSignResponse,
-  OfflineDirectSigner,
-  AminoSignResponse,
-  BroadcastMode,
   OfflineAminoSigner,
-  StdSignature,
-  StdSignDoc,
-  ICNSAdr36Signatures,
-  ChainInfoWithoutEndpoints,
+  OfflineDirectSigner,
   SecretUtils,
   SettledResponses,
+  StdSignature,
+  StdSignDoc,
 } from "@keplr-wallet/types";
+import SignClient from "@walletconnect/sign-client";
 import {
   CosmJSOfflineSigner,
   CosmJSOfflineSignerOnlyAmino,
 } from "@keplr-wallet/provider";
-import { payloadId } from "@walletconnect/utils";
-import deepmerge from "deepmerge";
 import { Buffer } from "buffer/";
-import { IndexedDBKVStore, KVStore } from "@keplr-wallet/common";
-
-// VersionFormatRegExp checks if a chainID is in the format required for parsing versions
-// The chainID should be in the form: `{identifier}-{version}`
-const ChainVersionFormatRegExp = /(.+)-([\d]+)/;
-
-function parseChainId(chainId: string): {
-  identifier: string;
-  version: number;
-} {
-  const split = chainId.split(ChainVersionFormatRegExp).filter(Boolean);
-  if (split.length !== 2) {
-    return {
-      identifier: chainId,
-      version: 0,
-    };
-  } else {
-    return { identifier: split[0], version: parseInt(split[1]) };
-  }
+import { ProposalTypes, SessionTypes } from "@walletconnect/types";
+import Long from "long";
+
+interface RequestParams {
+  topic: string;
+  request: {
+    method: string;
+    params: any;
+  };
+  chainId: string;
+  expiry?: number;
+}
+
+interface KeplrGetKeyWalletConnectV2Response {
+  // Name of the selected key store.
+  readonly name: string;
+  readonly algo: string;
+  readonly pubKey: string;
+  readonly address: string;
+  readonly bech32Address: string;
+  readonly isNanoLedger: boolean;
 }
 
-export type KeplrGetKeyWalletCoonectV1Response = {
-  address: string;
-  algo: string;
-  bech32Address: string;
-  isKeystone: boolean;
-  isNanoLedger: boolean;
-  name: string;
-  pubKey: string;
-};
-
-export type KeplrKeystoreMayChangedEventParam = {
-  algo: string;
-  name: string;
-  isKeystone: boolean;
-  isNanoLedger: boolean;
-  keys: {
-    chainIdentifier: string;
-    address: string;
-    bech32Address: string;
-    pubKey: string;
-  }[];
-};
-
-export class KeplrWalletConnectV1 implements Keplr {
+export class KeplrWalletConnectV2 implements Keplr {
+  defaultOptions: KeplrIntereactionOptions = {};
+
+  readonly version: string = "0.12.20";
+  readonly mode: KeplrMode = "walletconnect";
+  protected readonly storeKey = "keplr_wallet_connect_v2_key";
+
   constructor(
-    public readonly connector: IConnector,
+    public readonly signClient: SignClient,
     public readonly options: {
-      kvStore?: KVStore;
       sendTx?: Keplr["sendTx"];
-      onBeforeSendRequest?: (
-        request: Partial<IJsonRpcRequest>,
-        options?: IRequestOptions
-      ) => Promise<void> | void;
-      onAfterSendRequest?: (
-        response: any,
-        request: Partial<IJsonRpcRequest>,
-        options?: IRequestOptions
-      ) => Promise<void> | void;
-    } = {}
+      sessionProperties?: ProposalTypes.SessionProperties;
+    }
   ) {
-    if (!options.kvStore) {
-      options.kvStore = new IndexedDBKVStore("keplr_wallet_connect");
+    if (options.sessionProperties) {
+      this.saveKeys(options.sessionProperties);
     }
 
-    connector.on("disconnect", () => {
-      this.clearSaved();
+    signClient.on("session_event", (event) => {
+      if (event.params.event.name === "keplr_accountsChanged") {
+        this.saveKeys(event.params.event.data);
+
+        window.dispatchEvent(new Event("keplr_keystorechange"));
+      }
     });
 
-    connector.on("call_request", this.onCallReqeust);
+    signClient.on("session_delete", async () => {
+      localStorage.removeItem(this.getKeyLastSeenKey());
+    });
   }
 
-  readonly version: string = "0.9.0";
-  readonly mode: KeplrMode = "walletconnect";
-
-  defaultOptions: KeplrIntereactionOptions = {};
+  protected saveKeys(sessionProperty: ProposalTypes.SessionProperties) {
+    if (sessionProperty.hasOwnProperty("keys")) {
+      const keys = JSON.parse(sessionProperty["keys"]);
 
-  protected readonly onCallReqeust = async (
-    error: Error | null,
-    payload: any | null
-  ) => {
-    if (error) {
-      console.log(error);
-      return;
-    }
-
-    if (!payload) {
-      return;
+      if (keys.length > 0) {
+        keys.forEach((key: any) => {
+          if (key.hasOwnProperty("chainId")) {
+            this.saveLastSeenKey(
+              key["chainId"],
+              this.convertToKeplrGetKeyWalletConnectV2Response(key)
+            );
+          }
+        });
+      }
     }
+  }
 
+  protected convertToKeplrGetKeyWalletConnectV2Response(
+    data: any
+  ): KeplrGetKeyWalletConnectV2Response {
     if (
-      payload.method === "keplr_keystore_may_changed_event_wallet_connect_v1"
+      !data.hasOwnProperty("name") ||
+      !data.hasOwnProperty("algo") ||
+      !data.hasOwnProperty("pubKey") ||
+      !data.hasOwnProperty("address") ||
+      !data.hasOwnProperty("bech32Address") ||
+      !data.hasOwnProperty("isNanoLedger")
     ) {
-      const param = payload.params[0] as
-        | KeplrKeystoreMayChangedEventParam
-        | undefined;
-      if (!param) {
-        return;
-      }
+      throw new Error("Invalid data");
+    }
 
-      const lastSeenKeys = await this.getAllLastSeenKey();
-      if (!lastSeenKeys) {
-        return;
-      }
+    return {
+      name: data.name as string,
+      algo: data.algo as string,
+      pubKey: data.pubKey as string,
+      address: data.address as string,
+      bech32Address: data.bech32Address as string,
+      isNanoLedger: data.isNanoLedger === "true",
+    };
+  }
 
-      const mayChangedKeyMap: Record<
-        string,
-        KeplrGetKeyWalletCoonectV1Response
-      > = {};
-      for (const mayChangedKey of param.keys) {
-        mayChangedKeyMap[mayChangedKey.chainIdentifier] = {
-          address: mayChangedKey.address,
-          algo: param.algo,
-          bech32Address: mayChangedKey.bech32Address,
-          isKeystone: param.isKeystone,
-          isNanoLedger: param.isNanoLedger,
-          name: param.name,
-          pubKey: mayChangedKey.pubKey,
-        };
-      }
+  protected getLastSession(): SessionTypes.Struct | undefined {
+    const lastKeyIndex = this.signClient.session.getAll().length - 1;
+    return this.signClient.session.getAll()[lastKeyIndex];
+  }
 
-      let hasChanged = false;
-
-      for (const chainId of Object.keys(lastSeenKeys)) {
-        const savedKey = lastSeenKeys[chainId];
-        if (savedKey) {
-          const { identifier } = parseChainId(chainId);
-          const mayChangedKey = mayChangedKeyMap[identifier];
-          if (mayChangedKey) {
-            if (
-              mayChangedKey.algo !== savedKey.algo ||
-              mayChangedKey.name !== savedKey.name ||
-              mayChangedKey.isKeystone !== savedKey.isKeystone ||
-              mayChangedKey.isNanoLedger !== savedKey.isNanoLedger ||
-              mayChangedKey.address !== savedKey.address ||
-              mayChangedKey.bech32Address !== savedKey.bech32Address ||
-              mayChangedKey.pubKey !== savedKey.pubKey
-            ) {
-              hasChanged = true;
-
-              lastSeenKeys[chainId] = mayChangedKey;
-            }
-          }
-        }
-      }
+  protected getCurrentTopic(): string {
+    const lastSession = this.getLastSession();
 
-      if (hasChanged) {
-        await this.saveAllLastSeenKey(lastSeenKeys);
-        window.dispatchEvent(new Event("keplr_keystorechange"));
-      }
+    if (!lastSession) {
+      throw new Error("No session");
     }
-  };
 
-  protected async clearSaved(): Promise<void> {
-    const kvStore = this.options.kvStore!;
+    return lastSession.topic;
+  }
 
-    await Promise.all([
-      kvStore.set(this.getKeyHasEnabled(), null),
-      kvStore.set(this.getKeyLastSeenKey(), null),
-    ]);
+  protected getKeyLastSeenKey() {
+    const topic = this.getCurrentTopic();
+    return `${this.storeKey}/${topic}-key`;
   }
 
-  protected async sendCustomRequest(
-    request: Partial<IJsonRpcRequest>,
-    options?: IRequestOptions
-  ): Promise<any> {
-    if (this.options.onBeforeSendRequest) {
-      await this.options.onBeforeSendRequest(request, options);
+  protected getLastSeenKey(
+    chainId: string
+  ): KeplrGetKeyWalletConnectV2Response | undefined {
+    const saved = this.getAllLastSeenKey();
+
+    if (!saved) {
+      return undefined;
     }
 
-    const res = await this.connector.sendCustomRequest(request, options);
+    return saved[chainId];
+  }
 
-    if (this.options.onAfterSendRequest) {
-      await this.options.onAfterSendRequest(res, request, options);
+  protected getAllLastSeenKey() {
+    const data = localStorage.getItem(this.getKeyLastSeenKey());
+    if (!data) {
+      return undefined;
     }
 
-    return res;
+    return JSON.parse(data);
   }
 
-  async enable(chainIds: string | string[]): Promise<void> {
-    if (typeof chainIds === "string") {
-      chainIds = [chainIds];
-    }
+  protected saveLastSeenKey(
+    chainId: string,
+    response: KeplrGetKeyWalletConnectV2Response
+  ) {
+    let saved = this.getAllLastSeenKey();
 
-    const hasEnabledChainIds = await this.getHasEnabledChainIds();
-    let allEnabled = true;
-    for (const chainId of chainIds) {
-      if (hasEnabledChainIds.indexOf(chainId) < 0) {
-        allEnabled = false;
-        break;
-      }
+    if (!saved) {
+      saved = {};
     }
 
-    if (allEnabled) {
-      return;
-    }
+    saved[chainId] = response;
 
-    await this.sendCustomRequest({
-      id: payloadId(),
-      jsonrpc: "2.0",
-      method: "keplr_enable_wallet_connect_v1",
-      params: chainIds,
-    });
+    this.saveAllLastSeenKey(saved);
+  }
 
-    await this.saveHasEnabledChainIds(chainIds);
+  protected saveAllLastSeenKey(data: {
+    [chainId: string]: KeplrGetKeyWalletConnectV2Response | undefined;
+  }) {
+    localStorage.setItem(this.getKeyLastSeenKey(), JSON.stringify(data));
+  }
+
+  protected async sendCustomRequest<T>(
+    requestParams: RequestParams
+  ): Promise<T> {
+    const response = await this.signClient.request(requestParams);
+    return response as T;
   }
 
-  protected getKeyHasEnabled() {
-    return `${this.connector.session.handshakeTopic}-enabled`;
+  protected getNamespaceChainId(): string {
+    const lastSession = this.getLastSession();
+
+    if (
+      lastSession &&
+      lastSession.namespaces.hasOwnProperty("cosmos") &&
+      lastSession.namespaces["cosmos"].hasOwnProperty("accounts")
+    ) {
+      const splitAccount =
+        lastSession.namespaces["cosmos"]["accounts"][0].split(":");
+
+      return `${splitAccount[0]}:${splitAccount[1]}`;
+    }
+
+    return "cosmos:cosmoshub-4";
   }
 
-  protected async getHasEnabledChainIds(): Promise<string[]> {
-    return (
-      (await this.options.kvStore!.get<string[]>(this.getKeyHasEnabled())) ?? []
+  protected checkDeepLink() {
+    const mobileLinkInfo = localStorage.getItem(
+      "wallet-connect-v2-mobile-link"
     );
+
+    if (mobileLinkInfo) {
+      window.location.href = JSON.parse(mobileLinkInfo).href;
+    }
+  }
+
+  changeKeyRingName(_opts: {
+    defaultName: string;
+    editable?: boolean | undefined;
+  }): Promise<string> {
+    throw new Error("Not yet implemented");
   }
 
-  protected async saveHasEnabledChainIds(chainIds: string[]) {
-    const hasEnabledChainIds = await this.getHasEnabledChainIds();
-    for (const chainId of chainIds) {
-      if (hasEnabledChainIds.indexOf(chainId) < 0) {
-        hasEnabledChainIds.push(chainId);
+  disable(_chainIds?: string | string[]): Promise<void> {
+    throw new Error("Not yet implemented");
+  }
+
+  async enable(chainIds: string | string[]): Promise<void> {
+    if (typeof chainIds === "string") {
+      chainIds = [chainIds];
+    }
+
+    // Check public key from local storage.
+    const keys = await this.getAllLastSeenKey();
+    if (keys) {
+      const hasChainId = chainIds.every((chainId) => {
+        return Object.keys(keys).includes(chainId);
+      });
+
+      if (hasChainId) {
+        return;
       }
     }
-    await this.options.kvStore!.set(
-      this.getKeyHasEnabled(),
-      hasEnabledChainIds
-    );
+
+    this.checkDeepLink();
+
+    // Request enable from the mobile wallet.
+    const topic = this.getCurrentTopic();
+    const chainId = this.getNamespaceChainId();
+    if (!chainId) {
+      throw new Error("No Namespace chain id");
+    }
+    const param = {
+      topic: topic,
+      chainId: this.getNamespaceChainId(),
+      request: {
+        method: "keplr_enable",
+        params: {
+          chainId: chainIds,
+        },
+      },
+    };
+
+    await this.sendCustomRequest<void>(param);
+
+    // session의 정보가 업데이트 되기 전에 다음로직이 실행되면 안되기 때문에 namespace가 업데이트 될때까지 기다린다.
+    // We wait for the namespace to be updated because we don't want the next logic to run before the session's information is updated.
+    return new Promise(async (resolve) => {
+      while (true) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        const lastSession = this.getLastSession();
+        if (
+          lastSession &&
+          lastSession.namespaces.hasOwnProperty("cosmos") &&
+          lastSession.namespaces["cosmos"].hasOwnProperty("accounts")
+        ) {
+          const hasChainId = lastSession.namespaces["cosmos"]["accounts"].some(
+            (account) => {
+              const chainId = account.replace("cosmos:", "").split(":")[0];
+              return chainIds.includes(chainId);
+            }
+          );
+
+          if (hasChainId) {
+            resolve();
+            return;
+          }
+        }
+      }
+    });
   }
 
   enigmaDecrypt(
@@ -277,10 +309,28 @@ export class KeplrWalletConnectV1 implements Keplr {
     throw new Error("Not yet implemented");
   }
 
+  experimentalSignEIP712CosmosTx_v0(
+    _chainId: string,
+    _signer: string,
+    _eip712: {
+      types: Record<string, { name: string; type: string }[] | undefined>;
+      domain: Record<string, any>;
+      primaryType: string;
+    },
+    _signDoc: StdSignDoc,
+    _signOptions: KeplrSignOptions = {}
+  ): Promise<AminoSignResponse> {
+    throw new Error("Not yet implemented");
+  }
+
   experimentalSuggestChain(_chainInfo: ChainInfo): Promise<void> {
     throw new Error("Not yet implemented");
   }
 
+  getChainInfosWithoutEndpoints(): Promise<ChainInfoWithoutEndpoints[]> {
+    throw new Error("Not yet implemented");
+  }
+
   getEnigmaPubKey(_chainId: string): Promise<Uint8Array> {
     throw new Error("Not yet implemented");
   }
@@ -297,122 +347,81 @@ export class KeplrWalletConnectV1 implements Keplr {
   }
 
   async getKey(chainId: string): Promise<Key> {
-    const lastSeenKey = await this.getLastSeenKey(chainId);
+    // Check public key from local storage.
+    const lastSeenKey = this.getLastSeenKey(chainId);
     if (lastSeenKey) {
       return {
-        address: Buffer.from(lastSeenKey.address, "hex"),
         algo: lastSeenKey.algo,
         bech32Address: lastSeenKey.bech32Address,
-        isKeystone: lastSeenKey.isKeystone,
-        isNanoLedger: lastSeenKey.isNanoLedger,
+        address: Buffer.from(lastSeenKey.address, "base64"),
         name: lastSeenKey.name,
-        pubKey: Buffer.from(lastSeenKey.pubKey, "hex"),
+        pubKey: Buffer.from(lastSeenKey.pubKey, "base64"),
+        isNanoLedger: lastSeenKey.isNanoLedger,
+        isKeystone: false,
       };
     }
 
-    const response = (
-      await this.sendCustomRequest({
-        id: payloadId(),
-        jsonrpc: "2.0",
-        method: "keplr_get_key_wallet_connect_v1",
-        params: [chainId],
-      })
-    )[0] as KeplrGetKeyWalletCoonectV1Response;
-
-    await this.saveLastSeenKey(chainId, response);
-
-    return {
-      address: Buffer.from(response.address, "hex"),
-      algo: response.algo,
-      bech32Address: response.bech32Address,
-      isKeystone: response.isKeystone,
-      isNanoLedger: response.isNanoLedger,
-      name: response.name,
-      pubKey: Buffer.from(response.pubKey, "hex"),
-    };
-  }
-
-  getKeysSettled(_chainIds: string[]): Promise<SettledResponses<Key>> {
-    throw new Error("Not yet implemented");
-  }
-
-  protected getKeyLastSeenKey() {
-    return `${this.connector.session.handshakeTopic}-key`;
-  }
-
-  protected async getLastSeenKey(
-    chainId: string
-  ): Promise<KeplrGetKeyWalletCoonectV1Response | undefined> {
-    const saved = await this.getAllLastSeenKey();
-
-    if (!saved) {
-      return undefined;
-    }
-
-    return saved[chainId];
-  }
-
-  protected async getAllLastSeenKey() {
-    return await this.options.kvStore!.get<{
-      [chainId: string]: KeplrGetKeyWalletCoonectV1Response | undefined;
-    }>(this.getKeyLastSeenKey());
-  }
-
-  protected async saveAllLastSeenKey(data: {
-    [chainId: string]: KeplrGetKeyWalletCoonectV1Response | undefined;
-  }) {
-    await this.options.kvStore!.set(this.getKeyLastSeenKey(), data);
-  }
-
-  protected async saveLastSeenKey(
-    chainId: string,
-    response: KeplrGetKeyWalletCoonectV1Response
-  ) {
-    let saved = await this.getAllLastSeenKey();
-
-    if (!saved) {
-      saved = {};
+    // Check public key from session properties.
+    const lastSession = this.getLastSession();
+    if (lastSession && lastSession.sessionProperties) {
+      const sessionChainId = lastSession.sessionProperties["chainId"];
+
+      if (sessionChainId === chainId) {
+        return {
+          algo: lastSession.sessionProperties["algo"],
+          bech32Address: lastSession.sessionProperties["bech32Address"],
+          address: Buffer.from(
+            lastSession.sessionProperties["address"],
+            "base64"
+          ),
+          name: lastSession.sessionProperties["name"],
+          pubKey: Buffer.from(
+            lastSession.sessionProperties["pubKey"],
+            "base64"
+          ),
+          isNanoLedger:
+            lastSession.sessionProperties["isNanoLedger"] === "true",
+          isKeystone: false,
+        };
+      }
     }
 
-    saved[chainId] = response;
-
-    await this.saveAllLastSeenKey(saved);
-  }
+    // Request `get_key` from the mobile wallet.
+    const topic = this.getCurrentTopic();
+    const param = {
+      topic,
+      chainId: this.getNamespaceChainId(),
+      request: {
+        method: "keplr_getKey",
+        params: {
+          chainId,
+        },
+      },
+    };
 
-  signArbitrary(
-    _chainId: string,
-    _signer: string,
-    _data: string | Uint8Array
-  ): Promise<StdSignature> {
-    throw new Error("Not yet implemented");
-  }
+    const response = await this.sendCustomRequest<{
+      name: string;
+      algo: string;
+      pubKey: string;
+      address: string;
+      bech32Address: string;
+      isNanoLedger: boolean;
+    }>(param);
 
-  verifyArbitrary(
-    _chainId: string,
-    _signer: string,
-    _data: string | Uint8Array,
-    _signature: StdSignature
-  ): Promise<boolean> {
-    throw new Error("Not yet implemented");
+    return {
+      ...response,
+      pubKey: Buffer.from(response.pubKey, "base64"),
+      address: Buffer.from(response.address, "base64"),
+      isKeystone: false,
+    };
   }
 
-  signEthereum(
-    _chainId: string,
-    _signer: string,
-    _data: string | Uint8Array,
-    _mode: EthSignType
-  ): Promise<Uint8Array> {
-    throw new Error("Not yet implemented");
-  }
+  async getKeysSettled(chainIds: string[]): Promise<SettledResponses<Key>> {
+    const paramArray = chainIds.map(async (chainId) => {
+      return await this.getKey(chainId);
+    });
 
-  signICNSAdr36(
-    _chainId: string,
-    _contractAddress: string,
-    _owner: string,
-    _username: string,
-    _addressChainIds: string[]
-  ): Promise<ICNSAdr36Signatures> {
-    throw new Error("Not yet implemented");
+    return await Promise.allSettled(paramArray);
   }
 
   getOfflineSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner {
@@ -440,15 +449,6 @@ export class KeplrWalletConnectV1 implements Keplr {
     throw new Error("Not yet implemented");
   }
 
-  /**
-   * In the extension environment, this API let the extension to send the tx on behalf of the client.
-   * But, in the wallet connect environment, in order to send the tx on behalf of the client, wallet should receive the tx data from remote.
-   * However, this approach is not efficient and hard to ensure the stability and `KeplrWalletConnect` should have the informations of rpc and rest endpoints.
-   * So, rather than implementing this, just fallback to the client sided implementation or throw error of the client sided implementation is not delivered to the `options`.
-   * @param chainId
-   * @param stdTx
-   * @param mode
-   */
   sendTx(
     chainId: string,
     tx: Uint8Array,
@@ -465,71 +465,155 @@ export class KeplrWalletConnectV1 implements Keplr {
     chainId: string,
     signer: string,
     signDoc: StdSignDoc,
-    signOptions: KeplrSignOptions = {}
+    signOptions?: KeplrSignOptions
   ): Promise<AminoSignResponse> {
-    return (
-      await this.sendCustomRequest({
-        id: payloadId(),
-        jsonrpc: "2.0",
-        method: "keplr_sign_amino_wallet_connect_v1",
-        params: [
+    this.checkDeepLink();
+
+    const topic = this.getCurrentTopic();
+
+    const param = {
+      topic,
+      chainId: this.getNamespaceChainId(),
+      request: {
+        method: "keplr_signAmino",
+        params: {
           chainId,
           signer,
           signDoc,
-          deepmerge(this.defaultOptions.sign ?? {}, signOptions),
-        ],
-      })
-    )[0];
+          signOptions: signOptions,
+        },
+      },
+    };
+
+    return await this.sendCustomRequest<AminoSignResponse>(param);
   }
 
-  signDirect(
-    _chainId: string,
-    _signer: string,
-    _signDoc: {
+  signArbitrary(
+    chainId: string,
+    signer: string,
+    data: string | Uint8Array
+  ): Promise<StdSignature> {
+    this.checkDeepLink();
+
+    const topic = this.getCurrentTopic();
+
+    const param = {
+      topic,
+      chainId: this.getNamespaceChainId(),
+      request: {
+        method: "keplr_signArbitrary",
+        params: {
+          chainId,
+          signer,
+          type: typeof data === "string" ? "string" : "Uint8Array",
+          data:
+            typeof data === "string"
+              ? data
+              : Buffer.from(data).toString("base64"),
+        },
+      },
+    };
+    return this.sendCustomRequest<StdSignature>(param);
+  }
+
+  async signDirect(
+    chainId: string,
+    signer: string,
+    signDoc: {
       bodyBytes?: Uint8Array | null;
       authInfoBytes?: Uint8Array | null;
       chainId?: string | null;
       accountNumber?: Long | null;
     },
-    _signOptions: KeplrSignOptions = {}
+    signOptions?: KeplrSignOptions
   ): Promise<DirectSignResponse> {
-    throw new Error("Not yet implemented");
-  }
+    this.checkDeepLink();
 
-  suggestToken(
-    _chainId: string,
-    _contractAddress: string,
-    _viewingKey?: string
-  ): Promise<void> {
-    throw new Error("Not yet implemented");
+    const topic = this.getCurrentTopic();
+
+    const param = {
+      topic,
+      chainId: this.getNamespaceChainId(),
+      request: {
+        method: "keplr_signDirect",
+        params: {
+          chainId,
+          signer,
+          signDoc: {
+            chainId: signDoc.chainId,
+            accountNumber: signDoc.accountNumber?.toString(),
+            bodyBytes: signDoc.bodyBytes
+              ? Buffer.from(signDoc.bodyBytes).toString("base64")
+              : null,
+            authInfoBytes: signDoc.authInfoBytes
+              ? Buffer.from(signDoc.authInfoBytes).toString("base64")
+              : null,
+          },
+          signOptions: signOptions,
+        },
+      },
+    };
+
+    const response = await this.sendCustomRequest<{
+      readonly signed: {
+        bodyBytes?: string | null;
+        authInfoBytes?: string | null;
+        chainId?: string | null;
+        accountNumber?: string | null;
+      };
+      readonly signature: StdSignature;
+    }>(param);
+
+    return {
+      signature: response.signature,
+      signed: {
+        chainId: response.signed.chainId ?? "",
+        accountNumber: response.signed.accountNumber
+          ? Long.fromString(response.signed.accountNumber)
+          : new Long(0),
+        bodyBytes: response.signed.bodyBytes
+          ? Buffer.from(response.signed.bodyBytes, "base64")
+          : new Uint8Array([]),
+        authInfoBytes: response.signed.authInfoBytes
+          ? Buffer.from(response.signed.authInfoBytes, "base64")
+          : new Uint8Array([]),
+      },
+    };
   }
 
-  experimentalSignEIP712CosmosTx_v0(
+  signEthereum(
     _chainId: string,
     _signer: string,
-    _eip712: {
-      types: Record<string, { name: string; type: string }[] | undefined>;
-      domain: Record<string, any>;
-      primaryType: string;
-    },
-    _signDoc: StdSignDoc,
-    _signOptions: KeplrSignOptions = {}
-  ): Promise<AminoSignResponse> {
+    _data: string | Uint8Array,
+    _type: EthSignType
+  ): Promise<Uint8Array> {
     throw new Error("Not yet implemented");
   }
 
-  getChainInfosWithoutEndpoints(): Promise<ChainInfoWithoutEndpoints[]> {
+  signICNSAdr36(
+    _chainId: string,
+    _contractAddress: string,
+    _owner: string,
+    _username: string,
+    _addressChainIds: string[]
+  ): Promise<ICNSAdr36Signatures> {
     throw new Error("Not yet implemented");
   }
 
-  disable(_chainIds?: string | string[]): Promise<void> {
+  suggestToken(
+    _chainId: string,
+    _contractAddress: string,
+    _viewingKey?: string
+  ): Promise<void> {
     throw new Error("Not yet implemented");
   }
 
-  changeKeyRingName(_opts: {
-    defaultName: string;
-    editable?: boolean | undefined;
-  }): Promise<string> {
+  verifyArbitrary(
+    _chainId: string,
+    _signer: string,
+    _data: string | Uint8Array,
+    _signature: StdSignature
+  ): Promise<boolean> {
     throw new Error("Not yet implemented");
   }
 }