@cowprotocol/sdk-order-signing 0.2.2-beta.0 → 0.2.2

package/README.md

@@ -18,8 +18,6 @@ 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'
@@ -71,7 +69,7 @@ const { orderId: generatedId, orderDigest } = await OrderSigningUtils.generateOr
 )
 ```
 
-### Usage with Umbrella SDK
+### Usage with CoW SDK
 
 ```typescript
 import { CowSdk, OrderSigningUtils, SupportedChainId, UnsignedOrder } from '@cowprotocol/cow-sdk'

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { SupportedChainId } from '@cowprotocol/sdk-config';
+import { SupportedChainId, CowEnv, AddressPerChain, ProtocolOptions } from '@cowprotocol/sdk-config';
 import { ContractsOrder, OrderUidParams } from '@cowprotocol/sdk-contracts-ts';
 import { SignerLike, Signer, TypedDataDomain } from '@cowprotocol/sdk-common';
 import { OrderParameters, EcdsaSigningScheme } from '@cowprotocol/sdk-order-book';
@@ -28,6 +28,8 @@ interface SignOrderParams {
     signer: SignerLike;
     order: UnsignedOrder;
     signingScheme: EcdsaSigningScheme;
+    env?: CowEnv;
+    settlementContractOverride?: Partial<AddressPerChain>;
 }
 /**
  * Parameters for signing an order cancellation.
@@ -41,6 +43,8 @@ interface SignOrderCancellationParams {
     signer: SignerLike;
     orderUid: string;
     signingScheme: EcdsaSigningScheme;
+    env?: CowEnv;
+    settlementContractOverride?: Partial<AddressPerChain>;
 }
 /**
  * Parameters for signing multiple bulk order cancellations.
@@ -54,8 +58,21 @@ interface SignOrderCancellationsParams {
     signer: SignerLike;
     orderUids: string[];
     signingScheme: EcdsaSigningScheme;
+    env?: CowEnv;
+    settlementContractOverride?: Partial<AddressPerChain>;
 }
 
+declare const ORDER_PRIMARY_TYPE: "Order";
+/**
+ * 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.
+ */
+declare const COW_EIP712_TYPES: {
+    Order: {
+        name: string;
+        type: string;
+    }[];
+};
 /**
  * Utility class for signing order intents and cancellations.
  *
@@ -106,7 +123,7 @@ declare class OrderSigningUtils {
      * @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>;
+    static signOrder(order: UnsignedOrder, chainId: SupportedChainId, signer: Signer, options?: ProtocolOptions): 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.
@@ -114,7 +131,7 @@ declare class OrderSigningUtils {
      * @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>;
+    static signOrderCancellation(orderUid: string, chainId: SupportedChainId, signer: Signer, options?: ProtocolOptions): Promise<SigningResult>;
     /**
      * Sign a cancellation message of multiple order intents with the specified signer.
      * @param {string[]} orderUids An array of `orderUid` to cancel.
@@ -122,21 +139,21 @@ declare class OrderSigningUtils {
      * @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>;
+    static signOrderCancellations(orderUids: string[], chainId: SupportedChainId, signer: Signer, options?: ProtocolOptions): 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>;
+    static getDomain(chainId: SupportedChainId, options?: ProtocolOptions): 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<{
+    static generateOrderId(chainId: SupportedChainId, order: ContractsOrder, params: Pick<OrderUidParams, 'owner'>, options?: ProtocolOptions): Promise<{
         orderId: string;
         orderDigest: string;
     }>;
@@ -145,13 +162,33 @@ declare class OrderSigningUtils {
      * @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>;
+    static getDomainSeparator(chainId: SupportedChainId, options?: ProtocolOptions): Promise<string>;
+    static getEIP712Types(): typeof COW_EIP712_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.
+     * Encodes an order and ECDSA signature for EIP-1271 smart contract signature verification.
+     *
+     * @remarks This method encodes the order data and ECDSA signature into a format suitable for
+     *          EIP-1271 signature verification by smart contracts. The order struct is ABI-encoded
+     *          as a tuple along with the ECDSA signature bytes. String fields in the order are
+     *          hashed using keccak256 before encoding.
+     *
+     * @param {UnsignedOrder} orderToSign The unsigned order to encode for EIP-1271 verification.
+     * @param {string} ecdsaSignature The ECDSA signature (typically 65 bytes hex-encoded) to include in the encoding.
+     * @returns {string} The ABI-encoded order struct and signature, ready for EIP-1271 verification.
+     *
+     * @see https://eips.ethereum.org/EIPS/eip-1271
+     *
+     * @example
+     * ```typescript
+     * const orderToSign: UnsignedOrder = { ... }
+     * const ecdsaSignature = '0x...' // 65 bytes signature from signing the order
+     *
+     * const eip1271Signature = OrderSigningUtils.getEip1271Signature(orderToSign, ecdsaSignature)
+     * // Use eip1271Signature with a smart contract wallet that implements EIP-1271
+     * ```
      */
