@keplr-wallet/background 0.13.1 → 0.13.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keplr-wallet/background",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "main": "build/index.js",
   "author": "chainapsis",
   "license": "Apache-2.0",
@@ -32,17 +32,17 @@
     "@ethersproject/hash": "^5.7.0",
     "@ethersproject/transactions": "^5.7.0",
     "@ethersproject/wallet": "^5.7.0",
-    "@keplr-wallet/chain-validator": "0.13.1",
-    "@keplr-wallet/common": "0.13.1",
-    "@keplr-wallet/cosmos": "0.13.1",
-    "@keplr-wallet/crypto": "0.13.1",
-    "@keplr-wallet/ledger-cosmos": "0.13.1",
-    "@keplr-wallet/popup": "0.13.1",
-    "@keplr-wallet/proto-types": "0.13.1",
-    "@keplr-wallet/router": "0.13.1",
-    "@keplr-wallet/simple-fetch": "0.13.1",
-    "@keplr-wallet/types": "0.13.1",
-    "@keplr-wallet/unit": "0.13.1",
+    "@keplr-wallet/chain-validator": "0.13.3",
+    "@keplr-wallet/common": "0.13.3",
+    "@keplr-wallet/cosmos": "0.13.3",
+    "@keplr-wallet/crypto": "0.13.3",
+    "@keplr-wallet/ledger-cosmos": "0.13.3",
+    "@keplr-wallet/popup": "0.13.3",
+    "@keplr-wallet/proto-types": "0.13.3",
+    "@keplr-wallet/router": "0.13.3",
+    "@keplr-wallet/simple-fetch": "0.13.3",
+    "@keplr-wallet/types": "0.13.3",
+    "@keplr-wallet/unit": "0.13.3",
     "@ledgerhq/hw-app-eth": "6.42.8",
     "@ledgerhq/hw-app-starknet": "^3.0.1",
     "@ledgerhq/hw-transport": "^6.31.4",
@@ -69,5 +69,5 @@
     "mobx-utils": "^6",
     "starknet": "^7"
   },
-  "gitHead": "005bf5131f8612e3a773b864b673361ca9d9ab85"
+  "gitHead": "43844091838596f5c4ebd3d9386ddd5151398b04"
 }

package/src/index.ts

@@ -219,6 +219,7 @@ export function init(
     interactionService,
     chainsUIService,
     analyticsService,
+    backgroundTxService,
     msgPrivilegedOrigins,
     msgPrivilegedCosmwasmContractMap
   );

package/src/keyring-cosmos/handler.ts

@@ -22,6 +22,8 @@ import {
   RequestCosmosSignDirectAuxMsg,
   GetCosmosKeysForEachVaultWithSearchSettledMsg,
   PrivilegeCosmosSignAminoExecuteCosmWasmMsg,
+  RequestSignFigureMarketsAuthMsg,
+  RequestCosmosSignDirectWithMessagesMsg,
 } from "./messages";
 import { KeyRingCosmosService } from "./service";
 import { PermissionInteractiveService } from "../permission-interactive";
@@ -119,6 +121,16 @@ export const getHandler: (
           env,
           msg as PrivilegeCosmosSignAminoExecuteCosmWasmMsg
         );
+      case RequestSignFigureMarketsAuthMsg:
+        return handleRequestSignFigureMarketsAuthMsg(
+          service,
+          permissionInteractionService
+        )(env, msg as RequestSignFigureMarketsAuthMsg);
+      case RequestCosmosSignDirectWithMessagesMsg:
+        return handleRequestCosmosSignDirectWithMessagesMsg(
+          service,
+          permissionInteractionService
+        )(env, msg as RequestCosmosSignDirectWithMessagesMsg);
       default:
         throw new KeplrError("keyring", 221, "Unknown msg type");
     }
@@ -490,3 +502,52 @@ const handleRequestCosmosSignDirectAuxMsg: (
     };
   };
 };
