@cowprotocol/sdk-trading 0.3.2-beta.0 → 0.4.0

package/dist/index.js

@@ -63,17 +63,62 @@ var import_sdk_order_book = require("@cowprotocol/sdk-order-book");
 var import_sdk_config = require("@cowprotocol/sdk-config");
 var DEFAULT_QUOTE_VALIDITY = 60 * 30;
 var DEFAULT_SLIPPAGE_BPS = 50;
-var ETH_FLOW_DEFAULT_SLIPPAGE_BPS = {
-  ...(0, import_sdk_config.mapSupportedNetworks)(DEFAULT_SLIPPAGE_BPS),
-  // 0.5% by default for most chains
-  [import_sdk_config.SupportedChainId.MAINNET]: 200
-  // 2% for mainnet
-};
+var ETH_FLOW_DEFAULT_SLIPPAGE_BPS = (0, import_sdk_config.mapSupportedNetworks)(DEFAULT_SLIPPAGE_BPS);
 var SIGN_SCHEME_MAP = {
   [import_sdk_order_book.EcdsaSigningScheme.EIP712]: import_sdk_order_book.SigningScheme.EIP712,
   [import_sdk_order_book.EcdsaSigningScheme.ETHSIGN]: import_sdk_order_book.SigningScheme.ETHSIGN
 };
 var GAS_LIMIT_DEFAULT = BigInt(15e4);
