@keplr-wallet/provider 0.12.0-alpha.0 → 0.12.0-alpha.2

package/src/core.ts

@@ -1,4 +1,3 @@
-import { ChainIdHelper } from "@keplr-wallet/cosmos";
 import {
   ChainInfo,
   EthSignType,
@@ -7,44 +6,34 @@ import {
   KeplrMode,
   KeplrSignOptions,
   Key,
-} from "@keplr-wallet/types";
-import { BACKGROUND_PORT, MessageRequester } from "@keplr-wallet/router";
-import {
   BroadcastMode,
   AminoSignResponse,
   StdSignDoc,
   StdTx,
-  OfflineSigner,
+  OfflineAminoSigner,
   StdSignature,
-} from "@cosmjs/launchpad";
+  DirectSignResponse,
+  OfflineDirectSigner,
+  ICNSAdr36Signatures,
+  ChainInfoWithoutEndpoints,
+  SecretUtils,
+  SettledResponses,
+} from "@keplr-wallet/types";
 import {
-  EnableAccessMsg,
-  SuggestChainInfoMsg,
-  GetKeyMsg,
-  SuggestTokenMsg,
-  SendTxMsg,
-  GetSecret20ViewingKey,
-  RequestSignAminoMsg,
-  RequestSignDirectMsg,
-  GetPubkeyMsg,
-  ReqeustEncryptMsg,
-  RequestDecryptMsg,
-  GetTxEncryptionKeyMsg,
-  RequestVerifyADR36AminoSignDoc,
-} from "./types";
-import { SecretUtils } from "secretjs/types/enigmautils";
+  BACKGROUND_PORT,
+  MessageRequester,
+  sendSimpleMessage,
+} from "@keplr-wallet/router";
 
 import { KeplrEnigmaUtils } from "./enigma";
-import { DirectSignResponse, OfflineDirectSigner } from "@cosmjs/proto-signing";
 
 import { CosmJSOfflineSigner, CosmJSOfflineSignerOnlyAmino } from "./cosmjs";
 import deepmerge from "deepmerge";
 import Long from "long";
 import { Buffer } from "buffer/";
+import { KeplrCoreTypes } from "./core-types";
 