+
+const handleRequestSignFigureMarketsAuthMsg: (
+  service: KeyRingCosmosService,
+  permissionInteractionService: PermissionInteractiveService
+) => InternalHandler<RequestSignFigureMarketsAuthMsg> = (
+  service,
+  permissionInteractionService
+) => {
+  return async (env, msg) => {
+    await permissionInteractionService.ensureEnabled(
+      env,
+      [msg.chainId],
+      msg.origin
+    );
+
+    return await service.signFigureMarketsAuth(
+      env,
+      msg.origin,
+      msg.chainId,
+      msg.signer,
+      msg.message
+    );
+  };
+};
+
+const handleRequestCosmosSignDirectWithMessagesMsg: (
+  service: KeyRingCosmosService,
+  permissionInteractionService: PermissionInteractiveService
+) => InternalHandler<RequestCosmosSignDirectWithMessagesMsg> = (
+  service,
+  permissionInteractionService
+) => {
+  return async (env, msg) => {
+    await permissionInteractionService.ensureEnabled(
+      env,
+      [msg.chainId],
+      msg.origin
+    );
+
+    return await service.signDirectWithMessagesSelected(
+      env,
+      msg.origin,
+      msg.chainId,
+      msg.signer,
+      msg.messages,
+      msg.signDirectWithMessagesOptions
+    );
+  };
+};

package/src/keyring-cosmos/init.ts

@@ -17,6 +17,8 @@ import {
   PrivilegeCosmosSignAminoDelegateMsg,
   RequestCosmosSignDirectAuxMsg,
   PrivilegeCosmosSignAminoExecuteCosmWasmMsg,
+  RequestSignFigureMarketsAuthMsg,
+  RequestCosmosSignDirectWithMessagesMsg,
 } from "./messages";
 import { ROUTE } from "./constants";
 import { getHandler } from "./handler";
@@ -43,6 +45,8 @@ export function init(
   router.registerMessage(RequestICNSAdr36SignaturesMsg);
   router.registerMessage(EnableVaultsWithCosmosAddressMsg);
   router.registerMessage(RequestCosmosSignDirectAuxMsg);
+  router.registerMessage(RequestSignFigureMarketsAuthMsg);
+  router.registerMessage(RequestCosmosSignDirectWithMessagesMsg);
 
   router.addHandler(ROUTE, getHandler(service, permissionInteractionService));
 }

package/src/keyring-cosmos/messages.ts

@@ -850,3 +850,97 @@ export class EnableVaultsWithCosmosAddressMsg extends Message<
     return EnableVaultsWithCosmosAddressMsg.type();
   }
 }
+
+export class RequestSignFigureMarketsAuthMsg extends Message<{
+  signedMessage: string;
+  signature: StdSignature;
+}> {
+  public static type() {
+    return "request-sign-figure-markets-auth";
+  }
+
+  constructor(
+    public readonly chainId: string,
+    public readonly signer: string,
+    public readonly message: string
+  ) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.chainId) {
+      throw new KeplrError("keyring", 270, "chain id not set");
+    }
+
+    if (!this.signer) {
+      throw new KeplrError("keyring", 230, "signer not set");
+    }
+
+    // Validate bech32 address.
+    Bech32Address.validate(this.signer);
+
+    if (!this.message) {
+      throw new KeplrError("keyring", 231, "message not set");
+    }
+  }
+
+  override approveExternal(): boolean {
+    return true;
+  }
+
+  route(): string {
+    return ROUTE;
+  }
+
+  type(): string {
+    return RequestSignFigureMarketsAuthMsg.type();
+  }
+}
+
+export class RequestCosmosSignDirectWithMessagesMsg extends Message<{
+  readonly txHash: string;
+}> {
+  public static type() {
+    return "request-cosmos-sign-direct-with-messages";
+  }
+
+  constructor(
+    public readonly chainId: string,
+    public readonly signer: string,
+    // base64 encoded protobuf messages.
+    public readonly messages: string[],
+    public readonly signDirectWithMessagesOptions: {
+      memo?: string;
+      sync?: boolean;
+      timeoutHeight?: number;
+      gasAdjustment?: number;
+    }
+  ) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.chainId) {
+      throw new KeplrError("keyring", 270, "chain id not set");
+    }
+
+    if (!this.signer) {
+      throw new KeplrError("keyring", 230, "signer not set");
+    }
+
+    // Validate bech32 address.
+    Bech32Address.validate(this.signer);
+  }
+
+  override approveExternal(): boolean {
+    return true;
+  }
+
+  route(): string {
+    return ROUTE;
+  }
+
+  type(): string {
+    return RequestCosmosSignDirectWithMessagesMsg.type();
+  }
+}

