@cowprotocol/cow-sdk 0.0.6 → 0.0.10

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

@@ -1,114 +0,0 @@
-import log from 'loglevel'
-import { CowError } 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('Unknown reason for bad quote fetch', orderPostError)
-        return orderPostError.description
-      }
-    } catch (error) {
-      log.error('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(
-          '[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,343 +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 '/api/cow/types'
-import { CowError, 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(`Error querying fee from API - sellToken: ${sellToken}, buyToken: ${buyToken}`)
-    }
-
-    throw quoteError
-  } else {
-    return response.json()
-  }
-}
-
-export class CowApi<T extends ChainId> {
-  chainId: T
-  context: Context
-
-  API_NAME = 'CoW Protocol'
-
-  constructor(chainId: T, context: Context) {
-    this.chainId = chainId
-    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> {
-    log.debug(`[api:${this.API_NAME}] Get profile data for`, this.chainId, address)
-    if (this.chainId !== ChainId.MAINNET) {
-      log.info('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(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 })
-    log.debug('[util:operator] Get trades for', this.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('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 })
-    log.debug(`[api:${this.API_NAME}] Get orders for `, this.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('Error getting orders information:', error)
-      throw new OperatorError(UNHANDLED_ORDER_ERROR)
-    }
-  }
-
-  async getOrder(orderId: string): Promise<OrderMetaData | null> {
-    log.debug(`[api:${this.API_NAME}] Get order for `, this.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('Error getting order information:', error)
-      throw new OperatorError(UNHANDLED_ORDER_ERROR)
-    }
-  }
-
-  async getPriceQuoteLegacy(params: PriceQuoteParams): Promise<PriceInformation | null> {
-    const { baseToken, quoteToken, amount, kind } = params
-    log.debug(`[api:${this.API_NAME}] Get price from API`, params)
-
-    const response = await this.get(
-      `/markets/${toErc20Address(baseToken, this.chainId)}-${toErc20Address(
-        quoteToken,
-        this.chainId
-      )}/${kind}/${amount}`
-    ).catch((error) => {
-      log.error('Error getting price quote:', error)
-      throw new QuoteError(UNHANDLED_QUOTE_ERROR)
-    })
-
-    return _handleQuoteResponse<PriceInformation | null>(response)
-  }
-
-  async getQuote(params: FeeQuoteParams): Promise<SimpleGetQuoteResponse> {
-    const quoteParams = this.mapNewToLegacyParams(params, this.chainId)
-    const response = await this.post('/quote', quoteParams)
-
-    return _handleQuoteResponse<SimpleGetQuoteResponse>(response)
-  }
-
-  async sendSignedOrderCancellation(params: OrderCancellationParams): Promise<void> {
-    const { cancellation, owner: from } = params
-
-    log.debug(`[api:${this.API_NAME}] Delete signed order for network`, this.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(`[api:${this.API_NAME}] Cancelled order`, cancellation.orderUid, this.chainId)
-  }
-
-  async sendOrder(params: { order: Omit<OrderCreation, 'appData'>; owner: string }): Promise<OrderID> {
-    const fullOrder: OrderCreation = { ...params.order, appData: this.context.appDataHash }
-    const { owner } = params
-    log.debug(`[api:${this.API_NAME}] Post signed order for network`, this.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(`[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 getApiBaseUrl(): string {
-    const baseUrl = this.API_BASE_URL[this.chainId]
-
-    if (!baseUrl) {
-      throw new CowError(`Unsupported Network. The ${this.API_NAME} API is not deployed in the Network ` + this.chainId)
-    } else {
-      return baseUrl + '/v1'
-    }
-  }
-
-  private getProfileApiBaseUrl(): string {
-    const baseUrl = this.PROFILE_API_BASE_URL[this.chainId]
-
-    if (!baseUrl) {
-      throw new CowError(`Unsupported Network. The ${this.API_NAME} API is not deployed in the Network ` + this.chainId)
-    } else {
-      return baseUrl + '/v1'
-    }
-  }
-
-  private fetch(url: string, method: 'GET' | 'POST' | 'DELETE', data?: any): Promise<Response> {
-    const baseUrl = this.getApiBaseUrl()
-    return fetch(baseUrl + url, {
-      headers: this.DEFAULT_HEADERS,
-      method,
-      body: data !== undefined ? JSON.stringify(data) : data,
-    })
-  }
-
-  private fetchProfile(url: string, method: 'GET' | 'POST' | 'DELETE', data?: any): Promise<Response> {
-    const baseUrl = 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)
-  }
-}

package/src/api/cow/types.ts

@@ -1,82 +0,0 @@
-import { OrderKind } from '@gnosis.pm/gp-v2-contracts'
-import { SupportedChainId as ChainId } from '/constants/chains'
-import { OrderCancellation, SigningSchemeValue } from '/utils/sign'
-
-/**
- * Unique identifier for the order, calculated by keccak256(orderDigest, ownerAddress, validTo),
- * where orderDigest = keccak256(orderStruct). bytes32.
- */
-export type OrderID = string
-export type ApiOrderStatus = 'fulfilled' | 'expired' | 'cancelled' | 'presignaturePending' | 'open'
-
-export interface OrderMetaData {
-  creationDate: string
-  owner: string
-  uid: OrderID
-  availableBalance: string
-  executedBuyAmount: string
-  executedSellAmount: string
-  executedSellAmountBeforeFees: string
-  executedFeeAmount: string
-  invalidated: false
-  sellToken: string
-  buyToken: string
-  sellAmount: string
-  buyAmount: string
-  validTo: number
-  appData: number
-  feeAmount: string
-  kind: OrderKind
-  partiallyFillable: false
-  signature: string
-  signingScheme: SigningSchemeValue
-  status: ApiOrderStatus
-  receiver: string
-}
-
-export interface TradeMetaData {
-  blockNumber: number
-  logIndex: number
-  orderUid: OrderID
-  owner: string
-  sellToken: string
-  buyToken: string
-  sellAmount: string
-  buyAmount: string
-  sellAmountBeforeFees: string
-  txHash: string
-}
-
-export interface UnsupportedToken {
-  [token: string]: {
-    address: string
-    dateAdded: number
-  }
-}
-
-export type PaginationParams = {
-  limit?: number
-  offset?: number
-}
-
-export type OrderCancellationParams = {
-  chainId: ChainId
-  cancellation: OrderCancellation
-  owner: string
-}
-
-export type GetOrdersParams = {
-  owner: string
-} & PaginationParams
-
-export type GetTradesParams = {
-  owner: string
-} & PaginationParams
-
-export type ProfileData = {
-  totalTrades: number
-  totalReferrals: number
-  tradeVolumeUsd: number
-  referralVolumeUsd: number
-  lastUpdated: string
-}

package/src/api/index.ts

@@ -1 +0,0 @@
-export * from './cow'

package/src/constants/chains.ts

@@ -1,11 +0,0 @@
-export enum SupportedChainId {
-  MAINNET = 1,
-  RINKEBY = 4,
-  GNOSIS_CHAIN = 100,
-}
-
-export const ALL_SUPPORTED_CHAIN_IDS: SupportedChainId[] = [
-  SupportedChainId.MAINNET,
-  SupportedChainId.RINKEBY,
-  SupportedChainId.GNOSIS_CHAIN,
-]

package/src/constants/index.ts

@@ -1,14 +0,0 @@
-import contractNetworks from '@gnosis.pm/gp-v2-contracts/networks.json'
-import { SupportedChainId as ChainId } from './chains'
-
-const { GPv2Settlement } = contractNetworks
-
-export const GP_SETTLEMENT_CONTRACT_ADDRESS: Partial<Record<number, string>> = {
-  [ChainId.MAINNET]: GPv2Settlement[ChainId.MAINNET].address,
-  [ChainId.RINKEBY]: GPv2Settlement[ChainId.RINKEBY].address,
-  [ChainId.GNOSIS_CHAIN]: GPv2Settlement[ChainId.GNOSIS_CHAIN].address,
-}
-
-export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
-
-export const DEFAULT_APP_DATA_HASH = '0x0000000000000000000000000000000000000000000000000000000000000000'

package/src/constants/tokens.ts

@@ -1,16 +0,0 @@
-import { SupportedChainId as ChainId } from '/constants/chains'
-import { Token } from '/types'
-
-export const XDAI_SYMBOL = 'XDAI'
-
-export const WRAPPED_NATIVE_TOKEN: Record<ChainId, Token> = {
-  [ChainId.MAINNET]: new Token('WETH', '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'),
-  [ChainId.RINKEBY]: new Token('WETH', '0xc778417E063141139Fce010982780140Aa0cD5Ab'),
-  [ChainId.GNOSIS_CHAIN]: new Token('WXDAI', '0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d'),
-}
-
-export const NATIVE: Record<ChainId, string> = {
-  [ChainId.MAINNET]: 'ETH',
-  [ChainId.RINKEBY]: 'ETH',
-  [ChainId.GNOSIS_CHAIN]: XDAI_SYMBOL,
-}

package/src/index.ts

@@ -1,4 +0,0 @@
-export { CowError } from '/utils/common'
-export { ALL_SUPPORTED_CHAIN_IDS } from '/constants/chains'
-export * from '/types'
-export * from '/CowSdk'

package/src/schemas/appData.schema.json

@@ -1,70 +0,0 @@
-{
-  "$id": "https://cowswap.exchange/appdata.schema.json",
-  "$schema": "http://json-schema.org/draft-07/schema",
-  "description": "Metadata JSON document for adding information to orders.",
-  "required": ["version", "metadata"],
-  "title": "AppData Root Schema",
-  "type": "object",
-  "properties": {
-    "version": {
-      "$id": "#/properties/version",
-      "description": "Semantic versioning of document",
-      "examples": ["1.0.0", "1.2.3"],
-      "title": "Semantic Versioning",
-      "type": "string"
-    },
-    "appCode": {
-      "$id": "#/properties/appCode",
-      "description": "The code identifying the CLI, UI, service generating the order.",
-      "examples": ["CowSwap"],
-      "title": "App Code",
-      "type": "string"
-    },
-    "metadata": {
-      "$id": "#/properties/metadata",
-      "default": {},
-      "description": "Each metadata will specify one aspect of the order.",
-      "required": [],
-      "title": "Metadata descriptors",
-      "type": "object",
-      "properties": {
-        "referrer": {
-          "$ref": "#/definitions/kindMetadata/referrer"
-        }
-      }
-    }
-  },
-  "definitions": {
-    "version": {
-      "$id": "#/definitions/version",
-      "description": "Semantic versioning of document",
-      "examples": ["1.0.0", "1.2.3"],
-      "title": "Semantic Versioning",
-      "type": "string"
-    },
-    "ethereumAddress": {
-      "$id": "#/definitions/ethereumAddress",
-      "pattern": "^0x[a-fA-F0-9]{40}$",
-      "title": "Ethereum compatible address",
-      "examples": ["0xb6BAd41ae76A11D10f7b0E664C5007b908bC77C9"],
-      "type": "string"
-    },
-    "kindMetadata": {
-      "referrer": {
-        "$id": "#/definitions/referrer",
-        "required": ["version", "address"],
-        "title": "Referrer",
-        "type": "object",
-        "properties": {
-          "version": {
-            "$ref": "#/definitions/version"
-          },
-          "address": {
-            "$ref": "#/definitions/ethereumAddress",
-            "title": "Referrer address"
-          }
-        }
-      }
-    }
-  }
-}

package/src/types/index.ts

@@ -1,5 +0,0 @@
-export * from '/api/cow/types'
-export { OrderKind } from '@gnosis.pm/gp-v2-contracts'
-export class Token {
-  constructor(public symbol: string, public address: string) {}
-}