@cowprotocol/cow-sdk 5.10.2 → 5.11.0-RC.0

package/dist/src/cow-shed/README.md

@@ -0,0 +1,60 @@
+# Cow Shed SDK
+
+The Cow Shed SDK is a TypeScript library that provides a set of functions to interact with the [Cow Shed contract](https://github.com/cowdao-grants/cow-shed).
+
+In essence, CoW Shed acts as a user owned smart contract (1/1 multisig if you will) that can execute multiple calls on behalf of the user (once the user has pre-authorized the calls).
+
+## Usage
+
+```ts
+import { ethers } from 'ethers'
+import { CowShedSdk, ICoWShedCall, SupportedChainId } from '@cowprotocol/cow-sdk'
+
+const cowShedSdk = new CowShedSdk({
+  signer: '<privateKeyOrEthersSigner>', // You can provide the signer in the constructor, or the `signCalls` method
+})
+
+// Get the cow-shed account for any given chainId and owner's address
+const cowShedAccount = cowShedSdk.getCowShedAccount(1, '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045')
+
+// Prepare the calls you want to execute using the cow-shed account
+const calls: ICoWShedCall[] = [
+  {
+    target: '<contract-address-1>',
+    callData: 'call-data-1',
+    value: 0n,
+    isDelegateCall: true,
+    allowFailure: false,
+  },
+  {
+    target: '<contract-address-2>',
+    callData: '<call-data-2>',
+    value: 0n,
+    isDelegateCall: true,
+    allowFailure: false,
+  }
+]
+
+// Sign the calls
+const preAuthorizedCall = await cowShedSdk.signCalls({
+  chainId: SupportedChainId.MAINNET,
+  calls,
+  signer: '<privateKeyOrEthersSigner>',
+})
+
+// Get the details of the pre-authorized call you need to send
+const { signedMulticall, gasLimit, cowShedAccount } = preAuthorizedCall
+const { to, data, value } = signedMulticall
+
+// Execute the transaction using any wallet. The calldata has been pre-authed, so you don't need any special permissions to send this transaction
+let anotherWallet = new ethers.Wallet('<another-private-key>');
+const tx = await anotherWallet.sendTransaction({
+  to,
+  data,
+  value,
+  gasLimit,  
+})
+```
+
+
+

package/dist/src/trading/README.md

@@ -32,6 +32,7 @@ Main functions:
 - `getQuote` - Fetch a quote for a swap order.
 
 Special cases:
+- 'setTraderParams' - In case if you work with different chains and need to switch between them in runtime.
 - `postSellNativeCurrencyOrder` - Sell blockchain native tokens (e.g., ETH on Ethereum).
 - `getPreSignTransaction` - Sign an order using a smart contract wallet.
 
@@ -165,7 +166,7 @@ const parameters: TradeParameters = {
   amount: '120000000000000000'
 }
 
-const orderId = await sdk.postSwapOrder(parameters)
+const { orderId } = await sdk.postSwapOrder(parameters)
 
 console.log('Order created, id: ', orderId)
 ```
@@ -211,7 +212,7 @@ const limitOrderParameters: LimitTradeParameters = {
   buyAmount: '66600000000000000000',
 }
 
-const orderId = await sdk.postLimitOrder(limitOrderParameters)
+const { orderId } = await sdk.postLimitOrder(limitOrderParameters)
 
 console.log('Order created, id: ', orderId)
 ```
@@ -248,7 +249,7 @@ const parameters: TradeParameters = {
   amount: '120000000000000000'
 }
 
-const orderId = await sdk.postSellNativeCurrencyOrder(parameters)
+const { orderId } = await sdk.postSellNativeCurrencyOrder(parameters)
 
 console.log('Order created, id: ', orderId)
 ```
@@ -303,7 +304,7 @@ console.log('Quote:', quoteResults)
 If you want to create an order with a smart-contract wallet, you should specify the `signingScheme` parameter in the `postSwapOrder` function.
 And then you need to send a transaction from `getPreSignTransaction` result in order to sign the order.
 
-#### Example
+#### Example of Swap order
 
 ```typescript
 import {
@@ -336,13 +337,60 @@ const advancedParameters: SwapAdvancedSettings = {
 }
 
 const smartContractWalletAddress = '0x<smartContractWalletAddress>'
-const orderId = await sdk.postSwapOrder(parameters, advancedParameters)
+const { orderId } = await sdk.postSwapOrder(parameters, advancedParameters)
+const preSignTransaction = await sdk.getPreSignTransaction({ orderId, account: smartContractWalletAddress })
+
+console.log('Order created with "pre-sign" state, id: ', orderId)
+console.log('Execute the transaction to sign the order', preSignTransaction)
+```
+
+#### Example of Limit order
+
+```typescript
+import {
+  SupportedChainId,
+  OrderKind,
+  LimitTradeParameters,
+  LimitOrderAdvancedSettings,
+  SigningScheme,
+  TradingSdk
+} from '@cowprotocol/cow-sdk'
+
+const sdk = new TradingSdk({
+  chainId: SupportedChainId.SEPOLIA,
+  signer: '<privateKeyOrEthersSigner>',
+  appCode: '<YOUR_APP_CODE>',
+})
+
+const smartContractWalletAddress = '0x<smartContractWalletAddress>'
+
+const limitOrderParameters: LimitTradeParameters = {
+  kind: OrderKind.BUY,
+  sellToken: '0xfff9976782d46cc05630d1f6ebab18b2324d6b14',
+  sellTokenDecimals: 18,
+  buyToken: '0x0625afb445c3b6b7b929342a04a22599fd5dbb59',
+  buyTokenDecimals: 18,
+  sellAmount: '120000000000000000',
+  buyAmount: '66600000000000000000',
+  owner: smartContractWalletAddress // See note bellow why you need to specify the parameter
+}
+
+const advancedParameters: LimitOrderAdvancedSettings = {
+  additionalParams: {
+    signingScheme: SigningScheme.PRESIGN
+  }
+}
+
+const { orderId } = await sdk.postLimitOrder(limitOrderParameters, advancedParameters)
 const preSignTransaction = await sdk.getPreSignTransaction({ orderId, account: smartContractWalletAddress })
 
 console.log('Order created with "pre-sign" state, id: ', orderId)
 console.log('Execute the transaction to sign the order', preSignTransaction)
 ```
 
+> **Note:** it's important to specify the `owner` parameter if you create an order with a smart-contract wallet, and it differs from the signer (for example Safe).
+> CoW Protocol will use `owner` in order to check the order owner balance, allowance and other things.
+
 ### Optional parameters
 
 Both `postSwapOrder` and `postLimitOrder` functions have optional parameters.
@@ -381,7 +429,7 @@ const parameters: TradeParameters = {
   receiver: '0xdef1ca1fb7f1232777520aa7f396b4e015f497ab' // Just a random address, don't use it!
 }
 
-const orderId = await sdk.postSwapOrder(parameters)
+const { orderId } = await sdk.postSwapOrder(parameters)
 
 console.log('Order created, id: ', orderId)
 ```
@@ -441,7 +489,7 @@ const advancedSettings: SwapAdvancedSettings = {
     }
   },
 }