package/src/keyring-cosmos/service.ts

@@ -7,11 +7,13 @@ import {
   DirectSignResponse,
   KeplrSignOptions,
   Key,
+  StdFee,
   StdSignature,
   StdSignDoc,
 } from "@keplr-wallet/types";
 import { APP_PORT, Env, KeplrError } from "@keplr-wallet/router";
 import {
+  BaseAccount,
   Bech32Address,
   ChainIdHelper,
   checkAndValidateADR36AminoSignDoc,
@@ -29,16 +31,24 @@ import { InteractionService } from "../interaction";
 import { Buffer } from "buffer/";
 import {
   AuthInfo,
+  Fee,
   SignDoc,
   SignDocDirectAux,
+  SignerInfo,
   TxBody,
+  TxRaw,
 } from "@keplr-wallet/proto-types/cosmos/tx/v1beta1/tx";
 import Long from "long";
 import { PubKeySecp256k1 } from "@keplr-wallet/crypto";
 import { AnalyticsService } from "../analytics";
 import { ChainsUIService } from "../chains-ui";
-import { Int } from "@keplr-wallet/unit";
+import { Dec, Int } from "@keplr-wallet/unit";
 import bigInteger from "big-integer";
+import { PubKey } from "@keplr-wallet/proto-types/cosmos/crypto/secp256k1/keys";
+import { SignMode } from "@keplr-wallet/proto-types/cosmos/tx/signing/v1beta1/signing";
+import { Any } from "@keplr-wallet/proto-types/google/protobuf/any";
+import { simpleFetch } from "@keplr-wallet/simple-fetch";
+import { BackgroundTxService } from "../tx";
 
 export class KeyRingCosmosService {
   constructor(
@@ -47,6 +57,7 @@ export class KeyRingCosmosService {
     protected readonly interactionService: InteractionService,
     protected readonly chainsUIService: ChainsUIService,
     protected readonly analyticsService: AnalyticsService,
+    protected readonly backgroundTxService: BackgroundTxService,
     protected readonly msgPrivilegedOrigins: string[],
     protected readonly msgPrivilegedCosmwasmContractMap: Record<
       string,
@@ -1050,6 +1061,281 @@ export class KeyRingCosmosService {
     );
   }
 
+  async signDirectWithMessagesSelected(
+    env: Env,
+    origin: string,
+    chainId: string,
+    signer: string,
+    // base64 encoded protobuf messages.
+    messages: string[],
+    signDirectWithMessagesOptions: {
+      memo?: string;
+      sync?: boolean;
+      timeoutHeight?: number;
+      gasAdjustment?: number;
+    }
+  ): Promise<{
+    txHash: string;
+  }> {
+    return await this.signDirectWithMessages(
+      env,
+      origin,
+      this.keyRingService.selectedVaultId,
+      chainId,
+      signer,
+      messages,
+      signDirectWithMessagesOptions
+    );
+  }
+
+  async signDirectWithMessages(
+    env: Env,
+    origin: string,
+    vaultId: string,
+    chainId: string,
+    signer: string,
+    // base64 encoded protobuf messages.
+    messages: string[],
+    signDirectWithMessagesOptions: {
+      memo?: string;
+      sync?: boolean;
+      timeoutHeight?: number;
+      gasAdjustment?: number;
+    }
+  ): Promise<{
+    txHash: string;
+  }> {
+    const useEthereumSign =
+      this.chainsService
+        .getChainInfoOrThrow(chainId)
+        .features?.includes("eth-key-sign") === true;
+
+    const chainIsInjective = chainId.startsWith("injective");
+    const chainIsStratos = chainId.startsWith("stratos");
+    const chainIsCysic = chainId.startsWith("cysic");
+
+    const key = await this.getKey(vaultId, chainId);
+    const bech32Address = key.bech32Address;
+
+    const account = await BaseAccount.fetchFromRest(
+      this.chainsService.getChainInfoOrThrow(chainId).rest,
+      bech32Address,
+      true
+    );
+
+    const anyMessages: Any[] = messages.map((message) => {
+      const bz = Buffer.from(message, "base64");
+      const any = Any.decode(bz);
+      return {
+        typeUrl: any.typeUrl,
+        value: any.value,
+      };
+    });
+
+    const feeCurrency =
+      this.chainsService.getChainInfoOrThrow(chainId).feeCurrencies[0];
+
+    const { gasUsed } = await this.simulateTx(
+      vaultId,
+      chainId,
+      anyMessages,
+      {
+        amount: [
+          {
+            denom: feeCurrency.coinMinimalDenom,
+            amount: "1",
+          },
+        ],
+      },
+      signDirectWithMessagesOptions.memo
+    );
+    const gasAdjustment = signDirectWithMessagesOptions.gasAdjustment || 1.5;
+
+    const gasLimitDec = new Dec(gasUsed).mulTruncate(new Dec(gasAdjustment));
+
+    const signDoc = {
+      bodyBytes: TxBody.encode(
+        TxBody.fromPartial({
+          messages: anyMessages,
+          memo: signDirectWithMessagesOptions.memo,
+        })
+      ).finish(),
+      authInfoBytes: AuthInfo.encode({
+        signerInfos: [
+          {
+            publicKey: {
+              typeUrl: (() => {
+                if (!useEthereumSign) {
+                  return "/cosmos.crypto.secp256k1.PubKey";
+                }
+
+                if (chainIsInjective) {
+                  return "/injective.crypto.v1beta1.ethsecp256k1.PubKey";
+                }
+
+                if (chainIsStratos) {
+                  return "/stratos.crypto.v1.ethsecp256k1.PubKey";
+                }
+
+                if (
+                  this.chainsService
+                    .getChainInfoOrThrow(chainId)
+                    .features?.includes("eth-secp256k1-cosmos")
+                ) {
+                  return "/cosmos.evm.crypto.v1.ethsecp256k1.PubKey";
+                }
+                if (
+                  this.chainsService
+                    .getChainInfoOrThrow(chainId)
+                    .features?.includes("eth-secp256k1-initia")
+                ) {
+                  return "/initia.crypto.v1beta1.ethsecp256k1.PubKey";
+                }
+
+                if (chainIsCysic) {
+                  return "/cysicmint.crypto.v1.ethsecp256k1.PubKey";
+                }
+
+                return "/ethermint.crypto.v1.ethsecp256k1.PubKey";
+              })(),
+              value: PubKey.encode({
+                key: key.pubKey,
+              }).finish(),
+            },
+            modeInfo: {
+              single: {
+                mode: SignMode.SIGN_MODE_DIRECT,
+              },
+              multi: undefined,
+            },
+            sequence: account.getSequence().toString(),
+          },
+        ],
+        fee: Fee.fromPartial({
+          amount: [
+            {
+              denom: feeCurrency.coinMinimalDenom,
+              amount: new Dec(feeCurrency.gasPriceStep?.average ?? 0.025)
+                .mul(gasLimitDec)
+                .roundUp()
+                .toString(),
+            },
+          ],
+          gasLimit: gasLimitDec.roundUp().toString(),
+        }),
+      }).finish(),
+      chainId: chainId,
+      accountNumber: account.getAccountNumber().toString(),
+    };
+
+    const signed = await this.signDirect(
+      env,
+      origin,
+      vaultId,
+      chainId,
+      signer,
+      signDoc,
+      {
+        preferNoSetMemo: !!signDirectWithMessagesOptions.memo,
+        preferNoSetFee: true,
+      }
+    );
+
+    const tx = TxRaw.encode({
+      bodyBytes: signed.signed.bodyBytes,
+      authInfoBytes: signed.signed.authInfoBytes,
+      signatures: [Buffer.from(signed.signature.signature, "base64")],
+    }).finish();
+
+    const waitFulfillment = signDirectWithMessagesOptions.sync !== false;
+    const txHash = await this.backgroundTxService.sendTx(chainId, tx, "sync", {
+      waitFulfillment,
+    });
+
+    if (waitFulfillment) {
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    return {
+      txHash: Buffer.from(txHash).toString("hex"),
+    };
+  }
+
+  async simulateTx(
+    vaultId: string,
+    chainId: string,
+    msgs: Any[],
+    fee: Omit<StdFee, "gas">,
+    memo: string = ""
+  ): Promise<{
+    gasUsed: number;
+  }> {
+    const key = await this.getKey(vaultId, chainId);
+    const bech32Address = key.bech32Address;
+
+    const account = await BaseAccount.fetchFromRest(
+      this.chainsService.getChainInfoOrThrow(chainId).rest,
+      bech32Address,
+      true
+    );
+
+    const unsignedTx = TxRaw.encode({
+      bodyBytes: TxBody.encode(
+        TxBody.fromPartial({
+          messages: msgs,
+          memo: memo,
+        })
+      ).finish(),
+      authInfoBytes: AuthInfo.encode({
+        signerInfos: [
+          SignerInfo.fromPartial({
+            // Pub key is ignored.
+            // It is fine to ignore the pub key when simulating tx.
+            // However, the estimated gas would be slightly smaller because tx size doesn't include pub key.
+            modeInfo: {
+              single: {
+                mode: SignMode.SIGN_MODE_LEGACY_AMINO_JSON,
+              },
+              multi: undefined,
+            },
+            sequence: account.getSequence().toString(),
+          }),
+        ],
+        fee: Fee.fromPartial({
+          amount: fee.amount.map((amount) => {
+            return { amount: amount.amount, denom: amount.denom };
+          }),
+        }),
+      }).finish(),
+      // Because of the validation of tx itself, the signature must exist.
+      // However, since they do not actually verify the signature, it is okay to use any value.
+      signatures: [new Uint8Array(64)],
+    }).finish();
+
+    // TODO: Add response type
+    const result = await simpleFetch<any>(
+      this.chainsService.getChainInfoOrThrow(chainId).rest,
+      "/cosmos/tx/v1beta1/simulate",
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          tx_bytes: Buffer.from(unsignedTx).toString("base64"),
+        }),
+      }
+    );
+
+    const gasUsed = parseInt(result.data.gas_info.gas_used);
+    if (Number.isNaN(gasUsed)) {
+      throw new Error(`Invalid integer gas: ${result.data.gas_info.gas_used}`);
+    }
+
+    return {
+      gasUsed,
+    };
+  }
+
   /**
    * Sign a direct-encoded transaction with pre-authorization
    * @dev only sign the transaction, not simulate or broadcast
@@ -1459,6 +1745,70 @@ export class KeyRingCosmosService {
     );
   }
 
+  async signFigureMarketsAuth(
+    _env: Env,
+    origin: string,
+    chainId: string,
+    signer: string,
+    // base64 encoded.
+    message: string
+  ): Promise<{
+    signedMessage: string;
+    signature: StdSignature;
+  }> {
+    const parsed = JSON.parse(Buffer.from(message, "base64").toString());
+    if (
+      parsed.chainId !== this.chainsService.getChainInfoOrThrow(chainId).chainId
+    ) {
+      throw new Error("chain id unmatched");
+    }
+    if (new URL(parsed.domain).origin !== new URL(origin).origin) {
+      throw new Error("domain and origin unmatched");
+    }
+
+    const vaultId = this.keyRingService.selectedVaultId;
+
+    const chainInfo = this.chainsService.getChainInfoOrThrow(chainId);
+    const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
+    const forceEVMLedger = chainInfo.features?.includes(
+      "force-enable-evm-ledger"
+    );
+
+    const keyInfo = this.keyRingService.getKeyInfo(vaultId);
+    if (!keyInfo) {
+      throw new Error("Null key info");
+    }
+
+    if (isEthermintLike && keyInfo.type === "ledger" && !forceEVMLedger) {
+      KeyRingCosmosService.throwErrorIfEthermintWithLedgerButNotSupported(
+        chainId
+      );
+    }
+
+    const key = await this.getKey(vaultId, chainId);
+    const bech32Prefix =
+      this.chainsService.getChainInfoOrThrow(chainId).bech32Config
+        ?.bech32PrefixAccAddr ?? "";
+    const bech32Address = new Bech32Address(key.address).toBech32(bech32Prefix);
+    if (signer !== bech32Address || parsed.address !== bech32Address) {
+      throw new Error("Signer mismatched");
+    }
+
+    const signature = await this.keyRingService.sign(
+      chainId,
+      vaultId,
+      Buffer.from(message, "base64"),
+      isEthermintLike ? "keccak256" : "sha256"
+    );
+    return {
+      signedMessage: message,
+      signature: encodeSecp256k1Signature(
+        key.pubKey,
+        new Uint8Array([...signature.r, ...signature.s])
+      ),
+    };
+  }
+
   async requestICNSAdr36SignaturesSelected(
     env: Env,
     origin: string,