@cowprotocol/cow-sdk 0.0.8-RC.0 → 0.0.11

package/src/api/cow/errors/OperatorError.ts

@@ -1,142 +0,0 @@
-import log from 'loglevel'
-import { CowError, logPrefix } from '../../../utils/common'
-
-type ApiActionType = 'get' | 'create' | 'delete'
-
-export interface ApiErrorObject {
-  errorType: ApiErrorCodes
-  description: string
-  data?: any
-}
-
-// Conforms to backend API
-// https://github.com/gnosis/gp-v2-services/blob/d932e11c9a2125fdba239530be7684799f694909/crates/orderbook/openapi.yml#L801
-// and
-// https://github.com/gnosis/gp-v2-services/blob/d932e11c9a2125fdba239530be7684799f694909/crates/orderbook/openapi.yml#L740
-export enum ApiErrorCodes {
-  DuplicateOrder = 'DuplicateOrder',
-  InvalidSignature = 'InvalidSignature',
-  MissingOrderData = 'MissingOrderData',
-  InsufficientValidTo = 'InsufficientValidTo',
-  InsufficientAllowance = 'InsufficientAllowance',
-  InsufficientBalance = 'InsufficientBalance',
-  InsufficientFee = 'InsufficientFee',
-  WrongOwner = 'WrongOwner',
-  NotFound = 'NotFound',
-  OrderNotFound = 'OrderNotFound',
-  AlreadyCancelled = 'AlreadyCancelled',
-  OrderFullyExecuted = 'OrderFullyExecuted',
-  OrderExpired = 'OrderExpired',
-  NoLiquidity = 'NoLiquidity',
-  UnsupportedToken = 'UnsupportedToken',
-  AmountIsZero = 'AmountIsZero',
-  SellAmountDoesNotCoverFee = 'SellAmountDoesNotCoverFee',
-  TransferEthToContract = 'TransferEthToContract',
-  UNHANDLED_GET_ERROR = 'UNHANDLED_GET_ERROR',
-  UNHANDLED_CREATE_ERROR = 'UNHANDLED_CREATE_ERROR',
-  UNHANDLED_DELETE_ERROR = 'UNHANDLED_DELETE_ERROR',
-}
-
-export enum ApiErrorCodeDetails {
-  DuplicateOrder = 'There was another identical order already submitted. Please try again.',
-  InsufficientFee = "The signed fee is insufficient. It's possible that is higher now due to a change in the gas price, ether price, or the sell token price. Please try again to get an updated fee quote.",
-  InvalidSignature = 'The order signature is invalid. Check whether your Wallet app supports off-chain signing.',
-  MissingOrderData = 'The order has missing information',
-  InsufficientValidTo = 'The order you are signing is already expired. This can happen if you set a short expiration in the settings and waited too long before signing the transaction. Please try again.',
-  InsufficientAllowance = "The account doesn't have enough funds",
-  InsufficientBalance = 'The account needs to approve the selling token in order to trade',
-  WrongOwner = "The signature is invalid.\n\nIt's likely that the signing method provided by your wallet doesn't comply with the standards required by CowSwap.\n\nCheck whether your Wallet app supports off-chain signing (EIP-712 or ETHSIGN).",
-  NotFound = 'Token pair selected has insufficient liquidity',
-  OrderNotFound = 'The order you are trying to cancel does not exist',
-  AlreadyCancelled = 'Order is already cancelled',
-  OrderFullyExecuted = 'Order is already filled',
-  OrderExpired = 'Order is expired',
-  NoLiquidity = 'Token pair selected has insufficient liquidity',
-  UnsupportedToken = 'One of the tokens you are trading is unsupported. Please read the FAQ for more info.',
-  AmountIsZero = 'Amount is zero',
-  SellAmountDoesNotCoverFee = 'Sell amount does not sufficiently cover the current fee',
-  TransferEthToContract = 'Sending the native currency to smart contract wallets is not currently supported',
-  UNHANDLED_GET_ERROR = 'Order fetch failed. This may be due to a server or network connectivity issue. Please try again later.',
-  UNHANDLED_CREATE_ERROR = 'The order was not accepted by the network',
-  UNHANDLED_DELETE_ERROR = 'The order cancellation was not accepted by the network',
-}
-
-function _mapActionToErrorDetail(action?: ApiActionType) {
-  switch (action) {
-    case 'get':
-      return ApiErrorCodeDetails.UNHANDLED_GET_ERROR
-    case 'create':
-      return ApiErrorCodeDetails.UNHANDLED_CREATE_ERROR
-    case 'delete':
-      return ApiErrorCodeDetails.UNHANDLED_DELETE_ERROR
-    default:
-      log.error(
-        logPrefix,
-        '[OperatorError::_mapActionToErrorDetails] Uncaught error mapping error action type to server error. Please try again later.'
-      )
-      return 'Something failed. Please try again later.'
-  }
-}
-
-export default class OperatorError extends CowError {
-  name = 'OperatorError'
-  description: ApiErrorObject['description']
-
-  // Status 400 errors
-  // https://github.com/gnosis/gp-v2-services/blob/9014ae55412a356e46343e051aefeb683cc69c41/orderbook/openapi.yml#L563
-  static apiErrorDetails = ApiErrorCodeDetails
-
-  public static async getErrorMessage(response: Response, action: ApiActionType) {
-    try {
-      const orderPostError: ApiErrorObject = await response.json()
-
-      if (orderPostError.errorType) {
-        const errorMessage = OperatorError.apiErrorDetails[orderPostError.errorType]
-        // shouldn't fall through as this error constructor expects the error code to exist but just in case
-        return errorMessage || orderPostError.errorType
-      } else {
-        log.error(logPrefix, 'Unknown reason for bad order submission', orderPostError)
-        return orderPostError.description
-      }
-    } catch (error) {
-      log.error(logPrefix, 'Error handling a 400 error. Likely a problem deserialising the JSON response')
-      return _mapActionToErrorDetail(action)
-    }
-  }
-  static async getErrorFromStatusCode(response: Response, action: 'create' | 'delete') {
-    switch (response.status) {
-      case 400:
-      case 404:
-        return this.getErrorMessage(response, action)
-
-      case 403:
-        return `The order cannot be ${action === 'create' ? 'accepted' : 'cancelled'}. Your account is deny-listed.`
-
-      case 429:
-        return `The order cannot be ${
-          action === 'create' ? 'accepted. Too many order placements' : 'cancelled. Too many order cancellations'
-        }. Please, retry in a minute`
-
-      case 500:
-      default:
-        log.error(
-          logPrefix,
-          `[OperatorError::getErrorFromStatusCode] Error ${
-            action === 'create' ? 'creating' : 'cancelling'
-          } the order, status code:`,
-          response.status || 'unknown'
-        )
-        return `Error ${action === 'create' ? 'creating' : 'cancelling'} the order`
-    }
-  }
-  constructor(apiError: ApiErrorObject) {
-    super(apiError.description, apiError.errorType)
-
-    this.description = apiError.description
-    this.message = ApiErrorCodeDetails[apiError.errorType]
-  }
-}
-
-export function isValidOperatorError(error: any): error is OperatorError {
-  return error instanceof OperatorError
-}

