feat: add support for EthSecp256k1 public keys and signatures

- Implemented encoding for EthSecp256k1 public keys in amino format.
- Added functions to encode and decode EthSecp256k1 signatures.
- Updated pubkey type definitions to include EthSecp256k1.
- Enhanced signing clients to handle EthSecp256k1 accounts.
- Created DirectEthSecp256k1HdWallet for managing EthSecp256k1 keypairs.
- Added tests for DirectEthSecp256k1HdWallet and DirectEthSecp256k1Wallet functionalities.

Author: allthatjazzleo

packages/amino/src/addresses.ts

@@ -2,6 +2,8 @@
 
 import { ripemd160, sha256 } from "@cosmjs/crypto";
 import { fromBase64, toBech32 } from "@cosmjs/encoding";
+import { keccak256 } from "@cosmjs/crypto";
+import { Secp256k1 } from "@cosmjs/crypto";
 
 import { encodeAminoPubkey } from "./encoding";
 import { isEd25519Pubkey, isMultisigThresholdPubkey, isSecp256k1Pubkey, Pubkey } from "./pubkeys";
@@ -20,6 +22,14 @@ export function rawSecp256k1PubkeyToRawAddress(pubkeyData: Uint8Array): Uint8Arr
   return ripemd160(sha256(pubkeyData));
 }
 
