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

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

package/src/utils/appData.spec.ts

@@ -1,109 +0,0 @@
-import { validateAppDataDocument, getSerializedCID, loadIpfsFromCid } from './appData'
-
-const VALID_RESULT = {
-  result: true,
-}
-
-const INVALID_CID_LENGTH = 'Incorrect length'
-
-test('Valid minimal document', async () => {
-  const validation = await validateAppDataDocument({
-    version: '0.1.0',
-    metadata: {},
-  })
-  expect(validation).toEqual(VALID_RESULT)
-})
-
-test('Valid minimal document + appCode', async () => {
-  const validation = await validateAppDataDocument({
-    version: '0.1.0',
-    appCode: 'MyApp',
-    metadata: {},
-  })
-  expect(validation).toEqual(VALID_RESULT)
-})
-
-test('Valid minimal document + appCode + referrer', async () => {
-  const validation = await validateAppDataDocument({
-    version: '0.1.0',
-    appCode: 'MyApp',
-    metadata: {
-      referrer: {
-        version: '0.1.0',
-        address: '0xFEB4acf3df3cDEA7399794D0869ef76A6EfAff52',
-      },
-    },
-  })
-  expect(validation).toEqual(VALID_RESULT)
-})
-
-test('Invalid: Bad referrer', async () => {
-  const validation = await validateAppDataDocument({
-    version: '0.1.0',
-    appCode: 'MyApp',
-    metadata: {
-      referrer: {
-        version: '0.1.0',
-        address: 'this is not an ethereum address',
-      },
-    },
-  })
-  expect(validation.result).toBeFalsy()
-})
-
-test('Invalid: No version', async () => {
-  const validation = await validateAppDataDocument({
-    appCode: 'MyApp',
-    metadata: {},
-  })
-  expect(validation.result).toBeFalsy()
-})
-
-test('Invalid: No metadata', async () => {
-  const validation = await validateAppDataDocument({
-    version: '0.1.0',
-    appCode: 'MyApp',
-  })
-  expect(validation.result).toBeFalsy()
-})
-
-test('Invalid: No metadata', async () => {
-  const validation = await validateAppDataDocument({
-    version: '0.1.0',
-    appCode: 'MyApp',
-  })
-  expect(validation.result).toBeFalsy()
-})
-
-test('Invalid: No metadata', async () => {
-  const validation = await validateAppDataDocument({
-    version: '0.1.0',
-    appCode: 'MyApp',
-  })
-  expect(validation.result).toBeFalsy()
-})
-
-test('Valid serialized appData CID', async () => {
-  const hash = '0xa6c81f4ca727252a05b108f1742a07430f28d474d2a3492d8f325746824d22e5'
-  const serializedCidV0 = 'QmZZhNnqMF1gRywNKnTPuZksX7rVjQgTT3TJAZ7R6VE3b2'
-  const cidV0 = await getSerializedCID(hash)
-
-  expect(cidV0).toEqual(serializedCidV0)
-})
-
-test('Invalid: serialized appData CID format ', async () => {
-  const invalidHash = '0xa6c81f4ca727252a05b108f1742'
-  try {
-    await getSerializedCID(invalidHash)
-  } catch (e: any) {
-    expect(e.message).toEqual(INVALID_CID_LENGTH)
-  }
-})
-
-test('Valid IPFS appData from CID', async () => {
-  const validSerializedCidV0 = 'QmZZhNnqMF1gRywNKnTPuZksX7rVjQgTT3TJAZ7R6VE3b2'
-  const appDataDocument = await loadIpfsFromCid(validSerializedCidV0)
-  const validation = await validateAppDataDocument(appDataDocument)
-
-  expect(validation).toEqual(VALID_RESULT)
-})

package/src/utils/appData.ts

@@ -1,58 +0,0 @@
-import Ajv, { ErrorObject, ValidateFunction } from 'ajv'
-import { fromHexString } from './common'
-import { DEFAULT_IPFS_GATEWAY_URI } from '../constants'
-import { AppDataDoc } from '../types'
-
-let validate: ValidateFunction | undefined
-let ajv: Ajv
-
-interface ValidationResult {
-  result: boolean
-  errors?: ErrorObject[]
-}
-
-async function getValidator(): Promise<{ ajv: Ajv; validate: ValidateFunction }> {
-  if (!ajv) {
-    ajv = new Ajv()
-  }
-
-  if (!validate) {
-    const appDataSchema = await import('../schemas/appData.schema.json')
-    validate = ajv.compile(appDataSchema)
-  }
-
-  return { ajv, validate }
-}
-
-export async function getSerializedCID(hash: string): Promise<void | string> {
-  const cidVersion = 0x1 //cidv1
-  const codec = 0x70 //dag-pb
-  const type = 0x12 //sha2-256
-  const length = 32 //256 bits
-  const _hash = hash.replace(/(^0x)/, '')
-
-  const hexHash = fromHexString(_hash)
-
-  if (!hexHash) return
-
-  const uint8array = Uint8Array.from([cidVersion, codec, type, length, ...hexHash])
-  const { CID } = await import('multiformats/cid')
-  return CID.decode(uint8array).toV0().toString()
-}
-
-export async function loadIpfsFromCid(cid: string, ipfsUri = DEFAULT_IPFS_GATEWAY_URI): Promise<AppDataDoc> {
-  const { default: fetch } = await import('cross-fetch')
-  const response = await fetch(`${ipfsUri}/${cid}`)
-
-  return await response.json()
-}
-
-export async function validateAppDataDocument(appDataDocument: unknown): Promise<ValidationResult> {
-  const { ajv, validate } = await getValidator()
-  const result = !!validate(appDataDocument)
-
-  return {
-    result,
-    errors: ajv.errors ?? undefined,
-  }
-}