-type Writeable<T> = { -readonly [P in keyof T]: T[P] };
-
-export class Keplr implements IKeplr {
+export class Keplr implements IKeplr, KeplrCoreTypes {
   protected enigmaUtils: Map<string, SecretUtils> = new Map();
 
   public defaultOptions: KeplrIntereactionOptions = {};
@@ -60,14 +49,35 @@ export class Keplr implements IKeplr {
       chainIds = [chainIds];
     }
 
-    await this.requester.sendMessage(
+    await sendSimpleMessage(
+      this.requester,
       BACKGROUND_PORT,
-      new EnableAccessMsg(chainIds)
+      "permission-interactive",
+      "enable-access",
+      {
+        chainIds,
+      }
+    );
+  }
+
+  async disable(chainIds?: string | string[]): Promise<void> {
+    if (typeof chainIds === "string") {
+      chainIds = [chainIds];
+    }
+
+    await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "permission-interactive",
+      "disable-access",
+      {
+        chainIds: chainIds ?? [],
+      }
     );
   }
 
   async experimentalSuggestChain(
-    suggestingChainInfo: ChainInfo & {
+    chainInfo: ChainInfo & {
       // Legacy
       gasPriceStep?: {
         readonly low: number;
@@ -76,40 +86,21 @@ export class Keplr implements IKeplr {
       };
     }
   ): Promise<void> {
-    const chainIdentifier = ChainIdHelper.parse(suggestingChainInfo.chainId)
-      .identifier;
-    // TODO: 테스트 끝나면 chainapsis public repo URL로 바꿔야 한다.
-    const chainInfoResponse = await fetch(
-      `https://raw.githubusercontent.com/danielkim89/cicd-test/main/cosmos/${chainIdentifier}.json`
-    );
-    let chainInfo: Writeable<
-      ChainInfo & {
-        // Legacy
-        gasPriceStep?: {
-          readonly low: number;
-          readonly average: number;
-          readonly high: number;
-        };
-      }
-    > = suggestingChainInfo;
-    if (chainInfoResponse.ok) {
-      chainInfo = await chainInfoResponse.json();
-      chainInfo.isFromCommunity = true;
-    }
-
     if (chainInfo.gasPriceStep) {
       // Gas price step in ChainInfo is legacy format.
       // Try to change the recent format for backward-compatibility.
       const gasPriceStep = { ...chainInfo.gasPriceStep };
       for (const feeCurrency of chainInfo.feeCurrencies) {
         if (!feeCurrency.gasPriceStep) {
-          (feeCurrency as {
-            gasPriceStep?: {
-              readonly low: number;
-              readonly average: number;
-              readonly high: number;
-            };
-          }).gasPriceStep = gasPriceStep;
+          (
+            feeCurrency as {
+              gasPriceStep?: {
+                readonly low: number;
+                readonly average: number;
+                readonly high: number;
+              };
+            }
+          ).gasPriceStep = gasPriceStep;
         }
       }
       delete chainInfo.gasPriceStep;
@@ -119,13 +110,58 @@ export class Keplr implements IKeplr {
       );
     }
 
-    const msg = new SuggestChainInfoMsg(chainInfo);
-    await this.requester.sendMessage(BACKGROUND_PORT, msg);
+    if ((chainInfo as any).coinType) {
+      console.warn(
+        "The `coinType` field of the `ChainInfo` is removed. This is automatically handled as of right now, but the upcoming update would potentially cause errors."
+      );
+      delete (chainInfo as any).coinType;
+    }
+
+    return await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "chains",
+      "suggest-chain-info",
+      {
+        chainInfo,
+      }
+    );
   }
 
   async getKey(chainId: string): Promise<Key> {
-    const msg = new GetKeyMsg(chainId);
-    return await this.requester.sendMessage(BACKGROUND_PORT, msg);
+    return await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "keyring-cosmos",
+      "get-cosmos-key",
+      {
+        chainId,
+      }
+    );
+  }
+
+  async getKeysSettled(chainIds: string[]): Promise<SettledResponses<Key>> {
+    return await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "keyring-cosmos",
+      "get-cosmos-keys-settled",
+      {
+        chainIds,
+      }
+    );
+  }
+
+  async getChainInfosWithoutEndpoints(): Promise<ChainInfoWithoutEndpoints[]> {
+    return (
+      await sendSimpleMessage(
+        this.requester,
+        BACKGROUND_PORT,
+        "chains",
+        "get-chain-infos-without-endpoints",
+        {}
+      )
+    ).chainInfos;
   }
 
   async sendTx(
@@ -133,8 +169,17 @@ export class Keplr implements IKeplr {
     tx: StdTx | Uint8Array,
     mode: BroadcastMode
   ): Promise<Uint8Array> {
-    const msg = new SendTxMsg(chainId, tx, mode);
-    return await this.requester.sendMessage(BACKGROUND_PORT, msg);
+    return await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "background-tx",
+      "send-tx-to-background",
+      {
+        chainId,
+        tx,
+        mode,
+      }
+    );
   }
 
   async signAmino(
@@ -143,13 +188,18 @@ export class Keplr implements IKeplr {
     signDoc: StdSignDoc,
     signOptions: KeplrSignOptions = {}
   ): Promise<AminoSignResponse> {
-    const msg = new RequestSignAminoMsg(
-      chainId,
-      signer,
-      signDoc,
-      deepmerge(this.defaultOptions.sign ?? {}, signOptions)
+    return await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "keyring-cosmos",
+      "request-cosmos-sign-amino",
+      {
+        chainId,
+        signer,
+        signDoc,
+        signOptions: deepmerge(this.defaultOptions.sign ?? {}, signOptions),
+      }
     );
-    return await this.requester.sendMessage(BACKGROUND_PORT, msg);
   }
 
   async signDirect(
@@ -163,20 +213,25 @@ export class Keplr implements IKeplr {
     },
     signOptions: KeplrSignOptions = {}
   ): Promise<DirectSignResponse> {
-    const msg = new RequestSignDirectMsg(
-      chainId,
-      signer,
+    const response = await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "keyring-cosmos",
+      "request-cosmos-sign-direct",
       {
-        bodyBytes: signDoc.bodyBytes,
-        authInfoBytes: signDoc.authInfoBytes,
-        chainId: signDoc.chainId,
-        accountNumber: signDoc.accountNumber
-          ? signDoc.accountNumber.toString()
-          : null,
-      },
-      deepmerge(this.defaultOptions.sign ?? {}, signOptions)
+        chainId,
+        signer,
+        signDoc: {
+          bodyBytes: signDoc.bodyBytes,
+          authInfoBytes: signDoc.authInfoBytes,
+          chainId: signDoc.chainId,
+          accountNumber: signDoc.accountNumber
+            ? signDoc.accountNumber.toString()
+            : null,
+        },
+        signOptions: deepmerge(this.defaultOptions.sign ?? {}, signOptions),
+      }
     );
-    const response = await this.requester.sendMessage(BACKGROUND_PORT, msg);
 
     return {
       signed: {
@@ -194,14 +249,20 @@ export class Keplr implements IKeplr {
     signer: string,
     data: string | Uint8Array
   ): Promise<StdSignature> {
-    let isADR36WithString: boolean;
-    [data, isADR36WithString] = this.getDataForADR36(data);
-    const signDoc = this.getADR36SignDoc(signer, data);
-
-    const msg = new RequestSignAminoMsg(chainId, signer, signDoc, {
-      isADR36WithString,
-    });
-    return (await this.requester.sendMessage(BACKGROUND_PORT, msg)).signature;
+    return await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "keyring-cosmos",
+      "request-cosmos-sign-amino-adr-36",
+      {
+        chainId,
+        signer,
+        data: typeof data === "string" ? Buffer.from(data) : data,
+        signOptions: {
+          isADR36WithString: typeof data === "string",
+        },
+      }
+    );
   }
 
   async verifyArbitrary(
@@ -214,52 +275,62 @@ export class Keplr implements IKeplr {
       data = Buffer.from(data);
     }
 
-    return await this.requester.sendMessage(
+    return await sendSimpleMessage(
+      this.requester,
       BACKGROUND_PORT,
-      new RequestVerifyADR36AminoSignDoc(chainId, signer, data, signature)
+      "keyring-cosmos",
+      "verify-cosmos-sign-amino-adr-36",
+      {
+        chainId,
+        signer,
+        data,
+        signature,
+      }
     );
   }
 
   async signEthereum(
-    chainId: string,
-    signer: string,
-    data: string | Uint8Array,
-    type: EthSignType
+    _chainId: string,
+    _signer: string,
+    _data: string | Uint8Array,
+    _type: EthSignType
   ): Promise<Uint8Array> {
-    if (type !== EthSignType.MESSAGE && type !== EthSignType.TRANSACTION) {
-      throw new Error(
-        "Unsupported Ethereum signing type: expected 'message' or 'transaction.'"
-      );
-    }
-
-    let isADR36WithString: boolean;
-    [data, isADR36WithString] = this.getDataForADR36(data);
-    const signDoc = this.getADR36SignDoc(signer, data);
-
-    if (data === "") {
-      throw new Error("Signing empty data is not supported.");
-    }
+    throw new Error("TODO");
+  }
 
-    const msg = new RequestSignAminoMsg(chainId, signer, signDoc, {
-      isADR36WithString,
-      ethSignType: type,
-    });
-    const signature = (await this.requester.sendMessage(BACKGROUND_PORT, msg))
-      .signature;
-    return Buffer.from(signature.signature, "base64");
+  async signICNSAdr36(
+    chainId: string,
+    contractAddress: string,
+    owner: string,
+    username: string,
+    addressChainIds: string[]
+  ): Promise<ICNSAdr36Signatures> {
+    return await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "keyring-cosmos",
+      "request-icns-adr-36-signatures-v2",
+      {
+        chainId,
+        contractAddress,
+        owner,
+        username,
+        addressChainIds,
+      }
+    );
   }
 
-  getOfflineSigner(chainId: string): OfflineSigner & OfflineDirectSigner {
+  getOfflineSigner(chainId: string): OfflineAminoSigner & OfflineDirectSigner {
     return new CosmJSOfflineSigner(chainId, this);
   }
 
-  getOfflineSignerOnlyAmino(chainId: string): OfflineSigner {
+  getOfflineSignerOnlyAmino(chainId: string): OfflineAminoSigner {
     return new CosmJSOfflineSignerOnlyAmino(chainId, this);
   }
 
   async getOfflineSignerAuto(
     chainId: string
-  ): Promise<OfflineSigner | OfflineDirectSigner> {
+  ): Promise<OfflineAminoSigner | OfflineDirectSigner> {
     const key = await this.getKey(chainId);
     if (key.isNanoLedger) {
       return new CosmJSOfflineSignerOnlyAmino(chainId, this);
@@ -272,22 +343,44 @@ export class Keplr implements IKeplr {
     contractAddress: string,
     viewingKey?: string
   ): Promise<void> {
-    const msg = new SuggestTokenMsg(chainId, contractAddress, viewingKey);
-    await this.requester.sendMessage(BACKGROUND_PORT, msg);
+    return await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "token-cw20",
+      "SuggestTokenMsg",
+      {
+        chainId,
+        contractAddress,
+        viewingKey,
+      }
+    );
   }
 
   async getSecret20ViewingKey(
     chainId: string,
     contractAddress: string
   ): Promise<string> {
-    const msg = new GetSecret20ViewingKey(chainId, contractAddress);
-    return await this.requester.sendMessage(BACKGROUND_PORT, msg);
+    return await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "token-cw20",
+      "get-secret20-viewing-key",
+      {
+        chainId,
+        contractAddress,
+      }
+    );
   }
 
   async getEnigmaPubKey(chainId: string): Promise<Uint8Array> {
-    return await this.requester.sendMessage(
+    return await sendSimpleMessage(
+      this.requester,
       BACKGROUND_PORT,
-      new GetPubkeyMsg(chainId)
+      "secret-wasm",
+      "get-pubkey-msg",
+      {
+        chainId,
+      }
     );
   }
 
@@ -295,9 +388,15 @@ export class Keplr implements IKeplr {
     chainId: string,
     nonce: Uint8Array
   ): Promise<Uint8Array> {
-    return await this.requester.sendMessage(
+    return await sendSimpleMessage(
+      this.requester,
       BACKGROUND_PORT,
-      new GetTxEncryptionKeyMsg(chainId, nonce)
+      "secret-wasm",
+      "get-tx-encryption-key-msg",
+      {
+        chainId,
+        nonce,
+      }
     );
   }
 
@@ -307,24 +406,38 @@ export class Keplr implements IKeplr {
     // eslint-disable-next-line @typescript-eslint/ban-types
     msg: object
   ): Promise<Uint8Array> {
-    return await this.requester.sendMessage(
+    return await sendSimpleMessage(
+      this.requester,
       BACKGROUND_PORT,
-      new ReqeustEncryptMsg(chainId, contractCodeHash, msg)
+      "secret-wasm",
+      "request-encrypt-msg",
+      {
+        chainId,
+        contractCodeHash,
+        msg,
+      }
     );
   }
 
   async enigmaDecrypt(
     chainId: string,
-    ciphertext: Uint8Array,
+    cipherText: Uint8Array,
     nonce: Uint8Array
   ): Promise<Uint8Array> {
-    if (!ciphertext || ciphertext.length === 0) {
+    if (!cipherText || cipherText.length === 0) {
       return new Uint8Array();
     }
 
-    return await this.requester.sendMessage(
+    return await sendSimpleMessage(
+      this.requester,
       BACKGROUND_PORT,
-      new RequestDecryptMsg(chainId, ciphertext, nonce)
+      "secret-wasm",
+      "request-decrypt-msg",
+      {
+        chainId,
+        cipherText,
+        nonce,
+      }
     );
   }
 
@@ -339,36 +452,58 @@ export class Keplr implements IKeplr {
     return enigmaUtils;
   }
 
-  protected getDataForADR36(data: string | Uint8Array): [string, boolean] {
-    let isADR36WithString = false;
-    if (typeof data === "string") {
-      data = Buffer.from(data).toString("base64");
-      isADR36WithString = true;
-    } else {
-      data = Buffer.from(data).toString("base64");
-    }
-    return [data, isADR36WithString];
+  async 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> {
+    return await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "keyring-cosmos",
+      "request-sign-eip-712-cosmos-tx-v0",
+      {
+        chainId,
+        signer,
+        eip712,
+        signDoc,
+        signOptions: deepmerge(this.defaultOptions.sign ?? {}, signOptions),
+      }
+    );
   }
 
-  protected getADR36SignDoc(signer: string, data: string): StdSignDoc {
-    return {
-      chain_id: "",
-      account_number: "0",
-      sequence: "0",
-      fee: {
-        gas: "0",
-        amount: [],
-      },
-      msgs: [
-        {
-          type: "sign/MsgSignData",
-          value: {
-            signer,
-            data,
-          },
-        },
-      ],
-      memo: "",
-    };
+  async __core__getAnalyticsId(): Promise<string> {
+    return await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "analytics",
+      "get-analytics-id",
+      {}
+    );
+  }
+
+  async changeKeyRingName({
+    defaultName,
+    editable = true,
+  }: {
+    defaultName: string;
+    editable?: boolean;
+  }): Promise<string> {
+    return await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "keyring-v2",
+      "change-keyring-name-interactive",
+      {
+        defaultName,
+        editable,
+      }
+    );
   }
 }

package/src/cosmjs.ts

@@ -1,15 +1,15 @@
 import {
-  OfflineSigner,
+  Keplr,
+  OfflineDirectSigner,
+  OfflineAminoSigner,
   AccountData,
   AminoSignResponse,
   StdSignDoc,
-} from "@cosmjs/launchpad";
-import { Keplr } from "@keplr-wallet/types";
-import { OfflineDirectSigner } from "@cosmjs/proto-signing";
-import { DirectSignResponse } from "@cosmjs/proto-signing/build/signer";
-import { SignDoc } from "@cosmjs/proto-signing/build/codec/cosmos/tx/v1beta1/tx";
+  DirectSignResponse,
+  SignDoc,
+} from "@keplr-wallet/types";
 
-export class CosmJSOfflineSignerOnlyAmino implements OfflineSigner {
+export class CosmJSOfflineSignerOnlyAmino implements OfflineAminoSigner {
   constructor(
     protected readonly chainId: string,
     protected readonly keplr: Keplr
@@ -56,11 +56,9 @@ export class CosmJSOfflineSignerOnlyAmino implements OfflineSigner {
 
 export class CosmJSOfflineSigner
   extends CosmJSOfflineSignerOnlyAmino
-  implements OfflineSigner, OfflineDirectSigner {
-  constructor(
-    protected readonly chainId: string,
-    protected readonly keplr: Keplr
-  ) {
+  implements OfflineAminoSigner, OfflineDirectSigner
+{
+  constructor(chainId: string, keplr: Keplr) {
     super(chainId, keplr);
   }
 

package/src/enigma.ts

@@ -1,5 +1,4 @@
-import { SecretUtils } from "secretjs/types/enigmautils";
-import { Keplr } from "@keplr-wallet/types";
+import { Keplr, SecretUtils } from "@keplr-wallet/types";
 
 /**
  * KeplrEnigmaUtils duplicates the public methods that are supported on secretjs's EnigmaUtils class.