@keplr-wallet/provider 0.9.4 → 0.9.9

package/src/inject.ts

@@ -3,10 +3,11 @@ import {
   Keplr,
   Keplr as IKeplr,
   KeplrIntereactionOptions,
+  KeplrMode,
   KeplrSignOptions,
   Key,
 } from "@keplr-wallet/types";
-import { Result } from "@keplr-wallet/router";
+import { Result, JSONUint8Array } from "@keplr-wallet/router";
 import {
   BroadcastMode,
   AminoSignResponse,
@@ -14,15 +15,14 @@ import {
   StdTx,
   OfflineSigner,
 } from "@cosmjs/launchpad";
-import { cosmos } from "@keplr-wallet/cosmos";
 import { SecretUtils } from "secretjs/types/enigmautils";
 
 import { KeplrEnigmaUtils } from "./enigma";
 import { DirectSignResponse, OfflineDirectSigner } from "@cosmjs/proto-signing";
 
-import { JSONUint8Array } from "@keplr-wallet/router/build/json-uint8-array";
 import { CosmJSOfflineSigner, CosmJSOfflineSignerOnlyAmino } from "./cosmjs";
 import deepmerge from "deepmerge";
+import Long from "long";
 
 export interface ProxyRequest {
   type: "proxy-request";
@@ -44,9 +44,23 @@ export interface ProxyRequestResponse {
  * This will use `window.postMessage` to interact with the content script.
  */
 export class InjectedKeplr implements IKeplr {
-  static startProxy(keplr: IKeplr) {
-    window.addEventListener("message", async (e: any) => {
-      const message: ProxyRequest = e.data;
+  static startProxy(
+    keplr: IKeplr,
+    eventListener: {
+      addMessageListener: (fn: (e: any) => void) => void;
+      postMessage: (message: any) => void;
+    } = {
+      addMessageListener: (fn: (e: any) => void) =>
+        window.addEventListener("message", fn),
+      postMessage: (message) =>
+        window.postMessage(message, window.location.origin),
+    },
+    parseMessage?: (message: any) => any
+  ) {
+    eventListener.addMessageListener(async (e: any) => {
+      const message: ProxyRequest = parseMessage
+        ? parseMessage(e.data)
+        : e.data;
       if (!message || message.type !== "proxy-request") {
         return;
       }
@@ -60,6 +74,10 @@ export class InjectedKeplr implements IKeplr {
           throw new Error("Version is not function");
         }
 
+        if (message.method === "mode") {
+          throw new Error("Mode is not function");
+        }
+
         if (message.method === "defaultOptions") {
           throw new Error("DefaultOptions is not function");
         }
@@ -89,11 +107,45 @@ export class InjectedKeplr implements IKeplr {
           throw new Error("GetEnigmaUtils method can't be proxy request");
         }
 
-        const result = await keplr[message.method](
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-ignore
-          ...JSONUint8Array.unwrap(message.args)
-        );
+        const result =
+          message.method === "signDirect"
+            ? await (async () => {
+                const receivedSignDoc: {
+                  bodyBytes?: Uint8Array | null;
+                  authInfoBytes?: Uint8Array | null;
+                  chainId?: string | null;
+                  accountNumber?: string | null;
+                } = message.args[2];
+
+                const result = await keplr.signDirect(
+                  message.args[0],
+                  message.args[1],
+                  {
+                    bodyBytes: receivedSignDoc.bodyBytes,
+                    authInfoBytes: receivedSignDoc.authInfoBytes,
+                    chainId: receivedSignDoc.chainId,
+                    accountNumber: receivedSignDoc.accountNumber
+                      ? Long.fromString(receivedSignDoc.accountNumber)
+                      : null,
+                  },
+                  message.args[3]
+                );
+
+                return {
+                  signed: {
+                    bodyBytes: result.signed.bodyBytes,
+                    authInfoBytes: result.signed.authInfoBytes,
+                    chainId: result.signed.chainId,
+                    accountNumber: result.signed.accountNumber.toString(),
+                  },
+                  signature: result.signature,
+                };
+              })()
+            : await keplr[message.method](
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                ...JSONUint8Array.unwrap(message.args)
+              );
 
         const proxyResponse: ProxyRequestResponse = {
           type: "proxy-request-response",
@@ -103,7 +155,7 @@ export class InjectedKeplr implements IKeplr {
           },
         };
 
-        window.postMessage(proxyResponse, window.location.origin);
+        eventListener.postMessage(proxyResponse);
       } catch (e) {
         const proxyResponse: ProxyRequestResponse = {
           type: "proxy-request-response",
@@ -113,7 +165,7 @@ export class InjectedKeplr implements IKeplr {
           },
         };
 
-        window.postMessage(proxyResponse, window.location.origin);
+        eventListener.postMessage(proxyResponse);
       }
     });
   }
@@ -135,7 +187,9 @@ export class InjectedKeplr implements IKeplr {
 
     return new Promise((resolve, reject) => {
       const receiveResponse = (e: any) => {
-        const proxyResponse: ProxyRequestResponse = e.data;
+        const proxyResponse: ProxyRequestResponse = this.parseMessage
+          ? this.parseMessage(e.data)
+          : e.data;
 
         if (!proxyResponse || proxyResponse.type !== "proxy-request-response") {
           return;
@@ -145,7 +199,7 @@ export class InjectedKeplr implements IKeplr {
           return;
         }
 
-        window.removeEventListener("message", receiveResponse);
+        this.eventListener.removeMessageListener(receiveResponse);
 
         const result = JSONUint8Array.unwrap(proxyResponse.result);
 
@@ -162,9 +216,9 @@ export class InjectedKeplr implements IKeplr {
         resolve(result.return);
       };
 
-      window.addEventListener("message", receiveResponse);
+      this.eventListener.addMessageListener(receiveResponse);
 
-      window.postMessage(proxyMessage, window.location.origin);
+      this.eventListener.postMessage(proxyMessage);
     });
   }
 
@@ -172,7 +226,23 @@ export class InjectedKeplr implements IKeplr {
 
   public defaultOptions: KeplrIntereactionOptions = {};
 
-  constructor(public readonly version: string) {}
+  constructor(
+    public readonly version: string,
+    public readonly mode: KeplrMode,
+    protected readonly eventListener: {
+      addMessageListener: (fn: (e: any) => void) => void;
+      removeMessageListener: (fn: (e: any) => void) => void;
+      postMessage: (message: any) => void;
+    } = {
+      addMessageListener: (fn: (e: any) => void) =>
+        window.addEventListener("message", fn),
+      removeMessageListener: (fn: (e: any) => void) =>
+        window.removeEventListener("message", fn),
+      postMessage: (message) =>
+        window.postMessage(message, window.location.origin),
+    },
+    protected readonly parseMessage?: (message: any) => any
+  ) {}
 
   async enable(chainIds: string | string[]): Promise<void> {
     await this.requestMethod("enable", [chainIds]);
@@ -211,24 +281,46 @@ export class InjectedKeplr implements IKeplr {
   async signDirect(
     chainId: string,
     signer: string,
-    signDoc: cosmos.tx.v1beta1.ISignDoc,
+    signDoc: {
+      bodyBytes?: Uint8Array | null;
+      authInfoBytes?: Uint8Array | null;
+      chainId?: string | null;
+      accountNumber?: Long | null;
+    },
     signOptions: KeplrSignOptions = {}
   ): Promise<DirectSignResponse> {
     const result = await this.requestMethod("signDirect", [
       chainId,
       signer,
-      signDoc,
+      // We can't send the `Long` with remaing the type.
+      // Receiver should change the `string` to `Long`.
+      {
+        bodyBytes: signDoc.bodyBytes,
+        authInfoBytes: signDoc.authInfoBytes,
+        chainId: signDoc.chainId,
+        accountNumber: signDoc.accountNumber
+          ? signDoc.accountNumber.toString()
+          : null,
+      },
       deepmerge(this.defaultOptions.sign ?? {}, signOptions),
     ]);
 
-    // IMPORTANT: Remember that the proto message is encoded by not the Uint8Json but the Message#toJson.
-    //            So the result is not properly decoded as Uint8Array
-    //            and even it has the long type by string without type conversion.
-    //            So, we have to decode it by the proto message.
-    const jsonSignDoc = result.signed as { [k: string]: any };
-    const decodedSignDoc = cosmos.tx.v1beta1.SignDoc.fromObject(jsonSignDoc);
+    const signed: {
+      bodyBytes: Uint8Array;
+      authInfoBytes: Uint8Array;
+      chainId: string;
+      accountNumber: string;
+    } = result.signed;
+
     return {
-      signed: decodedSignDoc,
+      signed: {
+        bodyBytes: signed.bodyBytes,
+        authInfoBytes: signed.authInfoBytes,
+        chainId: signed.chainId,
+        // We can't send the `Long` with remaing the type.
+        // Sender should change the `Long` to `string`.
+        accountNumber: Long.fromString(signed.accountNumber),
+      },
       signature: result.signature,
     };
   }

package/src/types/index.ts

@@ -0,0 +1 @@
+export * from "./msgs";

package/src/types/msgs.ts

@@ -0,0 +1,423 @@
+import { Message } from "@keplr-wallet/router";
+import { ChainInfo, KeplrSignOptions, Key } from "@keplr-wallet/types";
+import { AminoSignResponse, StdSignature, StdSignDoc } from "@cosmjs/launchpad";
+
+export class EnableAccessMsg extends Message<void> {
+  public static type() {
+    return "enable-access";
+  }
+
+  constructor(public readonly chainIds: string[]) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.chainIds || this.chainIds.length === 0) {
+      throw new Error("chain id not set");
+    }
+  }
+
+  route(): string {
+    return "permission";
+  }
+
+  type(): string {
+    return EnableAccessMsg.type();
+  }
+}
+
+export class GetKeyMsg extends Message<Key> {
+  public static type() {
+    return "get-key";
+  }
+
+  constructor(public readonly chainId: string) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.chainId) {
+      throw new Error("chain id not set");
+    }
+  }
+
+  route(): string {
+    return "keyring";
+  }
+
+  type(): string {
+    return GetKeyMsg.type();
+  }
+}
+
+export class SuggestChainInfoMsg extends Message<void> {
+  public static type() {
+    return "suggest-chain-info";
+  }
+
+  constructor(public readonly chainInfo: ChainInfo) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.chainInfo) {
+      throw new Error("chain info not set");
+    }
+  }
+
+  route(): string {
+    return "chains";
+  }
+
+  type(): string {
+    return SuggestChainInfoMsg.type();
+  }
+}
+
+export class SuggestTokenMsg extends Message<void> {
+  public static type() {
+    return "suggest-token";
+  }
+
+  constructor(
+    public readonly chainId: string,
+    public readonly contractAddress: string,
+    public readonly viewingKey?: string
+  ) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.chainId) {
+      throw new Error("Chain id is empty");
+    }
+
+    if (!this.contractAddress) {
+      throw new Error("Contract address is empty");
+    }
+  }
+
+  route(): string {
+    return "tokens";
+  }
+
+  type(): string {
+    return SuggestTokenMsg.type();
+  }
+}
+
+// Return the tx hash
+export class SendTxMsg extends Message<Uint8Array> {
+  public static type() {
+    return "send-tx-to-background";
+  }
+
+  constructor(
+    public readonly chainId: string,
+    public readonly tx: unknown,
+    public readonly mode: "async" | "sync" | "block"
+  ) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.chainId) {
+      throw new Error("chain id is empty");
+    }
+
+    if (!this.tx) {
+      throw new Error("tx is empty");
+    }
+
+    if (
+      !this.mode ||
+      (this.mode !== "sync" && this.mode !== "async" && this.mode !== "block")
+    ) {
+      throw new Error("invalid mode");
+    }
+  }
+
+  route(): string {
+    return "background-tx";
+  }
+
+  type(): string {
+    return SendTxMsg.type();
+  }
+}
+
+export class GetSecret20ViewingKey extends Message<string> {
+  public static type() {
+    return "get-secret20-viewing-key";
+  }
+
+  constructor(
+    public readonly chainId: string,
+    public readonly contractAddress: string
+  ) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.chainId) {
+      throw new Error("Chain id is empty");
+    }
+
+    if (!this.contractAddress) {
+      throw new Error("Contract address is empty");
+    }
+  }
+
+  route(): string {
+    return "tokens";
+  }
+
+  type(): string {
+    return GetSecret20ViewingKey.type();
+  }
+}
+
+export class RequestSignAminoMsg extends Message<AminoSignResponse> {
+  public static type() {
+    return "request-sign-amino";
+  }
+
+  constructor(
+    public readonly chainId: string,
+    public readonly signer: string,
+    public readonly signDoc: StdSignDoc,
+    public readonly signOptions: KeplrSignOptions = {}
+  ) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.chainId) {
+      throw new Error("chain id not set");
+    }
+
+    if (!this.signer) {
+      throw new Error("signer not set");
+    }
+
+    // It is not important to check this on the client side as opposed to increasing the bundle size.
+    // Validate bech32 address.
+    // Bech32Address.validate(this.signer);
+
+    if (this.signDoc.chain_id !== this.chainId) {
+      throw new Error(
+        "Chain id in the message is not matched with the requested chain id"
+      );
+    }
+
+    if (!this.signOptions) {
+      throw new Error("Sign options are null");
+    }
+  }
+
+  route(): string {
+    return "keyring";
+  }
+
+  type(): string {
+    return RequestSignAminoMsg.type();
+  }
+}
+
+export class RequestSignDirectMsg extends Message<{
+  readonly signed: {
+    bodyBytes: Uint8Array;
+    authInfoBytes: Uint8Array;
+    chainId: string;
+    accountNumber: string;
+  };
+  readonly signature: StdSignature;
+}> {
+  public static type() {
+    return "request-sign-direct";
+  }
+
+  constructor(
+    public readonly chainId: string,
+    public readonly signer: string,
+    public readonly signDoc: {
+      bodyBytes?: Uint8Array | null;
+      authInfoBytes?: Uint8Array | null;
+      chainId?: string | null;
+      accountNumber?: string | null;
+    },
+    public readonly signOptions: KeplrSignOptions = {}
+  ) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.chainId) {
+      throw new Error("chain id not set");
+    }
+
+    if (!this.signer) {
+      throw new Error("signer not set");
+    }
+
+    // It is not important to check this on the client side as opposed to increasing the bundle size.
+    // Validate bech32 address.
+    // Bech32Address.validate(this.signer);
+
+    // const signDoc = cosmos.tx.v1beta1.SignDoc.create({
+    //   bodyBytes: this.signDoc.bodyBytes,
+    //   authInfoBytes: this.signDoc.authInfoBytes,
+    //   chainId: this.signDoc.chainId,
+    //   accountNumber: this.signDoc.accountNumber
+    //     ? Long.fromString(this.signDoc.accountNumber)
+    //     : undefined,
+    // });
+    //
+    // if (signDoc.chainId !== this.chainId) {
+    //   throw new Error(
+    //     "Chain id in the message is not matched with the requested chain id"
+    //   );
+    // }
+
+    if (!this.signOptions) {
+      throw new Error("Sign options are null");
+    }
+  }
+
+  route(): string {
+    return "keyring";
+  }
+
+  type(): string {
+    return RequestSignDirectMsg.type();
+  }
+}
+
+export class GetPubkeyMsg extends Message<Uint8Array> {
+  public static type() {
+    return "get-pubkey-msg";
+  }
+
+  constructor(public readonly chainId: string) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.chainId) {
+      throw new Error("chain id not set");
+    }
+  }
+
+  route(): string {
+    return "secret-wasm";
+  }
+
+  type(): string {
+    return GetPubkeyMsg.type();
+  }
+}
+
+export class ReqeustEncryptMsg extends Message<Uint8Array> {
+  public static type() {
+    return "request-encrypt-msg";
+  }
+
+  constructor(
+    public readonly chainId: string,
+    public readonly contractCodeHash: string,
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    public readonly msg: object
+  ) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.chainId) {
+      throw new Error("chain id not set");
+    }
+
+    if (!this.contractCodeHash) {
+      throw new Error("contract code hash not set");
+    }
+
+    if (!this.msg) {
+      throw new Error("msg not set");
+    }
+  }
+
+  route(): string {
+    return "secret-wasm";
+  }
+
+  type(): string {
+    return ReqeustEncryptMsg.type();
+  }
+}
+
+export class RequestDecryptMsg extends Message<Uint8Array> {
+  public static type() {
+    return "request-decrypt-msg";
+  }
+
+  constructor(
+    public readonly chainId: string,
+    public readonly cipherText: Uint8Array,
+    public readonly nonce: Uint8Array
+  ) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.chainId) {
+      throw new Error("chain id not set");
+    }
+
+    if (!this.cipherText || this.cipherText.length === 0) {
+      throw new Error("ciphertext not set");
+    }
+
+    if (!this.nonce || this.nonce.length === 0) {
+      throw new Error("nonce not set");
+    }
+  }
+
+  route(): string {
+    return "secret-wasm";
+  }
+
+  type(): string {
+    return RequestDecryptMsg.type();
+  }
+}
+
+export class GetTxEncryptionKeyMsg extends Message<Uint8Array> {
+  public static type() {
+    return "get-tx-encryption-key-msg";
+  }
+
+  constructor(
+    public readonly chainId: string,
+    public readonly nonce: Uint8Array
+  ) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.chainId) {
+      throw new Error("chain id not set");
+    }
+
+    if (!this.nonce) {
+      // Nonce of zero length is permitted.
+      throw new Error("nonce is null");
+    }
+  }
+
+  route(): string {
+    return "secret-wasm";
+  }
+
+  type(): string {
+    return GetTxEncryptionKeyMsg.type();
+  }
+}

