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

package/src/inject.ts

@@ -7,29 +7,31 @@ import {
   KeplrMode,
   KeplrSignOptions,
   Key,
-} from "@keplr-wallet/types";
-import { Result, JSONUint8Array } from "@keplr-wallet/router";
-import {
   BroadcastMode,
   AminoSignResponse,
   StdSignDoc,
-  StdTx,
-  OfflineSigner,
+  OfflineAminoSigner,
   StdSignature,
-} from "@cosmjs/launchpad";
-import { SecretUtils } from "secretjs/types/enigmautils";
-
+  StdTx,
+  DirectSignResponse,
+  OfflineDirectSigner,
+  ICNSAdr36Signatures,
+  ChainInfoWithoutEndpoints,
+  SecretUtils,
+  SettledResponses,
+} from "@keplr-wallet/types";
+import { Result } from "@keplr-wallet/router";
+import { JSONUint8Array } from "@keplr-wallet/common";
 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 { KeplrCoreTypes } from "./core-types";
 
 export interface ProxyRequest {
   type: "proxy-request";
   id: string;
-  method: keyof Keplr;
+  method: keyof (Keplr & KeplrCoreTypes);
   args: any[];
 }
 
@@ -39,15 +41,57 @@ export interface ProxyRequestResponse {
   result: Result | undefined;
 }
 
+function defineUnwritablePropertyIfPossible(o: any, p: string, value: any) {
+  const descriptor = Object.getOwnPropertyDescriptor(o, p);
+  if (!descriptor || descriptor.writable) {
+    if (!descriptor || descriptor.configurable) {
+      Object.defineProperty(o, p, {
+        value,
+        writable: false,
+      });
+    } else {
+      o[p] = value;
+    }
+  } else {
+    console.warn(
+      `Failed to inject ${p} from keplr. Probably, other wallet is trying to intercept Keplr`
+    );
+  }
+}
+
+export function injectKeplrToWindow(keplr: IKeplr): void {
+  defineUnwritablePropertyIfPossible(window, "keplr", keplr);
+  defineUnwritablePropertyIfPossible(
+    window,
+    "getOfflineSigner",
+    keplr.getOfflineSigner
+  );
+  defineUnwritablePropertyIfPossible(
+    window,
+    "getOfflineSignerOnlyAmino",
+    keplr.getOfflineSignerOnlyAmino
+  );
+  defineUnwritablePropertyIfPossible(
+    window,
+    "getOfflineSignerAuto",
+    keplr.getOfflineSignerAuto
+  );
+  defineUnwritablePropertyIfPossible(
+    window,
+    "getEnigmaUtils",
+    keplr.getEnigmaUtils
+  );
+}
+
 /**
  * InjectedKeplr would be injected to the webpage.
  * In the webpage, it can't request any messages to the extension because it doesn't have any API related to the extension.
  * So, to request some methods of the extension, this will proxy the request to the content script that is injected to webpage on the extension level.
  * This will use `window.postMessage` to interact with the content script.
  */
