@cowprotocol/sdk-order-signing 0.1.0-monorepo.0

package/README.md

@@ -0,0 +1,152 @@
+<p align="center">
+  <img width="400" src="https://github.com/cowprotocol/cow-sdk/raw/main/docs/images/CoW.png" />
+</p>
+
+# SDK Order Signing
+
+This package provides EIP-712 order signing and cancellation utilities for the CoW Protocol. It handles all the cryptographic operations required to sign orders and cancellations according to CoW Protocol's specifications.
+
+## Installation
+
+```bash
+npm install @cowprotocol/sdk-order-signing
+or
+pnpm add @cowprotocol/sdk-order-signing
+or
+yarn add @cowprotocol/sdk-order-signing
+```
+
+## Usage
+
+### Individual package usage
+
+```typescript
+import { OrderSigningUtils, SupportedChainId, UnsignedOrder, SigningResult } from '@cowprotocol/sdk-order-signing'
+import { EthersV6Adapter } from '@cowprotocol/sdk-ethers-v6-adapter'
+import { JsonRpcProvider, Wallet } from 'ethers'
+
+// Configure the adapter
+const provider = new JsonRpcProvider('YOUR_RPC_URL')
+const wallet = new Wallet('YOUR_PRIVATE_KEY', provider)
+const adapter = new EthersV6Adapter({ provider, signer: wallet })
+
+// Create order signing utils
+const orderSigning = new OrderSigningUtils(adapter)
+
+// Sign an order
+const orderToSign: UnsignedOrder = {
+  sellToken: '0xA0b86a33E6417b528874E10EB3a95beb4F25A0E3',
+  buyToken: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+  sellAmount: '1000000000000000000',
+  buyAmount: '1000000000000000000',
+  validTo: Math.floor(Date.now() / 1000) + 3600,
+  appData: '0x0000000000000000000000000000000000000000000000000000000000000000',
+  feeAmount: '0',
+  kind: 'sell',
+  partiallyFillable: false,
+  sellTokenBalance: 'erc20',
+  buyTokenBalance: 'erc20',
+  receiver: '0x0000000000000000000000000000000000000000',
+}
+
+const signingResult: SigningResult = await OrderSigningUtils.signOrder(
+  orderToSign,
+  SupportedChainId.MAINNET,
+  adapter.signer,
+)
+
+// Sign order cancellation
+const orderId = 'ORDER_UID_TO_CANCEL'
+const cancellationResult = await OrderSigningUtils.signOrderCancellation(
+  orderId,
+  SupportedChainId.MAINNET,
+  adapter.signer,
+)
+
+// Generate order ID
+const { orderId: generatedId, orderDigest } = await OrderSigningUtils.generateOrderId(
+  SupportedChainId.MAINNET,
+  orderToSign as any,
+  { owner: await adapter.signer.getAddress() },
+)
+```
+
+### Usage with Umbrella SDK
+
+```typescript
+import { CowSdk, OrderSigningUtils, SupportedChainId, UnsignedOrder } from '@cowprotocol/cow-sdk'
+import { EthersV6Adapter } from '@cowprotocol/sdk-ethers-v6-adapter'
+import { JsonRpcProvider, Wallet } from 'ethers'
+
+// Configure the adapter
+const provider = new JsonRpcProvider('YOUR_RPC_URL')
+const wallet = new Wallet('YOUR_PRIVATE_KEY', provider)
+const adapter = new EthersV6Adapter({ provider, signer: wallet })
+
+// Initialize the unified SDK
+const sdk = new CowSdk({
+  chainId: SupportedChainId.MAINNET,
+  adapter,
+})
+
+// Sign order using the umbrella SDK
+const signingResult = await sdk.orderSigning.signOrder(orderToSign, SupportedChainId.MAINNET, adapter.signer)
+
+// Sign cancellation
+const cancellationResult = await sdk.orderSigning.signOrderCancellation(
+  orderId,
+  SupportedChainId.MAINNET,
+  adapter.signer,
+)
+```
+
+## Signing Schemes
+
+The SDK supports multiple signing schemes:
+
+### EIP-712 (Default)
+
+Standard wallet signature using EIP-712 typed data:
+
+```typescript
+// Automatically uses EIP-712 for wallet signers
+const result = await OrderSigningUtils.signOrder(order, chainId, signer)
+```
+
+### Smart Contract Wallets (Pre-sign)
+
+For smart contract wallets like Safe:
+
+```typescript
+import { SigningScheme } from '@cowprotocol/sdk-order-signing'
+
+// For smart contract wallets, specify the signing scheme
+// Then execute the pre-sign transaction on-chain
+```
+
+### EIP-1271
+
+For contracts that implement EIP-1271:
+
+```typescript
+// Used for contracts that can validate signatures
+// The SDK automatically detects and handles this
+```
+
+## Integration with Order Book
+
+This package works seamlessly with the Order Book API:
+
+```typescript
+// 1. Sign the order
+const signingResult = await OrderSigningUtils.signOrder(order, chainId, signer)
+
+// 2. Submit to order book
+const orderId = await orderBookApi.sendOrder({ ...order, ...signingResult })
+
+// 3. Cancel if needed
+const cancellation = await OrderSigningUtils.signOrderCancellation(orderId, chainId, signer)
+await orderBookApi.sendSignedOrderCancellations({ ...cancellation, orderUids: [orderId] })
+```
+
+> **Note:** This package handles the cryptographic aspects of CoW Protocol orders. It's typically used in conjunction with the Trading SDK or Order Book API for complete order management workflows.