-    static getEIP712Types(): Record<string, unknown>;
+    static getEip1271Signature(orderToSign: UnsignedOrder, ecdsaSignature: string): string;
+    static encodeUnsignedOrder(orderToSign: UnsignedOrder): Record<string, string>;
 }
 
-export { OrderSigningUtils, type SignOrderCancellationParams, type SignOrderCancellationsParams, type SignOrderParams, type SigningResult, type UnsignedOrder };
+export { COW_EIP712_TYPES, ORDER_PRIMARY_TYPE, OrderSigningUtils, type SignOrderCancellationParams, type SignOrderCancellationsParams, type SignOrderParams, type SigningResult, type UnsignedOrder };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { SupportedChainId } from '@cowprotocol/sdk-config';
+import { SupportedChainId, CowEnv, AddressPerChain, ProtocolOptions } from '@cowprotocol/sdk-config';
 import { ContractsOrder, OrderUidParams } from '@cowprotocol/sdk-contracts-ts';
 import { SignerLike, Signer, TypedDataDomain } from '@cowprotocol/sdk-common';
 import { OrderParameters, EcdsaSigningScheme } from '@cowprotocol/sdk-order-book';
@@ -28,6 +28,8 @@ interface SignOrderParams {
     signer: SignerLike;
     order: UnsignedOrder;
     signingScheme: EcdsaSigningScheme;
+    env?: CowEnv;
+    settlementContractOverride?: Partial<AddressPerChain>;
 }
 /**
  * Parameters for signing an order cancellation.
@@ -41,6 +43,8 @@ interface SignOrderCancellationParams {
     signer: SignerLike;
     orderUid: string;
     signingScheme: EcdsaSigningScheme;
+    env?: CowEnv;
+    settlementContractOverride?: Partial<AddressPerChain>;
 }
 /**
  * Parameters for signing multiple bulk order cancellations.
@@ -54,8 +58,21 @@ interface SignOrderCancellationsParams {
     signer: SignerLike;
     orderUids: string[];
     signingScheme: EcdsaSigningScheme;
+    env?: CowEnv;
+    settlementContractOverride?: Partial<AddressPerChain>;
 }
 
+declare const ORDER_PRIMARY_TYPE: "Order";
+/**
+ * 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.
+ */
+declare const COW_EIP712_TYPES: {
+    Order: {
+        name: string;
+        type: string;
+    }[];
+};
 /**
  * Utility class for signing order intents and cancellations.
  *
@@ -106,7 +123,7 @@ declare class OrderSigningUtils {
      * @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>;
+    static signOrder(order: UnsignedOrder, chainId: SupportedChainId, signer: Signer, options?: ProtocolOptions): 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.
@@ -114,7 +131,7 @@ declare class OrderSigningUtils {
      * @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>;
+    static signOrderCancellation(orderUid: string, chainId: SupportedChainId, signer: Signer, options?: ProtocolOptions): Promise<SigningResult>;
     /**
      * Sign a cancellation message of multiple order intents with the specified signer.
      * @param {string[]} orderUids An array of `orderUid` to cancel.
@@ -122,21 +139,21 @@ declare class OrderSigningUtils {
      * @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>;
+    static signOrderCancellations(orderUids: string[], chainId: SupportedChainId, signer: Signer, options?: ProtocolOptions): 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>;
+    static getDomain(chainId: SupportedChainId, options?: ProtocolOptions): 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<{
+    static generateOrderId(chainId: SupportedChainId, order: ContractsOrder, params: Pick<OrderUidParams, 'owner'>, options?: ProtocolOptions): Promise<{
         orderId: string;
         orderDigest: string;
     }>;
@@ -145,13 +162,33 @@ declare class OrderSigningUtils {
      * @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>;
+    static getDomainSeparator(chainId: SupportedChainId, options?: ProtocolOptions): Promise<string>;
+    static getEIP712Types(): typeof COW_EIP712_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.
+     * Encodes an order and ECDSA signature for EIP-1271 smart contract signature verification.
+     *
+     * @remarks This method encodes the order data and ECDSA signature into a format suitable for
+     *          EIP-1271 signature verification by smart contracts. The order struct is ABI-encoded
+     *          as a tuple along with the ECDSA signature bytes. String fields in the order are
+     *          hashed using keccak256 before encoding.
+     *
+     * @param {UnsignedOrder} orderToSign The unsigned order to encode for EIP-1271 verification.
+     * @param {string} ecdsaSignature The ECDSA signature (typically 65 bytes hex-encoded) to include in the encoding.
+     * @returns {string} The ABI-encoded order struct and signature, ready for EIP-1271 verification.
+     *
+     * @see https://eips.ethereum.org/EIPS/eip-1271
+     *
+     * @example
+     * ```typescript
+     * const orderToSign: UnsignedOrder = { ... }
+     * const ecdsaSignature = '0x...' // 65 bytes signature from signing the order
+     *
+     * const eip1271Signature = OrderSigningUtils.getEip1271Signature(orderToSign, ecdsaSignature)
+     * // Use eip1271Signature with a smart contract wallet that implements EIP-1271
+     * ```
      */
