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

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

package/src/utils/sign.ts

@@ -1,224 +0,0 @@
-import {
-  domain as domainGp,
-  signOrder as signOrderGp,
-  signOrderCancellation as signOrderCancellationGp,
-  EcdsaSignature,
-  Order,
-  OrderCancellation as OrderCancellationGp,
-  Signature,
-  TypedDataV3Signer,
-  IntChainIdTypedDataV4Signer,
-  SigningScheme,
-} from '@gnosis.pm/gp-v2-contracts'
-import log from 'loglevel'
-
-import { SupportedChainId as ChainId } from '../constants/chains'
-import { GP_SETTLEMENT_CONTRACT_ADDRESS } from '../constants'
-import { TypedDataDomain, Signer } from '@ethersproject/abstract-signer'
-import { CowError, logPrefix } from './common'
-
-// For error codes, see:
-// - https://eth.wiki/json-rpc/json-rpc-error-codes-improvement-proposal
-// - https://www.jsonrpc.org/specification#error_object
-const METAMASK_SIGNATURE_ERROR_CODE = -32603
-const METHOD_NOT_FOUND_ERROR_CODE = -32601
-const V4_ERROR_MSG_REGEX = /eth_signTypedData_v4 does not exist/i
-const V3_ERROR_MSG_REGEX = /eth_signTypedData_v3 does not exist/i
-const RPC_REQUEST_FAILED_REGEX = /RPC request failed/i
-const METAMASK_STRING_CHAINID_REGEX = /provided chainid .* must match the active chainid/i
-
-export type UnsignedOrder = Omit<Order, 'receiver'> & { receiver: string }
-
-export interface SignOrderParams {
-  chainId: ChainId
-  signer: Signer
-  order: UnsignedOrder
-  signingScheme: SigningScheme
-}
-
-// posted to /api/v1/orders on Order creation
-// serializable, so no BigNumbers
-//  See https://protocol-rinkeby.dev.gnosisdev.com/api/
-export interface OrderCreation extends UnsignedOrder {
-  signingScheme: SigningScheme // signed method
-
-  // Signature is used for:
-  //  - Signature: EIP-712,ETHSIGN
-  //  - Owner address: for PRESIGN
-  signature: string // 65 bytes encoded as hex without `0x` prefix. r + s + v from the spec
-}
-
-export interface SingOrderCancellationParams {
-  chainId: ChainId
-  signer: Signer
-  orderId: string
-  signingScheme: SigningScheme
-}
-
-export interface OrderCancellation extends OrderCancellationGp {
-  signature: string
-  signingScheme: SigningScheme
-}
-
-export type SigningSchemeValue = 'eip712' | 'ethsign' | 'eip1271' | 'presign'
-
-interface SchemaInfo {
-  libraryValue: number
-  apiValue: SigningSchemeValue
-}
-const mapSigningSchema: Map<SigningScheme, SchemaInfo> = new Map([
-  [SigningScheme.EIP712, { libraryValue: 0, apiValue: 'eip712' }],
-  [SigningScheme.ETHSIGN, { libraryValue: 1, apiValue: 'ethsign' }],
-  [SigningScheme.EIP1271, { libraryValue: 2, apiValue: 'eip1271' }],
-  [SigningScheme.PRESIGN, { libraryValue: 3, apiValue: 'presign' }],
-])
-
-function _getSigningSchemeInfo(ecdaSigningScheme: SigningScheme): SchemaInfo {
-  const value = mapSigningSchema.get(ecdaSigningScheme)
-  if (value === undefined) {
-    throw new CowError('Unknown schema ' + ecdaSigningScheme)
-  }
-
-  return value
-}
-
-interface ProviderRpcError extends Error {
-  message: string
-  code: number
-  data?: unknown
-}
-
-function isProviderRpcError(error: unknown): error is ProviderRpcError {
-  return (error as ProviderRpcError).code !== undefined || (error as ProviderRpcError).message !== undefined
-}
-
-export function getSigningSchemeApiValue(ecdaSigningScheme: SigningScheme): string {
-  return _getSigningSchemeInfo(ecdaSigningScheme).apiValue
-}
-
-export function getSigningSchemeLibValue(ecdaSigningScheme: SigningScheme): number {
-  return _getSigningSchemeInfo(ecdaSigningScheme).libraryValue
-}
-
-function _getDomain(chainId: ChainId): TypedDataDomain {
-  // Get settlement contract address
-  const settlementContract = GP_SETTLEMENT_CONTRACT_ADDRESS[chainId]
-
-  if (!settlementContract) {
-    throw new CowError('Unsupported network. Settlement contract is not deployed')
-  }
-
-  return domainGp(chainId, settlementContract)
-}
-
-async function _signOrder(params: SignOrderParams): Promise<Signature> {
-  const { chainId, signer, order, signingScheme } = params
-
-  const domain = _getDomain(chainId)
-
-  return signOrderGp(domain, order, signer, getSigningSchemeLibValue(signingScheme))
-}
-
-async function _signOrderCancellation(params: SingOrderCancellationParams): Promise<Signature> {
-  const { chainId, signer, signingScheme, orderId } = params
-
-  const domain = _getDomain(chainId)
-
-  return signOrderCancellationGp(domain, orderId, signer, getSigningSchemeLibValue(signingScheme))
-}
-
-export type SigningResult = { signature: string; signingScheme: SigningScheme }
-
-async function _signPayload(
-  payload: any,
-  signFn: typeof _signOrder | typeof _signOrderCancellation,
-  signer: Signer,
-  signingMethod: 'v4' | 'int_v4' | 'v3' | 'eth_sign' = 'v4'
-): Promise<SigningResult> {
-  const signingScheme = signingMethod === 'eth_sign' ? SigningScheme.ETHSIGN : SigningScheme.EIP712
-  let signature: Signature | null = null
-
-  let _signer
-  try {
-    switch (signingMethod) {
-      case 'v3':
-        _signer = new TypedDataV3Signer(signer)
-        break
-      case 'int_v4':
-        _signer = new IntChainIdTypedDataV4Signer(signer)
-        break
-      default:
-        _signer = signer
-    }
-  } catch (e) {
-    log.error(logPrefix, 'Wallet not supported:', e)
-    throw new CowError('Wallet not supported')
-  }
-
-  try {
-    signature = (await signFn({ ...payload, signer: _signer, signingScheme })) as EcdsaSignature // Only ECDSA signing supported for now
-  } catch (e) {
-    if (!isProviderRpcError(e)) {
-      // Some other error signing. Let it bubble up.
-      log.error(logPrefix, e)
-      throw e
-    }
-
-    if (e.code === METHOD_NOT_FOUND_ERROR_CODE || RPC_REQUEST_FAILED_REGEX.test(e.message)) {
-      // Maybe the wallet returns the proper error code? We can only hope 🤞
-      // OR it failed with a generic message, there's no error code set, and we also hope it'll work
-      // with other methods...
-      switch (signingMethod) {
-        case 'v4':
-          return _signPayload(payload, signFn, signer, 'v3')
-        case 'v3':
-          return _signPayload(payload, signFn, signer, 'eth_sign')
-        default:
-          throw e
-      }
-    } else if (METAMASK_STRING_CHAINID_REGEX.test(e.message)) {
-      // Metamask now enforces chainId to be an integer
-      return _signPayload(payload, signFn, signer, 'int_v4')
-    } else if (e.code === METAMASK_SIGNATURE_ERROR_CODE) {
-      // We tried to sign order the nice way.
-      // That works fine for regular MM addresses. Does not work for Hardware wallets, though.
-      // See https://github.com/MetaMask/metamask-extension/issues/10240#issuecomment-810552020
-      // So, when that specific error occurs, we know this is a problem with MM + HW.
-      // Then, we fallback to ETHSIGN.
-      return _signPayload(payload, signFn, signer, 'eth_sign')
-    } else if (V4_ERROR_MSG_REGEX.test(e.message)) {
-      // Failed with `v4`, and the wallet does not set the proper error code
-      return _signPayload(payload, signFn, signer, 'v3')
-    } else if (V3_ERROR_MSG_REGEX.test(e.message)) {
-      // Failed with `v3`, and the wallet does not set the proper error code
-      return _signPayload(payload, signFn, signer, 'eth_sign')
-    }
-  }
-  return { signature: signature!.data.toString(), signingScheme }
-}
-/**
- * Returns the signature for the specified order with the signing scheme encoded
- * into the signature.
- * @export
- * @param {UnsignedOrder} order The order to sign.
- * @param {ChainId} chainId The chain Id
- * @param {Signer} signer The owner for the order used to sign.
- * @return {*} Encoded signature including signing scheme for the order.
- */
-export async function signOrder(order: UnsignedOrder, chainId: ChainId, signer: Signer): Promise<SigningResult> {
-  return _signPayload({ order, chainId }, _signOrder, signer)
-}
-
-/**
- * Returns the signature for the Order Cancellation with the signing scheme encoded
- * into the signature.
- *
- * @export
- * @param {string} orderId The unique identifier of the order being cancelled.
- * @param {ChainId} chainId The chain Id
- * @param {Signer} signer The owner for the order used to sign.
- * @return {*} Encoded signature including signing scheme for the order.
- */
-export async function signOrderCancellation(orderId: string, chainId: ChainId, signer: Signer): Promise<SigningResult> {
-  return _signPayload({ orderId, chainId }, _signOrderCancellation, signer)
-}

