@keplr-wallet/provider 0.12.131 → 0.12.133-rc.0

package/src/inject.ts

@@ -24,6 +24,10 @@ import {
   EIP6963EventNames,
   EIP6963ProviderInfo,
   EIP6963ProviderDetail,
+  IStarknetProvider,
+  WalletEvents,
+  AccountChangeEventHandler,
+  NetworkChangeEventHandler,
 } from "@keplr-wallet/types";
 import {
   Result,
@@ -36,6 +40,13 @@ import deepmerge from "deepmerge";
 import Long from "long";
 import { KeplrCoreTypes } from "./core-types";
 import EventEmitter from "events";
+import {
+  AccountInterface,
+  Call,
+  DeployAccountSignerDetails,
+  InvocationsSignerDetails,
+  ProviderInterface,
+} from "starknet";
 
 export interface ProxyRequest {
   type: "proxy-request";
@@ -43,6 +54,7 @@ export interface ProxyRequest {
   method: keyof (Keplr & KeplrCoreTypes);
   args: any[];
   ethereumProviderMethod?: keyof IEthereumProvider;
+  starknetProviderMethod?: keyof IStarknetProvider;
 }
 
 export interface ProxyRequestResponse {
@@ -91,6 +103,12 @@ export function injectKeplrToWindow(keplr: IKeplr): void {
     "getEnigmaUtils",
     keplr.getEnigmaUtils
   );
+
+  defineUnwritablePropertyIfPossible(
+    window,
+    "starknet_braavos",
+    keplr.starknet
+  );
 }
 
 /**
@@ -148,6 +166,7 @@ export class InjectedKeplr implements IKeplr, KeplrCoreTypes {
         if (
           !keplr[message.method] ||
           (message.method !== "ethereum" &&
+            message.method !== "starknet" &&
             typeof keplr[message.method] !== "function")
         ) {
           throw new Error(`Invalid method: ${message.method}`);
@@ -305,6 +324,76 @@ export class InjectedKeplr implements IKeplr, KeplrCoreTypes {
             );
           }
 
+          if (method === "starknet") {
+            const starknetProviderMethod = message.starknetProviderMethod;
+
+            if (starknetProviderMethod?.startsWith("protected")) {
+              throw new Error("Rejected");
+            }
+
+            if (starknetProviderMethod === "id") {
+              throw new Error("id is not function");
+            }
+
+            if (starknetProviderMethod === "name") {
+              throw new Error("name is not function");
+            }
+
+            if (starknetProviderMethod === "version") {
+              throw new Error("version is not function");
+            }
+
+            if (starknetProviderMethod === "icon") {
+              throw new Error("icon is not function");
+            }
+
+            if (starknetProviderMethod === "chainId") {
+              throw new Error("chainId is not function");
+            }
+
+            if (starknetProviderMethod === "selectedAddress") {
+              throw new Error("selectedAddress is not function");
+            }
+
+            if (starknetProviderMethod === "isConnected") {
+              throw new Error("isConnected is not function");
+            }
+
+            if (starknetProviderMethod === "account") {
+              throw new Error("account is not function");
+            }
+
+            if (starknetProviderMethod === "provider") {
+              throw new Error("provider is not function");
+            }
+
+            if (
+              starknetProviderMethod === undefined ||
+              typeof keplr.starknet?.[starknetProviderMethod] !== "function"
+            ) {
+              throw new Error(
+                `${message.starknetProviderMethod} is not function or invalid Starknet provider method`
+              );
+            }
+
+            const messageArgs = JSONUint8Array.unwrap(message.args);
+            if (starknetProviderMethod === "request") {
+              return await keplr.starknet.request(
+                typeof messageArgs === "string"
+                  ? JSON.parse(messageArgs)
+                  : messageArgs
+              );
+            }
+
+            return await keplr.starknet[starknetProviderMethod](
+              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+              // @ts-ignore
+              ...(typeof messageArgs === "string"
+                ? JSON.parse(messageArgs)
+                : messageArgs)
+            );
+          }
+
           return await keplr[method](
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
@@ -410,6 +499,14 @@ export class InjectedKeplr implements IKeplr, KeplrCoreTypes {
   constructor(
     public readonly version: string,
     public readonly mode: KeplrMode,
+    protected readonly onStarknetStateChange: (state: {
+      selectedAddress: string | null;
+      chainId: string | null;
+      rpc: string | null;
+    }) => void,
+    protected readonly onStarknetAccountChange: (state: {
+      selectedAddress: string | null;
+    }) => void,
     protected readonly eventListener: {
       addMessageListener: (fn: (e: any) => void) => void;
       removeMessageListener: (fn: (e: any) => void) => void;
@@ -422,8 +519,13 @@ export class InjectedKeplr implements IKeplr, KeplrCoreTypes {
       postMessage: (message) =>
         window.postMessage(message, window.location.origin),
     },
-    protected readonly parseMessage?: (message: any) => any,
-    protected readonly eip6963ProviderInfo?: EIP6963ProviderInfo
+    protected readonly parseMessage: ((message: any) => any) | undefined,
+    protected readonly eip6963ProviderInfo: EIP6963ProviderInfo | undefined,
+    protected readonly starknetProviderInfo: {
+      id: string;
+      name: string;
+      icon: string;
+    }
   ) {
     // Freeze fields/method except for "defaultOptions"
     // Intentionally, "defaultOptions" can be mutated to allow a webpage to change the options with cosmjs usage.
@@ -870,12 +972,77 @@ export class InjectedKeplr implements IKeplr, KeplrCoreTypes {
     return await this.requestMethod("__core__webpageClosed", []);
   }
 
+  async getStarknetKey(chainId: string): Promise<{
+    name: string;
+    hexAddress: string;
+    pubKey: Uint8Array;
+    address: Uint8Array;
+  }> {
+    return await this.requestMethod("getStarknetKey", [chainId]);
+  }
+
+  async getStarknetKeysSettled(chainIds: string[]): Promise<
+    SettledResponses<{
+      name: string;
+      hexAddress: string;
+      pubKey: Uint8Array;
+      address: Uint8Array;
+    }>
+  > {
+    return await this.requestMethod("getStarknetKeysSettled", [chainIds]);
+  }
+
+  async signStarknetTx(
+    chainId: string,
+    transactions: Call[],
+    details: InvocationsSignerDetails
+  ): Promise<{
+    transactions: Call[];
+    details: InvocationsSignerDetails;
+    signature: string[];
+  }> {
+    return await this.requestMethod("signStarknetTx", [
+      chainId,
+      transactions,
+      details,
+    ]);
+  }
+
+  async signStarknetDeployAccountTransaction(
+    chainId: string,
+    transaction: DeployAccountSignerDetails
+  ): Promise<{
+    transaction: DeployAccountSignerDetails;
+    signature: string[];
+  }> {
+    return await this.requestMethod("signStarknetDeployAccountTransaction", [
+      chainId,
+      transaction,
+    ]);
+  }
+
+  generateStarknetProvider(): IStarknetProvider {
+    return new StarknetProvider(
+      this.starknetProviderInfo.id,
+      this.starknetProviderInfo.name,
+      this.version,
+      this.starknetProviderInfo.icon,
+      () => this,
+      this.onStarknetStateChange,
+      this.onStarknetAccountChange,
+      this.eventListener,
+      this.parseMessage
+    );
+  }
+
   public readonly ethereum = new EthereumProvider(
-    this,
+    () => this,
     this.eventListener,
     this.parseMessage,
     this.eip6963ProviderInfo
   );
+
+  public readonly starknet = this.generateStarknetProvider();
 }
 
 class EthereumProvider extends EventEmitter implements IEthereumProvider {
@@ -893,7 +1060,7 @@ class EthereumProvider extends EventEmitter implements IEthereumProvider {
   protected _currentChainId: string | null = null;
 
   constructor(
-    protected readonly injectedKeplr: InjectedKeplr,
+    protected readonly injectedKeplr: () => InjectedKeplr,
     protected readonly eventListener: {
       addMessageListener: (fn: (e: any) => void) => void;
       removeMessageListener: (fn: (e: any) => void) => void;
@@ -915,13 +1082,13 @@ class EthereumProvider extends EventEmitter implements IEthereumProvider {
 
     window.addEventListener("keplr_keystorechange", async () => {
       if (this._currentChainId) {
-        const chainInfo = await injectedKeplr.getChainInfoWithoutEndpoints(
+        const chainInfo = await injectedKeplr().getChainInfoWithoutEndpoints(
           this._currentChainId
         );
 
         if (chainInfo) {
           const selectedAddress = (
-            await injectedKeplr.getKey(this._currentChainId)
+            await injectedKeplr().getKey(this._currentChainId)
           ).ethereumHexAddress;
           this._handleAccountsChanged(selectedAddress);
         }
@@ -1145,3 +1312,267 @@ class EthereumProvider extends EventEmitter implements IEthereumProvider {
     })) as string;
   };
 }
+
+class StarknetProvider implements IStarknetProvider {
+  isConnected: boolean = false;
+
+  // It must be in plain text format not hexadecimal string. e.g. "SN_MAIN"
+  chainId?: string = undefined;
+
+  selectedAddress?: string = undefined;
+
+  account?: AccountInterface = undefined;
+
+  provider?: ProviderInterface = undefined;
+
+  // It must be in the CAIP-2 chain ID format. e.g. "starknet:SN_MAIN"
+  protected _currentChainId?: string = undefined;
+
+  protected _userWalletEvents: WalletEvents[] = [];
+
+  constructor(
+    public readonly id: string,
+    public readonly name: string,
+    public readonly version: string,
+    public readonly icon: string,
+
+    protected readonly _injectedKeplr: () => InjectedKeplr,
+    protected readonly onStateChange: (state: {
+      selectedAddress: string | null;
+      chainId: string | null;
+      rpc: string | null;
+    }) => void,
+    protected readonly onAccountChange: (state: {
+      selectedAddress: string | null;
+    }) => void,
+    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
+  ) {
+    this._initProviderState();
+
+    window.addEventListener("keplr_keystorechange", async () => {
+      if (this._currentChainId) {
+        const selectedAddress = (
+          await this._injectedKeplr().getStarknetKey(this._currentChainId)
+        ).hexAddress;
+
+        this.selectedAddress = selectedAddress;
+
+        this.onAccountChange({
+          selectedAddress,
+        });
+
+        this._userWalletEvents.forEach((userWalletEvent) => {
+          if (userWalletEvent.type === "accountsChanged") {
+            userWalletEvent.handler([selectedAddress]);
+          }
+        });
+      }
+    });
+
+    window.addEventListener("keplr_starknetChainChanged", (event) => {
+      const origin = (event as CustomEvent).detail.origin;
+      const starknetChainId = (event as CustomEvent).detail.starknetChainId;
+
+      this.chainId = starknetChainId;
+
+      if (origin === window.location.origin) {
+        this._userWalletEvents.forEach((userWalletEvent) => {
+          if (userWalletEvent.type === "networkChanged") {
+            userWalletEvent.handler(starknetChainId);
+          }
+        });
+      }
+    });
+  }
+
+  protected async _requestMethod<T = unknown>(
+    method: keyof IStarknetProvider,
+    args: Record<string, any>
+  ): Promise<T> {
+    const bytes = new Uint8Array(8);
+    const id: string = Array.from(crypto.getRandomValues(bytes))
+      .map((value) => {
+        return value.toString(16);
+      })
+      .join("");
+
+    const proxyMessage: ProxyRequest = {
+      type: "proxy-request",
+      id,
+      method: "starknet",
+      args: JSONUint8Array.wrap(args),
+      starknetProviderMethod: method,
+    };
+
+    return new Promise<T>((resolve, reject) => {
+      const receiveResponse = (e: any) => {
+        const proxyResponse: ProxyRequestResponse = this._parseMessage
+          ? this._parseMessage(e.data)
+          : e.data;
+
+        if (!proxyResponse || proxyResponse.type !== "proxy-request-response") {
+          return;
+        }
+
+        if (proxyResponse.id !== id) {
+          return;
+        }
+
+        this._eventListener.removeMessageListener(receiveResponse);
+
+        const result = JSONUint8Array.unwrap(proxyResponse.result);
+
+        if (!result) {
+          reject(new Error("Result is null"));
+          return;
+        }
+
+        if (result.error) {
+          const error = result.error;
+          reject(
+            error.code && !error.module
+              ? new EthereumProviderRpcError(
+                  error.code,
+                  error.message,
+                  error.data
+                )
+              : new Error(error)
+          );
+          return;
+        }
+
+        resolve(result.return as T);
+      };
+
+      this._eventListener.addMessageListener(receiveResponse);
+
+      this._eventListener.postMessage(proxyMessage);
+    });
+  }
+
+  protected async _initProviderState() {
+    const { currentChainId, selectedAddress, rpc } = await this.request<{
+      currentChainId: string | null;
+      selectedAddress: string | null;
+      rpc: string | null;
+    }>({
+      type: "keplr_initStarknetProviderState",
+    });
+
+    if (currentChainId != null && selectedAddress != null && rpc != null) {
+      this.onStateChange({
+        selectedAddress,
+        chainId: currentChainId,
+        rpc,
+      });
+
+      this._currentChainId = currentChainId;
+      this.chainId = currentChainId.replace("starknet:", "");
+      this.selectedAddress = selectedAddress;
+      this.isConnected = true;
+    } else {
+      this.onStateChange({
+        selectedAddress: null,
+        chainId: null,
+        rpc: null,
+      });
+    }
+  }
+
+  async request<T = unknown>({
+    type,
+    params,
+  }: {
+    type: string;
+    params?: unknown[] | Record<string, unknown>;
+  }): Promise<T> {
+    if (typeof type !== "string") {
+      throw new Error("Invalid parameter: `type` must be a string");
+    }
+
+    return await this._requestMethod<T>("request", {
+      type,
+      params,
+    });
+  }
+  async enable(_options?: {
+    starknetVersion?: "v4" | "v5";
+  }): Promise<string[]> {
+    const { currentChainId, selectedAddress, rpc } = await this.request<{
+      currentChainId: string;
+      selectedAddress: string;
+      rpc: string;
+    }>({
+      type: "keplr_enableStarknetProvider",
+    });
+
+    this.onStateChange({
+      selectedAddress,
+      chainId: currentChainId,
+      rpc,
+    });
+
+    this._currentChainId = currentChainId;
+    this.chainId = currentChainId.replace("starknet:", "");
+    this.selectedAddress = selectedAddress;
+    this.isConnected = true;
+
+    return [selectedAddress];
+  }
+  async isPreauthorized(): Promise<boolean> {
+    const { currentChainId, selectedAddress } = await this.request<{
+      currentChainId: string | null;
+      selectedAddress: string | null;
+    }>({
+      type: "keplr_initStarknetProviderState",
+    });
+
+    if (currentChainId != null && selectedAddress != null) {
+      return true;
+    }
+
+    return false;
+  }
+  on<E extends WalletEvents>(event: E["type"], handleEvent: E["handler"]) {
+    if (event === "accountsChanged") {
+      this._userWalletEvents.push({
+        type: "accountsChanged",
+        handler: handleEvent as AccountChangeEventHandler,
+      });
+    } else if (event === "networkChanged") {
+      this._userWalletEvents.push({
+        type: "networkChanged",
+        handler: handleEvent as NetworkChangeEventHandler,
+      });
+    } else {
+      throw new Error("Invalid event type");
+    }
+  }
+  off<E extends WalletEvents>(event: E["type"], handleEvent: E["handler"]) {
+    if (event !== "accountsChanged" && event !== "networkChanged") {
+      throw new Error("Invalid event type");
+    }
+
+    const eventIndex = this._userWalletEvents.findIndex(
+      (userEvent) =>
+        userEvent.type === event && userEvent.handler === handleEvent
+    );
+
+    if (eventIndex >= 0) {
+      this._userWalletEvents.splice(eventIndex, 1);
+    }
+  }
+}