package/build/mock.d.ts

@@ -1,43 +0,0 @@
-import { Keplr, KeplrIntereactionOptions, KeplrSignOptions, Key } from "@keplr-wallet/types";
-import { AminoSignResponse, BroadcastMode, OfflineSigner, Secp256k1HdWallet, StdSignDoc, StdTx } from "@cosmjs/launchpad";
-import { SecretUtils } from "secretjs/types/enigmautils";
-import { OfflineDirectSigner } from "@cosmjs/proto-signing";
-import { DirectSignResponse } from "@cosmjs/proto-signing/build/signer";
-export declare class MockKeplr implements Keplr {
-    readonly sendTxFn: (chainId: string, stdTx: StdTx, mode: BroadcastMode) => Promise<Uint8Array>;
-    readonly chainInfos: {
-        readonly chainId: string;
-        readonly bech32Config: {
-            readonly bech32PrefixAccAddr: string;
-        };
-    }[];
-    readonly mnemonic: string;
-    readonly version: string;
-    defaultOptions: KeplrIntereactionOptions;
-    readonly walletMap: {
-        [chainId: string]: Secp256k1HdWallet | undefined;
-    };
-    getHdWallet(chainId: string): Promise<Secp256k1HdWallet>;
-    constructor(sendTxFn: (chainId: string, stdTx: StdTx, mode: BroadcastMode) => Promise<Uint8Array>, chainInfos: {
-        readonly chainId: string;
-        readonly bech32Config: {
-            readonly bech32PrefixAccAddr: string;
-        };
-    }[], mnemonic: string);
-    enable(): Promise<void>;
-    enigmaDecrypt(): Promise<Uint8Array>;
-    enigmaEncrypt(): Promise<Uint8Array>;
-    experimentalSuggestChain(): Promise<void>;
-    getEnigmaPubKey(): Promise<Uint8Array>;
-    getEnigmaUtils(): SecretUtils;
-    getKey(chainId: string): Promise<Key>;
-    getOfflineSigner(chainId: string): OfflineSigner & OfflineDirectSigner;
-    getSecret20ViewingKey(): Promise<string>;
-    sendTx(chainId: string, stdTx: StdTx, mode: BroadcastMode): Promise<Uint8Array>;
-    signAmino(chainId: string, signer: string, signDoc: StdSignDoc, _?: KeplrSignOptions): Promise<AminoSignResponse>;
-    signDirect(): Promise<DirectSignResponse>;
-    suggestToken(): Promise<void>;
-    getEnigmaTxEncryptionKey(_chainId: string, _nonce: Uint8Array): Promise<Uint8Array>;
-    getOfflineSignerAuto(_chainId: string): Promise<OfflineSigner | OfflineDirectSigner>;
-    getOfflineSignerOnlyAmino(_chainId: string): OfflineSigner;
-}