-    static getEIP712Types(): Record<string, unknown>;
+    static getEip1271Signature(orderToSign: UnsignedOrder, ecdsaSignature: string): string;
+    static encodeUnsignedOrder(orderToSign: UnsignedOrder): Record<string, string>;
 }
 
-export { OrderSigningUtils, type SignOrderCancellationParams, type SignOrderCancellationsParams, type SignOrderParams, type SigningResult, type UnsignedOrder };
+export { COW_EIP712_TYPES, ORDER_PRIMARY_TYPE, OrderSigningUtils, type SignOrderCancellationParams, type SignOrderCancellationsParams, type SignOrderParams, type SigningResult, type UnsignedOrder };

package/dist/index.js

@@ -20,6 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  COW_EIP712_TYPES: () => COW_EIP712_TYPES,
+  ORDER_PRIMARY_TYPE: () => ORDER_PRIMARY_TYPE,
   OrderSigningUtils: () => OrderSigningUtils
 });
 module.exports = __toCommonJS(src_exports);
@@ -47,18 +49,18 @@ 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);
+  const { chainId, signer, order, signingScheme, env, settlementContractOverride } = params;
+  const domain = getDomain(chainId, { env, settlementContractOverride });
   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);
+  const { chainId, signer, signingScheme, orderUid, env, settlementContractOverride } = params;
+  const domain = getDomain(chainId, { env, settlementContractOverride });
   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);