package/dist/index.d.mts

@@ -0,0 +1,154 @@
+import { SupportedChainId } from '@cowprotocol/sdk-config';
+import { ContractsOrder, OrderUidParams } from '@cowprotocol/sdk-contracts-ts';
+import { SignerLike, AbstractProviderAdapter, Signer, TypedDataDomain } from '@cowprotocol/sdk-common';
+import { OrderParameters, EcdsaSigningScheme } from '@cowprotocol/sdk-order-book';
+
+/**
+ * Unsigned order intent to be placed.
+ */
+type UnsignedOrder = Omit<OrderParameters, 'receiver'> & {
+    receiver: string;
+};
+/**
+ * Encoded signature including signing scheme for the order.
+ */
+type SigningResult = {
+    signature: string;
+    signingScheme: EcdsaSigningScheme;
+};
+/**
+ * Parameters for signing an order intent.
+ * @param chainId The CoW Protocol `chainId` context that's being used.
+ * @param signer The signer who is placing the order intent.
+ * @param order The unsigned order intent to be placed.
+ * @param signingScheme The signing scheme to use for the signature.
+ */
+interface SignOrderParams {
+    chainId: SupportedChainId;
+    signer: SignerLike;
+    order: UnsignedOrder;
+    signingScheme: EcdsaSigningScheme;
+}
+/**
+ * Parameters for signing an order cancellation.
+ * @param chainId The CoW Protocol `chainId` context that's being used.
+ * @param signer The signer who initially placed the order intent.
+ * @param orderUid The unique identifier of the order to cancel.
+ * @param signingScheme The signing scheme to use for the signature.
+ */
+interface SignOrderCancellationParams {
+    chainId: SupportedChainId;
+    signer: SignerLike;
+    orderUid: string;
+    signingScheme: EcdsaSigningScheme;
+}
+/**
+ * Parameters for signing multiple bulk order cancellations.
+ * @param chainId The CoW Protocol `chainId` context that's being used.
+ * @param signer The signer who initially placed the order intents.
+ * @param orderUids An array of `orderUid` to cancel.
+ * @param signingScheme The signing scheme to use for the signature.
+ */
+interface SignOrderCancellationsParams {
+    chainId: SupportedChainId;
+    signer: SignerLike;
+    orderUids: string[];
+    signingScheme: EcdsaSigningScheme;
+}
+
+/**
+ * Utility class for signing order intents and cancellations.
+ *
+ * @remarks This class only supports `eth_sign` and wallet-native EIP-712 signing. For use of
+ *          `presign` and `eip1271` {@link https://docs.cow.fi/ | see the docs}.
+ * @example
+ *
+ * ```typescript
+ * import { OrderSigningUtils, SupportedChainId, UnsignedOrder } from '@cowprotocol/cow-sdk'
+ * import { Web3Provider } from '@ethersproject/providers'
+ *
+ * const account = 'YOUR_WALLET_ADDRESS'
+ * const chainId = 100 // Gnosis chain
+ * const provider = new Web3Provider(window.ethereum)
+ * const signer = provider.getSigner()
+ *
+ * async function main() {
+ *     const orderToSign: UnsignedOrder = { ... }
+ *     const orderSigningResult = await OrderSigningUtils.signOrder(orderToSign, chainId, signer)
+ *
+ *     const orderId = await orderBookApi.sendOrder({ ...orderToSign, ...orderSigningResult })
+ *
+ *     const order = await orderBookApi.getOrder(orderId)
+ *
+ *     const trades = await orderBookApi.getTrades({ orderId })
+ *
+ *     const orderCancellationSigningResult = await OrderSigningUtils.signOrderCancellations([orderId], chainId, signer)
+ *
+ *     const cancellationResult = await orderBookApi.sendSignedOrderCancellations({...orderCancellationSigningResult, orderUids: [orderId] })
+ *
+ *     console.log('Results: ', { orderId, order, trades, orderCancellationSigningResult, cancellationResult })
+ * }
+ * ```
+ */
+declare class OrderSigningUtils {
+    constructor(adapter?: AbstractProviderAdapter);
+    /**
+     * Sign the order intent with the specified signer.
+     *
+     * @remarks If the API reports an error with the signature, it is likely to be due to an incorrectly
+     *          specified `chainId`. Please ensure that the `chainId` is correct for the network you are
+     *          using.
+     * @param {UnsignedOrder} order The unsigned order intent to be placed.
+     * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+     * @param {Signer} signer The signer who is placing the order intent.
+     * @returns {Promise<SigningResult>} Encoded signature including signing scheme for the order.
+     */
+    static signOrder(order: UnsignedOrder, chainId: SupportedChainId, signer: Signer): Promise<SigningResult>;
+    /**
+     * Sign a cancellation message of an order intent with the specified signer.
+     * @param {string} orderUid The unique identifier of the order to cancel.
+     * @param {SupportedChainId} chainId The CoW Protocol `chainid` context that's being used.
+     * @param {Signer} signer The signer who initially placed the order intent.
+     * @returns {Promise<SigningResult>} Encoded signature including signing scheme for the cancellation.
+     */
+    static signOrderCancellation(orderUid: string, chainId: SupportedChainId, signer: Signer): Promise<SigningResult>;
+    /**
+     * Sign a cancellation message of multiple order intents with the specified signer.
+     * @param {string[]} orderUids An array of `orderUid` to cancel.
+     * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+     * @param {Signer} signer The signer who initially placed the order intents.
+     * @returns {Promise<SigningResult>} Encoded signature including signing scheme for the cancellation.
+     */
+    static signOrderCancellations(orderUids: string[], chainId: SupportedChainId, signer: Signer): Promise<SigningResult>;
+    /**
+     * Get the EIP-712 typed domain data being used for signing.
+     * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+     * @return The EIP-712 typed domain data.
+     * @see https://eips.ethereum.org/EIPS/eip-712
+     */
+    static getDomain(chainId: SupportedChainId): Promise<TypedDataDomain>;
+    /**
+     * Hashes the order intent and generate deterministic order ID.
+     * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+     * @param {Order} order order to sign
+     * @param {Pick<OrderUidParams, 'owner'>} params order unique identifier parameters.
+     */
+    static generateOrderId(chainId: SupportedChainId, order: ContractsOrder, params: Pick<OrderUidParams, 'owner'>): Promise<{
+        orderId: string;
+        orderDigest: string;
+    }>;
+    /**
+     * Get the domain separator hash for the EIP-712 typed domain data being used for signing.
+     * @param chainId {SupportedChainId} chainId The CoW Protocol protocol `chainId` context that's being used.
+     * @returns A string representation of the EIP-712 typed domain data hash.
+     */
+    static getDomainSeparator(chainId: SupportedChainId): Promise<string>;
+    /**
+     * Get the EIP-712 types used for signing a GPv2Order.Data struct. This is useful for when
+     * signing orders using smart contracts, whereby this SDK cannot do the EIP-1271 signing for you.
+     * @returns The EIP-712 types used for signing.
+     */
+    static getEIP712Types(): Record<string, unknown>;
+}
+
+export { OrderSigningUtils, type SignOrderCancellationParams, type SignOrderCancellationsParams, type SignOrderParams, type SigningResult, type UnsignedOrder };

