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

package/src/api/cow/errors/QuoteError.ts

@@ -1,5 +1,5 @@
 import log from 'loglevel'
-import { CowError } from '/utils/common'
+import { CowError, logPrefix } from '../../../utils/common'
 import { ApiErrorCodes, ApiErrorObject } from './OperatorError'
 
 export interface GpQuoteErrorObject {
@@ -76,11 +76,11 @@ export default class GpQuoteError extends CowError {
         // shouldn't fall through as this error constructor expects the error code to exist but just in case
         return errorMessage || orderPostError.errorType
       } else {
-        log.error('Unknown reason for bad quote fetch', orderPostError)
+        log.error(logPrefix, 'Unknown reason for bad quote fetch', orderPostError)
         return orderPostError.description
       }
     } catch (error) {
-      log.error('Error handling 400/404 error. Likely a problem deserialising the JSON response')
+      log.error(logPrefix, 'Error handling 400/404 error. Likely a problem deserialising the JSON response')
       return GpQuoteError.quoteErrorDetails.UNHANDLED_ERROR
     }
   }
@@ -94,6 +94,7 @@ export default class GpQuoteError extends CowError {
       case 500:
       default:
         log.error(
+          logPrefix,
           '[QuoteError::getErrorFromStatusCode] Error fetching quote, status code:',
           response.status || 'unknown'
         )

package/src/api/cow/index.ts

@@ -1,8 +1,8 @@
 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 { SupportedChainId as ChainId } from '../../constants/chains'
+import { getSigningSchemeApiValue, OrderCreation } from '../../utils/sign'
 import OperatorError, { ApiErrorCodeDetails, ApiErrorCodes, ApiErrorObject } from './errors/OperatorError'
 import QuoteError, {
   GpQuoteErrorCodes,
@@ -10,10 +10,10 @@ import QuoteError, {
   mapOperatorErrorToQuoteError,
   GpQuoteErrorDetails,
 } from './errors/QuoteError'
-import { toErc20Address } from '/utils/tokens'
-import { FeeQuoteParams, PriceInformation, PriceQuoteParams, SimpleGetQuoteResponse } from '/utils/price'
+import { toErc20Address } from '../../utils/tokens'
+import { FeeQuoteParams, PriceInformation, PriceQuoteParams, SimpleGetQuoteResponse } from '../../utils/price'
 
-import { ZERO_ADDRESS } from '/constants'
+import { ZERO_ADDRESS } from '../../constants'
 import {
   GetOrdersParams,
   GetTradesParams,
@@ -22,9 +22,9 @@ import {
   OrderMetaData,
   ProfileData,
   TradeMetaData,
-} from '/api/cow/types'
-import { CowError, objectToQueryString } from '/utils/common'
-import { Context } from '/utils/context'
+} from './types'
+import { CowError, logPrefix, objectToQueryString } from '../../utils/common'
+import { Context } from '../../utils/context'
 
 function getGnosisProtocolUrl(isDev: boolean): Partial<Record<ChainId, string>> {
   if (isDev) {
@@ -77,7 +77,7 @@ async function _handleQuoteResponse<T = any, P extends QuoteQuery = QuoteQuery>(
 
     if (params) {
       const { sellToken, buyToken } = params
-      log.error(`Error querying fee from API - sellToken: ${sellToken}, buyToken: ${buyToken}`)
+      log.error(logPrefix, `Error querying fee from API - sellToken: ${sellToken}, buyToken: ${buyToken}`)
     }
 
     throw quoteError
@@ -86,14 +86,12 @@ async function _handleQuoteResponse<T = any, P extends QuoteQuery = QuoteQuery>(
   }
 }
 
-export class CowApi<T extends ChainId> {
-  chainId: T
+export class CowApi {
   context: Context
 
   API_NAME = 'CoW Protocol'
 
-  constructor(chainId: T, context: Context) {
-    this.chainId = chainId
+  constructor(context: Context) {
     this.context = context
   }
 
@@ -110,9 +108,10 @@ export class CowApi<T extends ChainId> {
   }
 
   async getProfileData(address: string): Promise<ProfileData | null> {
-    log.debug(`[api:${this.API_NAME}] Get profile data for`, this.chainId, address)
-    if (this.chainId !== ChainId.MAINNET) {
-      log.info('Profile data is only available for mainnet')
+    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
     }
 
@@ -120,7 +119,7 @@ export class CowApi<T extends ChainId> {
 
     if (!response.ok) {
       const errorResponse = await response.json()
-      log.error(errorResponse)
+      log.error(logPrefix, errorResponse)
       throw new CowError(errorResponse?.description)
     } else {
       return response.json()
@@ -130,7 +129,8 @@ export class CowApi<T extends ChainId> {
   async getTrades(params: GetTradesParams): Promise<TradeMetaData[]> {
     const { owner, limit, offset } = params
     const qsParams = objectToQueryString({ owner, limit, offset })
-    log.debug('[util:operator] Get trades for', this.chainId, 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}`)
 
@@ -141,7 +141,7 @@ export class CowApi<T extends ChainId> {
         return response.json()
       }
     } catch (error) {
-      log.error('Error getting trades:', error)
+      log.error(logPrefix, 'Error getting trades:', error)
       throw new CowError('Error getting trades: ' + error)
     }
   }
@@ -149,7 +149,8 @@ export class CowApi<T extends ChainId> {
   async getOrders(params: GetOrdersParams): Promise<OrderMetaData[]> {
     const { owner, limit = 1000, offset = 0 } = params
     const queryString = objectToQueryString({ limit, offset })
-    log.debug(`[api:${this.API_NAME}] Get orders for `, this.chainId, owner, 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}`)
@@ -161,13 +162,34 @@ export class CowApi<T extends ChainId> {
         return response.json()
       }
     } catch (error) {
-      log.error('Error getting orders information:', 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> {
-    log.debug(`[api:${this.API_NAME}] Get order for `, this.chainId, orderId)
+    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}`)
 
@@ -178,22 +200,20 @@ export class CowApi<T extends ChainId> {
         return response.json()
       }
     } catch (error) {
-      log.error('Error getting order information:', 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
-    log.debug(`[api:${this.API_NAME}] Get price from API`, 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, this.chainId)}-${toErc20Address(
-        quoteToken,
-        this.chainId
-      )}/${kind}/${amount}`
+      `/markets/${toErc20Address(baseToken, chainId)}-${toErc20Address(quoteToken, chainId)}/${kind}/${amount}`
     ).catch((error) => {
-      log.error('Error getting price quote:', error)
+      log.error(logPrefix, 'Error getting price quote:', error)
       throw new QuoteError(UNHANDLED_QUOTE_ERROR)
     })
 
@@ -201,7 +221,8 @@ export class CowApi<T extends ChainId> {
   }
 
   async getQuote(params: FeeQuoteParams): Promise<SimpleGetQuoteResponse> {
-    const quoteParams = this.mapNewToLegacyParams(params, this.chainId)
+    const chainId = await this.context.chainId
+    const quoteParams = this.mapNewToLegacyParams(params, chainId)
     const response = await this.post('/quote', quoteParams)
 
     return _handleQuoteResponse<SimpleGetQuoteResponse>(response)
@@ -209,8 +230,8 @@ export class CowApi<T extends ChainId> {
 
   async sendSignedOrderCancellation(params: OrderCancellationParams): Promise<void> {
     const { cancellation, owner: from } = params
-
-    log.debug(`[api:${this.API_NAME}] Delete signed order for network`, this.chainId, cancellation)
+    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,
@@ -224,13 +245,14 @@ export class CowApi<T extends ChainId> {
       throw new CowError(errorMessage)
     }
 
-    log.debug(`[api:${this.API_NAME}] Cancelled order`, cancellation.orderUid, this.chainId)
+    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(`[api:${this.API_NAME}] Post signed order for network`, this.chainId, fullOrder)
+    log.debug(logPrefix, `[api:${this.API_NAME}] Post signed order for network`, chainId, fullOrder)
 
     // Call API
     const response = await this.post(`/orders`, {
@@ -247,7 +269,7 @@ export class CowApi<T extends ChainId> {
     }
 
     const uid = (await response.json()) as string
-    log.debug(`[api:${this.API_NAME}] Success posting the signed order`, uid)
+    log.debug(logPrefix, `[api:${this.API_NAME}] Success posting the signed order`, uid)
     return uid
   }
 
@@ -287,28 +309,30 @@ export class CowApi<T extends ChainId> {
     return finalParams
   }
 
-  private getApiBaseUrl(): string {
-    const baseUrl = this.API_BASE_URL[this.chainId]
+  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 ` + this.chainId)
+      throw new CowError(`Unsupported Network. The ${this.API_NAME} API is not deployed in the Network ` + chainId)
     } else {
       return baseUrl + '/v1'
     }
   }
 
-  private getProfileApiBaseUrl(): string {
-    const baseUrl = this.PROFILE_API_BASE_URL[this.chainId]
+  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 ` + this.chainId)
+      throw new CowError(`Unsupported Network. The ${this.API_NAME} API is not deployed in the Network ` + chainId)
     } else {
       return baseUrl + '/v1'
     }
   }
 
-  private fetch(url: string, method: 'GET' | 'POST' | 'DELETE', data?: any): Promise<Response> {
-    const baseUrl = this.getApiBaseUrl()
+  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,
@@ -316,8 +340,8 @@ export class CowApi<T extends ChainId> {
     })
   }
 
-  private fetchProfile(url: string, method: 'GET' | 'POST' | 'DELETE', data?: any): Promise<Response> {
-    const baseUrl = this.getProfileApiBaseUrl()
+  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,

package/src/api/cow/types.ts

@@ -1,6 +1,6 @@
 import { OrderKind } from '@gnosis.pm/gp-v2-contracts'
-import { SupportedChainId as ChainId } from '/constants/chains'
-import { OrderCancellation, SigningSchemeValue } from '/utils/sign'
+import { SupportedChainId as ChainId } from '../../constants/chains'
+import { OrderCancellation, SigningSchemeValue } from '../../utils/sign'
 
 /**
  * Unique identifier for the order, calculated by keccak256(orderDigest, ownerAddress, validTo),

package/src/api/index.ts

@@ -1 +1,2 @@
 export * from './cow'
+export * from './metadata'

package/src/api/metadata/index.ts

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,17 @@
+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/index.ts

@@ -12,3 +12,5 @@ export const GP_SETTLEMENT_CONTRACT_ADDRESS: Partial<Record<number, string>> = {
 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,5 +1,5 @@
-import { SupportedChainId as ChainId } from '/constants/chains'
-import { Token } from '/types'
+import { SupportedChainId as ChainId } from './chains'
+import { Token } from '../types'
 
 export const XDAI_SYMBOL = 'XDAI'
 

package/src/index.ts

@@ -1,4 +1,4 @@
-export { CowError } from '/utils/common'
-export { ALL_SUPPORTED_CHAIN_IDS } from '/constants/chains'
-export * from '/types'
-export * from '/CowSdk'
+export { CowError } from './utils/common'
+export { ALL_SUPPORTED_CHAIN_IDS } from './constants/chains'
+export * from './types'
+export { CowSdk } from './CowSdk'

package/src/types/index.ts

@@ -1,4 +1,5 @@
-export * from '/api/cow/types'
+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,9 +1,11 @@
-import { validateAppDataDocument } from './appData'
+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',
@@ -64,3 +66,44 @@ test('Invalid: No metadata', async () => {
   })
   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,4 +1,7 @@
 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
@@ -21,9 +24,32 @@ async function getValidator(): Promise<{ ajv: Ajv; validate: ValidateFunction }>
   return { ajv, validate }
 }
 
-export async function validateAppDataDocument(appDataDocument: any): Promise<ValidationResult> {
+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 = !!(await validate(appDataDocument))
+  const result = !!validate(appDataDocument)
 
   return {
     result,

package/src/utils/common.ts

@@ -25,3 +25,11 @@ export function objectToQueryString(o: any): string {
 
   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,14 +1,21 @@
 import { Signer } from 'ethers'
-import { CowError } from './common'
-import { DEFAULT_APP_DATA_HASH } from '/constants'
+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 }
+export const DefaultCowContext = {
+  appDataHash: DEFAULT_APP_DATA_HASH,
+  isDevEnvironment: false,
+  ipfsUri: DEFAULT_IPFS_GATEWAY_URI,
+}
 
 /**
  *
@@ -17,26 +24,66 @@ export const DefaultCowContext = { appDataHash: DEFAULT_APP_DATA_HASH, isDevEnvi
  * @class Context
  * @implements {Required<CowContext>}
  */
-export class Context implements Required<CowContext> {
-  private context: 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
+  }
 
-  constructor(context: CowContext) {
-    this.context = { ...DefaultCowContext, ...context }
+  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
+    return this.#context.appDataHash ?? DefaultCowContext.appDataHash
   }
 
   get isDevEnvironment(): boolean {
-    return this.context.isDevEnvironment ?? DefaultCowContext.isDevEnvironment
+    return this.#context.isDevEnvironment ?? DefaultCowContext.isDevEnvironment
   }
 
-  get signer(): Signer {
-    if (this.context.signer) {
-      return this.context.signer
-    }
+  get signer(): Signer | undefined {
+    return this.#context.signer
+  }
 
-    throw new CowError('No signer was provided')
+  get ipfsUri(): string {
+    return this.#context.ipfsUri ?? DefaultCowContext.ipfsUri
   }
 }

package/src/utils/price.ts

@@ -1,5 +1,5 @@
 import { GetQuoteResponse } from '@gnosis.pm/gp-v2-contracts'
-import { OrderMetaData } from '/api/cow/types'
+import { OrderMetaData } from '../api/cow/types'
 
 export interface QuoteParams {
   quoteParams: FeeQuoteParams

package/src/utils/sign.ts

@@ -12,10 +12,10 @@ import {
 } 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 { SupportedChainId as ChainId } from '../constants/chains'
+import { GP_SETTLEMENT_CONTRACT_ADDRESS } from '../constants'
 import { TypedDataDomain, Signer } from '@ethersproject/abstract-signer'
-import { CowError } from './common'
+import { CowError, logPrefix } from './common'
 
 // For error codes, see:
 // - https://eth.wiki/json-rpc/json-rpc-error-codes-improvement-proposal
@@ -151,7 +151,7 @@ async function _signPayload(
         _signer = signer
     }
   } catch (e) {
-    log.error('Wallet not supported:', e)
+    log.error(logPrefix, 'Wallet not supported:', e)
     throw new CowError('Wallet not supported')
   }
 
@@ -160,7 +160,7 @@ async function _signPayload(
   } catch (e) {
     if (!isProviderRpcError(e)) {
       // Some other error signing. Let it bubble up.
-      log.error(e)
+      log.error(logPrefix, e)
       throw e
     }