Proposing a transaction with Viem

[talentlessguy]

I have the following code:

import { SafeApiKit } from '../safe/ApiKit.js' // port of `SafeApiKit` but only with `proposeTransaction` method
import { OperationType } from '../safe/types.js'
import { sendTransaction } from 'viem/actions'
import { http, createWalletClient } from 'viem'

const account = privateKeyToAccount(process.env.PK as `0x${string}`)

const walletClient = createWalletClient({
  transport: http(),
  chain: chain === 'mainnet' ? mainnet : goerli,
  account,
})

const apiKit = new SafeApiKit({
  chainId: await walletClient.getChainId(),
  txServiceUrl: 'https://safe-transaction-mainnet.safe.global',
})

 const tx = { operation: OperationType.Call }

const sig = await walletClient.signTransaction({
  operation: OperationType.Call, // type error because there's no `operation` in a transaction request
  ...request,
})

await apiKit.proposeTransaction({
  safeAddress,
  senderAddress: account.address,
  safeTransactionData: tx,
  senderSignature: sig,
})

There's no operation defined in a transaction request. How would I make viem understand what OperationType is?

For context: I am trying to propose a tx to update ENS data using a multisig, and I don't need anything else from the Protocol / API kit.

here's also my simplified ApiKit class for easier reproduction:

export class SafeApiKit {
  #txServiceBaseUrl: string
  chainId: number

  constructor({ txServiceUrl, chainId }: SafeApiKitConfig) {
    this.#txServiceBaseUrl = getTxServiceBaseUrl(txServiceUrl)
    this.chainId = chainId
  }
  /**
   * Creates a new multi-signature transaction with its confirmations and stores it in the Safe Transaction Service.
   *
   * @param proposeTransactionConfig - The configuration of the proposed transaction
   * @returns The hash of the Safe transaction proposed
   */
  async proposeTransaction({
    safeAddress,
    safeTransactionData,
    safeTxHash,
    senderAddress,
    senderSignature,
    origin,
  }: ProposeTransactionProps): Promise<void> {
    if (!isAddress(safeAddress)) throw new InvalidSafeAddress(safeAddress)

    const { address: safe } = await getEip3770Address({
      fullAddress: safeAddress,
      chainId: this.chainId,
    })
    const { address: sender } = await getEip3770Address({
      fullAddress: senderAddress,
      chainId: this.chainId,
    })
    if (!isHash(safeTxHash)) throw new InvalidTxHashError(safeTxHash)

    return sendRequest({
      url: `${this.#txServiceBaseUrl}/v1/safes/${safe}/multisig-transactions/`,
      method: HttpMethod.Post,
      body: {
        ...safeTransactionData,
        contractTransactionHash: safeTxHash,
        sender,
        signature: senderSignature,
        origin,
      },
    })
  }
}