+var ERC20_APPROVE_ABI = [
+  {
+    constant: false,
+    inputs: [
+      {
+        name: "_spender",
+        type: "address"
+      },
+      {
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    name: "approve",
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var ERC20_ALLOWANCE_ABI = [
+  {
+    constant: true,
+    inputs: [
+      {
+        name: "_owner",
+        type: "address"
+      },
+      {
+        name: "_spender",
+        type: "address"
+      }
+    ],
+    name: "allowance",
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  }
+];
 
 // src/postCoWProtocolTrade.ts
 var import_sdk_order_signing2 = require("@cowprotocol/sdk-order-signing");
@@ -365,10 +410,18 @@ async function postSellNativeCurrencyOrder(orderBookApi, appData, _params, addit
 }
 
 // src/postCoWProtocolTrade.ts
+var import_sdk_common5 = require("@cowprotocol/sdk-common");
+
+// src/utils/resolveSigner.ts
 var import_sdk_common4 = require("@cowprotocol/sdk-common");
-async function postCoWProtocolTrade(orderBookApi, appData, params, additionalParams = {}, paramSigner) {
+function resolveSigner(signer) {
   const adapter = (0, import_sdk_common4.getGlobalAdapter)();
-  const signer = paramSigner ? adapter.createSigner(paramSigner) : adapter.signer;
+  return signer ? adapter.createSigner(signer) : adapter.signer;
+}
+
+// src/postCoWProtocolTrade.ts
+async function postCoWProtocolTrade(orderBookApi, appData, params, additionalParams = {}, paramSigner) {
+  const signer = resolveSigner(paramSigner);
   const { networkCostsAmount = "0", signingScheme: _signingScheme = import_sdk_order_book4.SigningScheme.EIP712 } = additionalParams;
   const isEthFlow = getIsEthFlowOrder(params);
   if (isEthFlow) {
@@ -384,7 +437,7 @@ async function postCoWProtocolTrade(orderBookApi, appData, params, additionalPar
   const chainId = orderBookApi.context.chainId;
   const from = owner || await signer.getAddress();
   const orderToSign = getOrderToSign({ chainId, from, networkCostsAmount, isEthFlow }, params, appData.appDataKeccak256);
-  (0, import_sdk_common4.log)("Signing order...");
+  (0, import_sdk_common5.log)("Signing order...");
   const { signature, signingScheme } = await (async () => {
     if (_signingScheme === import_sdk_order_book4.SigningScheme.PRESIGN) {
       return { signature: from, signingScheme: import_sdk_order_book4.SigningScheme.PRESIGN };
@@ -402,24 +455,24 @@ async function postCoWProtocolTrade(orderBookApi, appData, params, additionalPar
     appData: fullAppData,
     appDataHash: appDataKeccak256
   };
-  (0, import_sdk_common4.log)("Posting order...");
+  (0, import_sdk_common5.log)("Posting order...");
   const orderId = await orderBookApi.sendOrder(orderBody);
-  (0, import_sdk_common4.log)(`Order created, id: ${orderId}`);
+  (0, import_sdk_common5.log)(`Order created, id: ${orderId}`);
   return { orderId, signature, signingScheme, orderToSign };
 }
 
 // src/getQuote.ts
-var import_sdk_common9 = require("@cowprotocol/sdk-common");
-var import_sdk_order_book6 = require("@cowprotocol/sdk-order-book");
+var import_sdk_common11 = require("@cowprotocol/sdk-common");
+var import_sdk_order_book7 = require("@cowprotocol/sdk-order-book");
 
 // src/appDataUtils.ts
 var import_sdk_app_data = require("@cowprotocol/sdk-app-data");
-var import_sdk_common5 = require("@cowprotocol/sdk-common");
+var import_sdk_common6 = require("@cowprotocol/sdk-common");
 var import_deepmerge = __toESM(require("deepmerge"));
 async function buildAppData({ slippageBps, appCode, orderClass: orderClassName, partnerFee }, advancedParams) {
   const quoteParams = { slippageBips: slippageBps };
   const orderClass = { orderClass: orderClassName };
-  const metadataApiSdk = new import_sdk_app_data.MetadataApi((0, import_sdk_common5.getGlobalAdapter)());
+  const metadataApiSdk = new import_sdk_app_data.MetadataApi((0, import_sdk_common6.getGlobalAdapter)());
   const doc = await metadataApiSdk.generateAppDataDoc(
     (0, import_deepmerge.default)(
       {
@@ -437,7 +490,7 @@ async function buildAppData({ slippageBps, appCode, orderClass: orderClassName,
   return { doc, fullAppData, appDataKeccak256 };
 }
 async function generateAppDataFromDoc(doc) {
-  const adapter = (0, import_sdk_common5.getGlobalAdapter)();
+  const adapter = (0, import_sdk_common6.getGlobalAdapter)();
   const fullAppData = await (0, import_sdk_app_data.stringifyDeterministic)(doc);
   const appDataKeccak256 = adapter.utils.keccak256(adapter.utils.toUtf8Bytes(fullAppData));
   return { fullAppData, appDataKeccak256 };
@@ -486,12 +539,16 @@ async function getOrderTypedData(chainId, orderToSign) {
   };
 }
 
+// src/resolveSlippageSuggestion.ts
+var import_sdk_common10 = require("@cowprotocol/sdk-common");
+var import_sdk_order_book6 = require("@cowprotocol/sdk-order-book");
+
 // src/suggestSlippageBps.ts
-var import_sdk_common8 = require("@cowprotocol/sdk-common");
+var import_sdk_common9 = require("@cowprotocol/sdk-common");
 var import_sdk_order_book5 = require("@cowprotocol/sdk-order-book");
 
 // src/suggestSlippageFromFee.ts
-var import_sdk_common6 = require("@cowprotocol/sdk-common");
+var import_sdk_common7 = require("@cowprotocol/sdk-common");
 function suggestSlippageFromFee(params) {
   const { feeAmount, multiplyingFactorPercent } = params;
   if (feeAmount < 0n) {
@@ -500,11 +557,11 @@ function suggestSlippageFromFee(params) {
   if (multiplyingFactorPercent < 0) {
     throw new Error("multiplyingFactorPercent must be non-negative: " + multiplyingFactorPercent);
   }
-  return (0, import_sdk_common6.applyPercentage)(feeAmount, multiplyingFactorPercent);
+  return (0, import_sdk_common7.applyPercentage)(feeAmount, multiplyingFactorPercent);
 }
 
 // src/suggestSlippageFromVolume.ts
-var import_sdk_common7 = require("@cowprotocol/sdk-common");
+var import_sdk_common8 = require("@cowprotocol/sdk-common");
 function suggestSlippageFromVolume(params) {
   const { sellAmountBeforeNetworkCosts, sellAmountAfterNetworkCosts, isSell, slippagePercent } = params;
   const sellAmount = isSell ? sellAmountAfterNetworkCosts : sellAmountBeforeNetworkCosts;
@@ -514,7 +571,7 @@ function suggestSlippageFromVolume(params) {
   if (slippagePercent < 0) {
     throw new Error("slippagePercent must be non-negative: " + slippagePercent);
   }
-  return (0, import_sdk_common7.applyPercentage)(sellAmount, slippagePercent);
+  return (0, import_sdk_common8.applyPercentage)(sellAmount, slippagePercent);
 }
 
 // src/suggestSlippageBps.ts
@@ -522,7 +579,13 @@ var MAX_SLIPPAGE_BPS = 1e4;
 var SLIPPAGE_FEE_MULTIPLIER_PERCENT = 50;
 var SLIPPAGE_VOLUME_MULTIPLIER_PERCENT = 0.5;
 function suggestSlippageBps(params) {
-  const { quote, tradeParameters, trader, isEthFlow } = params;
+  const {
+    quote,
+    tradeParameters,
+    trader,
+    isEthFlow,
+    volumeMultiplierPercent = SLIPPAGE_VOLUME_MULTIPLIER_PERCENT
+  } = params;
   const { sellTokenDecimals, buyTokenDecimals } = tradeParameters;
   const { isSell, sellAmountBeforeNetworkCosts, sellAmountAfterNetworkCosts } = (0, import_sdk_order_book5.getQuoteAmountsWithCosts)({
     sellDecimals: sellTokenDecimals,
@@ -539,7 +602,7 @@ function suggestSlippageBps(params) {
     isSell,
     sellAmountBeforeNetworkCosts,
     sellAmountAfterNetworkCosts,
-    slippagePercent: SLIPPAGE_VOLUME_MULTIPLIER_PERCENT
+    slippagePercent: volumeMultiplierPercent
   });
   const totalSlippageBps = slippageBpsFromFee + slippageBpsFromVolume;
   const slippagePercent = getSlippagePercent({
@@ -548,13 +611,57 @@ function suggestSlippageBps(params) {
     sellAmountAfterNetworkCosts,
     slippage: totalSlippageBps
   });
-  const slippageBps = (0, import_sdk_common8.percentageToBps)(slippagePercent);
-  return Math.max(Math.min(slippageBps, MAX_SLIPPAGE_BPS), getDefaultSlippageBps(trader.chainId, isEthFlow));
+  const slippageBps = (0, import_sdk_common9.percentageToBps)(slippagePercent);
+  const lowerCap = isEthFlow ? ETH_FLOW_DEFAULT_SLIPPAGE_BPS[trader.chainId] : 0;
+  return Math.max(Math.min(slippageBps, MAX_SLIPPAGE_BPS), lowerCap);
+}
+
+// src/resolveSlippageSuggestion.ts
+async function resolveSlippageSuggestion(chainId, tradeParameters, trader, quote, isEthFlow, advancedSettings) {
+  const suggestSlippageParams = {
+    isEthFlow,
+    quote,
+    tradeParameters,
+    trader,
+    advancedSettings
+  };
+  const getSlippageSuggestion = advancedSettings?.getSlippageSuggestion;
+  const priceQuality = advancedSettings?.quoteRequest?.priceQuality ?? import_sdk_order_book6.PriceQuality.OPTIMAL;
+  const defaultSuggestion = suggestSlippageBps(suggestSlippageParams);
+  if (priceQuality === import_sdk_order_book6.PriceQuality.FAST || !getSlippageSuggestion) {
+    return { slippageBps: defaultSuggestion };
+  }
+  const amountsAndCosts = (0, import_sdk_order_book6.getQuoteAmountsAndCosts)({
+    orderParams: quote.quote,
+    slippagePercentBps: 0,
+    partnerFeeBps: getPartnerFeeBps(tradeParameters.partnerFee),
+    sellDecimals: tradeParameters.sellTokenDecimals,
+    buyDecimals: tradeParameters.buyTokenDecimals
+  });
+  try {
+    const suggestedSlippage = await getSlippageSuggestion({
+      chainId,
+      sellToken: tradeParameters.sellToken,
+      buyToken: tradeParameters.buyToken,
+      sellAmount: amountsAndCosts.afterSlippage.sellAmount,
+      buyAmount: amountsAndCosts.afterSlippage.buyAmount
+    });
+    const suggestedSlippageBps = suggestedSlippage.slippageBps;
+    return {
+      slippageBps: suggestedSlippageBps ? suggestSlippageBps({
+        ...suggestSlippageParams,
+        volumeMultiplierPercent: (0, import_sdk_common10.bpsToPercentage)(suggestedSlippageBps)
+      }) : defaultSuggestion
+    };
+  } catch (e) {
+    (0, import_sdk_common10.log)(`getSlippageSuggestion() error: ${e.message || String(e)}`);
+    return { slippageBps: defaultSuggestion };
+  }
 }
 
 // src/getQuote.ts
 var ETH_FLOW_AUX_QUOTE_PARAMS = {
-  signingScheme: import_sdk_order_book6.SigningScheme.EIP1271,
+  signingScheme: import_sdk_order_book7.SigningScheme.EIP1271,
   onchainOrder: true,
   // Ethflow orders are subsidized in the backend.
   // This means we can assume the verification gas costs are zero for the quote/fee estimation
@@ -570,17 +677,22 @@ async function getQuoteRaw(_tradeParameters, trader, advancedSettings, _orderBoo
     amount,
     kind,
     partnerFee,
-    validFor = DEFAULT_QUOTE_VALIDITY,
+    validFor,
+    validTo,
     slippageBps,
     env = "prod"
   } = tradeParameters;
-  (0, import_sdk_common9.log)(
+  if (validTo !== void 0 && validFor !== void 0) {
+    throw new Error("Cannot specify both validFor and validTo. Use validFor for relative time or validTo for absolute time.");
+  }
+  const effectiveValidFor = validFor ?? DEFAULT_QUOTE_VALIDITY;
+  (0, import_sdk_common11.log)(
     `getQuote for: Swap ${amount} ${sellToken} for ${buyToken} on chain ${chainId} with ${slippageBps !== void 0 ? `${slippageBps} BPS` : "AUTO"} slippage`
   );
-  const orderBookApi = _orderBookApi || new import_sdk_order_book6.OrderBookApi({ chainId, env });
+  const orderBookApi = _orderBookApi || new import_sdk_order_book7.OrderBookApi({ chainId, env });
   const receiver = tradeParameters.receiver || from;
   const isSell = kind === "sell";
-  (0, import_sdk_common9.log)("Building app data...");
+  (0, import_sdk_common11.log)("Building app data...");
   const defaultSlippageBps = getDefaultSlippageBps(chainId, isEthFlow);
   const slippageBpsOrDefault = slippageBps ?? defaultSlippageBps;
   const buildAppDataParams = {
@@ -591,40 +703,41 @@ async function getQuoteRaw(_tradeParameters, trader, advancedSettings, _orderBoo
   };
   const appDataInfo = await buildAppData(buildAppDataParams, advancedSettings?.appData);
   const { appDataKeccak256, fullAppData } = appDataInfo;
-  (0, import_sdk_common9.log)(`App data: appDataKeccak256=${appDataKeccak256} fullAppData=${fullAppData}`);
+  (0, import_sdk_common11.log)(`App data: appDataKeccak256=${appDataKeccak256} fullAppData=${fullAppData}`);
   const quoteRequest = {
     from,
     sellToken,
     buyToken,
     receiver,
-    validFor,
+    ...validTo !== void 0 ? { validTo } : { validFor: effectiveValidFor },
     appData: fullAppData,
     appDataHash: appDataKeccak256,
-    priceQuality: import_sdk_order_book6.PriceQuality.OPTIMAL,
+    priceQuality: import_sdk_order_book7.PriceQuality.OPTIMAL,
     // Do not change this parameter because we rely on the fact that quote has id
-    signingScheme: import_sdk_order_book6.SigningScheme.EIP712,
+    signingScheme: import_sdk_order_book7.SigningScheme.EIP712,
     ...isEthFlow ? ETH_FLOW_AUX_QUOTE_PARAMS : {},
-    ...isSell ? { kind: import_sdk_order_book6.OrderQuoteSideKindSell.SELL, sellAmountBeforeFee: amount } : { kind: import_sdk_order_book6.OrderQuoteSideKindBuy.BUY, buyAmountAfterFee: amount },
+    ...isSell ? { kind: import_sdk_order_book7.OrderQuoteSideKindSell.SELL, sellAmountBeforeFee: amount } : { kind: import_sdk_order_book7.OrderQuoteSideKindBuy.BUY, buyAmountAfterFee: amount },
     ...advancedSettings?.quoteRequest
   };
-  (0, import_sdk_common9.log)("Getting quote...");
+  (0, import_sdk_common11.log)("Getting quote...");
   const quote = await orderBookApi.getQuote(quoteRequest);
-  const suggestedSlippageBps = suggestSlippageBps({
-    isEthFlow,
-    quote,
+  const { slippageBps: suggestedSlippageBps } = await resolveSlippageSuggestion(
+    chainId,
     tradeParameters,
     trader,
+    quote,
+    isEthFlow,
     advancedSettings
-  });
+  );
   const commonResult = {
     isEthFlow,
     quote,
     orderBookApi,
-    suggestedSlippageBps
+    suggestedSlippageBps: suggestedSlippageBps || defaultSlippageBps
   };
   if (slippageBps === void 0) {
-    if (suggestedSlippageBps > defaultSlippageBps) {
-      (0, import_sdk_common9.log)(
+    if (suggestedSlippageBps) {
+      (0, import_sdk_common11.log)(
         `Suggested slippage is greater than ${defaultSlippageBps} BPS (default), using the suggested slippage (${suggestedSlippageBps} BPS)`
       );
       const newAppDataInfo = await buildAppData(
@@ -634,7 +747,7 @@ async function getQuoteRaw(_tradeParameters, trader, advancedSettings, _orderBoo
         },
         advancedSettings?.appData
       );
-      (0, import_sdk_common9.log)(
+      (0, import_sdk_common11.log)(
         `App data with new suggested slippage: appDataKeccak256=${newAppDataInfo.appDataKeccak256} fullAppData=${newAppDataInfo.fullAppData}`
       );
       return {
@@ -644,9 +757,7 @@ async function getQuoteRaw(_tradeParameters, trader, advancedSettings, _orderBoo
         slippageBps: suggestedSlippageBps
       };
     } else {
-      (0, import_sdk_common9.log)(
-        `Suggested slippage is only ${suggestedSlippageBps} BPS. Using the default slippage (${defaultSlippageBps} BPS)`
-      );
+      (0, import_sdk_common11.log)(`No suggested slippage. Using the default slippage (${defaultSlippageBps} BPS)`);
     }
   }
   return {
@@ -661,7 +772,7 @@ async function getQuote(_tradeParameters, trader, advancedSettings, _orderBookAp
   const { quote, orderBookApi, tradeParameters, slippageBps, suggestedSlippageBps, appDataInfo, isEthFlow } = await getQuoteRaw(_tradeParameters, trader, advancedSettings, _orderBookApi);
   const { partnerFee, sellTokenDecimals, buyTokenDecimals } = tradeParameters;
   const { chainId, account: from } = trader;
-  const amountsAndCosts = (0, import_sdk_order_book6.getQuoteAmountsAndCosts)({
+  const amountsAndCosts = (0, import_sdk_order_book7.getQuoteAmountsAndCosts)({
     orderParams: quote.quote,
     slippagePercentBps: slippageBps,
     partnerFeeBps: getPartnerFeeBps(partnerFee),
@@ -688,7 +799,7 @@ async function getQuote(_tradeParameters, trader, advancedSettings, _orderBookAp
   };
 }
 async function getTrader(swapParameters) {
-  const signer = (0, import_sdk_common9.getGlobalAdapter)().signerOrNull();
+  const signer = (0, import_sdk_common11.getGlobalAdapter)().signerOrNull();
   const account = swapParameters.owner || await signer?.getAddress();
   return {
     chainId: swapParameters.chainId,
@@ -697,8 +808,7 @@ async function getTrader(swapParameters) {
   };
 }
 async function getQuoteWithSigner(swapParameters, advancedSettings, orderBookApi) {
-  const adapter = (0, import_sdk_common9.getGlobalAdapter)();
-  const signer = swapParameters.signer ? adapter.createSigner(swapParameters.signer) : adapter.signer;
+  const signer = resolveSigner(swapParameters.signer);
   const trader = await getTrader(swapParameters);
   const result = await getQuote(swapParameters, trader, advancedSettings, orderBookApi);
   return {
@@ -754,8 +864,8 @@ async function postSwapOrderFromQuote({
 }
 
 // src/postLimitOrder.ts
-var import_sdk_order_book7 = require("@cowprotocol/sdk-order-book");
-var import_sdk_common10 = require("@cowprotocol/sdk-common");
+var import_sdk_order_book8 = require("@cowprotocol/sdk-order-book");
+var import_sdk_common12 = require("@cowprotocol/sdk-common");
 async function postLimitOrder(params, advancedSettings, _orderBookApi) {
   const appDataSlippage = advancedSettings?.appData?.metadata?.quote?.slippageBips;
   const partnerFeeOverride = advancedSettings?.appData?.metadata?.partnerFee;
@@ -772,9 +882,9 @@ async function postLimitOrder(params, advancedSettings, _orderBookApi) {
     params.env = "prod";
   }
   const { appCode, chainId, sellToken, buyToken, sellAmount, buyAmount, partnerFee } = params;
-  (0, import_sdk_common10.log)(`Limit order ${sellAmount} ${sellToken} for ${buyAmount} ${buyToken} on chain ${chainId}`);
-  const orderBookApi = _orderBookApi || new import_sdk_order_book7.OrderBookApi({ chainId, env: params.env });
-  (0, import_sdk_common10.log)("Building app data...");
+  (0, import_sdk_common12.log)(`Limit order ${sellAmount} ${sellToken} for ${buyAmount} ${buyToken} on chain ${chainId}`);
+  const orderBookApi = _orderBookApi || new import_sdk_order_book8.OrderBookApi({ chainId, env: params.env });
+  (0, import_sdk_common12.log)("Building app data...");
   const appDataInfo = await buildAppData(
     {
       slippageBps: params.slippageBps,
@@ -787,35 +897,109 @@ async function postLimitOrder(params, advancedSettings, _orderBookApi) {
   return postCoWProtocolTrade(orderBookApi, appDataInfo, params, advancedSettings?.additionalParams, params.signer);
 }
 
-// src/getPreSignTransaction.ts
+// src/getSettlementContract.ts
+var import_sdk_common13 = require("@cowprotocol/sdk-common");
 var import_sdk_config5 = require("@cowprotocol/sdk-config");
-var import_sdk_common11 = require("@cowprotocol/sdk-common");
-async function getPreSignTransaction(signer, chainId, account, orderId) {
-  const contract = import_sdk_common11.ContractFactory.createSettlementContract(account, signer);
-  const settlementContractAddress = import_sdk_config5.COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS[chainId];
+function getSettlementContract(chainId, signer) {
+  return import_sdk_common13.ContractFactory.createSettlementContract(import_sdk_config5.COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS[chainId], signer);
+}
+
+// src/getPreSignTransaction.ts
+async function getPreSignTransaction(signer, chainId, orderId) {
+  const contract = getSettlementContract(chainId, signer);
   const preSignatureCall = contract.interface.encodeFunctionData("setPreSignature", [orderId, true]);
   const gas = await contract.estimateGas.setPreSignature?.(orderId, true).catch(() => GAS_LIMIT_DEFAULT) || GAS_LIMIT_DEFAULT;
   return {
     data: preSignatureCall,
     gasLimit: "0x" + calculateGasMargin(gas).toString(16),
-    to: settlementContractAddress,
-    // Para onde enviar a transação
+    to: contract.address,
     value: "0"
   };
 }
 
 // src/tradingSdk.ts
-var import_sdk_common12 = require("@cowprotocol/sdk-common");
-var import_sdk_common13 = require("@cowprotocol/sdk-common");
+var import_sdk_common14 = require("@cowprotocol/sdk-common");
+var import_sdk_order_signing4 = require("@cowprotocol/sdk-order-signing");
+
+// src/onChainCancellation.ts
+var CANCELLATION_GAS_LIMIT_DEFAULT = 150000n;
+async function getEthFlowCancellation(ethFlowContract, order) {
+  const cancelOrderParams = {
+    buyToken: order.buyToken,
+    receiver: order.receiver || order.owner,
+    sellAmount: order.sellAmount,
+    buyAmount: order.buyAmount,
+    appData: order.appData.toString(),
+    feeAmount: order.feeAmount,
+    validTo: order.validTo.toString(),
+    partiallyFillable: false,
+    quoteId: 0
+    // value doesn't matter, set to 0 for reducing gas costs
+  };
+  return getOnChainCancellation(ethFlowContract, cancelOrderParams);
+}
+async function getSettlementCancellation(settlementContract, order) {
+  const cancelOrderParams = order.uid;
+  return getOnChainCancellation(settlementContract, cancelOrderParams);
+}
+async function getOnChainCancellation(contract, cancelOrderParams) {
+  const estimatedGas = await (async () => {
+    try {
+      if (contract.estimateGas.invalidateOrder) {
+        const estimated = await contract.estimateGas.invalidateOrder(cancelOrderParams);
+        return BigInt(estimated.toHexString ? estimated.toHexString() : `0x${estimated.toString(16)}`);
+      }
+      return CANCELLATION_GAS_LIMIT_DEFAULT;
+    } catch (error) {
+      console.error(error);
+      return CANCELLATION_GAS_LIMIT_DEFAULT;
+    }
+  })();
+  const data = contract.interface.encodeFunctionData("invalidateOrder", [cancelOrderParams]);
+  return {
+    estimatedGas,
+    transaction: {
+      data,
+      gasLimit: "0x" + estimatedGas.toString(16),
+      to: contract.address,
+      value: "0x0"
+    }
+  };
+}
+
+// src/utils/resolveOrderBookApi.ts
+var import_sdk_order_book9 = require("@cowprotocol/sdk-order-book");
+var orderBookApiCache = /* @__PURE__ */ new Map([
+  ["prod", /* @__PURE__ */ new Map()],
+  ["staging", /* @__PURE__ */ new Map()]
+]);
+function resolveOrderBookApi(chainId, env, existingOrderBookApi) {
+  if (existingOrderBookApi) {
+    existingOrderBookApi.context.chainId = chainId;
+    existingOrderBookApi.context.env = env;
+    return existingOrderBookApi;
+  }
+  const envCache = orderBookApiCache.get(env) ?? /* @__PURE__ */ new Map();
+  const cached = envCache.get(chainId);
+  if (cached)
+    return cached;
+  const orderBookApi = new import_sdk_order_book9.OrderBookApi({ chainId, env });
+  envCache.set(chainId, orderBookApi);
+  orderBookApiCache.set(env, envCache);
+  return orderBookApi;
+}
+
+// src/tradingSdk.ts
+var import_sdk_config6 = require("@cowprotocol/sdk-config");
 var TradingSdk = class {
   constructor(traderParams = {}, options = {}, adapter) {
     this.traderParams = traderParams;
     this.options = options;
     if (options.enableLogging !== void 0) {
-      (0, import_sdk_common12.enableLogging)(options.enableLogging);
+      (0, import_sdk_common14.enableLogging)(options.enableLogging);
     }
     if (adapter) {
-      (0, import_sdk_common13.setGlobalAdapter)(adapter);
+      (0, import_sdk_common14.setGlobalAdapter)(adapter);
     }
   }
   setTraderParams(params) {
@@ -847,7 +1031,7 @@ var TradingSdk = class {
               }),
               // It's important to get a fresh instance of the signer
               // Because quote might be called with another signer
-              signer: (0, import_sdk_common12.getGlobalAdapter)().signer
+              signer: (0, import_sdk_common14.getGlobalAdapter)().signer
             }
           },
           advancedSettings2
@@ -908,16 +1092,123 @@ var TradingSdk = class {
     );
   }
   async getPreSignTransaction(params) {
-    const adapter = (0, import_sdk_common12.getGlobalAdapter)();
     const traderParams = this.mergeParams(params);
-    const signer = traderParams.signer ? adapter.createSigner(traderParams.signer) : adapter.signer;
-    return getPreSignTransaction(signer, traderParams.chainId, params.account, params.orderId);
+    const signer = resolveSigner(traderParams.signer);
+    return getPreSignTransaction(signer, traderParams.chainId, params.orderUid);
+  }
+  async getOrder(params) {
+    const orderBookApi = this.resolveOrderBookApi(params);
+    return orderBookApi.getOrder(params.orderUid);
+  }
+  async offChainCancelOrder(params) {
+    const orderBookApi = this.resolveOrderBookApi(params);
+    const signer = resolveSigner(params.signer);
+    const { orderUid } = params;
+    const chainId = params.chainId || this.traderParams.chainId;
+    if (!chainId) {
+      throw new Error("Chain ID is missing in offChainCancelOrder() call");
+    }
+    const orderCancellationSigning = await import_sdk_order_signing4.OrderSigningUtils.signOrderCancellations([orderUid], chainId, signer);
+    await orderBookApi.sendSignedOrderCancellations({
+      ...orderCancellationSigning,
+      orderUids: [orderUid]
+    });
+    return true;
+  }
+  async onChainCancelOrder(params, _order) {
+    const chainId = params.chainId || this.traderParams.chainId;
+    if (!chainId) {
+      throw new Error("Chain ID is missing in offChainCancelOrder() call");
+    }
+    const order = _order ?? await this.getOrder(params);
+    const isEthFlowOrder = !!order.onchainOrderData;
+    const signer = params.signer ? (0, import_sdk_common14.getGlobalAdapter)().createSigner(params.signer) : (0, import_sdk_common14.getGlobalAdapter)().signer;
+    const { transaction } = await (isEthFlowOrder ? getEthFlowCancellation(getEthFlowContract(signer, chainId, params.env ?? this.traderParams.env), order) : getSettlementCancellation(getSettlementContract(chainId, signer), order));
+    const txReceipt = await signer.sendTransaction(transaction);
+    return txReceipt.hash;
+  }
+  /**
+   * Checks the current allowance for the CoW Protocol Vault Relayer to spend an ERC-20 token.
+   *
+   * @param params - Parameters including token address and owner address
+   * @returns Promise resolving to the current allowance amount as a bigint
+   *
+   * @example
+   * ```typescript
+   * const params = {
+   *   tokenAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+   *   owner: '0x123...',
+   *   chainId: 1,
+   * }
+   *
+   * const allowance = await sdk.getCowProtocolAllowance(params)
+   * console.log('Current allowance:', allowance.toString())
+   * ```
+   */
+  async getCowProtocolAllowance(params) {
+    const chainId = params.chainId || this.traderParams.chainId;
+    if (!chainId) {
+      throw new Error("Chain ID is missing in getCowProtocolAllowance() call");
+    }
+    const adapter = (0, import_sdk_common14.getGlobalAdapter)();
+    const vaultRelayerAddress = import_sdk_config6.COW_PROTOCOL_VAULT_RELAYER_ADDRESS[chainId];
+    return await adapter.readContract({
+      address: params.tokenAddress,
+      abi: ERC20_ALLOWANCE_ABI,
+      functionName: "allowance",
+      args: [params.owner, vaultRelayerAddress]
+    });
+  }
+  /**
+   * Approves the CoW Protocol Vault Relayer to spend a specified amount of an ERC-20 token.
+   * This method creates an on-chain approval transaction.
+   *
+   * @param params - Parameters including token address and amount to approve
+   * @returns Promise resolving to the transaction hash of the approval transaction
+   *
+   * @example
+   * ```typescript
+   * const params = {
+   *   tokenAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+   *   amount: '1000000000', // 1000 USDC (6 decimals)
+   *   chainId: 1,
+   * }
+   *
+   * const txHash = await sdk.approveCowProtocol(params)
+   * console.log('Approval transaction:', txHash)
+   * ```
+   */
+  async approveCowProtocol(params) {
+    const chainId = params.chainId || this.traderParams.chainId;
+    if (!chainId) {
+      throw new Error("Chain ID is missing in approveCowProtocol() call");
+    }
+    const adapter = (0, import_sdk_common14.getGlobalAdapter)();
+    const signer = resolveSigner(params.signer);
+    const vaultRelayerAddress = import_sdk_config6.COW_PROTOCOL_VAULT_RELAYER_ADDRESS[chainId];
+    const txParams = {
+      to: params.tokenAddress,
+      data: adapter.utils.encodeFunction(ERC20_APPROVE_ABI, "approve", [
+        vaultRelayerAddress,
+        "0x" + params.amount.toString(16)
+      ])
+    };
+    const txReceipt = await signer.sendTransaction(txParams);
+    return txReceipt.hash;
+  }
+  resolveOrderBookApi(params) {
+    const chainId = params.chainId ?? this.traderParams.chainId;
+    const env = params.env ?? this.traderParams.env ?? "prod";
+    if (!chainId) {
+      throw new Error("Chain ID is missing in getOrder() call");
+    }
+    return resolveOrderBookApi(chainId, env);
   }
   mergeParams(params) {
     const { chainId, signer, appCode, env } = params;
     const traderParams = {
       chainId: chainId || this.traderParams.chainId,
-      signer: signer || this.traderParams.signer || (0, import_sdk_common12.getGlobalAdapter)().signer,
+      signer: signer || this.traderParams.signer || (0, import_sdk_common14.getGlobalAdapter)().signer,
       appCode: appCode || this.traderParams.appCode,
       env: env || this.traderParams.env
     };