package/src/api/cow/errors/QuoteError.ts

@@ -1,115 +0,0 @@
-import log from 'loglevel'
-import { CowError, logPrefix } from '../../../utils/common'
-import { ApiErrorCodes, ApiErrorObject } from './OperatorError'
-
-export interface GpQuoteErrorObject {
-  errorType: GpQuoteErrorCodes
-  description: string
-  data?: any
-}
-
-// Conforms to backend API
-// https://github.com/gnosis/gp-v2-services/blob/0bd5f7743bebaa5acd3be13e35ede2326a096f14/orderbook/openapi.yml#L562
-export enum GpQuoteErrorCodes {
-  UnsupportedToken = 'UnsupportedToken',
-  InsufficientLiquidity = 'InsufficientLiquidity',
-  FeeExceedsFrom = 'FeeExceedsFrom',
-  ZeroPrice = 'ZeroPrice',
-  UNHANDLED_ERROR = 'UNHANDLED_ERROR',
-}
-
-export enum GpQuoteErrorDetails {
-  UnsupportedToken = 'One of the tokens you are trading is unsupported. Please read the FAQ for more info.',
-  InsufficientLiquidity = 'Token pair selected has insufficient liquidity',
-  FeeExceedsFrom = 'Current fee exceeds entered "from" amount',
-  ZeroPrice = 'Quoted price is zero. This is likely due to a significant price difference between the two tokens. Please try increasing amounts.',
-  UNHANDLED_ERROR = 'Quote fetch failed. This may be due to a server or network connectivity issue. Please try again later.',
-}
-
-export function mapOperatorErrorToQuoteError(error?: ApiErrorObject): GpQuoteErrorObject {
-  switch (error?.errorType) {
-    case ApiErrorCodes.NotFound:
-    case ApiErrorCodes.NoLiquidity:
-      return {
-        errorType: GpQuoteErrorCodes.InsufficientLiquidity,
-        description: GpQuoteErrorDetails.InsufficientLiquidity,
-      }
-
-    case ApiErrorCodes.SellAmountDoesNotCoverFee:
-      return {
-        errorType: GpQuoteErrorCodes.FeeExceedsFrom,
-        description: GpQuoteErrorDetails.FeeExceedsFrom,
-        data: error?.data,
-      }
-
-    case ApiErrorCodes.UnsupportedToken:
-      return {
-        errorType: GpQuoteErrorCodes.UnsupportedToken,
-        description: error.description,
-      }
-    case ApiErrorCodes.SellAmountDoesNotCoverFee:
-      return {
-        errorType: GpQuoteErrorCodes.FeeExceedsFrom,
-        description: error.description,
-      }
-    default:
-      return { errorType: GpQuoteErrorCodes.UNHANDLED_ERROR, description: GpQuoteErrorDetails.UNHANDLED_ERROR }
-  }
-}
-
-export default class GpQuoteError extends CowError {
-  name = 'QuoteErrorObject'
-  description: string
-  // any data attached
-  data?: any
-
-  // Status 400 errors
-  // https://github.com/gnosis/gp-v2-services/blob/9014ae55412a356e46343e051aefeb683cc69c41/orderbook/openapi.yml#L563
-  static quoteErrorDetails = GpQuoteErrorDetails
-
-  public static async getErrorMessage(response: Response) {
-    try {
-      const orderPostError: GpQuoteErrorObject = await response.json()
-
-      if (orderPostError.errorType) {
-        const errorMessage = GpQuoteError.quoteErrorDetails[orderPostError.errorType]
-        // shouldn't fall through as this error constructor expects the error code to exist but just in case
-        return errorMessage || orderPostError.errorType
-      } else {
-        log.error(logPrefix, 'Unknown reason for bad quote fetch', orderPostError)
-        return orderPostError.description
-      }
-    } catch (error) {
-      log.error(logPrefix, 'Error handling 400/404 error. Likely a problem deserialising the JSON response')
-      return GpQuoteError.quoteErrorDetails.UNHANDLED_ERROR
-    }
-  }
-
-  static async getErrorFromStatusCode(response: Response) {
-    switch (response.status) {
-      case 400:
-      case 404:
-        return this.getErrorMessage(response)
-
-      case 500:
-      default:
-        log.error(
-          logPrefix,
-          '[QuoteError::getErrorFromStatusCode] Error fetching quote, status code:',
-          response.status || 'unknown'
-        )
-        return 'Error fetching quote'
-    }
-  }
-  constructor(quoteError: GpQuoteErrorObject) {
-    super(quoteError.description, quoteError.errorType)
-
-    this.description = quoteError.description
-    this.message = GpQuoteError.quoteErrorDetails[quoteError.errorType]
-    this.data = quoteError?.data
-  }
-}
-
-export function isValidQuoteError(error: any): error is GpQuoteError {
-  return error instanceof GpQuoteError
-}