+export function rawEthSecp256k1PubkeyToRawAddress(pubkeyData: Uint8Array): Uint8Array {
+  const uncompressed = Secp256k1.uncompressPubkey(pubkeyData);
+  const pubkeyWithoutPrefix = uncompressed.slice(1);
+  const hash = keccak256(pubkeyWithoutPrefix);
+  return hash.slice(-20);
+}
+
+
 // For secp256k1 this assumes we already have a compressed pubkey.
 export function pubkeyToRawAddress(pubkey: Pubkey): Uint8Array {
   if (isSecp256k1Pubkey(pubkey)) {

packages/amino/src/encoding.ts

@@ -4,6 +4,7 @@ import { arrayContentStartsWith } from "@cosmjs/utils";
 
 import {
   Ed25519Pubkey,
+  EthSecp256k1Pubkey,
   isEd25519Pubkey,
   isMultisigThresholdPubkey,
   isSecp256k1Pubkey,
@@ -41,6 +42,20 @@ export function encodeEd25519Pubkey(pubkey: Uint8Array): Ed25519Pubkey {
   };
 }
 
+/**
+ * Takes a EthSecp256k1 public key as raw bytes and returns the Amino JSON
+ * representation of it (the type/value wrapper object).
+ */
+export function encodeEthSecp256k1Pubkey(pubkey: Uint8Array): EthSecp256k1Pubkey {
+  if (pubkey.length !== 33 || (pubkey[0] !== 0x02 && pubkey[0] !== 0x03)) {
+    throw new Error("Public key must be compressed secp256k1, i.e. 33 bytes starting with 0x02 or 0x03");
+  }
+  return {
+    type: pubkeyType.ethsecp256k1,
+    value: toBase64(pubkey),
+  };
+}
+
 // As discussed in https://github.com/binance-chain/javascript-sdk/issues/163
 // Prefixes listed here: https://github.com/tendermint/tendermint/blob/d419fffe18531317c28c29a292ad7d253f6cafdf/docs/spec/blockchain/encoding.md#public-key-cryptography
 // Last bytes is varint-encoded length prefix

packages/amino/src/index.ts

@@ -3,6 +3,7 @@ export {
   pubkeyToRawAddress,
   rawEd25519PubkeyToRawAddress,
   rawSecp256k1PubkeyToRawAddress,
+  rawEthSecp256k1PubkeyToRawAddress,
 } from "./addresses";
 export { addCoins, Coin, coin, coins, parseCoins } from "./coins";
 export {
@@ -12,6 +13,7 @@ export {
   encodeBech32Pubkey,
   encodeEd25519Pubkey,
   encodeSecp256k1Pubkey,
+  encodeEthSecp256k1Pubkey,
 } from "./encoding";
 export { createMultisigThresholdPubkey } from "./multisig";
 export { omitDefault } from "./omitdefault";
@@ -21,16 +23,18 @@ export {
   isEd25519Pubkey,
   isMultisigThresholdPubkey,
   isSecp256k1Pubkey,
+  isEthSecp256k1Pubkey,
   isSinglePubkey,
   MultisigThresholdPubkey,
   Pubkey,
   pubkeyType,
   Secp256k1Pubkey,
+  EthSecp256k1Pubkey,
   SinglePubkey,
 } from "./pubkeys";
 export { extractKdfConfiguration, Secp256k1HdWallet, Secp256k1HdWalletOptions } from "./secp256k1hdwallet";
 export { Secp256k1Wallet } from "./secp256k1wallet";
-export { decodeSignature, encodeSecp256k1Signature, StdSignature } from "./signature";
+export { decodeSignature, encodeEthSecp256k1Signature, encodeSecp256k1Signature, StdSignature } from "./signature";
 export { AminoMsg, makeSignDoc, serializeSignDoc, StdFee, StdSignDoc } from "./signdoc";
 export { AccountData, Algo, AminoSignResponse, OfflineAminoSigner } from "./signer";
 export { isStdTx, makeStdTx, StdTx } from "./stdtx";

packages/amino/src/pubkeys.ts

@@ -24,10 +24,21 @@ export function isSecp256k1Pubkey(pubkey: Pubkey): pubkey is Secp256k1Pubkey {
   return (pubkey as Secp256k1Pubkey).type === "tendermint/PubKeySecp256k1";
 }
 
+export interface EthSecp256k1Pubkey extends SinglePubkey {
+  readonly type: "os/PubKeyEthSecp256k1";
+  readonly value: string;
+}
+
+export function isEthSecp256k1Pubkey(pubkey: Pubkey): pubkey is EthSecp256k1Pubkey {
+  return (pubkey as EthSecp256k1Pubkey).type === "os/PubKeyEthSecp256k1";
+}
+
 export const pubkeyType = {
-  /** @see https://github.com/tendermint/tendermint/blob/v0.33.0/crypto/ed25519/ed25519.go#L22 */
-  secp256k1: "tendermint/PubKeySecp256k1" as const,
   /** @see https://github.com/tendermint/tendermint/blob/v0.33.0/crypto/secp256k1/secp256k1.go#L23 */
+  secp256k1: "tendermint/PubKeySecp256k1" as const,
+  /** @see https://github.com/cosmos/evm/blob/main/crypto/ethsecp256k1/ethsecp256k1.go#L36 */
+  ethsecp256k1: "os/PubKeyEthSecp256k1" as const,
+  /** @see https://github.com/tendermint/tendermint/blob/v0.33.0/crypto/ed25519/ed25519.go#L22 */
   ed25519: "tendermint/PubKeyEd25519" as const,
   /** @see https://github.com/tendermint/tendermint/blob/v0.33.0/crypto/sr25519/codec.go#L12 */
   sr25519: "tendermint/PubKeySr25519" as const,

packages/amino/src/signature.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { fromBase64, toBase64 } from "@cosmjs/encoding";
 
-import { encodeSecp256k1Pubkey } from "./encoding";
+import { encodeEthSecp256k1Pubkey, encodeSecp256k1Pubkey } from "./encoding";
 import { Pubkey, pubkeyType } from "./pubkeys";
 
 export interface StdSignature {
@@ -28,6 +28,25 @@ export function encodeSecp256k1Signature(pubkey: Uint8Array, signature: Uint8Arr
   };
 }
 
+/**
+ * Takes a binary pubkey and signature to create a signature object
+ *
+ * @param pubkey a compressed secp256k1 public key
+ * @param signature a 64 byte fixed length representation of secp256k1 signature components r and s
+ */
+export function encodeEthSecp256k1Signature(pubkey: Uint8Array, signature: Uint8Array): StdSignature {
+  if (signature.length !== 64) {
+    throw new Error(
+      "Signature must be 64 bytes long. Cosmos SDK uses a 2x32 byte fixed length encoding for the secp256k1 signature integers r and s.",
+    );
+  }
+
+  return {
+    pub_key: encodeEthSecp256k1Pubkey(pubkey),
+    signature: toBase64(signature),
+  };
+}
+
 export function decodeSignature(signature: StdSignature): {
   readonly pubkey: Uint8Array;
   readonly signature: Uint8Array;
@@ -39,6 +58,11 @@ export function decodeSignature(signature: StdSignature): {
         pubkey: fromBase64(signature.pub_key.value),
         signature: fromBase64(signature.signature),
       };
+    case pubkeyType.ethsecp256k1:
+      return {
+        pubkey: fromBase64(signature.pub_key.value),
+        signature: fromBase64(signature.signature),
+      };
     default:
       throw new Error("Unsupported pubkey type");
   }

packages/cosmwasm-stargate/src/signingcosmwasmclient.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/naming-convention */
-import { encodeSecp256k1Pubkey, makeSignDoc as makeSignDocAmino } from "@cosmjs/amino";
+import { encodeEthSecp256k1Pubkey, encodeSecp256k1Pubkey, makeSignDoc as makeSignDocAmino } from "@cosmjs/amino";
 import { sha256 } from "@cosmjs/crypto";
 import { fromBase64, toHex, toUtf8 } from "@cosmjs/encoding";
 import { Int53, Uint53 } from "@cosmjs/math";
@@ -750,7 +750,12 @@ export class SigningCosmWasmClient extends CosmWasmClient {
     if (!accountFromSigner) {
       throw new Error("Failed to retrieve account from signer");
     }
-    const pubkey = encodePubkey(encodeSecp256k1Pubkey(accountFromSigner.pubkey));
+    let pubkey;
+    if (accountFromSigner.algo == "eth_secp256k1") {
+      pubkey = encodePubkey(encodeEthSecp256k1Pubkey(accountFromSigner.pubkey));
+    } else {
+      pubkey = encodePubkey(encodeSecp256k1Pubkey(accountFromSigner.pubkey));
+    }
     const txBody: TxBodyEncodeObject = {
       typeUrl: "/cosmos.tx.v1beta1.TxBody",
       value: {