@keplr-wallet/provider 0.12.212 → 0.12.213

package/src/core.ts

@@ -22,6 +22,12 @@ import {
   IEthereumProvider,
   IStarknetProvider,
   WalletEvents,
+  SupportedPaymentType,
+  IBitcoinProvider,
+  Network as BitcoinNetwork,
+  BitcoinSignMessageType,
+  ChainType as BitcoinChainType,
+  SignPsbtOptions,
 } from "@keplr-wallet/types";
 import {
   BACKGROUND_PORT,
@@ -1136,6 +1142,104 @@ export class Keplr implements IKeplr, KeplrCoreTypes {
     });
   }
 
+  async getBitcoinKey(chainId: string): Promise<{
+    name: string;
+    pubKey: Uint8Array;
+    address: string;
+    paymentType: SupportedPaymentType;
+    isNanoLedger: boolean;
+  }> {
+    return new Promise((resolve, reject) => {
+      let f = false;
+      sendSimpleMessage(
+        this.requester,
+        BACKGROUND_PORT,
+        "keyring-bitcoin",
+        "get-bitcoin-key",
+        {
+          chainId,
+        }
+      )
+        .then(resolve)
+        .catch(reject)
+        .finally(() => (f = true));
+
+      setTimeout(() => {
+        if (!f) {
+          this.protectedTryOpenSidePanelIfEnabled();
+        }
+      }, 100);
+    });
+  }
+
+  async getBitcoinKeysSettled(chainIds: string[]): Promise<
+    SettledResponses<{
+      name: string;
+      pubKey: Uint8Array;
+      address: string;
+      paymentType: SupportedPaymentType;
+      isNanoLedger: boolean;
+    }>
+  > {
+    return new Promise((resolve, reject) => {
+      let f = false;
+      sendSimpleMessage(
+        this.requester,
+        BACKGROUND_PORT,
+        "keyring-bitcoin",
+        "get-bitcoin-keys-settled",
+        {
+          chainIds,
+        }
+      )
+        .then(resolve)
+        .catch(reject)
+        .finally(() => (f = true));
+
+      setTimeout(() => {
+        if (!f) {
+          this.protectedTryOpenSidePanelIfEnabled();
+        }
+      }, 100);
+    });
+  }
+
+  async signPsbt(
+    chainId: string,
+    psbtHex: string,
+    options?: SignPsbtOptions
+  ): Promise<string> {
+    return await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "keyring-bitcoin",
+      "request-sign-bitcoin-psbt",
+      {
+        chainId,
+        psbtHex,
+        options,
+      }
+    );
+  }
+
+  async signPsbts(
+    chainId: string,
+    psbtsHexes: string[],
+    options?: SignPsbtOptions
+  ): Promise<string[]> {
+    return await sendSimpleMessage(
+      this.requester,
+      BACKGROUND_PORT,
+      "keyring-bitcoin",
+      "request-sign-bitcoin-psbts",
+      {
+        chainId,
+        psbtsHexes,
+        options,
+      }
+    );
+  }
+
   // IMPORTANT: protected로 시작하는 method는 InjectedKeplr.startProxy()에서 injected 쪽에서 event system으로도 호출할 수 없도록 막혀있다.
   //            protected로 시작하지 않는 method는 injected keplr에 없어도 event system을 통하면 호출 할 수 있다.
   //            이를 막기 위해서 method 이름을 protected로 시작하게 한다.
@@ -1451,6 +1555,8 @@ export class Keplr implements IKeplr, KeplrCoreTypes {
   public readonly ethereum = new EthereumProvider(this, this.requester);
 
   public readonly starknet = new StarknetProvider(this, this.requester);
+
+  public readonly bitcoin = new BitcoinProvider(this, this.requester);
 }
 
 // IMPORTANT: 사이드 패널을 열어야하는 JSON-RPC 메소드들이 생길 때마다 여기에 추가해야한다.
@@ -1690,3 +1796,208 @@ class StarknetProvider implements IStarknetProvider {
     throw new Error("Method not implemented.");
   }
 }