package/dist/index.d.ts

@@ -0,0 +1,154 @@
+import { SupportedChainId } from '@cowprotocol/sdk-config';
+import { ContractsOrder, OrderUidParams } from '@cowprotocol/sdk-contracts-ts';
+import { SignerLike, AbstractProviderAdapter, Signer, TypedDataDomain } from '@cowprotocol/sdk-common';
+import { OrderParameters, EcdsaSigningScheme } from '@cowprotocol/sdk-order-book';
+
+/**
+ * Unsigned order intent to be placed.
+ */
+type UnsignedOrder = Omit<OrderParameters, 'receiver'> & {
+    receiver: string;
+};
+/**
+ * Encoded signature including signing scheme for the order.
+ */
+type SigningResult = {
+    signature: string;
+    signingScheme: EcdsaSigningScheme;
+};
+/**
+ * Parameters for signing an order intent.
+ * @param chainId The CoW Protocol `chainId` context that's being used.
+ * @param signer The signer who is placing the order intent.
+ * @param order The unsigned order intent to be placed.
+ * @param signingScheme The signing scheme to use for the signature.
+ */
+interface SignOrderParams {
+    chainId: SupportedChainId;
+    signer: SignerLike;
+    order: UnsignedOrder;
+    signingScheme: EcdsaSigningScheme;
+}
+/**
+ * Parameters for signing an order cancellation.
+ * @param chainId The CoW Protocol `chainId` context that's being used.
+ * @param signer The signer who initially placed the order intent.
+ * @param orderUid The unique identifier of the order to cancel.
+ * @param signingScheme The signing scheme to use for the signature.
+ */
+interface SignOrderCancellationParams {
+    chainId: SupportedChainId;
+    signer: SignerLike;
+    orderUid: string;
+    signingScheme: EcdsaSigningScheme;
+}
+/**
+ * Parameters for signing multiple bulk order cancellations.
+ * @param chainId The CoW Protocol `chainId` context that's being used.
+ * @param signer The signer who initially placed the order intents.
+ * @param orderUids An array of `orderUid` to cancel.
+ * @param signingScheme The signing scheme to use for the signature.
+ */
+interface SignOrderCancellationsParams {
+    chainId: SupportedChainId;
+    signer: SignerLike;
+    orderUids: string[];
+    signingScheme: EcdsaSigningScheme;
+}
+
+/**
+ * Utility class for signing order intents and cancellations.
+ *
+ * @remarks This class only supports `eth_sign` and wallet-native EIP-712 signing. For use of
+ *          `presign` and `eip1271` {@link https://docs.cow.fi/ | see the docs}.
+ * @example
+ *
+ * ```typescript
+ * import { OrderSigningUtils, SupportedChainId, UnsignedOrder } from '@cowprotocol/cow-sdk'
+ * import { Web3Provider } from '@ethersproject/providers'
+ *
+ * const account = 'YOUR_WALLET_ADDRESS'
+ * const chainId = 100 // Gnosis chain
+ * const provider = new Web3Provider(window.ethereum)
+ * const signer = provider.getSigner()
+ *
+ * async function main() {
+ *     const orderToSign: UnsignedOrder = { ... }
+ *     const orderSigningResult = await OrderSigningUtils.signOrder(orderToSign, chainId, signer)
+ *
+ *     const orderId = await orderBookApi.sendOrder({ ...orderToSign, ...orderSigningResult })
+ *
+ *     const order = await orderBookApi.getOrder(orderId)
+ *
+ *     const trades = await orderBookApi.getTrades({ orderId })
+ *
+ *     const orderCancellationSigningResult = await OrderSigningUtils.signOrderCancellations([orderId], chainId, signer)
+ *
+ *     const cancellationResult = await orderBookApi.sendSignedOrderCancellations({...orderCancellationSigningResult, orderUids: [orderId] })
+ *
+ *     console.log('Results: ', { orderId, order, trades, orderCancellationSigningResult, cancellationResult })
+ * }
+ * ```
+ */
+declare class OrderSigningUtils {
+    constructor(adapter?: AbstractProviderAdapter);
+    /**
+     * Sign the order intent with the specified signer.
+     *
+     * @remarks If the API reports an error with the signature, it is likely to be due to an incorrectly
+     *          specified `chainId`. Please ensure that the `chainId` is correct for the network you are
+     *          using.
+     * @param {UnsignedOrder} order The unsigned order intent to be placed.
+     * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+     * @param {Signer} signer The signer who is placing the order intent.
+     * @returns {Promise<SigningResult>} Encoded signature including signing scheme for the order.
+     */
+    static signOrder(order: UnsignedOrder, chainId: SupportedChainId, signer: Signer): Promise<SigningResult>;
+    /**
+     * Sign a cancellation message of an order intent with the specified signer.
+     * @param {string} orderUid The unique identifier of the order to cancel.
+     * @param {SupportedChainId} chainId The CoW Protocol `chainid` context that's being used.
+     * @param {Signer} signer The signer who initially placed the order intent.
+     * @returns {Promise<SigningResult>} Encoded signature including signing scheme for the cancellation.
+     */
+    static signOrderCancellation(orderUid: string, chainId: SupportedChainId, signer: Signer): Promise<SigningResult>;
+    /**
+     * Sign a cancellation message of multiple order intents with the specified signer.
+     * @param {string[]} orderUids An array of `orderUid` to cancel.
+     * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+     * @param {Signer} signer The signer who initially placed the order intents.
+     * @returns {Promise<SigningResult>} Encoded signature including signing scheme for the cancellation.
+     */
+    static signOrderCancellations(orderUids: string[], chainId: SupportedChainId, signer: Signer): Promise<SigningResult>;
+    /**
+     * Get the EIP-712 typed domain data being used for signing.
+     * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+     * @return The EIP-712 typed domain data.
+     * @see https://eips.ethereum.org/EIPS/eip-712
+     */
+    static getDomain(chainId: SupportedChainId): Promise<TypedDataDomain>;
+    /**
+     * Hashes the order intent and generate deterministic order ID.
+     * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+     * @param {Order} order order to sign
+     * @param {Pick<OrderUidParams, 'owner'>} params order unique identifier parameters.
+     */
+    static generateOrderId(chainId: SupportedChainId, order: ContractsOrder, params: Pick<OrderUidParams, 'owner'>): Promise<{
+        orderId: string;
+        orderDigest: string;
+    }>;
+    /**
+     * Get the domain separator hash for the EIP-712 typed domain data being used for signing.
+     * @param chainId {SupportedChainId} chainId The CoW Protocol protocol `chainId` context that's being used.
+     * @returns A string representation of the EIP-712 typed domain data hash.
+     */
+    static getDomainSeparator(chainId: SupportedChainId): Promise<string>;
+    /**
+     * Get the EIP-712 types used for signing a GPv2Order.Data struct. This is useful for when
+     * signing orders using smart contracts, whereby this SDK cannot do the EIP-1271 signing for you.
+     * @returns The EIP-712 types used for signing.
+     */
+    static getEIP712Types(): Record<string, unknown>;
+}
+
+export { OrderSigningUtils, type SignOrderCancellationParams, type SignOrderCancellationsParams, type SignOrderParams, type SigningResult, type UnsignedOrder };

