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

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)
-  }
-}

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,2 +0,0 @@
-export * from './cow'
-export * from './metadata'

package/src/api/metadata/index.ts

@@ -1,37 +0,0 @@
-import log from 'loglevel'
-import { Context } from '../../utils/context'
-import { getSerializedCID, loadIpfsFromCid } from '../../utils/appData'
-import { AppDataDoc } from './types'
-import { CowError } from '../../utils/common'
-
-export class MetadataApi {
-  context: Context
-
-  constructor(context: Context) {
-    this.context = context
-  }
-
-  async decodeAppData(hash: string): Promise<void | AppDataDoc> {
-    try {
-      const cidV0 = await getSerializedCID(hash)
-      if (!cidV0) throw new CowError('Error getting serialized CID')
-      return await loadIpfsFromCid(cidV0)
-    } catch (error) {
-      log.error('Error decoding AppData:', error)
-      throw new CowError('Error decoding AppData: ' + error)
-    }
-  }
-
-  async cidToAppDataHex(ipfsHash: string): Promise<string | void> {
-    const { CID } = await import('multiformats/cid')
-
-    const { digest } = CID.parse(ipfsHash).multihash
-    return `0x${Buffer.from(digest).toString('hex')}`
-  }
-
-  async appDataHexToCid(hash: string): Promise<string | void> {
-    const cidV0 = await getSerializedCID(hash)
-    if (!cidV0) throw new CowError('Error getting serialized CID')
-    return cidV0
-  }
-}

package/src/api/metadata/types.ts

@@ -1,17 +0,0 @@
-interface Metadata {
-  version: string
-}
-
-export interface ReferralMetadata extends Metadata {
-  address: string
-}
-
-export type MetadataDoc = {
-  referrer?: ReferralMetadata
-}
-
-export type AppDataDoc = {
-  version: string
-  appCode?: string
-  metadata: MetadataDoc
-}

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,16 +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'
-
-export const DEFAULT_IPFS_GATEWAY_URI = 'https://gnosis.mypinata.cloud/ipfs'

package/src/constants/tokens.ts

@@ -1,16 +0,0 @@
-import { SupportedChainId as ChainId } from './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 { CowSdk } 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,6 +0,0 @@
-export * from '../api/cow/types'
-export * from '../api/metadata/types'
-export { OrderKind } from '@gnosis.pm/gp-v2-contracts'
-export class Token {
-  constructor(public symbol: string, public address: string) {}
-}