+
+const sidePanelOpenNeededBitcoinMethods = [
+  "switchNetwork",
+  "switchChain",
+  "signMessage",
+  "sendBitcoin",
+  "pushTx",
+  "signPsbt",
+  "signPsbts",
+];
+
+class BitcoinProvider extends EventEmitter implements IBitcoinProvider {
+  constructor(
+    protected readonly keplr: Keplr,
+    protected readonly requester: MessageRequester
+  ) {
+    super();
+  }
+
+  protected async protectedEnableAccess(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      let f = false;
+
+      sendSimpleMessage(
+        this.requester,
+        BACKGROUND_PORT,
+        "permission-interactive",
+        "enable-access-for-bitcoin",
+        {}
+      )
+        .then(resolve)
+        .catch(reject)
+        .finally(() => (f = true));
+
+      setTimeout(() => {
+        if (!f) {
+          this.keplr.protectedTryOpenSidePanelIfEnabled();
+        }
+      }, 100);
+    });
+  }
+
+  protected async protectedRequestMethod<T>({
+    method,
+    params,
+  }: {
+    method: string;
+    params: unknown[];
+  }): Promise<T> {
+    if (method !== "getAccounts") {
+      await this.protectedEnableAccess();
+    }
+
+    return new Promise((resolve, reject) => {
+      let f = false;
+      sendSimpleMessage(
+        this.requester,
+        BACKGROUND_PORT,
+        "keyring-bitcoin",
+        "request-method-to-bitcoin",
+        {
+          method,
+          params,
+        }
+      )
+        .then(resolve)
+        .catch(reject)
+        .finally(() => (f = true));
+
+      setTimeout(() => {
+        if (!f && sidePanelOpenNeededBitcoinMethods.includes(method)) {
+          this.keplr.protectedTryOpenSidePanelIfEnabled();
+        }
+      }, 100);
+    });
+  }
+
+  async getAccounts(): Promise<string[]> {
+    return this.protectedRequestMethod({
+      method: "getAccounts",
+      params: [],
+    });
+  }
+
+  async requestAccounts(): Promise<string[]> {
+    return this.protectedRequestMethod({
+      method: "requestAccounts",
+      params: [],
+    });
+  }
+
+  async disconnect(): Promise<void> {
+    return this.protectedRequestMethod({
+      method: "disconnect",
+      params: [],
+    });
+  }
+
+  async getNetwork(): Promise<BitcoinNetwork> {
+    return this.protectedRequestMethod({
+      method: "getNetwork",
+      params: [],
+    });
+  }
+
+  async switchNetwork(network: BitcoinNetwork): Promise<BitcoinNetwork> {
+    return this.protectedRequestMethod({
+      method: "switchNetwork",
+      params: [network],
+    });
+  }
+
+  async getChain(): Promise<{
+    enum: BitcoinChainType;
+    name: string;
+    network: BitcoinNetwork;
+  }> {
+    return this.protectedRequestMethod({
+      method: "getChain",
+      params: [],
+    });
+  }
+
+  async switchChain(chain: BitcoinChainType): Promise<BitcoinChainType> {
+    return this.protectedRequestMethod({
+      method: "switchChain",
+      params: [chain],
+    });
+  }
+
+  async getPublicKey(): Promise<string> {
+    return this.protectedRequestMethod({
+      method: "getPublicKey",
+      params: [],
+    });
+  }
+
+  async getBalance(): Promise<{
+    confirmed: number;
+    unconfirmed: number;
+    total: number;
+  }> {
+    return this.protectedRequestMethod({
+      method: "getBalance",
+      params: [],
+    });
+  }
+
+  async getInscriptions(): Promise<string[]> {
+    return this.protectedRequestMethod({
+      method: "getInscriptions",
+      params: [],
+    });
+  }
+
+  async signMessage(
+    message: string,
+    type?: BitcoinSignMessageType
+  ): Promise<string> {
+    // Default to ECDSA if type is not provided
+    return this.protectedRequestMethod({
+      method: "signMessage",
+      params: [message, type ?? BitcoinSignMessageType.ECDSA],
+    });
+  }
+
+  async sendBitcoin(to: string, amount: number): Promise<string> {
+    return this.protectedRequestMethod({
+      method: "sendBitcoin",
+      params: [to, amount],
+    });
+  }
+
+  async pushTx(rawTxHex: string): Promise<string> {
+    return this.protectedRequestMethod({
+      method: "pushTx",
+      params: [rawTxHex],
+    });
+  }
+
+  async signPsbt(psbtHex: string, options?: SignPsbtOptions): Promise<string> {
+    return this.protectedRequestMethod({
+      method: "signPsbt",
+      params: [psbtHex, options],
+    });
+  }
+
+  async signPsbts(
+    psbtsHexes: string[],
+    options?: SignPsbtOptions
+  ): Promise<string[]> {
+    return this.protectedRequestMethod({
+      method: "signPsbts",
+      params: [psbtsHexes, options],
+    });
+  }
+
+  async getAddress(): Promise<string> {
+    throw new Error("This method should not be called");
+  }
+
+  async connectWallet(): Promise<string[]> {
+    throw new Error("This method should not be called");
+  }
+}