package/src/api/cow/index.ts

@@ -1,367 +0,0 @@
-import log from 'loglevel'
-import fetch from 'cross-fetch'
-import { OrderKind, QuoteQuery } from '@gnosis.pm/gp-v2-contracts'
-import { SupportedChainId as ChainId } from '../../constants/chains'
-import { getSigningSchemeApiValue, OrderCreation } from '../../utils/sign'
-import OperatorError, { ApiErrorCodeDetails, ApiErrorCodes, ApiErrorObject } from './errors/OperatorError'
-import QuoteError, {
-  GpQuoteErrorCodes,
-  GpQuoteErrorObject,
-  mapOperatorErrorToQuoteError,
-  GpQuoteErrorDetails,
-} from './errors/QuoteError'
-import { toErc20Address } from '../../utils/tokens'
-import { FeeQuoteParams, PriceInformation, PriceQuoteParams, SimpleGetQuoteResponse } from '../../utils/price'
-
-import { ZERO_ADDRESS } from '../../constants'
-import {
-  GetOrdersParams,
-  GetTradesParams,
-  OrderCancellationParams,
-  OrderID,
-  OrderMetaData,
-  ProfileData,
-  TradeMetaData,
-} from './types'
-import { CowError, logPrefix, objectToQueryString } from '../../utils/common'
-import { Context } from '../../utils/context'
-
-function getGnosisProtocolUrl(isDev: boolean): Partial<Record<ChainId, string>> {
-  if (isDev) {
-    return {
-      [ChainId.MAINNET]: 'https://barn.api.cow.fi/mainnet/api',
-      [ChainId.RINKEBY]: 'https://barn.api.cow.fi/rinkeby/api',
-      [ChainId.GNOSIS_CHAIN]: 'https://barn.api.cow.fi/xdai/api',
-    }
-  }
-
-  return {
-    [ChainId.MAINNET]: 'https://api.cow.fi/mainnet/api',
-    [ChainId.RINKEBY]: 'https://api.cow.fi/rinkeby/api',
-    [ChainId.GNOSIS_CHAIN]: 'https://api.cow.fi/xdai/api',
-  }
-}
-
-function getProfileUrl(isDev: boolean): Partial<Record<ChainId, string>> {
-  if (isDev) {
-    return {
-      [ChainId.MAINNET]: 'https://barn.api.cow.fi/affiliate/api',
-    }
-  }
-
-  return {
-    [ChainId.MAINNET]: 'https://api.cow.fi/affiliate/api',
-  }
-}
-
-const UNHANDLED_QUOTE_ERROR: GpQuoteErrorObject = {
-  errorType: GpQuoteErrorCodes.UNHANDLED_ERROR,
-  description: GpQuoteErrorDetails.UNHANDLED_ERROR,
-}
-
-const UNHANDLED_ORDER_ERROR: ApiErrorObject = {
-  errorType: ApiErrorCodes.UNHANDLED_CREATE_ERROR,
-  description: ApiErrorCodeDetails.UNHANDLED_CREATE_ERROR,
-}
-
-async function _handleQuoteResponse<T = any, P extends QuoteQuery = QuoteQuery>(
-  response: Response,
-  params?: P
-): Promise<T> {
-  if (!response.ok) {
-    const errorObj: ApiErrorObject = await response.json()
-
-    // we need to map the backend error codes to match our own for quotes
-    const mappedError = mapOperatorErrorToQuoteError(errorObj)
-    const quoteError = new QuoteError(mappedError)
-
-    if (params) {
-      const { sellToken, buyToken } = params
-      log.error(logPrefix, `Error querying fee from API - sellToken: ${sellToken}, buyToken: ${buyToken}`)
-    }
-
-    throw quoteError
-  } else {
-    return response.json()
-  }
-}
-
-export class CowApi {
-  context: Context
-
-  API_NAME = 'CoW Protocol'
-
-  constructor(context: Context) {
-    this.context = context
-  }
-
-  get DEFAULT_HEADERS() {
-    return { 'Content-Type': 'application/json', 'X-AppId': this.context.appDataHash }
-  }
-
-  get API_BASE_URL() {
-    return getGnosisProtocolUrl(this.context.isDevEnvironment)
-  }
-
-  get PROFILE_API_BASE_URL(): Partial<Record<ChainId, string>> {
-    return getProfileUrl(this.context.isDevEnvironment)
-  }
-
-  async getProfileData(address: string): Promise<ProfileData | null> {
-    const chainId = await this.context.chainId
-    log.debug(logPrefix, `[api:${this.API_NAME}] Get profile data for`, chainId, address)
-    if (chainId !== ChainId.MAINNET) {
-      log.info(logPrefix, 'Profile data is only available for mainnet')
-      return null
-    }
-
-    const response = await this.getProfile(`/profile/${address}`)
-
-    if (!response.ok) {
-      const errorResponse = await response.json()
-      log.error(logPrefix, errorResponse)
-      throw new CowError(errorResponse?.description)
-    } else {
-      return response.json()
-    }
-  }
-
-  async getTrades(params: GetTradesParams): Promise<TradeMetaData[]> {
-    const { owner, limit, offset } = params
-    const qsParams = objectToQueryString({ owner, limit, offset })
-    const chainId = await this.context.chainId
-    log.debug(logPrefix, '[util:operator] Get trades for', chainId, owner, { limit, offset })
-    try {
-      const response = await this.get(`/trades${qsParams}`)
-
-      if (!response.ok) {
-        const errorResponse = await response.json()
-        throw new CowError(errorResponse)
-      } else {
-        return response.json()
-      }
-    } catch (error) {
-      log.error(logPrefix, 'Error getting trades:', error)
-      throw new CowError('Error getting trades: ' + error)
-    }
-  }
-
-  async getOrders(params: GetOrdersParams): Promise<OrderMetaData[]> {
-    const { owner, limit = 1000, offset = 0 } = params
-    const queryString = objectToQueryString({ limit, offset })
-    const chainId = await this.context.chainId
-    log.debug(logPrefix, `[api:${this.API_NAME}] Get orders for `, chainId, owner, limit, offset)
-
-    try {
-      const response = await this.get(`/account/${owner}/orders/${queryString}`)
-
-      if (!response.ok) {
-        const errorResponse: ApiErrorObject = await response.json()
-        throw new OperatorError(errorResponse)
-      } else {
-        return response.json()
-      }
-    } catch (error) {
-      log.error(logPrefix, 'Error getting orders information:', error)
-      throw new OperatorError(UNHANDLED_ORDER_ERROR)
-    }
-  }
-
-  async getTxOrders(txHash: string): Promise<OrderMetaData[]> {
-    const chainId = await this.context.chainId
-    log.debug(`[api:${this.API_NAME}] Get tx orders for `, chainId, txHash)
-
-    try {
-      const response = await this.get(`/transactions/${txHash}/orders`)
-
-      if (!response.ok) {
-        const errorResponse: ApiErrorObject = await response.json()
-        throw new OperatorError(errorResponse)
-      } else {
-        return response.json()
-      }
-    } catch (error) {
-      log.error('Error getting transaction orders information:', error)
-      if (error instanceof OperatorError) throw error
-      throw new OperatorError(UNHANDLED_ORDER_ERROR)
-    }
-  }
-
-  async getOrder(orderId: string): Promise<OrderMetaData | null> {
-    const chainId = await this.context.chainId
-    log.debug(logPrefix, `[api:${this.API_NAME}] Get order for `, chainId, orderId)
-    try {
-      const response = await this.get(`/orders/${orderId}`)
-
-      if (!response.ok) {
-        const errorResponse: ApiErrorObject = await response.json()
-        throw new OperatorError(errorResponse)
-      } else {
-        return response.json()
-      }
-    } catch (error) {
-      log.error(logPrefix, 'Error getting order information:', error)
-      throw new OperatorError(UNHANDLED_ORDER_ERROR)
-    }
-  }
-
-  async getPriceQuoteLegacy(params: PriceQuoteParams): Promise<PriceInformation | null> {
-    const { baseToken, quoteToken, amount, kind } = params
-    const chainId = await this.context.chainId
-    log.debug(logPrefix, `[api:${this.API_NAME}] Get price from API`, params, 'for', chainId)
-
-    const response = await this.get(
-      `/markets/${toErc20Address(baseToken, chainId)}-${toErc20Address(quoteToken, chainId)}/${kind}/${amount}`
-    ).catch((error) => {
-      log.error(logPrefix, 'Error getting price quote:', error)
-      throw new QuoteError(UNHANDLED_QUOTE_ERROR)
-    })
-
-    return _handleQuoteResponse<PriceInformation | null>(response)
-  }
-
-  async getQuote(params: FeeQuoteParams): Promise<SimpleGetQuoteResponse> {
-    const chainId = await this.context.chainId
-    const quoteParams = this.mapNewToLegacyParams(params, chainId)
-    const response = await this.post('/quote', quoteParams)
-
-    return _handleQuoteResponse<SimpleGetQuoteResponse>(response)
-  }
-
-  async sendSignedOrderCancellation(params: OrderCancellationParams): Promise<void> {
-    const { cancellation, owner: from } = params
-    const chainId = await this.context.chainId
-    log.debug(logPrefix, `[api:${this.API_NAME}] Delete signed order for network`, chainId, cancellation)
-
-    const response = await this.delete(`/orders/${cancellation.orderUid}`, {
-      signature: cancellation.signature,
-      signingScheme: getSigningSchemeApiValue(cancellation.signingScheme),
-      from,
-    })
-
-    if (!response.ok) {
-      // Raise an exception
-      const errorMessage = await OperatorError.getErrorFromStatusCode(response, 'delete')
-      throw new CowError(errorMessage)
-    }
-
-    log.debug(logPrefix, `[api:${this.API_NAME}] Cancelled order`, cancellation.orderUid, chainId)
-  }
-
-  async sendOrder(params: { order: Omit<OrderCreation, 'appData'>; owner: string }): Promise<OrderID> {
-    const fullOrder: OrderCreation = { ...params.order, appData: this.context.appDataHash }
-    const chainId = await this.context.chainId
-    const { owner } = params
-    log.debug(logPrefix, `[api:${this.API_NAME}] Post signed order for network`, chainId, fullOrder)
-
-    // Call API
-    const response = await this.post(`/orders`, {
-      ...fullOrder,
-      signingScheme: getSigningSchemeApiValue(fullOrder.signingScheme),
-      from: owner,
-    })
-
-    // Handle response
-    if (!response.ok) {
-      // Raise an exception
-      const errorMessage = await OperatorError.getErrorFromStatusCode(response, 'create')
-      throw new CowError(errorMessage)
-    }
-
-    const uid = (await response.json()) as string
-    log.debug(logPrefix, `[api:${this.API_NAME}] Success posting the signed order`, uid)
-    return uid
-  }
-
-  getOrderLink(orderId: OrderID): string {
-    const baseUrl = this.getApiBaseUrl()
-
-    return baseUrl + `/orders/${orderId}`
-  }
-
-  private mapNewToLegacyParams(params: FeeQuoteParams, chainId: ChainId): QuoteQuery {
-    const { amount, kind, userAddress, receiver, validTo, sellToken, buyToken } = params
-    const fallbackAddress = userAddress || ZERO_ADDRESS
-
-    const baseParams = {
-      sellToken: toErc20Address(sellToken, chainId),
-      buyToken: toErc20Address(buyToken, chainId),
-      from: fallbackAddress,
-      receiver: receiver || fallbackAddress,
-      appData: this.context.appDataHash,
-      validTo,
-      partiallyFillable: false,
-    }
-
-    const finalParams: QuoteQuery =
-      kind === OrderKind.SELL
-        ? {
-            kind: OrderKind.SELL,
-            sellAmountBeforeFee: amount,
-            ...baseParams,
-          }
-        : {
-            kind: OrderKind.BUY,
-            buyAmountAfterFee: amount,
-            ...baseParams,
-          }
-
-    return finalParams
-  }
-
-  private async getApiBaseUrl(): Promise<string> {
-    const chainId = await this.context.chainId
-    const baseUrl = this.API_BASE_URL[chainId]
-
-    if (!baseUrl) {
-      throw new CowError(`Unsupported Network. The ${this.API_NAME} API is not deployed in the Network ` + chainId)
-    } else {
-      return baseUrl + '/v1'
-    }
-  }
-
-  private async getProfileApiBaseUrl(): Promise<string> {
-    const chainId = await this.context.chainId
-    const baseUrl = this.PROFILE_API_BASE_URL[chainId]
-
-    if (!baseUrl) {
-      throw new CowError(`Unsupported Network. The ${this.API_NAME} API is not deployed in the Network ` + chainId)
-    } else {
-      return baseUrl + '/v1'
-    }
-  }
-
-  private async fetch(url: string, method: 'GET' | 'POST' | 'DELETE', data?: any): Promise<Response> {
-    const baseUrl = await this.getApiBaseUrl()
-    return fetch(baseUrl + url, {
-      headers: this.DEFAULT_HEADERS,
-      method,
-      body: data !== undefined ? JSON.stringify(data) : data,
-    })
-  }
-
-  private async fetchProfile(url: string, method: 'GET' | 'POST' | 'DELETE', data?: any): Promise<Response> {
-    const baseUrl = await this.getProfileApiBaseUrl()
-    return fetch(baseUrl + url, {
-      headers: this.DEFAULT_HEADERS,
-      method,
-      body: data !== undefined ? JSON.stringify(data) : data,
-    })
-  }
-
-  private post(url: string, data: any): Promise<Response> {
-    return this.fetch(url, 'POST', data)
-  }
-
-  private get(url: string): Promise<Response> {
-    return this.fetch(url, 'GET')
-  }
-
-  private getProfile(url: string): Promise<Response> {
-    return this.fetchProfile(url, 'GET')
-  }
-
-  private delete(url: string, data: any): Promise<Response> {
-    return this.fetch(url, 'DELETE', data)
-  }
-}