package/src/utils/common.ts

@@ -1,35 +0,0 @@
-export class CowError extends Error {
-  error_code?: string
-
-  constructor(message: string, error_code?: string) {
-    super(message)
-    this.error_code = error_code
-  }
-}
-
-export function objectToQueryString(o: any): string {
-  if (!o) {
-    return ''
-  }
-
-  const qs = new URLSearchParams()
-
-  for (const key of Object.keys(o)) {
-    const value = o[key]
-    if (value) {
-      qs.append(key, value)
-    }
-  }
-
-  const qsResult = qs.toString()
-
-  return qsResult ? `?${qsResult}` : ''
-}
-
-export const logPrefix = 'cow-sdk:'
-
-export function fromHexString(hexString: string) {
-  const stringMatch = hexString.match(/.{1,2}/g)
-  if (!stringMatch) return
-  return new Uint8Array(stringMatch.map((byte) => parseInt(byte, 16)))
-}

package/src/utils/context.ts

@@ -1,89 +0,0 @@
-import { Signer } from 'ethers'
-import log from 'loglevel'
-import { CowError, logPrefix } from './common'
-import { SupportedChainId as ChainId } from '../constants/chains'
-import { DEFAULT_APP_DATA_HASH, DEFAULT_IPFS_GATEWAY_URI } from '../constants'
-
-export interface CowContext {
-  appDataHash?: string
-  isDevEnvironment?: boolean
-  signer?: Signer
-  ipfsUri?: string
-}
-
-export const DefaultCowContext = {
-  appDataHash: DEFAULT_APP_DATA_HASH,
-  isDevEnvironment: false,
-  ipfsUri: DEFAULT_IPFS_GATEWAY_URI,
-}
-
-/**
- *
- *
- * @export
- * @class Context
- * @implements {Required<CowContext>}
- */
-export class Context implements Partial<CowContext> {
-  #context: CowContext
-  #chainId: ChainId
-
-  constructor(chainId: ChainId, context: CowContext) {
-    this.#chainId = this.updateChainId(chainId)
-    this.#context = { ...DefaultCowContext, ...context }
-  }
-
-  updateChainId(chainId: ChainId) {
-    if (!ChainId[chainId]) {
-      throw new CowError(`Invalid chainId: ${chainId}`)
-    }
-
-    log.debug(logPrefix, `Updating chainId to: ${chainId}`)
-
-    this.#chainId = chainId
-    return chainId
-  }
-
-  get chainId(): Promise<ChainId> {
-    const provider = this.#context.signer?.provider
-    if (!provider) {
-      return Promise.resolve(this.#chainId)
-    }
-
-    log.debug(logPrefix, 'Getting chainId from provider')
-
-    const getAndReconciliateNetwork = async () => {
-      const network = await provider.getNetwork()
-      const chainId = network.chainId
-
-      if (chainId !== this.#chainId) {
-        log.debug(
-          logPrefix,
-          `ChainId mismatch: Provider's chainId: ${chainId} vs Context's chainId: ${
-            this.#chainId
-          }. Updating Context's chainId`
-        )
-        this.updateChainId(chainId)
-      }
-      return chainId
-    }
-
-    return getAndReconciliateNetwork()
-  }
-
-  get appDataHash(): string {
-    return this.#context.appDataHash ?? DefaultCowContext.appDataHash
-  }
-
-  get isDevEnvironment(): boolean {
-    return this.#context.isDevEnvironment ?? DefaultCowContext.isDevEnvironment
-  }
-
-  get signer(): Signer | undefined {
-    return this.#context.signer
-  }
-
-  get ipfsUri(): string {
-    return this.#context.ipfsUri ?? DefaultCowContext.ipfsUri
-  }
-}

package/src/utils/price.ts

@@ -1,44 +0,0 @@
-import { GetQuoteResponse } from '@gnosis.pm/gp-v2-contracts'
-import { OrderMetaData } from '../api/cow/types'
-
-export interface QuoteParams {
-  quoteParams: FeeQuoteParams
-  fetchFee: boolean
-  previousFee?: FeeInformation
-  isPriceRefresh: boolean
-}
-
-export interface FeeInformation {
-  expirationDate: string
-  amount: string
-}
-
-export interface PriceInformation {
-  token: string
-  amount: string | null
-}
-
-// GetQuoteResponse from @gnosis.pm/gp-v2-contracts types Timestamp and BigNumberish
-// do not play well with our existing methods, using string instead
-export type SimpleGetQuoteResponse = Pick<GetQuoteResponse, 'from'> & {
-  // We need to map BigNumberIsh and Timestamp to what we use: string
-  quote: Omit<GetQuoteResponse['quote'], 'sellAmount' | 'buyAmount' | 'feeAmount' | 'validTo'> & {
-    sellAmount: string
-    buyAmount: string
-    validTo: string
-    feeAmount: string
-  }
-  expiration: string
-}
-
-export type FeeQuoteParams = Pick<OrderMetaData, 'sellToken' | 'buyToken' | 'kind'> & {
-  amount: string
-  userAddress?: string | null
-  receiver?: string | null
-  validTo: number
-}
-
-export type PriceQuoteParams = Omit<FeeQuoteParams, 'sellToken' | 'buyToken'> & {
-  baseToken: string
-  quoteToken: string
-}