package/src/inject.ts

@@ -28,6 +28,12 @@ import {
   WalletEvents,
   AccountChangeEventHandler,
   NetworkChangeEventHandler,
+  SupportedPaymentType,
+  IBitcoinProvider,
+  Network as BitcoinNetwork,
+  BitcoinSignMessageType,
+  ChainType as BitcoinChainType,
+  SignPsbtOptions,
 } from "@keplr-wallet/types";
 import {
   Result,
@@ -55,6 +61,7 @@ export interface ProxyRequest {
   args: any[];
   ethereumProviderMethod?: keyof IEthereumProvider;
   starknetProviderMethod?: keyof IStarknetProvider;
+  bitcoinProviderMethod?: keyof IBitcoinProvider;
 }
 
 export interface ProxyRequestResponse {
@@ -105,6 +112,8 @@ export function injectKeplrToWindow(keplr: IKeplr): void {
   );
 
   defineUnwritablePropertyIfPossible(window, "starknet_keplr", keplr.starknet);
+
+  defineUnwritablePropertyIfPossible(window, "bitcoin_keplr", keplr.bitcoin);
 }
 
 /**
@@ -169,6 +178,7 @@ export class InjectedKeplr implements IKeplr, KeplrCoreTypes {
           !keplr[message.method] ||
           (message.method !== "ethereum" &&
             message.method !== "starknet" &&
+            message.method !== "bitcoin" &&
             typeof keplr[message.method] !== "function")
         ) {
           throw new Error(`Invalid method: ${message.method}`);
@@ -396,6 +406,32 @@ export class InjectedKeplr implements IKeplr, KeplrCoreTypes {
             );
           }
 
+          if (method === "bitcoin") {
+            const bitcoinProviderMethod = message.bitcoinProviderMethod;
+
+            if (bitcoinProviderMethod?.startsWith("protected")) {
+              throw new Error("Rejected");
+            }
+
+            if (
+              bitcoinProviderMethod === undefined ||
+              typeof keplr.bitcoin?.[bitcoinProviderMethod] !== "function"
+            ) {
+              throw new Error(
+                `${message.bitcoinProviderMethod} is not function or invalid Bitcoin provider method`
+              );
+            }
+
+            const messageArgs = JSONUint8Array.unwrap(message.args);
+            return await keplr.bitcoin[bitcoinProviderMethod](
+              // 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
@@ -1044,6 +1080,48 @@ export class InjectedKeplr implements IKeplr, KeplrCoreTypes {
     );
   }
 
+  async getBitcoinKey(chainId: string): Promise<{
+    name: string;
+    pubKey: Uint8Array;
+    address: string;
+    paymentType: SupportedPaymentType;
+    isNanoLedger: boolean;
+  }> {
+    return await this.requestMethod("getBitcoinKey", [chainId]);
+  }
+
+  async getBitcoinKeysSettled(chainIds: string[]): Promise<
+    SettledResponses<{
+      name: string;
+      pubKey: Uint8Array;
+      address: string;
+      paymentType: SupportedPaymentType;
+      isNanoLedger: boolean;
+    }>
+  > {
+    return await this.requestMethod("getBitcoinKeysSettled", [chainIds]);
+  }
+
+  async signPsbt(
+    chainId: string,
+    psbtHex: string,
+    options?: SignPsbtOptions
+  ): Promise<string> {
+    return await this.requestMethod("signPsbt", [chainId, psbtHex, options]);
+  }
+
+  async signPsbts(
+    chainId: string,
+    psbtsHexes: string[],
+    options?: SignPsbtOptions
+  ): Promise<string[]> {
+    return await this.requestMethod("signPsbts", [
+      chainId,
+      psbtsHexes,
+      options,
+    ]);
+  }
+
   public readonly ethereum = new EthereumProvider(
     this.metaId,
     () => this,
@@ -1053,6 +1131,12 @@ export class InjectedKeplr implements IKeplr, KeplrCoreTypes {
   );
 
   public readonly starknet = this.generateStarknetProvider();
+
+  public readonly bitcoin = new BitcoinProvider(
+    () => this,
+    this.eventListener,
+    this.parseMessage
+  );
 }
 
 class EthereumProvider extends EventEmitter implements IEthereumProvider {
@@ -1598,3 +1682,165 @@ class StarknetProvider implements IStarknetProvider {
     }
   }
 }
+
+export class BitcoinProvider extends EventEmitter implements IBitcoinProvider {
+  constructor(
+    protected readonly _injectedKeplr: () => InjectedKeplr,
+    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
+  ) {
+    super();
+  }
+
+  protected async _requestMethod<T = unknown>(
+    method: keyof IBitcoinProvider,
+    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: "bitcoin",
+      args: JSONUint8Array.wrap(args),
+      bitcoinProviderMethod: 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;
+        }
+
+        // TODO: Handle error correctly
+        if (result.error) {
+          reject(new Error(result.error));
+          return;
+        }
+
+        resolve(result.return as T);
+      };
+
+      this._eventListener.addMessageListener(receiveResponse);
+
+      this._eventListener.postMessage(proxyMessage);
+    });
+  }
+
+  getAccounts(): Promise<string[]> {
+    return this._requestMethod("getAccounts", []);
+  }
+
+  async requestAccounts(): Promise<string[]> {
+    return this._requestMethod("requestAccounts", []);
+  }
+
+  async disconnect(): Promise<void> {
+    return this._requestMethod("disconnect", []);
+  }
+
+  async getNetwork(): Promise<BitcoinNetwork> {
+    return this._requestMethod("getNetwork", []);
+  }
+
+  async switchNetwork(network: BitcoinNetwork): Promise<BitcoinNetwork> {
+    return this._requestMethod("switchNetwork", [network]);
+  }
+
+  async getChain(): Promise<{
+    enum: BitcoinChainType;
+    name: string;
+    network: BitcoinNetwork;
+  }> {
+    return this._requestMethod("getChain", []);
+  }
+
+  async switchChain(chain: BitcoinChainType): Promise<BitcoinChainType> {
+    return this._requestMethod("switchChain", [chain]);
+  }
+
+  async getPublicKey(): Promise<string> {
+    return this._requestMethod("getPublicKey", []);
+  }
+
+  async getBalance(): Promise<{
+    confirmed: number;
+    unconfirmed: number;
+    total: number;
+  }> {
+    return this._requestMethod("getBalance", []);
+  }
+
+  async getInscriptions(): Promise<string[]> {
+    return this._requestMethod("getInscriptions", []);
+  }
+
+  async signMessage(
+    message: string,
+    type?: BitcoinSignMessageType
+  ): Promise<string> {
+    return this._requestMethod("signMessage", [message, type]);
+  }
+
+  async sendBitcoin(to: string, amount: number): Promise<string> {
+    return this._requestMethod("sendBitcoin", [to, amount]);
+  }
+
+  async pushTx(rawTxHex: string): Promise<string> {
+    return this._requestMethod("pushTx", [rawTxHex]);
+  }
+
+  async signPsbt(psbtHex: string, options?: SignPsbtOptions): Promise<string> {
+    return this._requestMethod("signPsbt", [psbtHex, options]);
+  }
+
+  async signPsbts(
+    psbtsHexes: string[],
+    options?: SignPsbtOptions
+  ): Promise<string[]> {
+    return this._requestMethod("signPsbts", [psbtsHexes, options]);
+  }
+
+  async getAddress(): Promise<string> {
+    const accounts = await this.getAccounts();
+    return accounts[0];
+  }
+
+  async connectWallet(): Promise<string[]> {
+    return this.requestAccounts();
+  }
+}