-export class InjectedKeplr implements IKeplr {
+export class InjectedKeplr implements IKeplr, KeplrCoreTypes {
   static startProxy(
-    keplr: IKeplr,
+    keplr: IKeplr & KeplrCoreTypes,
     eventListener: {
       addMessageListener: (fn: (e: any) => void) => void;
       postMessage: (message: any) => void;
@@ -172,7 +216,10 @@ export class InjectedKeplr implements IKeplr {
     });
   }
 
-  protected requestMethod(method: keyof IKeplr, args: any[]): Promise<any> {
+  protected requestMethod(
+    method: keyof (IKeplr & KeplrCoreTypes),
+    args: any[]
+  ): Promise<any> {
     const bytes = new Uint8Array(8);
     const id: string = Array.from(crypto.getRandomValues(bytes))
       .map((value) => {
@@ -244,12 +291,53 @@ export class InjectedKeplr implements IKeplr {
         window.postMessage(message, window.location.origin),
     },
     protected readonly parseMessage?: (message: any) => any
-  ) {}
+  ) {
+    // Freeze fields/method except for "defaultOptions"
+    // Intentionally, "defaultOptions" can be mutated to allow a webpage to change the options with cosmjs usage.
+    // Freeze fields
+    const fieldNames = Object.keys(this);
+    for (const fieldName of fieldNames) {
+      if (fieldName !== "defaultOptions") {
+        Object.defineProperty(this, fieldName, {
+          value: (this as any)[fieldName],
+          writable: false,
+        });
+      }
+
+      // If field is "eventListener", try to iterate one-level deep.
+      if (fieldName === "eventListener") {
+        const fieldNames = Object.keys(this.eventListener);
+        for (const fieldName of fieldNames) {
+          Object.defineProperty(this.eventListener, fieldName, {
+            value: (this.eventListener as any)[fieldName],
+            writable: false,
+          });
+        }
+      }
+    }
+    // Freeze methods
+    const methodNames = Object.getOwnPropertyNames(InjectedKeplr.prototype);
+    for (const methodName of methodNames) {
+      if (
+        methodName !== "constructor" &&
+        typeof (this as any)[methodName] === "function"
+      ) {
+        Object.defineProperty(this, methodName, {
+          value: (this as any)[methodName].bind(this),
+          writable: false,
+        });
+      }
+    }
+  }
 
   async enable(chainIds: string | string[]): Promise<void> {
     await this.requestMethod("enable", [chainIds]);
   }
 
+  async disable(chainIds?: string | string[]): Promise<void> {
+    await this.requestMethod("disable", [chainIds]);
+  }
+
   async experimentalSuggestChain(chainInfo: ChainInfo): Promise<void> {
     if (
       chainInfo.features?.includes("stargate") ||
@@ -267,6 +355,10 @@ export class InjectedKeplr implements IKeplr {
     return await this.requestMethod("getKey", [chainId]);
   }
 
+  async getKeysSettled(chainIds: string[]): Promise<SettledResponses<Key>> {
+    return await this.requestMethod("getKeysSettled", [chainIds]);
+  }
+
   async sendTx(
     chainId: string,
     tx: StdTx | Uint8Array,
@@ -350,6 +442,22 @@ export class InjectedKeplr implements IKeplr {
     return await this.requestMethod("signArbitrary", [chainId, signer, data]);
   }
 
+  signICNSAdr36(
+    chainId: string,
+    contractAddress: string,
+    owner: string,
+    username: string,
+    addressChainIds: string[]
+  ): Promise<ICNSAdr36Signatures> {
+    return this.requestMethod("signICNSAdr36", [
+      chainId,
+      contractAddress,
+      owner,
+      username,
+      addressChainIds,
+    ]);
+  }
+
   async verifyArbitrary(
     chainId: string,
     signer: string,
@@ -378,17 +486,17 @@ export class InjectedKeplr implements IKeplr {
     ]);
   }
 
-  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);
@@ -467,4 +575,44 @@ export class InjectedKeplr implements IKeplr {
     this.enigmaUtils.set(chainId, enigmaUtils);
     return enigmaUtils;
   }
+
+  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 this.requestMethod("experimentalSignEIP712CosmosTx_v0", [
+      chainId,
+      signer,
+      eip712,
+      signDoc,
+      deepmerge(this.defaultOptions.sign ?? {}, signOptions),
+    ]);
+  }
+
+  async getChainInfosWithoutEndpoints(): Promise<ChainInfoWithoutEndpoints[]> {
+    return await this.requestMethod("getChainInfosWithoutEndpoints", []);
+  }
+
+  __core__getAnalyticsId(): Promise<string> {
+    return this.requestMethod("__core__getAnalyticsId", []);
+  }
+
+  async changeKeyRingName({
+    defaultName,
+    editable = true,
+  }: {
+    defaultName: string;
+    editable?: boolean;
+  }): Promise<string> {
+    return await this.requestMethod("changeKeyRingName", [
+      { defaultName, editable },
+    ]);
+  }
 }

package/build/types/index.d.ts

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

package/build/types/index.js

@@ -1,14 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./msgs"), exports);
-//# sourceMappingURL=index.js.map

package/build/types/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yCAAuB"}

package/build/types/msgs.d.ts

@@ -1,150 +0,0 @@
-import { Message } from "@keplr-wallet/router";
-import { ChainInfo, EthSignType, KeplrSignOptions, Key } from "@keplr-wallet/types";
-import { AminoSignResponse, StdSignature, StdSignDoc } from "@cosmjs/launchpad";
-export declare class EnableAccessMsg extends Message<void> {
-    readonly chainIds: string[];
-    static type(): string;
-    constructor(chainIds: string[]);
-    validateBasic(): void;
-    route(): string;
-    type(): string;
-}
-export declare class GetKeyMsg extends Message<Key> {
-    readonly chainId: string;
-    static type(): string;
-    constructor(chainId: string);
-    validateBasic(): void;
-    route(): string;
-    type(): string;
-}
-export declare class SuggestChainInfoMsg extends Message<void> {
-    readonly chainInfo: ChainInfo;
-    static type(): string;
-    constructor(chainInfo: ChainInfo);
-    validateBasic(): void;
-    route(): string;
-    type(): string;
-}
-export declare class SuggestTokenMsg extends Message<void> {
-    readonly chainId: string;
-    readonly contractAddress: string;
-    readonly viewingKey?: string | undefined;
-    static type(): string;
-    constructor(chainId: string, contractAddress: string, viewingKey?: string | undefined);
-    validateBasic(): void;
-    route(): string;
-    type(): string;
-}
-export declare class SendTxMsg extends Message<Uint8Array> {
-    readonly chainId: string;
-    readonly tx: unknown;
-    readonly mode: "async" | "sync" | "block";
-    static type(): string;
-    constructor(chainId: string, tx: unknown, mode: "async" | "sync" | "block");
-    validateBasic(): void;
-    route(): string;
-    type(): string;
-}
-export declare class GetSecret20ViewingKey extends Message<string> {
-    readonly chainId: string;
-    readonly contractAddress: string;
-    static type(): string;
-    constructor(chainId: string, contractAddress: string);
-    validateBasic(): void;
-    route(): string;
-    type(): string;
-}
-export declare class RequestSignAminoMsg extends Message<AminoSignResponse> {
-    readonly chainId: string;
-    readonly signer: string;
-    readonly signDoc: StdSignDoc;
-    readonly signOptions: KeplrSignOptions & {
-        isADR36WithString?: boolean;
-        ethSignType?: EthSignType;
-    };
-    static type(): string;
-    constructor(chainId: string, signer: string, signDoc: StdSignDoc, signOptions?: KeplrSignOptions & {
-        isADR36WithString?: boolean;
-        ethSignType?: EthSignType;
-    });
-    validateBasic(): void;
-    route(): string;
-    type(): string;
-}
-export declare class RequestVerifyADR36AminoSignDoc extends Message<boolean> {
-    readonly chainId: string;
-    readonly signer: string;
-    readonly data: Uint8Array;
-    readonly signature: StdSignature;
-    static type(): string;
-    constructor(chainId: string, signer: string, data: Uint8Array, signature: StdSignature);
-    validateBasic(): void;
-    route(): string;
-    type(): string;
-}
-export declare class RequestSignDirectMsg extends Message<{
-    readonly signed: {
-        bodyBytes: Uint8Array;
-        authInfoBytes: Uint8Array;
-        chainId: string;
-        accountNumber: string;
-    };
-    readonly signature: StdSignature;
-}> {
-    readonly chainId: string;
-    readonly signer: string;
-    readonly signDoc: {
-        bodyBytes?: Uint8Array | null;
-        authInfoBytes?: Uint8Array | null;
-        chainId?: string | null;
-        accountNumber?: string | null;
-    };
-    readonly signOptions: KeplrSignOptions;
-    static type(): string;
-    constructor(chainId: string, signer: string, signDoc: {
-        bodyBytes?: Uint8Array | null;
-        authInfoBytes?: Uint8Array | null;
-        chainId?: string | null;
-        accountNumber?: string | null;
-    }, signOptions?: KeplrSignOptions);
-    validateBasic(): void;
-    route(): string;
-    type(): string;
-}
-export declare class GetPubkeyMsg extends Message<Uint8Array> {
-    readonly chainId: string;
-    static type(): string;
-    constructor(chainId: string);
-    validateBasic(): void;
-    route(): string;
-    type(): string;
-}
-export declare class ReqeustEncryptMsg extends Message<Uint8Array> {
-    readonly chainId: string;
-    readonly contractCodeHash: string;
-    readonly msg: object;
-    static type(): string;
-    constructor(chainId: string, contractCodeHash: string, msg: object);
-    validateBasic(): void;
-    route(): string;
-    type(): string;
-}
-export declare class RequestDecryptMsg extends Message<Uint8Array> {
-    readonly chainId: string;
-    readonly cipherText: Uint8Array;
-    readonly nonce: Uint8Array;
-    static type(): string;
-    constructor(chainId: string, cipherText: Uint8Array, nonce: Uint8Array);
-    validateBasic(): void;
-    route(): string;
-    type(): string;
-}
-export declare class GetTxEncryptionKeyMsg extends Message<Uint8Array> {
-    readonly chainId: string;
-    readonly nonce: Uint8Array;
-    static type(): string;
-    constructor(chainId: string, nonce: Uint8Array);
-    validateBasic(): void;
-    route(): string;
-    type(): string;
-}