+  const { chainId, signer, signingScheme, orderUids, env, settlementContractOverride } = params;
+  const domain = getDomain(chainId, { env, settlementContractOverride });
   return (0, import_sdk_contracts_ts.signOrderCancellations)(domain, orderUids, mapSigningSchema[signingScheme], signer);
 }
 async function _signPayload(payload, signFn, signer, signingMethod = "v4") {
@@ -121,24 +123,28 @@ async function _signPayload(payload, signFn, signer, signingMethod = "v4") {
   const data = signature?.data;
   return { signature: data?.toString() || "", signingScheme };
 }
-async function signOrder(order, chainId, signer) {
-  return _signPayload({ order, chainId }, _signOrder, signer);
+async function signOrder(order, chainId, signer, options) {
+  const { env, settlementContractOverride } = options ?? {};
+  return _signPayload({ order, chainId, env, settlementContractOverride }, _signOrder, signer);
 }
-async function signOrderCancellation(orderUid, chainId, signer) {
-  return _signPayload({ orderUid, chainId }, _signOrderCancellation, signer);
+async function signOrderCancellation(orderUid, chainId, signer, options) {
+  const { env, settlementContractOverride } = options ?? {};
+  return _signPayload({ orderUid, chainId, env, settlementContractOverride }, _signOrderCancellation, signer);
 }
-async function signOrderCancellations(orderUids, chainId, signer) {
-  return _signPayload({ orderUids, chainId }, _signOrderCancellations, signer);
+async function signOrderCancellations(orderUids, chainId, signer, options) {
+  const { env, settlementContractOverride } = options ?? {};
+  return _signPayload({ orderUids, chainId, env, settlementContractOverride }, _signOrderCancellations, signer);
 }
-function getDomain(chainId) {
-  const settlementContract = import_sdk_config.COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS[chainId];
+function getDomain(chainId, options) {
+  const { env, settlementContractOverride } = options ?? {};
+  const settlementContract = settlementContractOverride?.[chainId] ?? (env === "staging" ? import_sdk_config.COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS_STAGING[chainId] : 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);
+async function generateOrderId(chainId, order, params, options) {
+  const domain = await getDomain(chainId, options);
   const orderDigest = (0, import_sdk_contracts_ts.hashOrder)(domain, order);
   const orderId = (0, import_sdk_contracts_ts.packOrderUidParams)({
     ...params,
@@ -150,7 +156,25 @@ async function generateOrderId(chainId, order, params) {
 }
 
 // src/orderSigningUtils.ts
-var OrderSigningUtils = class {
+var import_sdk_order_book2 = require("@cowprotocol/sdk-order-book");
+var ORDER_PRIMARY_TYPE = "Order";
+var COW_EIP712_TYPES = {
+  [ORDER_PRIMARY_TYPE]: [
+    { 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" }
+  ]
+};
+var OrderSigningUtils = class _OrderSigningUtils {
   /**
    * Sign the order intent with the specified signer.
    *
@@ -162,8 +186,8 @@ var OrderSigningUtils = class {
    * @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);
+  static async signOrder(order, chainId, signer, options) {
+    return signOrder(order, chainId, signer, options);
   }
   /**
    * Sign a cancellation message of an order intent with the specified signer.
@@ -172,8 +196,8 @@ var OrderSigningUtils = class {
    * @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);
+  static async signOrderCancellation(orderUid, chainId, signer, options) {
+    return signOrderCancellation(orderUid, chainId, signer, options);
   }
   /**
    * Sign a cancellation message of multiple order intents with the specified signer.
@@ -182,8 +206,8 @@ var OrderSigningUtils = class {
    * @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);
+  static async signOrderCancellations(orderUids, chainId, signer, options) {
+    return signOrderCancellations(orderUids, chainId, signer, options);
   }
   /**
    * Get the EIP-712 typed domain data being used for signing.
@@ -191,8 +215,8 @@ var OrderSigningUtils = class {
    * @return The EIP-712 typed domain data.
    * @see https://eips.ethereum.org/EIPS/eip-712
    */
-  static async getDomain(chainId) {
-    return getDomain(chainId);
+  static async getDomain(chainId, options) {
+    return getDomain(chainId, options);
   }
   /**
    * Hashes the order intent and generate deterministic order ID.
@@ -200,15 +224,15 @@ var OrderSigningUtils = class {
    * @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);
+  static async generateOrderId(chainId, order, params, options) {
+    return generateOrderId(chainId, order, params, options);
   }
   /**
    * 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) {
+  static async getDomainSeparator(chainId, options) {
     const adapter = (0, import_sdk_common2.getGlobalAdapter)();
     const types = [
       { name: "name", type: "string" },
@@ -216,33 +240,71 @@ var OrderSigningUtils = class {
       { name: "chainId", type: "uint256" },
       { name: "verifyingContract", type: "address" }
     ];
-    return adapter.utils.hashDomain(getDomain(chainId), types);
+    return adapter.utils.hashDomain(getDomain(chainId, options), types);
+  }
+  static getEIP712Types() {
+    return COW_EIP712_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.
+   * Encodes an order and ECDSA signature for EIP-1271 smart contract signature verification.
+   *
+   * @remarks This method encodes the order data and ECDSA signature into a format suitable for
+   *          EIP-1271 signature verification by smart contracts. The order struct is ABI-encoded
+   *          as a tuple along with the ECDSA signature bytes. String fields in the order are
+   *          hashed using keccak256 before encoding.
+   *
+   * @param {UnsignedOrder} orderToSign The unsigned order to encode for EIP-1271 verification.
+   * @param {string} ecdsaSignature The ECDSA signature (typically 65 bytes hex-encoded) to include in the encoding.
+   * @returns {string} The ABI-encoded order struct and signature, ready for EIP-1271 verification.
+   *
+   * @see https://eips.ethereum.org/EIPS/eip-1271
+   *
+   * @example
+   * ```typescript
+   * const orderToSign: UnsignedOrder = { ... }
+   * const ecdsaSignature = '0x...' // 65 bytes signature from signing the order
+   *
+   * const eip1271Signature = OrderSigningUtils.getEip1271Signature(orderToSign, ecdsaSignature)
+   * // Use eip1271Signature with a smart contract wallet that implements EIP-1271
+   * ```
    */
-  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" }
-      ]
+  static getEip1271Signature(orderToSign, ecdsaSignature) {
+    const adapter = (0, import_sdk_common2.getGlobalAdapter)();
+    const EIP712Types = COW_EIP712_TYPES[ORDER_PRIMARY_TYPE];
+    const components = EIP712Types.map((component) => ({
+      name: component.name,
+      type: component.type === "string" ? "bytes32" : component.type
+    }));
+    const values = Object.values(_OrderSigningUtils.encodeUnsignedOrder(orderToSign));
+    return adapter.utils.encodeAbi(
+      [
+        {
+          components,
+          type: "tuple"
+        },
+        { type: "bytes" }
+      ],
+      [values, ecdsaSignature]
+    );
+  }
+  static encodeUnsignedOrder(orderToSign) {
+    const order = {
+      ...orderToSign,
+      sellTokenBalance: orderToSign.sellTokenBalance ?? import_sdk_order_book2.SellTokenSource.ERC20,
+      buyTokenBalance: orderToSign.buyTokenBalance ?? import_sdk_order_book2.BuyTokenDestination.ERC20
     };
+    const adapter = (0, import_sdk_common2.getGlobalAdapter)();
+    const EIP712Types = COW_EIP712_TYPES[ORDER_PRIMARY_TYPE];
+    return EIP712Types.reduce((acc, { name, type }) => {
+      const value = order[name];
+      acc[name] = type === "string" ? String(adapter.utils.id(value)) : value;
+      return acc;
+    }, {});
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  COW_EIP712_TYPES,
+  ORDER_PRIMARY_TYPE,
   OrderSigningUtils
 });

package/dist/index.mjs

@@ -15,7 +15,10 @@ import {
 } 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";
+import {
+  COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS,
+  COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS_STAGING
+} 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;
@@ -31,18 +34,18 @@ 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);
+  const { chainId, signer, order, signingScheme, env, settlementContractOverride } = params;
+  const domain = getDomain(chainId, { env, settlementContractOverride });
   return signOrderGp(domain, order, mapSigningSchema[signingScheme], signer);
 }
 async function _signOrderCancellation(params) {
-  const { chainId, signer, signingScheme, orderUid } = params;
-  const domain = getDomain(chainId);
+  const { chainId, signer, signingScheme, orderUid, env, settlementContractOverride } = params;
+  const domain = getDomain(chainId, { env, settlementContractOverride });
   return signOrderCancellationGp(domain, orderUid, mapSigningSchema[signingScheme], signer);
 }
 async function _signOrderCancellations(params) {
-  const { chainId, signer, signingScheme, orderUids } = params;
-  const domain = getDomain(chainId);
+  const { chainId, signer, signingScheme, orderUids, env, settlementContractOverride } = params;
+  const domain = getDomain(chainId, { env, settlementContractOverride });
   return signOrderCancellationsGp(domain, orderUids, mapSigningSchema[signingScheme], signer);
 }
 async function _signPayload(payload, signFn, signer, signingMethod = "v4") {
@@ -105,24 +108,28 @@ async function _signPayload(payload, signFn, signer, signingMethod = "v4") {
   const data = signature?.data;
   return { signature: data?.toString() || "", signingScheme };
 }
-async function signOrder(order, chainId, signer) {
-  return _signPayload({ order, chainId }, _signOrder, signer);
+async function signOrder(order, chainId, signer, options) {
+  const { env, settlementContractOverride } = options ?? {};
+  return _signPayload({ order, chainId, env, settlementContractOverride }, _signOrder, signer);
 }
-async function signOrderCancellation(orderUid, chainId, signer) {
-  return _signPayload({ orderUid, chainId }, _signOrderCancellation, signer);
+async function signOrderCancellation(orderUid, chainId, signer, options) {
+  const { env, settlementContractOverride } = options ?? {};
+  return _signPayload({ orderUid, chainId, env, settlementContractOverride }, _signOrderCancellation, signer);
 }
-async function signOrderCancellations(orderUids, chainId, signer) {
-  return _signPayload({ orderUids, chainId }, _signOrderCancellations, signer);
+async function signOrderCancellations(orderUids, chainId, signer, options) {
+  const { env, settlementContractOverride } = options ?? {};
+  return _signPayload({ orderUids, chainId, env, settlementContractOverride }, _signOrderCancellations, signer);
 }
-function getDomain(chainId) {
-  const settlementContract = COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS[chainId];
+function getDomain(chainId, options) {
+  const { env, settlementContractOverride } = options ?? {};
+  const settlementContract = settlementContractOverride?.[chainId] ?? (env === "staging" ? COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS_STAGING[chainId] : 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);
+async function generateOrderId(chainId, order, params, options) {
+  const domain = await getDomain(chainId, options);
   const orderDigest = hashOrder(domain, order);
   const orderId = packOrderUidParams({
     ...params,
@@ -134,7 +141,25 @@ async function generateOrderId(chainId, order, params) {
 }
 
 // src/orderSigningUtils.ts
-var OrderSigningUtils = class {
+import { BuyTokenDestination, SellTokenSource } from "@cowprotocol/sdk-order-book";
+var ORDER_PRIMARY_TYPE = "Order";
+var COW_EIP712_TYPES = {
+  [ORDER_PRIMARY_TYPE]: [
+    { 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" }
+  ]
+};
+var OrderSigningUtils = class _OrderSigningUtils {
   /**
    * Sign the order intent with the specified signer.
    *
@@ -146,8 +171,8 @@ var OrderSigningUtils = class {
    * @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);
+  static async signOrder(order, chainId, signer, options) {
+    return signOrder(order, chainId, signer, options);
   }
   /**
    * Sign a cancellation message of an order intent with the specified signer.
@@ -156,8 +181,8 @@ var OrderSigningUtils = class {
    * @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);
+  static async signOrderCancellation(orderUid, chainId, signer, options) {
+    return signOrderCancellation(orderUid, chainId, signer, options);
   }
   /**
    * Sign a cancellation message of multiple order intents with the specified signer.
@@ -166,8 +191,8 @@ var OrderSigningUtils = class {
    * @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);
+  static async signOrderCancellations(orderUids, chainId, signer, options) {
+    return signOrderCancellations(orderUids, chainId, signer, options);
   }
   /**
    * Get the EIP-712 typed domain data being used for signing.
@@ -175,8 +200,8 @@ var OrderSigningUtils = class {
    * @return The EIP-712 typed domain data.
    * @see https://eips.ethereum.org/EIPS/eip-712
    */
-  static async getDomain(chainId) {
-    return getDomain(chainId);
+  static async getDomain(chainId, options) {
+    return getDomain(chainId, options);
   }
   /**
    * Hashes the order intent and generate deterministic order ID.
@@ -184,15 +209,15 @@ var OrderSigningUtils = class {
    * @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);
+  static async generateOrderId(chainId, order, params, options) {
+    return generateOrderId(chainId, order, params, options);
   }
   /**
    * 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) {
+  static async getDomainSeparator(chainId, options) {
     const adapter = getGlobalAdapter();
     const types = [
       { name: "name", type: "string" },
@@ -200,32 +225,70 @@ var OrderSigningUtils = class {
       { name: "chainId", type: "uint256" },
       { name: "verifyingContract", type: "address" }
     ];
-    return adapter.utils.hashDomain(getDomain(chainId), types);
+    return adapter.utils.hashDomain(getDomain(chainId, options), types);
+  }
+  static getEIP712Types() {
+    return COW_EIP712_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.
+   * Encodes an order and ECDSA signature for EIP-1271 smart contract signature verification.
+   *
+   * @remarks This method encodes the order data and ECDSA signature into a format suitable for
+   *          EIP-1271 signature verification by smart contracts. The order struct is ABI-encoded
+   *          as a tuple along with the ECDSA signature bytes. String fields in the order are
+   *          hashed using keccak256 before encoding.
+   *
+   * @param {UnsignedOrder} orderToSign The unsigned order to encode for EIP-1271 verification.
+   * @param {string} ecdsaSignature The ECDSA signature (typically 65 bytes hex-encoded) to include in the encoding.
+   * @returns {string} The ABI-encoded order struct and signature, ready for EIP-1271 verification.
+   *
+   * @see https://eips.ethereum.org/EIPS/eip-1271
+   *
+   * @example
+   * ```typescript
+   * const orderToSign: UnsignedOrder = { ... }
+   * const ecdsaSignature = '0x...' // 65 bytes signature from signing the order
+   *
+   * const eip1271Signature = OrderSigningUtils.getEip1271Signature(orderToSign, ecdsaSignature)
+   * // Use eip1271Signature with a smart contract wallet that implements EIP-1271
+   * ```
    */
-  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" }
-      ]
+  static getEip1271Signature(orderToSign, ecdsaSignature) {
+    const adapter = getGlobalAdapter();
+    const EIP712Types = COW_EIP712_TYPES[ORDER_PRIMARY_TYPE];
+    const components = EIP712Types.map((component) => ({
+      name: component.name,
+      type: component.type === "string" ? "bytes32" : component.type
+    }));
+    const values = Object.values(_OrderSigningUtils.encodeUnsignedOrder(orderToSign));
+    return adapter.utils.encodeAbi(
+      [
+        {
+          components,
+          type: "tuple"
+        },
+        { type: "bytes" }
+      ],
+      [values, ecdsaSignature]
+    );
+  }
+  static encodeUnsignedOrder(orderToSign) {
+    const order = {
+      ...orderToSign,
+      sellTokenBalance: orderToSign.sellTokenBalance ?? SellTokenSource.ERC20,
+      buyTokenBalance: orderToSign.buyTokenBalance ?? BuyTokenDestination.ERC20
     };
+    const adapter = getGlobalAdapter();
+    const EIP712Types = COW_EIP712_TYPES[ORDER_PRIMARY_TYPE];
+    return EIP712Types.reduce((acc, { name, type }) => {
+      const value = order[name];
+      acc[name] = type === "string" ? String(adapter.utils.id(value)) : value;
+      return acc;
+    }, {});
   }
 };
 export {
+  COW_EIP712_TYPES,
+  ORDER_PRIMARY_TYPE,
   OrderSigningUtils
 };

package/package.json

@@ -1,7 +1,12 @@
 {
   "name": "@cowprotocol/sdk-order-signing",
-  "version": "0.2.2-beta.0",
+  "version": "0.2.2",
   "description": "TypeScript order signing for CoW Protocol SDK",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cowprotocol/cow-sdk.git",
+    "directory": "packages/order-signing"
+  },
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -14,10 +19,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@cowprotocol/sdk-common": "0.3.0-beta.0",
-    "@cowprotocol/sdk-config": "0.3.0-beta.0",
-    "@cowprotocol/sdk-contracts-ts": "2.1.4-beta.0",
-    "@cowprotocol/sdk-order-book": "0.2.2-beta.0"
+    "@cowprotocol/sdk-common": "0.8.2",
+    "@cowprotocol/sdk-config": "1.1.2",
+    "@cowprotocol/sdk-contracts-ts": "2.1.2",
+    "@cowprotocol/sdk-order-book": "2.0.3"
   },
   "devDependencies": {
     "@types/jest": "^29.5.5",
@@ -31,10 +36,10 @@
     "tsup": "^7.2.0",
     "typescript": "^5.2.2",
     "viem": "^2.28.4",
-    "@cowprotocol/sdk-ethers-v6-adapter": "0.2.2-beta.0",
-    "@cow-sdk/typescript-config": "0.0.0-beta.0",
-    "@cowprotocol/sdk-viem-adapter": "0.2.2-beta.0",
-    "@cowprotocol/sdk-ethers-v5-adapter": "0.2.2-beta.0"
+    "@cowprotocol/sdk-ethers-v5-adapter": "0.3.14",
+    "@cowprotocol/sdk-viem-adapter": "0.3.14",
+    "@cowprotocol/sdk-ethers-v6-adapter": "0.3.14",
+    "@cow-sdk/typescript-config": "0.0.0-beta.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",