package/dist/index.js

@@ -0,0 +1,253 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  OrderSigningUtils: () => OrderSigningUtils
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/orderSigningUtils.ts
+var import_sdk_common2 = require("@cowprotocol/sdk-common");
+
+// src/utils.ts
+var import_sdk_contracts_ts = require("@cowprotocol/sdk-contracts-ts");
+var import_sdk_common = require("@cowprotocol/sdk-common");
+var import_sdk_order_book = require("@cowprotocol/sdk-order-book");
+var import_sdk_config = require("@cowprotocol/sdk-config");
+var METAMASK_SIGNATURE_ERROR_CODE = -32603;
+var METHOD_NOT_FOUND_ERROR_CODE = -32601;
+var METHOD_NOT_FOUND_ERROR_MSG_REGEX = /Method not found/i;
+var V4_ERROR_MSG_REGEX = /eth_signTypedData_v4 does not exist/i;
+var V3_ERROR_MSG_REGEX = /eth_signTypedData_v3 does not exist/i;
+var RPC_REQUEST_FAILED_REGEX = /RPC request failed/i;
+var METAMASK_STRING_CHAINID_REGEX = /provided chainid .* must match the active chainid/i;
+var mapSigningSchema = {
+  [import_sdk_order_book.EcdsaSigningScheme.EIP712]: import_sdk_contracts_ts.ContractsSigningScheme.EIP712,
+  [import_sdk_order_book.EcdsaSigningScheme.ETHSIGN]: import_sdk_contracts_ts.ContractsSigningScheme.ETHSIGN
+};
+function isProviderRpcError(error) {
+  return error.code !== void 0 || error.message !== void 0;
+}
+async function _signOrder(params) {
+  const { chainId, signer, order, signingScheme } = params;
+  const domain = getDomain(chainId);
+  return (0, import_sdk_contracts_ts.signOrder)(domain, order, mapSigningSchema[signingScheme], signer);
+}
+async function _signOrderCancellation(params) {
+  const { chainId, signer, signingScheme, orderUid } = params;
+  const domain = getDomain(chainId);
+  return (0, import_sdk_contracts_ts.signOrderCancellation)(domain, orderUid, mapSigningSchema[signingScheme], signer);
+}
+async function _signOrderCancellations(params) {
+  const { chainId, signer, signingScheme, orderUids } = params;
+  const domain = getDomain(chainId);
+  return (0, import_sdk_contracts_ts.signOrderCancellations)(domain, orderUids, mapSigningSchema[signingScheme], signer);
+}
+async function _signPayload(payload, signFn, signer, signingMethod = "v4") {
+  const signingScheme = signingMethod === "eth_sign" ? import_sdk_order_book.EcdsaSigningScheme.ETHSIGN : import_sdk_order_book.EcdsaSigningScheme.EIP712;
+  let signature = null;
+  let _signer;
+  try {
+    switch (signingMethod) {
+      case "default":
+      case "v3":
+        _signer = (0, import_sdk_contracts_ts.getTypedDataVersionedSigner)(signer, "v3");
+        break;
+      case "int_v4":
+        _signer = (0, import_sdk_contracts_ts.getIntChainIdTypedDataV4Signer)(signer);
+        break;
+      default:
+        _signer = signer;
+    }
+  } catch (e) {
+    console.error("Wallet not supported:", e);
+    throw new import_sdk_common.CowError("Wallet not supported");
+  }
+  try {
+    signature = await signFn({ ...payload, signer: _signer, signingScheme });
+  } catch (e) {
+    if (!isProviderRpcError(e)) {
+      console.error(e);
+      throw e;
+    }
+    const regexErrorCheck = [METHOD_NOT_FOUND_ERROR_MSG_REGEX, RPC_REQUEST_FAILED_REGEX].some(
+      (regex) => (
+        // for example 1Inch error doesn't have e.message so we will check the output of toString()
+        [e.message, e.toString()].some((msg) => regex.test(msg))
+      )
+    );
+    if (e.code === METHOD_NOT_FOUND_ERROR_CODE || regexErrorCheck) {
+      switch (signingMethod) {
+        case "v4":
+          return _signPayload(payload, signFn, signer, "default");
+        case "default":
+          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)) {
+      return _signPayload(payload, signFn, signer, "int_v4");
+    } else if (e.code === METAMASK_SIGNATURE_ERROR_CODE) {
+      return _signPayload(payload, signFn, signer, "eth_sign");
+    } else if (V4_ERROR_MSG_REGEX.test(e.message)) {
+      return _signPayload(payload, signFn, signer, "v3");
+    } else if (V3_ERROR_MSG_REGEX.test(e.message)) {
+      return _signPayload(payload, signFn, signer, "eth_sign");
+    } else {
+      console.error(e);
+      throw e;
+    }
+  }
+  const data = signature?.data;
+  return { signature: data?.toString() || "", signingScheme };
+}
+async function signOrder(order, chainId, signer) {
+  return _signPayload({ order, chainId }, _signOrder, signer);
+}
+async function signOrderCancellation(orderUid, chainId, signer) {
+  return _signPayload({ orderUid, chainId }, _signOrderCancellation, signer);
+}
+async function signOrderCancellations(orderUids, chainId, signer) {
+  return _signPayload({ orderUids, chainId }, _signOrderCancellations, signer);
+}
+function getDomain(chainId) {
+  const settlementContract = import_sdk_config.COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS[chainId];
+  if (!settlementContract) {
+    throw new import_sdk_common.CowError("Unsupported network. Settlement contract is not deployed");
+  }
+  return import_sdk_contracts_ts.ContractsTs.domain(chainId, settlementContract);
+}
+async function generateOrderId(chainId, order, params) {
+  const domain = await getDomain(chainId);
+  const orderDigest = (0, import_sdk_contracts_ts.hashOrder)(domain, order);
+  const orderId = (0, import_sdk_contracts_ts.packOrderUidParams)({
+    ...params,
+    orderDigest,
+    // Different validTo when signing because EthFlow contract expects it to be max for all orders
+    validTo: order.validTo
+  });
+  return { orderId, orderDigest };
+}
+
+// src/orderSigningUtils.ts
+var OrderSigningUtils = class {
+  constructor(adapter) {
+    if (adapter) {
+      (0, import_sdk_common2.setGlobalAdapter)(adapter);
+    }
+  }
+  /**
+   * Sign the order intent with the specified signer.
+   *
+   * @remarks If the API reports an error with the signature, it is likely to be due to an incorrectly
+   *          specified `chainId`. Please ensure that the `chainId` is correct for the network you are
+   *          using.
+   * @param {UnsignedOrder} order The unsigned order intent to be placed.
+   * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+   * @param {Signer} signer The signer who is placing the order intent.
+   * @returns {Promise<SigningResult>} Encoded signature including signing scheme for the order.
+   */
+  static async signOrder(order, chainId, signer) {
+    return signOrder(order, chainId, signer);
+  }
+  /**
+   * Sign a cancellation message of an order intent with the specified signer.
+   * @param {string} orderUid The unique identifier of the order to cancel.
+   * @param {SupportedChainId} chainId The CoW Protocol `chainid` context that's being used.
+   * @param {Signer} signer The signer who initially placed the order intent.
+   * @returns {Promise<SigningResult>} Encoded signature including signing scheme for the cancellation.
+   */
+  static async signOrderCancellation(orderUid, chainId, signer) {
+    return signOrderCancellation(orderUid, chainId, signer);
+  }
+  /**
+   * Sign a cancellation message of multiple order intents with the specified signer.
+   * @param {string[]} orderUids An array of `orderUid` to cancel.
+   * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+   * @param {Signer} signer The signer who initially placed the order intents.
+   * @returns {Promise<SigningResult>} Encoded signature including signing scheme for the cancellation.
+   */
+  static async signOrderCancellations(orderUids, chainId, signer) {
+    return signOrderCancellations(orderUids, chainId, signer);
+  }
+  /**
+   * Get the EIP-712 typed domain data being used for signing.
+   * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+   * @return The EIP-712 typed domain data.
+   * @see https://eips.ethereum.org/EIPS/eip-712
+   */
+  static async getDomain(chainId) {
+    return getDomain(chainId);
+  }
+  /**
+   * Hashes the order intent and generate deterministic order ID.
+   * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+   * @param {Order} order order to sign
+   * @param {Pick<OrderUidParams, 'owner'>} params order unique identifier parameters.
+   */
+  static async generateOrderId(chainId, order, params) {
+    return generateOrderId(chainId, order, params);
+  }
+  /**
+   * Get the domain separator hash for the EIP-712 typed domain data being used for signing.
+   * @param chainId {SupportedChainId} chainId The CoW Protocol protocol `chainId` context that's being used.
+   * @returns A string representation of the EIP-712 typed domain data hash.
+   */
+  static async getDomainSeparator(chainId) {
+    const adapter = (0, import_sdk_common2.getGlobalAdapter)();
+    const types = [
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" }
+    ];
+    return adapter.utils.hashDomain(getDomain(chainId), types);
+  }
+  /**
+   * Get the EIP-712 types used for signing a GPv2Order.Data struct. This is useful for when
+   * signing orders using smart contracts, whereby this SDK cannot do the EIP-1271 signing for you.
+   * @returns The EIP-712 types used for signing.
+   */
+  static getEIP712Types() {
+    return {
+      Order: [
+        { name: "sellToken", type: "address" },
+        { name: "buyToken", type: "address" },
+        { name: "receiver", type: "address" },
+        { name: "sellAmount", type: "uint256" },
+        { name: "buyAmount", type: "uint256" },
+        { name: "validTo", type: "uint32" },
+        { name: "appData", type: "bytes32" },
+        { name: "feeAmount", type: "uint256" },
+        { name: "kind", type: "string" },
+        { name: "partiallyFillable", type: "bool" },
+        { name: "sellTokenBalance", type: "string" },
+        { name: "buyTokenBalance", type: "string" }
+      ]
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OrderSigningUtils
+});

package/dist/index.mjs

@@ -0,0 +1,239 @@
+// src/orderSigningUtils.ts
+import {
+  getGlobalAdapter,
+  setGlobalAdapter
+} from "@cowprotocol/sdk-common";
+
+// src/utils.ts
+import {
+  ContractsTs,
+  ContractsSigningScheme as SigningScheme,
+  getIntChainIdTypedDataV4Signer,
+  getTypedDataVersionedSigner,
+  hashOrder,
+  packOrderUidParams,
+  signOrder as signOrderGp,
+  signOrderCancellation as signOrderCancellationGp,
+  signOrderCancellations as signOrderCancellationsGp
+} from "@cowprotocol/sdk-contracts-ts";
+import { CowError } from "@cowprotocol/sdk-common";
+import { EcdsaSigningScheme } from "@cowprotocol/sdk-order-book";
+import { COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS } from "@cowprotocol/sdk-config";
+var METAMASK_SIGNATURE_ERROR_CODE = -32603;
+var METHOD_NOT_FOUND_ERROR_CODE = -32601;
+var METHOD_NOT_FOUND_ERROR_MSG_REGEX = /Method not found/i;
+var V4_ERROR_MSG_REGEX = /eth_signTypedData_v4 does not exist/i;
+var V3_ERROR_MSG_REGEX = /eth_signTypedData_v3 does not exist/i;
+var RPC_REQUEST_FAILED_REGEX = /RPC request failed/i;
+var METAMASK_STRING_CHAINID_REGEX = /provided chainid .* must match the active chainid/i;
+var mapSigningSchema = {
+  [EcdsaSigningScheme.EIP712]: SigningScheme.EIP712,
+  [EcdsaSigningScheme.ETHSIGN]: SigningScheme.ETHSIGN
+};
+function isProviderRpcError(error) {
+  return error.code !== void 0 || error.message !== void 0;
+}
+async function _signOrder(params) {
+  const { chainId, signer, order, signingScheme } = params;
+  const domain = getDomain(chainId);
+  return signOrderGp(domain, order, mapSigningSchema[signingScheme], signer);
+}
+async function _signOrderCancellation(params) {
+  const { chainId, signer, signingScheme, orderUid } = params;
+  const domain = getDomain(chainId);
+  return signOrderCancellationGp(domain, orderUid, mapSigningSchema[signingScheme], signer);
+}
+async function _signOrderCancellations(params) {
+  const { chainId, signer, signingScheme, orderUids } = params;
+  const domain = getDomain(chainId);
+  return signOrderCancellationsGp(domain, orderUids, mapSigningSchema[signingScheme], signer);
+}
+async function _signPayload(payload, signFn, signer, signingMethod = "v4") {
+  const signingScheme = signingMethod === "eth_sign" ? EcdsaSigningScheme.ETHSIGN : EcdsaSigningScheme.EIP712;
+  let signature = null;
+  let _signer;
+  try {
+    switch (signingMethod) {
+      case "default":
+      case "v3":
+        _signer = getTypedDataVersionedSigner(signer, "v3");
+        break;
+      case "int_v4":
+        _signer = getIntChainIdTypedDataV4Signer(signer);
+        break;
+      default:
+        _signer = signer;
+    }
+  } catch (e) {
+    console.error("Wallet not supported:", e);
+    throw new CowError("Wallet not supported");
+  }
+  try {
+    signature = await signFn({ ...payload, signer: _signer, signingScheme });
+  } catch (e) {
+    if (!isProviderRpcError(e)) {
+      console.error(e);
+      throw e;
+    }
+    const regexErrorCheck = [METHOD_NOT_FOUND_ERROR_MSG_REGEX, RPC_REQUEST_FAILED_REGEX].some(
+      (regex) => (
+        // for example 1Inch error doesn't have e.message so we will check the output of toString()
+        [e.message, e.toString()].some((msg) => regex.test(msg))
+      )
+    );
+    if (e.code === METHOD_NOT_FOUND_ERROR_CODE || regexErrorCheck) {
+      switch (signingMethod) {
+        case "v4":
+          return _signPayload(payload, signFn, signer, "default");
+        case "default":
+          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)) {
+      return _signPayload(payload, signFn, signer, "int_v4");
+    } else if (e.code === METAMASK_SIGNATURE_ERROR_CODE) {
+      return _signPayload(payload, signFn, signer, "eth_sign");
+    } else if (V4_ERROR_MSG_REGEX.test(e.message)) {
+      return _signPayload(payload, signFn, signer, "v3");
+    } else if (V3_ERROR_MSG_REGEX.test(e.message)) {
+      return _signPayload(payload, signFn, signer, "eth_sign");
+    } else {
+      console.error(e);
+      throw e;
+    }
+  }
+  const data = signature?.data;
+  return { signature: data?.toString() || "", signingScheme };
+}
+async function signOrder(order, chainId, signer) {
+  return _signPayload({ order, chainId }, _signOrder, signer);
+}
+async function signOrderCancellation(orderUid, chainId, signer) {
+  return _signPayload({ orderUid, chainId }, _signOrderCancellation, signer);
+}
+async function signOrderCancellations(orderUids, chainId, signer) {
+  return _signPayload({ orderUids, chainId }, _signOrderCancellations, signer);
+}
+function getDomain(chainId) {
+  const settlementContract = COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS[chainId];
+  if (!settlementContract) {
+    throw new CowError("Unsupported network. Settlement contract is not deployed");
+  }
+  return ContractsTs.domain(chainId, settlementContract);
+}
+async function generateOrderId(chainId, order, params) {
+  const domain = await getDomain(chainId);
+  const orderDigest = hashOrder(domain, order);
+  const orderId = packOrderUidParams({
+    ...params,
+    orderDigest,
+    // Different validTo when signing because EthFlow contract expects it to be max for all orders
+    validTo: order.validTo
+  });
+  return { orderId, orderDigest };
+}
+
+// src/orderSigningUtils.ts
+var OrderSigningUtils = class {
+  constructor(adapter) {
+    if (adapter) {
+      setGlobalAdapter(adapter);
+    }
+  }
+  /**
+   * Sign the order intent with the specified signer.
+   *
+   * @remarks If the API reports an error with the signature, it is likely to be due to an incorrectly
+   *          specified `chainId`. Please ensure that the `chainId` is correct for the network you are
+   *          using.
+   * @param {UnsignedOrder} order The unsigned order intent to be placed.
+   * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+   * @param {Signer} signer The signer who is placing the order intent.
+   * @returns {Promise<SigningResult>} Encoded signature including signing scheme for the order.
+   */
+  static async signOrder(order, chainId, signer) {
+    return signOrder(order, chainId, signer);
+  }
+  /**
+   * Sign a cancellation message of an order intent with the specified signer.
+   * @param {string} orderUid The unique identifier of the order to cancel.
+   * @param {SupportedChainId} chainId The CoW Protocol `chainid` context that's being used.
+   * @param {Signer} signer The signer who initially placed the order intent.
+   * @returns {Promise<SigningResult>} Encoded signature including signing scheme for the cancellation.
+   */
+  static async signOrderCancellation(orderUid, chainId, signer) {
+    return signOrderCancellation(orderUid, chainId, signer);
+  }
+  /**
+   * Sign a cancellation message of multiple order intents with the specified signer.
+   * @param {string[]} orderUids An array of `orderUid` to cancel.
+   * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+   * @param {Signer} signer The signer who initially placed the order intents.
+   * @returns {Promise<SigningResult>} Encoded signature including signing scheme for the cancellation.
+   */
+  static async signOrderCancellations(orderUids, chainId, signer) {
+    return signOrderCancellations(orderUids, chainId, signer);
+  }
+  /**
+   * Get the EIP-712 typed domain data being used for signing.
+   * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+   * @return The EIP-712 typed domain data.
+   * @see https://eips.ethereum.org/EIPS/eip-712
+   */
+  static async getDomain(chainId) {
+    return getDomain(chainId);
+  }
+  /**
+   * Hashes the order intent and generate deterministic order ID.
+   * @param {SupportedChainId} chainId The CoW Protocol `chainId` context that's being used.
+   * @param {Order} order order to sign
+   * @param {Pick<OrderUidParams, 'owner'>} params order unique identifier parameters.
+   */
+  static async generateOrderId(chainId, order, params) {
+    return generateOrderId(chainId, order, params);
+  }
+  /**
+   * Get the domain separator hash for the EIP-712 typed domain data being used for signing.
+   * @param chainId {SupportedChainId} chainId The CoW Protocol protocol `chainId` context that's being used.
+   * @returns A string representation of the EIP-712 typed domain data hash.
+   */
+  static async getDomainSeparator(chainId) {
+    const adapter = getGlobalAdapter();
+    const types = [
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" }
+    ];
+    return adapter.utils.hashDomain(getDomain(chainId), types);
+  }
+  /**
+   * Get the EIP-712 types used for signing a GPv2Order.Data struct. This is useful for when
+   * signing orders using smart contracts, whereby this SDK cannot do the EIP-1271 signing for you.
+   * @returns The EIP-712 types used for signing.
+   */
+  static getEIP712Types() {
+    return {
+      Order: [
+        { name: "sellToken", type: "address" },
+        { name: "buyToken", type: "address" },
+        { name: "receiver", type: "address" },
+        { name: "sellAmount", type: "uint256" },
+        { name: "buyAmount", type: "uint256" },
+        { name: "validTo", type: "uint32" },
+        { name: "appData", type: "bytes32" },
+        { name: "feeAmount", type: "uint256" },
+        { name: "kind", type: "string" },
+        { name: "partiallyFillable", type: "bool" },
+        { name: "sellTokenBalance", type: "string" },
+        { name: "buyTokenBalance", type: "string" }
+      ]
+    };
+  }
+};
+export {
+  OrderSigningUtils
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@cowprotocol/sdk-order-signing",
+  "version": "0.1.0-monorepo.0",
+  "description": "TypeScript order signing for CoW Protocol SDK",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "license": "MIT",
+  "files": [
+    "dist/**"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "lint": "eslint src/**/*.ts",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage --json --outputFile=jest.results.json && cat ./coverage/lcov.info | coveralls",
+    "test:coverage:html": "jest --silent=false --coverage --coverageReporters html",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@cowprotocol/sdk-common": "workspace:*",
+    "@cowprotocol/sdk-config": "workspace:*",
+    "@cowprotocol/sdk-contracts-ts": "workspace:*",
+    "@cowprotocol/sdk-order-book": "workspace:*"
+  },
+  "devDependencies": {
+    "@cowprotocol/sdk-ethers-v5-adapter": "workspace:*",
+    "@cowprotocol/sdk-ethers-v6-adapter": "workspace:*",
+    "@cow-sdk/typescript-config": "workspace:*",
+    "@cowprotocol/sdk-viem-adapter": "workspace:*",
+    "@types/jest": "^29.5.5",
+    "@types/node": "^20.17.31",
+    "ethers-v5": "npm:ethers@^5.7.2",
+    "ethers-v6": "npm:ethers@^6.13.7",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "eslint": "^8.48.0",
+    "tsup": "^7.2.0",
+    "typescript": "^5.2.2",
+    "viem": "^2.28.4"
+  }
+}