client.ts

import axios from 'axios';
import { ZeroAddress } from 'ethers';
import { Inject, Service } from 'typedi';

import { diConstants } from '@bonadocs/di';
import { BonadocsLogger } from '@bonadocs/logger';

import { ConfigService } from '../../configuration';
import { Tenderly } from '../../configuration/config.interface';
import { BaseHttpClient } from '../base';

import { BundleSimulationResult, EVMCall, SimulationResponseData, SimulationResult } from './types';

@Service()
export class TenderlyApiClient extends BaseHttpClient {
  constructor(
    @Inject() configService: ConfigService,
    @Inject(diConstants.logger) logger: BonadocsLogger,
  ) {
    const tenderlyConfigs = configService.getTransformed<Tenderly>('tenderly');
    super(
      configService,
      logger,
      axios.create({
        baseURL: `https://api.tenderly.co/api/v1/account/${tenderlyConfigs.username}/project/${tenderlyConfigs.project}`,
        validateStatus: () => true,
        timeout: 60000,
        headers: {
          'X-Access-Key': tenderlyConfigs.accessKey,
        },
      }),
    );
  }

  async simulateSingle(
    chainId: number,
    call: EVMCall,
  ): Promise<SimulationResponseData | undefined> {
    try {
      const response = await this.request<SimulationResult>({
        url: '/simulate',
        method: 'post',
        data: this.callToSimulationData(chainId, call),
      });

      if (response.status !== 200) {
        this.logger.error(`Unexpected response status: ${response.status}`);
        return undefined;
      }

      return this.normalizeSimulationResult(response.data);
    } catch (error) {
      if (axios.isAxiosError(error)) {
        this.logger.error('Axios error during simulation request', error.message);
      } else {
        this.logger.error('Unexpected error during simulation request', error);
      }
      return undefined;
    }
  }

  async simulateBundle(
    chainId: number,
    calls: EVMCall[],
  ): Promise<SimulationResponseData[] | undefined> {
    try {
      const response = await this.request<BundleSimulationResult>({
        url: '/simulate-bundle',
        method: 'post',
        data: { simulations: calls.map((call) => this.callToSimulationData(chainId, call)) },
      });

      if (response.status !== 200) {
        this.logger.error(`Unexpected response status: ${response.status}`);
        return undefined;
      }

      return response.data.simulation_results.map((result) =>
        this.normalizeSimulationResult(result),
      );
    } catch (error) {
      if (axios.isAxiosError(error)) {
        this.logger.error('Axios error during bundle simulation request', error.message);
      } else {
        this.logger.error('Unexpected error during bundle simulation request', error);
      }
      return undefined;
    }
  }

  private callToSimulationData(chainId: number, call: EVMCall) {
    const stateObjects = Object.fromEntries(
      call.simulationOverrides.accounts.map((acct) => [
        acct.address,
        {
          storage: acct.storage,
        },
      ]),
    );

    return {
      /* Simulation Configuration */
      save: false,
      save_if_fails: false,
      simulation_type: 'quick',
      network_id: chainId.toString(10),
      state_objects: stateObjects,

      /* Standard EVM Transaction object */
      from: call.overrides.from || ZeroAddress,
      to: call.to,
      input: call.data,
      gas: call.overrides.gasLimit,
      gas_price: call.overrides.gasPrice || call.overrides.maxFeePerGas,
      value: call.overrides.value,
    };
  }

  private normalizeSimulationResult(data: SimulationResult): SimulationResponseData {
    const resultData = data.transaction;
    return {
      error: !resultData.error_info
        ? undefined
        : {
            address: resultData.error_info.address,
            message: resultData.error_info.error_message || 'execution reverted',
          },
      receipt: {
        from: resultData.from!,
        to: resultData.to || null,
        status: resultData.status ? 1 : 0,
        blockHash: resultData.block_hash!,
        type: 2,
        blockNumber: resultData.block_number!,
        hash: resultData.hash!,
        index: resultData.index!,
        root: null,
        gasUsed: BigInt(resultData.gas_used!),
        contractAddress: resultData.transaction_info!.contract_address || null,
        cumulativeGasUsed: BigInt(resultData.cumulative_gas_used!),
        gasPrice: BigInt(resultData.gas_price!),
        effectiveGasPrice: BigInt(resultData.effective_gas_price!),
        logsBloom: '0x',
        logs:
          resultData.transaction_info!.logs?.map((l, i) => ({
            data: l.raw!.data!,
            address: l.raw!.address!,
            topics: l.raw!.topics!,
            transactionIndex: resultData.index!,
            removed: false,
            index: i,
            blockHash: resultData.block_hash!,
            blockNumber: resultData.block_number!,
            transactionHash: resultData.hash!,
          })) || [],
      },
    };
  }
}