@cowprotocol/cow-sdk 0.0.6 → 0.0.10

package/src/utils/appData.spec.ts

@@ -1,66 +0,0 @@
-import { validateAppDataDocument } from './appData'
-
-const VALID_RESULT = {
-  result: true,
-}
-
-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()
-})

package/src/utils/appData.ts

@@ -1,32 +0,0 @@
-import Ajv, { ErrorObject, ValidateFunction } from 'ajv'
-
-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 validateAppDataDocument(appDataDocument: any): Promise<ValidationResult> {
-  const { ajv, validate } = await getValidator()
-  const result = !!(await validate(appDataDocument))
-
-  return {
-    result,
-    errors: ajv.errors ?? undefined,
-  }
-}

package/src/utils/common.ts

@@ -1,27 +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}` : ''
-}

package/src/utils/context.ts

@@ -1,42 +0,0 @@
-import { Signer } from 'ethers'
-import { CowError } from './common'
-import { DEFAULT_APP_DATA_HASH } from '/constants'
-
-export interface CowContext {
-  appDataHash?: string
-  isDevEnvironment?: boolean
-  signer?: Signer
-}
-
-export const DefaultCowContext = { appDataHash: DEFAULT_APP_DATA_HASH, isDevEnvironment: false }
-
-/**
- *
- *
- * @export
- * @class Context
- * @implements {Required<CowContext>}
- */
-export class Context implements Required<CowContext> {
-  private context: CowContext
-
-  constructor(context: CowContext) {
-    this.context = { ...DefaultCowContext, ...context }
-  }
-
-  get appDataHash(): string {
-    return this.context.appDataHash ?? DefaultCowContext.appDataHash
-  }
-
-  get isDevEnvironment(): boolean {
-    return this.context.isDevEnvironment ?? DefaultCowContext.isDevEnvironment
-  }
-
-  get signer(): Signer {
-    if (this.context.signer) {
-      return this.context.signer
-    }
-
-    throw new CowError('No signer was provided')
-  }
-}

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 } 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('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(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,77 +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 GITLAB_TRIGGER_TOKEN
-fail_if_unset BUCKET_NAME
-fail_if_unset PUBLISH_SERVER
-fail_if_unset AWS_ACCESS_KEY_ID
-fail_if_unset AWS_SECRET_ACCESS_KEY
-fail_if_unset AWS_REGION
-
-git_username="GitHub Actions"
-git_useremail="GitHub-Actions@cow-sdk"
-
-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 pack --filename package.tgz
-
-aws configure set aws_access_key_id "$AWS_ACCESS_KEY_ID"
-aws configure set aws_secret_access_key "$AWS_SECRET_ACCESS_KEY"
-aws configure set region "$AWS_REGION"
-if ! aws s3 cp package.tgz "s3://$BUCKET_NAME/cow-sdk/cow-sdk-$version.tgz"; then
-  echo "Failed upload to aws"
-  exit 1
-fi
-
-if ! pipeline_url="$(\
-     curl --silent --request POST \
-       --form-string "token=$GITLAB_TRIGGER_TOKEN" \
-       --form-string "ref=master" \
-       --form-string "variables[PROJECT]=$package_name" \
-       --form-string "variables[VERSION]=$version" \
-       --form-string "variables[TOKEN]=$GITLAB_TRIGGER_TOKEN" \
-       "$PUBLISH_SERVER" \
-       | jq -e '.web_url'\
-     )"; then
-  echo "Error triggering publish request"
-  exit 1
-fi
-
-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 submitted for publication."
-echo "Progress can be tracked here: $pipeline_url"

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "paths": {
-      "/*": ["src/*"]
-    },
-    "moduleResolution": "node",
-    "module": "ESNext",
-    "target": "ESNext",
-    "strict": true,
-    "alwaysStrict": true,
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true,
-    "noEmit": true,
-    "forceConsistentCasingInFileNames": true,
-    "noUnusedLocals": true,
-  }
-}