package/src/utils/tokens.ts

@@ -1,12 +0,0 @@
-import { SupportedChainId as ChainId } from '../constants/chains'
-import { NATIVE, WRAPPED_NATIVE_TOKEN } from '../constants/tokens'
-
-export function toErc20Address(tokenAddress: string, chainId: ChainId): string {
-  let checkedAddress = tokenAddress
-
-  if (tokenAddress === NATIVE[chainId]) {
-    checkedAddress = WRAPPED_NATIVE_TOKEN[chainId].address
-  }
-
-  return checkedAddress
-}

package/src/workflows/publish.sh

@@ -1,49 +0,0 @@
-#!/bin/bash
-
-set -o nounset
-set -o pipefail
-set -o errexit
-
-fail_if_unset () {
-  local var_name="$1"
-  if [[ -z "${!var_name:-""}" ]]; then
-    printf '%s not set\n' "$var_name" >&2
-    exit 1
-  fi
-}
-
-package_exists () {
-  npm view --json "$1" &>/dev/null;
-}
-
-fail_if_unset NODE_AUTH_TOKEN
-
-git_username="GitHub Actions"
-git_useremail="GitHub-Actions@cow.fi"
-
-package_name="$(jq --raw-output .name ./package.json)"
-version="$(jq --raw-output .version ./package.json)"
-
-if package_exists "$package_name" && grep --silent --line-regexp --fixed-strings -- "$version" \
-    <(npm view --json "$package_name" | jq '.versions[] | .' --raw-output); then
-  echo "Version $version already published"
-  exit 1
-fi
-
-version_tag="v$version"
-if git fetch --end-of-options origin "refs/tags/$version_tag" 2>/dev/null; then
-  echo "Tag $version_tag is already present"
-  exit 1
-fi
-
-yarn publish --access public
-
-if ! git config --get user.name &>/dev/null; then
-  git config user.name "$git_username"
-  git config user.email "$git_useremail"
-fi
-git tag -m "Version $version" --end-of-options "$version_tag"
-
-git push origin "refs/tags/$version_tag"
-
-echo "Package $package_name version $version successfully published."

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "moduleResolution": "node",
-    "module": "ESNext",
-    "target": "ESNext",
-    "strict": true,
-    "alwaysStrict": true,
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true,
-    "noEmit": true,
-    "forceConsistentCasingInFileNames": true,
-    "noUnusedLocals": true
-  },
-  "exclude": [
-    "dist"
-  ]
-}