-const orderId = await sdk.postSwapOrder(parameters, advancedSettings)
+const { orderId } = await sdk.postSwapOrder(parameters, advancedSettings)
 
 console.log('Order created, id: ', orderId)
 ```

package/dist/src/weiroll/README.md

@@ -0,0 +1,58 @@
+# Weiroll utils
+
+This module some utilities to simplify the use of the [Weiroll contract](https://github.com/weiroll/weiroll).
+
+Weiroll is a simple and efficient operation-chaining/scripting language for the EVM. 
+
+The main utilities function are:
+- `createWeirollContract` which creates a Weiroll contract from an ethers contract to perform evm calls.
+- `createWeirollLibrary` which creates a Weiroll library from an ethers contract to perform static calls.
+- `createWeirollDelegateCall` which returns an EVM `delegatecall` with some plan encoded as Weiroll calldata. 
+
+To understand how this works, let's see an example:
+
+## Usage
+
+```ts
+import { CommandFlags, createWeirollDelegateCall, createWeirollContract } from './index'
+import { Planner, Contract as WeirollContract } from '@weiroll/weiroll.js'
+import { ethers } from 'ethers'
+
+const ERC20_ABI = [
+  'function balanceOf(address account) external view returns (uint256)',
+  'function transfer(address to, uint256 amount) external returns (bool)',
+] as const
+
+// Create ethers DAI contract
+const contract = new ethers.Contract('0x6b175474e89094c44da98b954eedeac495271d0f', ERC20_ABI)
+
+// Create the Weiroll contract (wrapping the ethers contract)
+// You can choose between different command flags, like `CALL`, `DELEGATECALL`, `STATICCALL`, etc.
+const daiContract = createWeirollContract(contract, CommandFlags.CALL)
+
+// Let's pretend we have a smart contract that wants to transfer all DAI to Vitalik
+const ownerContractAddress = '0xf6e72Db5454dd049d0788e411b06CfAF16853042'
+
+// Main function to create the delegatecall
+const { to, value, data } = createWeirollDelegateCall((planner: Planner) => {  
+  // Add to plan: Get the balance of the token
+  const daiBalance = planner.add(daiContract.balanceOf(ownerContractAddress))
+
+  // Add to plan: Transfer all balance to Vitalik. Note how we can chain the balance from previous call
+  planner.add(daiContract.transfer('0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045', daiBalance))
+})
+
+// Execute the delegatecall from "ownerContract" context. 
+// For illustration purposes, lets imagine there's a contract with a function `executeDelegateCall` (not a very realistic example because this would likely need a signature to be safe)
+
+// Create instance of owner contract
+const SMART_ACCOUNT_ABI = [
+  'function executeDelegateCall(address,uint256,bytes)',
+]
+const ownerContract = new ethers.Contract(ownerContractAddress, SMART_ACCOUNT_ABI)
+  
+// Execute the delegatecall, transferring all DAI to Vitalik
+const tx = await ownerContract.executeDelegateCall(to, value, data)
+```
+
+

package/dist/subgraph/api.d.ts

@@ -1,7 +1,7 @@
 import { Variables } from 'graphql-request';
 import { DocumentNode } from 'graphql/index';
-import { SupportedChainId } from '../common/chains';
-import { ApiContext } from '../common/configs';
+import { SupportedChainId } from '../chains/types';
+import { ApiContext } from '../common/types/config';
 import { LastDaysVolumeQuery, LastHoursVolumeQuery, TotalsQuery } from './graphql';
 type SubgraphApiBaseUrls = Record<SupportedChainId, string | null>;
 interface SubgraphApiContext extends Omit<ApiContext, 'baseUrls'> {

package/dist/test/utils.d.ts

@@ -0,0 +1 @@
+export declare function expectToEqual(actual: unknown, expected: unknown): void;

package/dist/trading/appDataUtils.d.ts

@@ -1,4 +1,5 @@
 import { AppDataInfo, AppDataRootSchema, BuildAppDataParams } from './types';
-import { AppDataParams } from '@cowprotocol/app-data';
+import { AppDataParams, type LatestAppDataDocVersion } from '@cowprotocol/app-data';
 export declare function buildAppData({ slippageBps, appCode, orderClass: orderClassName, partnerFee }: BuildAppDataParams, advancedParams?: AppDataParams): Promise<AppDataInfo>;
 export declare function generateAppDataFromDoc(doc: AppDataRootSchema): Promise<Pick<AppDataInfo, 'fullAppData' | 'appDataKeccak256'>>;
+export declare function mergeAppDataDoc(_doc: LatestAppDataDocVersion, appDataOverride: AppDataParams): Promise<AppDataInfo>;

package/dist/trading/calculateUniqueOrderId.d.ts

@@ -1,6 +1,5 @@
 import { UnsignedOrder } from '../order-signing';
-import { CowEnv, SupportedChainId } from '../common';
-export interface EthFlowOrderExistsCallback {
-    (orderId: string, orderDigest: string): Promise<boolean>;
-}
+import { CowEnv } from '../common';
+import { SupportedChainId } from '../chains';
+import { EthFlowOrderExistsCallback } from './types';
 export declare function calculateUniqueOrderId(chainId: SupportedChainId, order: UnsignedOrder, checkEthFlowOrderExists?: EthFlowOrderExistsCallback, env?: CowEnv): Promise<string>;

package/dist/trading/consts.d.ts

@@ -1,10 +1,8 @@
 import { SigningScheme } from '../order-book';
-export declare function log(text: string): void;
-export declare namespace log {
-    var enabled: boolean;
-}
+import { SupportedChainId } from '../chains';
 export declare const DEFAULT_QUOTE_VALIDITY: number;
 export declare const DEFAULT_SLIPPAGE_BPS = 50;
+export declare const ETH_FLOW_DEFAULT_SLIPPAGE_BPS: Record<SupportedChainId, number>;
 export declare const SIGN_SCHEME_MAP: {
     eip712: SigningScheme;
     ethsign: SigningScheme;

package/dist/trading/getEthFlowTransaction.d.ts

@@ -1,8 +1,9 @@
-import { Signer } from 'ethers';
-import { LimitTradeParametersFromQuote, TransactionParams } from './types';
-import { EthFlowOrderExistsCallback } from './calculateUniqueOrderId';
-import { SupportedChainId } from '../common';
-export declare function getEthFlowTransaction(signer: Signer, appDataKeccak256: string, _params: LimitTradeParametersFromQuote, chainId: SupportedChainId, networkCostsAmount?: string, checkEthFlowOrderExists?: EthFlowOrderExistsCallback): Promise<{
+import { LimitTradeParametersFromQuote, PostTradeAdditionalParams, TransactionParams } from './types';
+import { SupportedChainId } from '../chains';
+import { Signer } from '@ethersproject/abstract-signer';
+import type { UnsignedOrder } from '../order-signing';
+export declare function getEthFlowTransaction(signer: Signer, appDataKeccak256: string, _params: LimitTradeParametersFromQuote, chainId: SupportedChainId, additionalParams?: PostTradeAdditionalParams): Promise<{
     orderId: string;
     transaction: TransactionParams;
+    orderToSign: UnsignedOrder;
 }>;

package/dist/trading/getOrderTypedData.d.ts

@@ -1,4 +1,4 @@
 import { OrderTypedData } from './types';
 import { UnsignedOrder } from '../order-signing';
-import { SupportedChainId } from '../common';
+import { SupportedChainId } from '../chains';
 export declare function getOrderTypedData(chainId: SupportedChainId, orderToSign: UnsignedOrder): Promise<OrderTypedData>;

package/dist/trading/getPreSignTransaction.d.ts

@@ -1,4 +1,4 @@
-import { SupportedChainId } from '../common';
-import type { Signer } from 'ethers';
+import { SupportedChainId } from '../chains';
+import type { Signer } from '@ethersproject/abstract-signer';
 import { TransactionParams } from './types';
 export declare function getPreSignTransaction(signer: Signer, chainId: SupportedChainId, account: string, orderId: string): Promise<TransactionParams>;

package/dist/trading/getQuote.d.ts

@@ -1,6 +1,6 @@
 import { QuoteResults, QuoterParameters, SwapAdvancedSettings, SwapParameters, TradeParameters } from './types';
 import { OrderBookApi } from '../order-book';
-import { Signer } from 'ethers';
+import { Signer } from '@ethersproject/abstract-signer';
 export type QuoteResultsWithSigner = {
     result: QuoteResults & {
         signer: Signer;

package/dist/trading/postCoWProtocolTrade.d.ts

@@ -1,4 +1,4 @@
-import { OrderBookApi, SigningScheme } from '../order-book';
-import type { Signer } from 'ethers';
-import { AppDataInfo, LimitTradeParameters } from './types';
-export declare function postCoWProtocolTrade(orderBookApi: OrderBookApi, signer: Signer, appData: AppDataInfo, params: LimitTradeParameters, networkCostsAmount?: string, _signingScheme?: SigningScheme): Promise<string>;
+import { OrderBookApi } from '../order-book';
+import type { Signer } from '@ethersproject/abstract-signer';
+import { AppDataInfo, LimitTradeParameters, OrderPostingResult, PostTradeAdditionalParams } from './types';
+export declare function postCoWProtocolTrade(orderBookApi: OrderBookApi, signer: Signer, appData: AppDataInfo, params: LimitTradeParameters, additionalParams?: PostTradeAdditionalParams): Promise<OrderPostingResult>;

package/dist/trading/postLimitOrder.d.ts

@@ -1,3 +1,3 @@
-import { LimitOrderAdvancedSettings, LimitOrderParameters } from './types';
+import { LimitOrderAdvancedSettings, LimitOrderParameters, OrderPostingResult } from './types';
 import { OrderBookApi } from '../order-book';
-export declare function postLimitOrder(params: LimitOrderParameters, advancedSettings?: LimitOrderAdvancedSettings, _orderBookApi?: OrderBookApi): Promise<string>;
+export declare function postLimitOrder(params: LimitOrderParameters, advancedSettings?: LimitOrderAdvancedSettings, _orderBookApi?: OrderBookApi): Promise<OrderPostingResult>;

package/dist/trading/postSellNativeCurrencyOrder.d.ts

@@ -1,8 +1,4 @@
 import { Signer } from 'ethers';
-import { AppDataInfo, LimitTradeParametersFromQuote } from './types';
-import { EthFlowOrderExistsCallback } from './calculateUniqueOrderId';
+import { AppDataInfo, LimitTradeParametersFromQuote, OrderPostingResult, PostTradeAdditionalParams } from './types';
 import { OrderBookApi } from '../order-book';
-export declare function postSellNativeCurrencyOrder(orderBookApi: OrderBookApi, signer: Signer, appData: Pick<AppDataInfo, 'fullAppData' | 'appDataKeccak256'>, _params: LimitTradeParametersFromQuote, networkCostsAmount?: string, checkEthFlowOrderExists?: EthFlowOrderExistsCallback): Promise<{
-    txHash: string;
-    orderId: string;
-}>;
+export declare function postSellNativeCurrencyOrder(orderBookApi: OrderBookApi, signer: Signer, appData: Pick<AppDataInfo, 'fullAppData' | 'appDataKeccak256'>, _params: LimitTradeParametersFromQuote, additionalParams?: PostTradeAdditionalParams): Promise<OrderPostingResult>;

package/dist/trading/postSwapOrder.d.ts

@@ -1,5 +1,5 @@
-import { SwapAdvancedSettings, SwapParameters } from './types';
+import { OrderPostingResult, SwapAdvancedSettings, SwapParameters } from './types';
 import { QuoteResultsWithSigner } from './getQuote';
 import { OrderBookApi } from '../order-book';
-export declare function postSwapOrder(params: SwapParameters, advancedSettings?: SwapAdvancedSettings, orderBookApi?: OrderBookApi): Promise<string>;
-export declare function postSwapOrderFromQuote({ orderBookApi, result: { signer, appDataInfo, quoteResponse, tradeParameters } }: QuoteResultsWithSigner, advancedSettings?: SwapAdvancedSettings): Promise<string>;
+export declare function postSwapOrder(params: SwapParameters, advancedSettings?: SwapAdvancedSettings, orderBookApi?: OrderBookApi): Promise<OrderPostingResult>;
+export declare function postSwapOrderFromQuote({ orderBookApi, result: { signer, appDataInfo: _appDataInfo, quoteResponse, tradeParameters }, }: QuoteResultsWithSigner, advancedSettings?: SwapAdvancedSettings): Promise<OrderPostingResult>;

package/dist/trading/tradingSdk.d.ts

@@ -1,23 +1,26 @@
-import { LimitOrderAdvancedSettings, LimitTradeParameters, QuoteAndPost, SwapAdvancedSettings, TradeParameters, TraderParameters } from './types';
+import { LimitOrderAdvancedSettings, LimitTradeParameters, OrderPostingResult, QuoteAndPost, SwapAdvancedSettings, TradeParameters, TraderParameters } from './types';
+import { QuoteResultsWithSigner } from './getQuote';
 import { postSellNativeCurrencyOrder } from './postSellNativeCurrencyOrder';
 import { getPreSignTransaction } from './getPreSignTransaction';
 import { OrderBookApi } from '../order-book';
-interface TradingSdkOptions {
+export type WithPartialTraderParams<T> = T & Partial<TraderParameters>;
+export interface TradingSdkOptions {
     enableLogging: boolean;
     orderBookApi: OrderBookApi;
 }
 export declare class TradingSdk {
-    readonly traderParams: TraderParameters;
+    traderParams: Partial<TraderParameters>;
     readonly options: Partial<TradingSdkOptions>;
-    constructor(traderParams: TraderParameters, options?: Partial<TradingSdkOptions>);
-    getQuote(params: TradeParameters, advancedSettings?: SwapAdvancedSettings): Promise<QuoteAndPost>;
-    postSwapOrder(params: TradeParameters, advancedSettings?: SwapAdvancedSettings): Promise<string>;
-    postLimitOrder(params: LimitTradeParameters, advancedSettings?: LimitOrderAdvancedSettings): Promise<string>;
-    postSellNativeCurrencyOrder(params: TradeParameters, advancedSettings?: SwapAdvancedSettings): Promise<ReturnType<typeof postSellNativeCurrencyOrder>>;
-    getPreSignTransaction(params: {
+    constructor(traderParams?: Partial<TraderParameters>, options?: Partial<TradingSdkOptions>);
+    setTraderParams(params: Partial<TraderParameters>): this;
+    getQuote(params: WithPartialTraderParams<TradeParameters>, advancedSettings?: SwapAdvancedSettings): Promise<QuoteAndPost>;
+    getQuoteResults(params: WithPartialTraderParams<TradeParameters>, advancedSettings?: SwapAdvancedSettings): Promise<QuoteResultsWithSigner>;
+    postSwapOrder(params: WithPartialTraderParams<TradeParameters>, advancedSettings?: SwapAdvancedSettings): Promise<OrderPostingResult>;
+    postLimitOrder(params: WithPartialTraderParams<LimitTradeParameters>, advancedSettings?: LimitOrderAdvancedSettings): Promise<OrderPostingResult>;
+    postSellNativeCurrencyOrder(params: WithPartialTraderParams<TradeParameters>, advancedSettings?: SwapAdvancedSettings): Promise<ReturnType<typeof postSellNativeCurrencyOrder>>;
+    getPreSignTransaction(params: WithPartialTraderParams<{
         orderId: string;
         account: string;
-    }): ReturnType<typeof getPreSignTransaction>;
+    }>): ReturnType<typeof getPreSignTransaction>;
     private mergeParams;
 }
-export {};

package/dist/trading/types.d.ts

@@ -1,11 +1,8 @@
 import type { AppDataParams, latest, LatestAppDataDocVersion } from '@cowprotocol/app-data';
-import { AppData, AppDataHash, OrderKind, OrderParameters, OrderQuoteRequest, OrderQuoteResponse, QuoteAmountsAndCosts, TokenAmount } from '../order-book';
-import type { Signer } from '@ethersproject/abstract-signer';
-import type { CowEnv, SupportedChainId } from '../common';
-import type { ExternalProvider } from '@ethersproject/providers';
+import { AppData, AppDataHash, OrderKind, OrderParameters, OrderQuoteRequest, OrderQuoteResponse, QuoteAmountsAndCosts, type Signature, SigningScheme, TokenAmount } from '../order-book';
+import type { AccountAddress, CowEnv, SignerLike } from '../common';
 import type { UnsignedOrder } from '../order-signing';
-export type PrivateKey = string;
-export type AccountAddress = `0x${string}`;
+import type { SupportedChainId } from '../chains';
 export declare const ORDER_PRIMARY_TYPE: "Order";
 /**
  * EIP-712 typed data domain.
@@ -37,6 +34,7 @@ export interface OrderTypedData {
  */
 export interface TradeBaseParameters {
     kind: OrderKind;
+    owner?: AccountAddress;
     sellToken: OrderParameters['sellToken'];
     sellTokenDecimals: number;
     buyToken: OrderParameters['buyToken'];
@@ -60,7 +58,8 @@ export interface TradeOptionalParameters {
 export interface TraderParameters {
     chainId: SupportedChainId;
     appCode: latest.AppCode;
-    signer: Signer | ExternalProvider | PrivateKey;
+    signer: SignerLike;
+    env?: CowEnv;
 }
 export type QuoterParameters = Omit<TraderParameters, 'signer'> & {
     account: AccountAddress;
@@ -87,30 +86,63 @@ export interface LimitTradeParametersFromQuote extends LimitTradeParameters {
 export interface LimitOrderParameters extends TraderParameters, LimitTradeParameters {
 }
 export interface SwapAdvancedSettings {
-    quoteRequest?: Partial<Omit<OrderQuoteRequest, 'kind'>>;
+    quoteRequest?: Partial<Omit<OrderQuoteRequest, 'kind'> & {
+        validTo: number;
+    }>;
     appData?: AppDataParams;
+    additionalParams?: PostTradeAdditionalParams;
+    quoteSigner?: SignerLike;
 }
 export interface LimitOrderAdvancedSettings {
     appData?: AppDataParams;
+    additionalParams?: PostTradeAdditionalParams;
 }
 /**
- * Exhaustive set of data which includes information about trade, quote, order, "app-data", and more.
+ * Quote information for the CoW Protocol order, including information about the trade, quote, order, "app-data", and more.
+ *
  * This data is used to create a trade, sign an order, and post it to the order book.
  */
 export interface QuoteResults {
+    /**
+     * Information about the trade, including the kind of order, the owner, the sell and buy tokens, and the amount.
+     */
     tradeParameters: TradeParameters;
+    /**
+     * Details about costs and amounts, costs and fees of a quote.
+     */
     amountsAndCosts: QuoteAmountsAndCosts;
+    /**
+     * Information about the order to be signed.
+     *
+     * For signining, please use orderTypedData (EIP-712 typed data, which also includes the unsigned order)
+     */
     orderToSign: UnsignedOrder;
+    /**
+     * Information about the quote response from the order book API.
+     */
     quoteResponse: OrderQuoteResponse;
+    /**
+     * Information about the app-data, including the JSON document and the keccak256 hash of the full document.
+     */
     appDataInfo: AppDataInfo;
+    /**
+     * EIP-712 typed data for the order ready to be signed.
+     */
     orderTypedData: OrderTypedData;
 }
 export interface QuoteResultsSerialized extends Omit<QuoteResults, 'amountsAndCosts'> {
     amountsAndCosts: QuoteAmountsAndCosts<string>;
 }
+export interface OrderPostingResult {
+    orderId: string;
+    txHash?: string;
+    signingScheme: SigningScheme;
+    signature: Signature;
+    orderToSign: UnsignedOrder;
+}
 export interface QuoteAndPost {
     quoteResults: QuoteResults;
-    postSwapOrderFromQuote(): Promise<string>;
+    postSwapOrderFromQuote(advancedSettings?: SwapAdvancedSettings): Promise<OrderPostingResult>;
 }
 export type AppDataRootSchema = latest.AppDataRootSchema;
 export interface BuildAppDataParams {
@@ -120,7 +152,9 @@ export interface BuildAppDataParams {
     partnerFee?: latest.PartnerFee;
 }
 /**
- * https://github.com/cowprotocol/app-data
+ * Information about the app-data, including the JSON document and the keccak256 hash of the full document.
+ *
+ * See https://github.com/cowprotocol/app-data
  */
 export interface AppDataInfo {
     doc: LatestAppDataDocVersion;
@@ -136,4 +170,32 @@ export interface TransactionParams {
     to: string;
     value: string;
 }
+export interface EthFlowOrderExistsCallback {
+    (orderId: string, orderDigest: string): Promise<boolean>;
+}
+/**
+ * Additional parameters for posting orders.
+ * In most of the cases you don't need to use them.
+ */
+export interface PostTradeAdditionalParams {
+    /**
+     * Selling native token orders are special, because they are created from smart-contract,
+     * and their validTo is always the same.
+     * Because of that, you might get the same orderId when trying to create an order with the same parameters
+     * The callback is needed to check if there is already an order with the same orderId
+     *
+     * @see https://github.com/cowprotocol/ethflowcontract/blob/main/src/libraries/EthFlowOrder.sol#L90
+     */
+    checkEthFlowOrderExists?: EthFlowOrderExistsCallback;
+    /**
+     * Cost of executing the order onchain.
+     * The value is used in getQuoteAmountsAndCosts in order to calculate proper amounts
+     */
+    networkCostsAmount?: string;
+    /**
+     * By default, is EIP712 for EOA wallets.
+     * You might need other types of signing, for example PRESIGN when sign order via Smart Contract wallets.
+     */
+    signingScheme?: SigningScheme;
+}
 export {};

package/dist/trading/utils.d.ts

@@ -1,12 +1,10 @@
-import { LimitTradeParametersFromQuote, PrivateKey, TradeParameters } from './types';
+import { LimitTradeParametersFromQuote, TradeParameters } from './types';
 import { OrderQuoteResponse, QuoteAmountsAndCosts } from '../order-book';
-import { Signer } from 'ethers';
-import { type ExternalProvider } from '@ethersproject/providers';
+import { SupportedChainId } from '../chains';
 export declare function swapParamsToLimitOrderParams(params: TradeParameters, quoteResponse: OrderQuoteResponse): LimitTradeParametersFromQuote;
 export declare function getIsEthFlowOrder(params: {
     sellToken: string;
 }): boolean;
-export declare function getSigner(signer: Signer | ExternalProvider | PrivateKey): Signer;
 /**
  * Returns the gas value plus a margin for unexpected or variable gas costs (20%)
  * @param value the gas value to pad
@@ -21,3 +19,9 @@ export declare function getTradeParametersAfterQuote({ quoteParameters, orderPar
     quoteParameters: TradeParameters;
     orderParameters: TradeParameters;
 }): TradeParameters;
+/**
+ * ETH-flow orders are special and need to be adjusted
+ * 1. Sell token should be the wrapped native currency
+ * 2. Default slippage is 2%
+ */
+export declare function adjustEthFlowOrderParams(chainId: SupportedChainId, params: TradeParameters | LimitTradeParametersFromQuote): typeof params;

package/dist/utils-757fe114.js

@@ -0,0 +1,2 @@
+import{hashOrder as e,packOrderUidParams as t,IntChainIdTypedDataV4Signer as r,TypedDataVersionedSigner as n,signOrderCancellations as o,signOrderCancellation as i,signOrder as s,SigningScheme as c,domain as a}from"@cowprotocol/contracts";import{EcdsaSigningScheme as d,CowError as u,COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS as l}from"./index.module.js";import"cross-fetch/polyfill";import"limiter";import"exponential-backoff";import"ethers";import"@cowprotocol/app-data";import"ethers/lib/utils";import"deepmerge";import"@ethersproject/abstract-signer";import"@weiroll/weiroll.js";import"graphql-request";import"@openzeppelin/merkle-tree";const h=function(r,n,o){try{return Promise.resolve(k(r)).then(function(r){const i=e(r,n);return{orderId:t({...o,orderDigest:i,validTo:n.validTo}),orderDigest:i}})}catch(e){return Promise.reject(e)}},m=function(e,t,r){return f({orderUids:e,chainId:t},v,r)},g=function(e,t,r){return f({orderUid:e,chainId:t},w,r)},p=function(e,t,r){return f({order:e,chainId:t},P,r)},f=function(e,t,o,i="v4"){try{let c;function s(e){if(c)return e;const t=h?.data;return{signature:t?.toString()||"",signingScheme:a}}const a="eth_sign"===i?d.ETHSIGN:d.EIP712;let l,h=null;try{switch(i){case"default":case"v3":l=new n(o);break;case"int_v4":l=new r(o);break;default:l=o}}catch(g){throw console.error("Wallet not supported:",g),new u("Wallet not supported")}const m=function(r,n){try{var o=Promise.resolve(t({...e,signer:l,signingScheme:a})).then(function(e){h=e})}catch(e){return n(e)}return o&&o.then?o.then(void 0,n):o}(0,function(r){if(void 0===(n=r).code&&void 0===n.message)throw console.error(r),r;var n;const s=[S,T].some(e=>[r.message,r.toString()].some(t=>e.test(t)));if(r.code!==y&&!s){if(E.test(r.message)){const r=f(e,t,o,"int_v4");return c=1,r}if(r.code===I){const r=f(e,t,o,"eth_sign");return c=1,r}if(_.test(r.message)){const r=f(e,t,o,"v3");return c=1,r}if(j.test(r.message)){const r=f(e,t,o,"eth_sign");return c=1,r}throw console.error(r),r}switch(i){case"v4":const n=f(e,t,o,"default");return c=1,n;case"default":const i=f(e,t,o,"v3");return c=1,i;case"v3":const s=f(e,t,o,"eth_sign");return c=1,s;default:throw r}});return Promise.resolve(m&&m.then?m.then(s):s(m))}catch(p){return Promise.reject(p)}},v=function(e){try{const{chainId:t,signer:r,signingScheme:n,orderUids:i}=e,s=k(t);return Promise.resolve(o(s,i,r,b[n]))}catch(e){return Promise.reject(e)}},w=function(e){try{const{chainId:t,signer:r,signingScheme:n,orderUid:o}=e,s=k(t);return Promise.resolve(i(s,o,r,b[n]))}catch(e){return Promise.reject(e)}},P=function(e){try{const{chainId:t,signer:r,order:n,signingScheme:o}=e,i=k(t);return Promise.resolve(s(i,n,r,b[o]))}catch(e){return Promise.reject(e)}},I=-32603,y=-32601,S=/Method not found/i,_=/eth_signTypedData_v4 does not exist/i,j=/eth_signTypedData_v3 does not exist/i,T=/RPC request failed/i,E=/provided chainid .* must match the active chainid/i,b={[d.EIP712]:c.EIP712,[d.ETHSIGN]:c.ETHSIGN};function k(e){const t=l[e];if(!t)throw new u("Unsupported network. Settlement contract is not deployed");return a(e,t)}export{h as generateOrderId,k as getDomain,p as signOrder,g as signOrderCancellation,m as signOrderCancellations};
+//# sourceMappingURL=utils-757fe114.js.map

package/dist/utils-757fe114.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-757fe114.js","sources":["../src/order-signing/utils.ts"],"sourcesContent":["import type {\n  Order as OrderFromContract,\n  Signature,\n  TypedDataDomain,\n  EcdsaSigningScheme as EcdsaSigningSchemeContract,\n  Order,\n  OrderUidParams,\n} from '@cowprotocol/contracts'\nimport {\n  domain as domainGp,\n  EcdsaSignature,\n  IntChainIdTypedDataV4Signer,\n  SigningScheme,\n  hashOrder,\n  packOrderUidParams,\n  signOrder as signOrderGp,\n  signOrderCancellation as signOrderCancellationGp,\n  signOrderCancellations as signOrderCancellationsGp,\n  TypedDataVersionedSigner,\n} from '@cowprotocol/contracts'\nimport type { Signer } from '@ethersproject/abstract-signer'\nimport type { SigningResult, SignOrderParams, SignOrderCancellationParams, UnsignedOrder } from './types'\n\nimport { COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS } from '../common/consts/contracts'\nimport { CowError } from '../common'\nimport type { SupportedChainId } from '../chains'\nimport { EcdsaSigningScheme } from '../order-book'\nimport { SignOrderCancellationsParams } from './types'\n\n// For error codes, see:\n// - https://eth.wiki/json-rpc/json-rpc-error-codes-improvement-proposal\n// - https://www.jsonrpc.org/specification#error_object\nconst METAMASK_SIGNATURE_ERROR_CODE = -32603\nconst METHOD_NOT_FOUND_ERROR_CODE = -32601\n// Added the following because of 1Inch wallet who doesn't send the error code\n// So we will check the actual error text\nconst METHOD_NOT_FOUND_ERROR_MSG_REGEX = /Method not found/i\nconst V4_ERROR_MSG_REGEX = /eth_signTypedData_v4 does not exist/i\nconst V3_ERROR_MSG_REGEX = /eth_signTypedData_v3 does not exist/i\nconst RPC_REQUEST_FAILED_REGEX = /RPC request failed/i\nconst METAMASK_STRING_CHAINID_REGEX = /provided chainid .* must match the active chainid/i\n\nconst mapSigningSchema: Record<EcdsaSigningScheme, EcdsaSigningSchemeContract> = {\n  [EcdsaSigningScheme.EIP712]: SigningScheme.EIP712,\n  [EcdsaSigningScheme.ETHSIGN]: SigningScheme.ETHSIGN,\n}\n\ninterface ProviderRpcError extends Error {\n  message: string\n  code: number\n  data?: unknown\n}\n\ntype PayloadParams =\n  | Pick<SignOrderParams, 'order' & 'chainId'>\n  | Pick<SignOrderCancellationParams, 'chainId' & 'orderId'>\n  | Pick<SignOrderCancellationsParams, 'chainId' & 'orderUids'>\n\nfunction isProviderRpcError(error: unknown): error is ProviderRpcError {\n  return (error as ProviderRpcError).code !== undefined || (error as ProviderRpcError).message !== undefined\n}\n\nasync function _signOrder(params: SignOrderParams): Promise<Signature> {\n  const { chainId, signer, order, signingScheme } = params\n\n  const domain = getDomain(chainId)\n\n  return signOrderGp(domain, order as unknown as OrderFromContract, signer, mapSigningSchema[signingScheme])\n}\n\nasync function _signOrderCancellation(params: SignOrderCancellationParams): Promise<Signature> {\n  const { chainId, signer, signingScheme, orderUid } = params\n\n  const domain = getDomain(chainId)\n\n  return signOrderCancellationGp(domain, orderUid, signer, mapSigningSchema[signingScheme])\n}\n\nasync function _signOrderCancellations(params: SignOrderCancellationsParams): Promise<Signature> {\n  const { chainId, signer, signingScheme, orderUids } = params\n\n  const domain = getDomain(chainId)\n\n  return signOrderCancellationsGp(domain, orderUids, signer, mapSigningSchema[signingScheme])\n}\n\nasync function _signPayload(\n  payload: PayloadParams,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  signFn: (params: any) => Promise<Signature>,\n  signer: Signer,\n  signingMethod: 'default' | 'v4' | 'int_v4' | 'v3' | 'eth_sign' = 'v4'\n): Promise<SigningResult> {\n  const signingScheme: EcdsaSigningScheme =\n    signingMethod === 'eth_sign' ? EcdsaSigningScheme.ETHSIGN : EcdsaSigningScheme.EIP712\n  let signature: Signature | null = null\n\n  let _signer\n  try {\n    switch (signingMethod) {\n      case 'default':\n      case 'v3':\n        _signer = new TypedDataVersionedSigner(signer)\n        break\n      case 'int_v4':\n        _signer = new IntChainIdTypedDataV4Signer(signer)\n        break\n      default:\n        _signer = signer\n    }\n  } catch (e) {\n    console.error('Wallet not supported:', e)\n    throw new CowError('Wallet not supported')\n  }\n\n  try {\n    signature = (await signFn({ ...payload, signer: _signer, signingScheme })) as EcdsaSignature // Only ECDSA signing supported for now\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  } catch (e: any) {\n    if (!isProviderRpcError(e)) {\n      // Some other error signing. Let it bubble up.\n      console.error(e)\n      throw e\n    }\n\n    const regexErrorCheck = [METHOD_NOT_FOUND_ERROR_MSG_REGEX, RPC_REQUEST_FAILED_REGEX].some((regex) =>\n      // for example 1Inch error doesn't have e.message so we will check the output of toString()\n      [e.message, e.toString()].some((msg) => regex.test(msg))\n    )\n\n    if (e.code === METHOD_NOT_FOUND_ERROR_CODE || regexErrorCheck) {\n      // Maybe the wallet returns the proper error code? We can only hope 🤞\n      // OR it failed with a generic message, there's no error code set, and we also hope it'll work\n      // with other methods...\n      switch (signingMethod) {\n        case 'v4':\n          return _signPayload(payload, signFn, signer, 'default')\n        case 'default':\n          return _signPayload(payload, signFn, signer, 'v3')\n        case 'v3':\n          return _signPayload(payload, signFn, signer, 'eth_sign')\n        default:\n          throw e\n      }\n    } else if (METAMASK_STRING_CHAINID_REGEX.test(e.message)) {\n      // Metamask now enforces chainId to be an integer\n      return _signPayload(payload, signFn, signer, 'int_v4')\n    } else if (e.code === METAMASK_SIGNATURE_ERROR_CODE) {\n      // We tried to sign order the nice way.\n      // That works fine for regular MM addresses. Does not work for Hardware wallets, though.\n      // See https://github.com/MetaMask/metamask-extension/issues/10240#issuecomment-810552020\n      // So, when that specific error occurs, we know this is a problem with MM + HW.\n      // Then, we fallback to ETHSIGN.\n      return _signPayload(payload, signFn, signer, 'eth_sign')\n    } else if (V4_ERROR_MSG_REGEX.test(e.message)) {\n      // Failed with `v4`, and the wallet does not set the proper error code\n      return _signPayload(payload, signFn, signer, 'v3')\n    } else if (V3_ERROR_MSG_REGEX.test(e.message)) {\n      // Failed with `v3`, and the wallet does not set the proper error code\n      return _signPayload(payload, signFn, signer, 'eth_sign')\n    } else {\n      // Some other error signing. Let it bubble up.\n      console.error(e)\n      throw e\n    }\n  }\n\n  const data: unknown = signature?.data\n\n  return { signature: data?.toString() || '', signingScheme }\n}\n\n/**\n * Returns the signature for the specified order with the signing scheme encoded\n * into the signature.\n * @param {UnsignedOrder} order The order to sign.\n * @param {SupportedChainId} chainId The chain Id\n * @param {Signer} signer The owner for the order used to sign.\n * @return {*} Encoded signature including signing scheme for the order.\n */\nexport async function signOrder(\n  order: UnsignedOrder,\n  chainId: SupportedChainId,\n  signer: Signer\n): Promise<SigningResult> {\n  return _signPayload({ order, chainId }, _signOrder, signer)\n}\n\n/**\n * Returns the signature for the Order Cancellation with the signing scheme encoded\n * into the signature.\n * @param {string} orderUid The unique identifier of the order being cancelled.\n * @param {SupportedChainId} chainId The chain Id\n * @param {Signer} signer The owner for the order used to sign.\n * @return {*} Encoded signature including signing scheme for the order.\n */\nexport async function signOrderCancellation(\n  orderUid: string,\n  chainId: SupportedChainId,\n  signer: Signer\n): Promise<SigningResult> {\n  return _signPayload({ orderUid, chainId }, _signOrderCancellation, signer)\n}\n\n/**\n * Returns the signature for the Order Cancellations with the signing scheme encoded\n * into the signature.\n *\n * @param {string[]} orderUids The unique identifiers of the orders being cancelled.\n * @param {SupportedChainId} chainId The CoW Protocol protocol `chainId` context that's being used.\n * @param {Signer} signer The owner that had placed the orders used to sign.\n * @returns {*} Encoded signature including signing scheme for the order.\n */\nexport async function signOrderCancellations(\n  orderUids: string[],\n  chainId: SupportedChainId,\n  signer: Signer\n): Promise<SigningResult> {\n  return _signPayload({ orderUids, chainId }, _signOrderCancellations, signer)\n}\n\n/**\n * Returns the TypedDataDomain used for signing for the specified chainId.\n * @param {SupportedChainId} chainId The chain Id\n * @return {*} The TypedDataDomain for the specified chainId.\n * @throws {CowError} If the chainId is not supported.\n */\nexport function getDomain(chainId: SupportedChainId): TypedDataDomain {\n  // Get settlement contract address\n  const settlementContract = COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS[chainId]\n\n  if (!settlementContract) {\n    throw new CowError('Unsupported network. Settlement contract is not deployed')\n  }\n\n  return domainGp(chainId, settlementContract)\n}\n\n/**\n * Generate a deterministic order ID for the specified order.\n * @param {SupportedChainId} chainId The chain Id\n * @param {Order} order order to sign\n * @param {Pick<OrderUidParams, 'owner'>} params order unique identifier parameters.\n */\nexport async function generateOrderId(\n  chainId: SupportedChainId,\n  order: Order,\n  params: Pick<OrderUidParams, 'owner'>\n): Promise<{ orderId: string; orderDigest: string }> {\n  const domain = await getDomain(chainId)\n  const orderDigest = hashOrder(domain, order)\n  // Generate the orderId from owner, orderDigest, and max validTo\n  const orderId = packOrderUidParams({\n    ...params,\n    orderDigest,\n    // Different validTo when signing because EthFlow contract expects it to be max for all orders\n    validTo: order.validTo,\n  })\n\n  return { orderId, orderDigest }\n}\n"],"names":["generateOrderId","chainId","order","params","Promise","resolve","getDomain","then","domain","orderDigest","hashOrder","orderId","packOrderUidParams","validTo","e","reject","signOrderCancellations","orderUids","signer","_signPayload","_signOrderCancellations","signOrderCancellation","orderUid","_signOrderCancellation","signOrder","_signOrder","payload","signFn","signingMethod","_exit","_temp2","_result","data","signature","toString","signingScheme","EcdsaSigningScheme","ETHSIGN","EIP712","_signer","TypedDataVersionedSigner","IntChainIdTypedDataV4Signer","console","error","CowError","_temp","_signFn","_catch","undefined","code","message","regexErrorCheck","METHOD_NOT_FOUND_ERROR_MSG_REGEX","RPC_REQUEST_FAILED_REGEX","some","regex","msg","test","METHOD_NOT_FOUND_ERROR_CODE","METAMASK_STRING_CHAINID_REGEX","_signPayload5","METAMASK_SIGNATURE_ERROR_CODE","_signPayload6","V4_ERROR_MSG_REGEX","_signPayload7","V3_ERROR_MSG_REGEX","_signPayload8","_signPayload2","_signPayload3","_signPayload4","signOrderCancellationsGp","mapSigningSchema","signOrderCancellationGp","signOrderGp","SigningScheme","settlementContract","COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS","domainGp"],"mappings":"goBAoPsB,MAAAA,EAAeA,SACnCC,EACAC,EACAC,GAAqC,IAAAC,OAAAA,QAAAC,QAEhBC,EAAUL,IAAQM,KAAA,SAAjCC,GACN,MAAMC,EAAcC,EAAUF,EAAQN,GAStC,MAAO,CAAES,QAPOC,EAAmB,IAC9BT,EACHM,cAEAI,QAASX,EAAMW,UAGCJ,cAAa,EACjC,CAAC,MAAAK,GAAA,OAAAV,QAAAW,OAAAD,EAAA,CAAA,EA/CqBE,EAAsB,SAC1CC,EACAhB,EACAiB,GAEA,OAAOC,EAAa,CAAEF,YAAWhB,WAAWmB,EAAyBF,EACvE,EAvBsBG,EAAqB,SACzCC,EACArB,EACAiB,GAEA,OAAOC,EAAa,CAAEG,WAAUrB,WAAWsB,EAAwBL,EACrE,EAtBsBM,EAAS,SAC7BtB,EACAD,EACAiB,GAEA,OAAOC,EAAa,CAAEjB,QAAOD,WAAWwB,EAAYP,EACtD,EApGeC,EAAYA,SACzBO,EAEAC,EACAT,EACAU,EAAiE,MAAI,IAAAC,IAAAA,EAAAC,SAAAA,EAAAC,GAAA,GAAAF,EAAA,OAAAE,EA4ErE,MAAMC,EAAgBC,GAAWD,KAEjC,MAAO,CAAEC,UAAWD,GAAME,YAAc,GAAIC,gBAAe,CA5E3D,MAAMA,EACc,aAAlBP,EAA+BQ,EAAmBC,QAAUD,EAAmBE,OACjF,IAEIC,EAFAN,EAA8B,KAGlC,IACE,OAAQL,GACN,IAAK,UACL,IAAK,KACHW,EAAU,IAAIC,EAAyBtB,GACvC,MACF,IAAK,SACHqB,EAAU,IAAIE,EAA4BvB,GAC1C,MACF,QACEqB,EAAUrB,EAEf,CAAC,MAAOJ,GAEP,MADA4B,QAAQC,MAAM,wBAAyB7B,GACjC,IAAI8B,EAAS,uBACpB,CAAA,MAAAC,0BAEGzC,QAAAC,QACiBsB,EAAO,IAAKD,EAASR,OAAQqB,EAASJ,mBAAgB5B,KAAA,SAAAuC,GAAzEb,EAASa,CAAmF,4DAH7FC,CAEG,EAGH,SAAQjC,GACP,QA5D0CkC,KADlBL,EA6DA7B,GA5DSmC,WAA8DD,IAAvCL,EAA2BO,QA+DjF,MADAR,QAAQC,MAAM7B,GACRA,EAhEZ,IAA4B6B,EAmExB,MAAMQ,EAAkB,CAACC,EAAkCC,GAA0BC,KAAMC,GAEzF,CAACzC,EAAEoC,QAASpC,EAAEoB,YAAYoB,KAAME,GAAQD,EAAME,KAAKD,KACpD,GAEG1C,EAAEmC,OAASS,IAA+BP,EAcvC,IAAIQ,EAA8BF,KAAK3C,EAAEoC,SAAU,CAAA,MAAAU,EAEjDzC,EAAaO,EAASC,EAAQT,EAAQ,UAAS0C,OAAA/B,EAAA+B,EAAAA,CACvD,CAAU9C,GAAAA,EAAEmC,OAASY,EAA+B,CAAA,MAAAC,EAM5C3C,EAAaO,EAASC,EAAQT,EAAQ,YAAW4C,OAAAjC,EAAAiC,EAAAA,CACzD,CAAUC,GAAAA,EAAmBN,KAAK3C,EAAEoC,SAAU,CAAAc,MAAAA,EAEtC7C,EAAaO,EAASC,EAAQT,EAAQ,MAAK,OAAAW,EAAA,EAAAmC,CACnD,CAAM,GAAIC,EAAmBR,KAAK3C,EAAEoC,SAAU,CAAA,MAAAgB,EAEtC/C,EAAaO,EAASC,EAAQT,EAAQ,YAAWgD,OAAArC,EAAAqC,EAAAA,CACzD,CAGC,MADAxB,QAAQC,MAAM7B,GACRA,CACP,CA9BC,OAAQc,GACN,IAAK,KAAIuC,MAAAA,EACAhD,EAAaO,EAASC,EAAQT,EAAQ,WAAU,OAAAW,EAAA,EAAAsC,EACzD,IAAK,UAASC,MAAAA,EACLjD,EAAaO,EAASC,EAAQT,EAAQ,MAAK,OAAAW,EAAA,EAAAuC,EACpD,IAAK,KAAIC,MAAAA,EACAlD,EAAaO,EAASC,EAAQT,EAAQ,YAAW,OAAAW,EAAA,EAAAwC,EAC1D,QACE,MAAMvD,EAuBb,GAAA,OAAAV,QAAAC,QAAAwC,GAAAA,EAAAtC,KAAAsC,EAAAtC,KAAAuB,GAAAA,EAAAe,GAKH,CAAC,MAAA/B,GAAA,OAAAV,QAAAW,OAAAD,EAAA,CAAA,EA5FcM,EAAuBA,SAACjB,GAAoC,IACzE,MAAMF,QAAEA,EAAOiB,OAAEA,EAAMiB,cAAEA,EAAalB,UAAEA,GAAcd,EAEhDK,EAASF,EAAUL,GAEzB,OAAAG,QAAAC,QAAOiE,EAAyB9D,EAAQS,EAAWC,EAAQqD,EAAiBpC,IAC9E,CAAC,MAAArB,GAAA,OAAAV,QAAAW,OAAAD,EAAA,CAAA,EAdcS,EAAsBA,SAACpB,GAAmC,IACvE,MAAMF,QAAEA,EAAOiB,OAAEA,EAAMiB,cAAEA,EAAab,SAAEA,GAAanB,EAE/CK,EAASF,EAAUL,GAEzB,OAAAG,QAAAC,QAAOmE,EAAwBhE,EAAQc,EAAUJ,EAAQqD,EAAiBpC,IAC5E,CAAC,MAAArB,GAAA,OAAAV,QAAAW,OAAAD,EAAA,CAAA,EAdcW,EAAUA,SAACtB,GAAuB,IAC/C,MAAMF,QAAEA,EAAOiB,OAAEA,EAAMhB,MAAEA,EAAKiC,cAAEA,GAAkBhC,EAE5CK,EAASF,EAAUL,GAEzB,OAAAG,QAAAC,QAAOoE,EAAYjE,EAAQN,EAAuCgB,EAAQqD,EAAiBpC,IAC7F,CAAC,MAAArB,GAAA,OAAAV,QAAAW,OAAAD,EAAA,CAAA,EApCK+C,GAAiC,MACjCH,GAA+B,MAG/BN,EAAmC,oBACnCW,EAAqB,uCACrBE,EAAqB,uCACrBZ,EAA2B,sBAC3BM,EAAgC,qDAEhCY,EAA2E,CAC/E,CAACnC,EAAmBE,QAASoC,EAAcpC,OAC3C,CAACF,EAAmBC,SAAUqC,EAAcrC,SAuL9B,SAAA/B,EAAUL,GAExB,MAAM0E,EAAqBC,EAAyC3E,GAEpE,IAAK0E,EACH,MAAU,IAAA/B,EAAS,4DAGrB,OAAOiC,EAAS5E,EAAS0E,EAC3B"}

package/dist/utils-9a7618d8.js

@@ -0,0 +1,2 @@
+var e=require("@cowprotocol/contracts"),r=require("./index.js");require("cross-fetch/polyfill"),require("limiter"),require("exponential-backoff"),require("ethers"),require("@cowprotocol/app-data"),require("ethers/lib/utils"),require("deepmerge"),require("@ethersproject/abstract-signer"),require("@weiroll/weiroll.js"),require("graphql-request"),require("@openzeppelin/merkle-tree");const t=function(n,i,o,l="v4"){try{let f;function m(e){if(f)return e;const r=v?.data;return{signature:r?.toString()||"",signingScheme:p}}const p="eth_sign"===l?r.EcdsaSigningScheme.ETHSIGN:r.EcdsaSigningScheme.EIP712;let S,v=null;try{switch(l){case"default":case"v3":S=new e.TypedDataVersionedSigner(o);break;case"int_v4":S=new e.IntChainIdTypedDataV4Signer(o);break;default:S=o}}catch(P){throw console.error("Wallet not supported:",P),new r.CowError("Wallet not supported")}const w=function(e,r){try{var t=Promise.resolve(i({...n,signer:S,signingScheme:p})).then(function(e){v=e})}catch(e){return r(e)}return t&&t.then?t.then(void 0,r):t}(0,function(e){if(void 0===(r=e).code&&void 0===r.message)throw console.error(e),e;var r;const m=[a,h].some(r=>[e.message,e.toString()].some(e=>r.test(e)));if(e.code!==c&&!m){if(g.test(e.message)){const e=t(n,i,o,"int_v4");return f=1,e}if(e.code===s){const e=t(n,i,o,"eth_sign");return f=1,e}if(d.test(e.message)){const e=t(n,i,o,"v3");return f=1,e}if(u.test(e.message)){const e=t(n,i,o,"eth_sign");return f=1,e}throw console.error(e),e}switch(l){case"v4":const r=t(n,i,o,"default");return f=1,r;case"default":const s=t(n,i,o,"v3");return f=1,s;case"v3":const c=t(n,i,o,"eth_sign");return f=1,c;default:throw e}});return Promise.resolve(w&&w.then?w.then(m):m(w))}catch(q){return Promise.reject(q)}},n=function(r){try{const{chainId:t,signer:n,signingScheme:i,orderUids:o}=r,s=m(t);return Promise.resolve(e.signOrderCancellations(s,o,n,l[i]))}catch(e){return Promise.reject(e)}},i=function(r){try{const{chainId:t,signer:n,signingScheme:i,orderUid:o}=r,s=m(t);return Promise.resolve(e.signOrderCancellation(s,o,n,l[i]))}catch(e){return Promise.reject(e)}},o=function(r){try{const{chainId:t,signer:n,order:i,signingScheme:o}=r,s=m(t);return Promise.resolve(e.signOrder(s,i,n,l[o]))}catch(e){return Promise.reject(e)}},s=-32603,c=-32601,a=/Method not found/i,d=/eth_signTypedData_v4 does not exist/i,u=/eth_signTypedData_v3 does not exist/i,h=/RPC request failed/i,g=/provided chainid .* must match the active chainid/i,l={[r.EcdsaSigningScheme.EIP712]:e.SigningScheme.EIP712,[r.EcdsaSigningScheme.ETHSIGN]:e.SigningScheme.ETHSIGN};function m(t){const n=r.COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS[t];if(!n)throw new r.CowError("Unsupported network. Settlement contract is not deployed");return e.domain(t,n)}exports.generateOrderId=function(r,t,n){try{return Promise.resolve(m(r)).then(function(r){const i=e.hashOrder(r,t);return{orderId:e.packOrderUidParams({...n,orderDigest:i,validTo:t.validTo}),orderDigest:i}})}catch(e){return Promise.reject(e)}},exports.getDomain=m,exports.signOrder=function(e,r,n){return t({order:e,chainId:r},o,n)},exports.signOrderCancellation=function(e,r,n){return t({orderUid:e,chainId:r},i,n)},exports.signOrderCancellations=function(e,r,i){return t({orderUids:e,chainId:r},n,i)};
+//# sourceMappingURL=utils-9a7618d8.js.map