feat: add broadcastWithFeePayerSig to handle rfq gw/rfq executor

Author: Frederick-88

packages/sdk-ts/src/core/tx/broadcaster/MsgBroadcasterWithPk.ts

@@ -4,6 +4,7 @@ import {
   getNetworkInfo,
   getNetworkEndpoints,
 } from '@injectivelabs/networks'
+import * as CosmosTxV1Beta1TxPb from '@injectivelabs/core-proto-ts-v2/generated/cosmos/tx/v1beta1/tx_pb'
 import {
   getStdFee,
   toBigNumber,
@@ -14,7 +15,6 @@ import { createTransaction } from '../tx.js'
 import { TxGrpcApi } from '../api/TxGrpcApi.js'
 import { ofacList } from '../../../utils/ofac.js'
 import { PrivateKey } from '../../accounts/index.js'
-import { uint8ArrayToHex } from '../../../utils/encoding.js'
 import { IndexerGrpcWeb3GwApi } from '../../../client/index.js'
 import { getGasPriceBasedOnMessage } from '../../../utils/msgs.js'
 import {
@@ -25,9 +25,13 @@ import {
   ChainRestAuthApi,
   ChainRestTendermintApi,
 } from '../../../client/chain/rest/index.js'
+import {
+  uint8ArrayToHex,
+  hexToUint8Array,
+  base64ToUint8Array,
+} from '../../../utils/encoding.js'
 import type { NetworkEndpoints } from '@injectivelabs/networks'
 import type { ChainId, EvmChainId } from '@injectivelabs/ts-types'
-import type * as CosmosTxV1Beta1TxPb from '@injectivelabs/core-proto-ts-v2/generated/cosmos/tx/v1beta1/tx_pb'
 import type { Msgs } from '../../modules/msgs.js'
 import type { AccountDetails } from '../../../types/auth.js'
 import type { CreateTransactionArgs } from '../types/index.js'
@@ -442,6 +446,39 @@ export class MsgBroadcasterWithPk {
     return toBigNumber(latestHeight.toString()).plus(txTimeout)
   }
 
+  async broadcastWithFeePayerSig({
+    tx,
+    feePayerSig,
+    accountNumber,
+  }: {
+    feePayerSig: string
+    accountNumber: number
+    tx: Uint8Array | string
+  }) {
+    const { chainId, privateKey } = this
+
+    const txBytes = typeof tx === 'string' ? base64ToUint8Array(tx) : tx
+    const txRaw = CosmosTxV1Beta1TxPb.TxRaw.fromBinary(txBytes)
+
+    const signDoc = CosmosTxV1Beta1TxPb.SignDoc.create({
+      chainId,
+      bodyBytes: txRaw.bodyBytes,
+      authInfoBytes: txRaw.authInfoBytes,
+      accountNumber: BigInt(accountNumber),
+    })
+
+    const signDocBytes = CosmosTxV1Beta1TxPb.SignDoc.toBinary(signDoc)
+    const signature = await privateKey.sign(signDocBytes)
+
+    const feePayerSigBytes = feePayerSig.startsWith('0x')
+      ? hexToUint8Array(feePayerSig.slice(2))
+      : base64ToUint8Array(feePayerSig)
+
+    txRaw.signatures = [signature, feePayerSigBytes]
+
+    return await this.broadcastTxRaw(txRaw)
+  }
+
   private async broadcastTxRaw(txRaw: CosmosTxV1Beta1TxPb.TxRaw) {
     const { endpoints, txTimeout } = this
     const txResponse = await new TxGrpcApi(endpoints.grpc).broadcast(txRaw, {

packages/wallets/wallet-core/src/broadcaster/MsgBroadcaster.ts

@@ -61,14 +61,14 @@ import {
   getAminoStdSignDoc,
   getEip712TypedData,
   createWeb3Extension,
+  CosmosTxV1Beta1TxPb,
   getEip712TypedDataV2,
   createTxRawFromSigResponse,
   createTransactionWithSigners,
 } from '@injectivelabs/sdk-ts/core/tx'
 import { checkIfTxRunOutOfGas } from '../utils/index.js'
 import type { NetworkEndpoints } from '@injectivelabs/networks'
 import type { ThrownException } from '@injectivelabs/exceptions'
-import type { CosmosTxV1Beta1TxPb } from '@injectivelabs/sdk-ts'
 import type { DirectSignResponse } from '@injectivelabs/sdk-ts/types'
 import type { Wallet as WalletType } from '@injectivelabs/wallet-base'
 import type {
@@ -348,6 +348,108 @@ export class MsgBroadcaster {
     }
   }
 
+  /**
+   * Sign and broadcast a pre-built transaction that already includes
+   * a fee payer's signature, directly to chain (bypassing web3gw).
+   */
+  async broadcastWithFeePayerSig({
+    tx,
+    feePayerSig,
+    accountNumber,
+    injectiveAddress,
+  }: {
+    feePayerSig: string
+    accountNumber: number
+    tx: Uint8Array | string
+    injectiveAddress: string
+  }): Promise<TxResponse> {
+    const {
+      chainId,
+      endpoints,
+      walletStrategy,
+      txTimeout: txTimeoutInBlocks,
+    } = this
+
+    if (!isCosmosWallet(walletStrategy.wallet)) {
+      throw new GeneralException(
+        new Error(
+          'broadcastWithFeePayerSig only supports Cosmos wallets (Keplr, Leap, etc.). EVM wallets are not supported for SIGN_MODE_DIRECT.',
+        ),
+      )
+    }
+
+    const txBytes = typeof tx === 'string' ? base64ToUint8Array(tx) : tx
+    const txRaw = CosmosTxV1Beta1TxPb.TxRaw.fromBinary(txBytes)
+
+    const cosmosWallet = walletStrategy.getCosmosWallet(chainId)
+    const canDisableCosmosGasCheck = (
+      [Wallet.Keplr, Wallet.OWallet] as WalletType[]
+    ).includes(walletStrategy.wallet)
+
+    if (canDisableCosmosGasCheck && cosmosWallet.disableGasCheck) {
+      cosmosWallet.disableGasCheck(chainId)
+    }
+
+    try {
+      walletStrategy.emit(
+        WalletStrategyEmitterEventType.TransactionPreparationStart,
+      )
+
+      const directSignResponse = (await walletStrategy.signCosmosTransaction({
+        txRaw,
+        chainId,
+        accountNumber,
+        address: injectiveAddress,
+      })) as DirectSignResponse
+
+      walletStrategy.emit(
+        WalletStrategyEmitterEventType.TransactionPreparationEnd,
+      )
+
+      const signedTxRaw = CosmosTxV1Beta1TxPb.TxRaw.create()
+      signedTxRaw.bodyBytes = directSignResponse.signed.bodyBytes
+      signedTxRaw.authInfoBytes = directSignResponse.signed.authInfoBytes
+
+      const takerSig = base64ToUint8Array(
+        directSignResponse.signature.signature,
+      )
+      const feePayerSigBytes = feePayerSig.startsWith('0x')
+        ? hexToUint8Array(feePayerSig.slice(2))
+        : base64ToUint8Array(feePayerSig)
+
+      signedTxRaw.signatures = [takerSig, feePayerSigBytes]
+
+      walletStrategy.emit(
+        WalletStrategyEmitterEventType.TransactionBroadcastStart,
+      )
+
+      const txResponse = await new TxGrpcApi(endpoints.grpc).broadcast(
+        signedTxRaw,
+        { txTimeout: txTimeoutInBlocks },
+      )
+
+      walletStrategy.emit(
+        WalletStrategyEmitterEventType.TransactionBroadcastEnd,
+      )
+
+      return txResponse
+    } catch (e) {
+      const error = e as any
+
+      walletStrategy.emit(WalletStrategyEmitterEventType.TransactionFail)
+
+      if (isThrownException(error)) {
+        throw error
+      }
+
+      throw new TransactionException(new Error(error))
+    } finally {
+      if (canDisableCosmosGasCheck && cosmosWallet.enableGasCheck) {
+        cosmosWallet.enableGasCheck(chainId)
+      }
+    }
+  }
+
   /**
    * Prepare/sign/broadcast transaction using
    * Ethereum native wallets on the client side.