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

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