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

package/dist/index.mjs

@@ -3,20 +3,65 @@ import { SigningScheme as SigningScheme3 } from "@cowprotocol/sdk-order-book";
 
 // src/consts.ts
 import { EcdsaSigningScheme, SigningScheme } from "@cowprotocol/sdk-order-book";
-import { mapSupportedNetworks, SupportedChainId } from "@cowprotocol/sdk-config";
+import { mapSupportedNetworks } from "@cowprotocol/sdk-config";
 var DEFAULT_QUOTE_VALIDITY = 60 * 30;
 var DEFAULT_SLIPPAGE_BPS = 50;
-var ETH_FLOW_DEFAULT_SLIPPAGE_BPS = {
-  ...mapSupportedNetworks(DEFAULT_SLIPPAGE_BPS),
-  // 0.5% by default for most chains
-  [SupportedChainId.MAINNET]: 200
-  // 2% for mainnet
-};
+var ETH_FLOW_DEFAULT_SLIPPAGE_BPS = mapSupportedNetworks(DEFAULT_SLIPPAGE_BPS);
 var SIGN_SCHEME_MAP = {
   [EcdsaSigningScheme.EIP712]: SigningScheme.EIP712,
   [EcdsaSigningScheme.ETHSIGN]: 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
 import { OrderSigningUtils as OrderSigningUtils2 } from "@cowprotocol/sdk-order-signing";
@@ -320,10 +365,18 @@ async function postSellNativeCurrencyOrder(orderBookApi, appData, _params, addit
 }
 
 // src/postCoWProtocolTrade.ts
-import { getGlobalAdapter as getGlobalAdapter3, log as log2 } from "@cowprotocol/sdk-common";
-async function postCoWProtocolTrade(orderBookApi, appData, params, additionalParams = {}, paramSigner) {
+import { log as log2 } from "@cowprotocol/sdk-common";
+
+// src/utils/resolveSigner.ts
+import { getGlobalAdapter as getGlobalAdapter3 } from "@cowprotocol/sdk-common";
+function resolveSigner(signer) {
   const adapter = getGlobalAdapter3();
-  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 = SigningScheme3.EIP712 } = additionalParams;
   const isEthFlow = getIsEthFlowOrder(params);
   if (isEthFlow) {
@@ -364,13 +417,13 @@ async function postCoWProtocolTrade(orderBookApi, appData, params, additionalPar
 }
 
 // src/getQuote.ts
-import { getGlobalAdapter as getGlobalAdapter5, log as log3 } from "@cowprotocol/sdk-common";
+import { getGlobalAdapter as getGlobalAdapter5, log as log4 } from "@cowprotocol/sdk-common";
 import {
-  getQuoteAmountsAndCosts as getQuoteAmountsAndCosts2,
+  getQuoteAmountsAndCosts as getQuoteAmountsAndCosts3,
   OrderBookApi as OrderBookApi3,
   OrderQuoteSideKindBuy,
   OrderQuoteSideKindSell,
-  PriceQuality,
+  PriceQuality as PriceQuality2,
   SigningScheme as SigningScheme4
 } from "@cowprotocol/sdk-order-book";
 
@@ -451,6 +504,10 @@ async function getOrderTypedData(chainId, orderToSign) {
   };
 }
 
+// src/resolveSlippageSuggestion.ts
+import { bpsToPercentage, log as log3 } from "@cowprotocol/sdk-common";
+import { getQuoteAmountsAndCosts as getQuoteAmountsAndCosts2, PriceQuality } from "@cowprotocol/sdk-order-book";
+
 // src/suggestSlippageBps.ts
 import { percentageToBps } from "@cowprotocol/sdk-common";
 import { getQuoteAmountsWithCosts } from "@cowprotocol/sdk-order-book";
@@ -487,7 +544,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 } = getQuoteAmountsWithCosts({
     sellDecimals: sellTokenDecimals,
@@ -504,7 +567,7 @@ function suggestSlippageBps(params) {
     isSell,
     sellAmountBeforeNetworkCosts,
     sellAmountAfterNetworkCosts,
-    slippagePercent: SLIPPAGE_VOLUME_MULTIPLIER_PERCENT
+    slippagePercent: volumeMultiplierPercent
   });
   const totalSlippageBps = slippageBpsFromFee + slippageBpsFromVolume;
   const slippagePercent = getSlippagePercent({
@@ -514,7 +577,51 @@ function suggestSlippageBps(params) {
     slippage: totalSlippageBps
   });
   const slippageBps = percentageToBps(slippagePercent);
-  return Math.max(Math.min(slippageBps, MAX_SLIPPAGE_BPS), getDefaultSlippageBps(trader.chainId, isEthFlow));
+  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 ?? PriceQuality.OPTIMAL;
+  const defaultSuggestion = suggestSlippageBps(suggestSlippageParams);
+  if (priceQuality === PriceQuality.FAST || !getSlippageSuggestion) {
+    return { slippageBps: defaultSuggestion };
+  }
+  const amountsAndCosts = getQuoteAmountsAndCosts2({
+    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: bpsToPercentage(suggestedSlippageBps)
+      }) : defaultSuggestion
+    };
+  } catch (e) {
+    log3(`getSlippageSuggestion() error: ${e.message || String(e)}`);
+    return { slippageBps: defaultSuggestion };
+  }
 }
 
 // src/getQuote.ts
@@ -535,17 +642,22 @@ async function getQuoteRaw(_tradeParameters, trader, advancedSettings, _orderBoo
     amount,
     kind,
     partnerFee,
-    validFor = DEFAULT_QUOTE_VALIDITY,
+    validFor,
+    validTo,
     slippageBps,
     env = "prod"
   } = tradeParameters;
-  log3(
+  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;
+  log4(
     `getQuote for: Swap ${amount} ${sellToken} for ${buyToken} on chain ${chainId} with ${slippageBps !== void 0 ? `${slippageBps} BPS` : "AUTO"} slippage`
   );
   const orderBookApi = _orderBookApi || new OrderBookApi3({ chainId, env });
   const receiver = tradeParameters.receiver || from;
   const isSell = kind === "sell";
-  log3("Building app data...");
+  log4("Building app data...");
   const defaultSlippageBps = getDefaultSlippageBps(chainId, isEthFlow);
   const slippageBpsOrDefault = slippageBps ?? defaultSlippageBps;
   const buildAppDataParams = {
@@ -556,40 +668,41 @@ async function getQuoteRaw(_tradeParameters, trader, advancedSettings, _orderBoo
   };
   const appDataInfo = await buildAppData(buildAppDataParams, advancedSettings?.appData);
   const { appDataKeccak256, fullAppData } = appDataInfo;
-  log3(`App data: appDataKeccak256=${appDataKeccak256} fullAppData=${fullAppData}`);
+  log4(`App data: appDataKeccak256=${appDataKeccak256} fullAppData=${fullAppData}`);
   const quoteRequest = {
     from,
     sellToken,
     buyToken,
     receiver,
-    validFor,
+    ...validTo !== void 0 ? { validTo } : { validFor: effectiveValidFor },
     appData: fullAppData,
     appDataHash: appDataKeccak256,
-    priceQuality: PriceQuality.OPTIMAL,
+    priceQuality: PriceQuality2.OPTIMAL,
     // Do not change this parameter because we rely on the fact that quote has id
     signingScheme: SigningScheme4.EIP712,
     ...isEthFlow ? ETH_FLOW_AUX_QUOTE_PARAMS : {},
     ...isSell ? { kind: OrderQuoteSideKindSell.SELL, sellAmountBeforeFee: amount } : { kind: OrderQuoteSideKindBuy.BUY, buyAmountAfterFee: amount },
     ...advancedSettings?.quoteRequest
   };
-  log3("Getting quote...");
+  log4("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) {
-      log3(
+    if (suggestedSlippageBps) {
+      log4(
         `Suggested slippage is greater than ${defaultSlippageBps} BPS (default), using the suggested slippage (${suggestedSlippageBps} BPS)`
       );
       const newAppDataInfo = await buildAppData(
@@ -599,7 +712,7 @@ async function getQuoteRaw(_tradeParameters, trader, advancedSettings, _orderBoo
         },
         advancedSettings?.appData
       );
-      log3(
+      log4(
         `App data with new suggested slippage: appDataKeccak256=${newAppDataInfo.appDataKeccak256} fullAppData=${newAppDataInfo.fullAppData}`
       );
       return {
@@ -609,9 +722,7 @@ async function getQuoteRaw(_tradeParameters, trader, advancedSettings, _orderBoo
         slippageBps: suggestedSlippageBps
       };
     } else {
-      log3(
-        `Suggested slippage is only ${suggestedSlippageBps} BPS. Using the default slippage (${defaultSlippageBps} BPS)`
-      );
+      log4(`No suggested slippage. Using the default slippage (${defaultSlippageBps} BPS)`);
     }
   }
   return {
@@ -626,7 +737,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 = getQuoteAmountsAndCosts2({
+  const amountsAndCosts = getQuoteAmountsAndCosts3({
     orderParams: quote.quote,
     slippagePercentBps: slippageBps,
     partnerFeeBps: getPartnerFeeBps(partnerFee),
@@ -662,8 +773,7 @@ async function getTrader(swapParameters) {
   };
 }
 async function getQuoteWithSigner(swapParameters, advancedSettings, orderBookApi) {
-  const adapter = getGlobalAdapter5();
-  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 {
@@ -720,7 +830,7 @@ async function postSwapOrderFromQuote({
 
 // src/postLimitOrder.ts
 import { OrderBookApi as OrderBookApi4 } from "@cowprotocol/sdk-order-book";
-import { log as log4 } from "@cowprotocol/sdk-common";
+import { log as log5 } from "@cowprotocol/sdk-common";
 async function postLimitOrder(params, advancedSettings, _orderBookApi) {
   const appDataSlippage = advancedSettings?.appData?.metadata?.quote?.slippageBips;
   const partnerFeeOverride = advancedSettings?.appData?.metadata?.partnerFee;
@@ -737,9 +847,9 @@ async function postLimitOrder(params, advancedSettings, _orderBookApi) {
     params.env = "prod";
   }
   const { appCode, chainId, sellToken, buyToken, sellAmount, buyAmount, partnerFee } = params;
-  log4(`Limit order ${sellAmount} ${sellToken} for ${buyAmount} ${buyToken} on chain ${chainId}`);
+  log5(`Limit order ${sellAmount} ${sellToken} for ${buyAmount} ${buyToken} on chain ${chainId}`);
   const orderBookApi = _orderBookApi || new OrderBookApi4({ chainId, env: params.env });
-  log4("Building app data...");
+  log5("Building app data...");
   const appDataInfo = await buildAppData(
     {
       slippageBps: params.slippageBps,
@@ -752,26 +862,100 @@ async function postLimitOrder(params, advancedSettings, _orderBookApi) {
   return postCoWProtocolTrade(orderBookApi, appDataInfo, params, advancedSettings?.additionalParams, params.signer);
 }
 
-// src/getPreSignTransaction.ts
-import { COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS } from "@cowprotocol/sdk-config";
+// src/getSettlementContract.ts
 import { ContractFactory as ContractFactory2 } from "@cowprotocol/sdk-common";
-async function getPreSignTransaction(signer, chainId, account, orderId) {
-  const contract = ContractFactory2.createSettlementContract(account, signer);
-  const settlementContractAddress = COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS[chainId];
+import { COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS } from "@cowprotocol/sdk-config";
+function getSettlementContract(chainId, signer) {
+  return ContractFactory2.createSettlementContract(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
-import { enableLogging, getGlobalAdapter as getGlobalAdapter6 } from "@cowprotocol/sdk-common";
-import { setGlobalAdapter } from "@cowprotocol/sdk-common";
+import { enableLogging, getGlobalAdapter as getGlobalAdapter6, setGlobalAdapter } from "@cowprotocol/sdk-common";
+import { OrderSigningUtils as OrderSigningUtils4 } from "@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
+import { OrderBookApi as OrderBookApi5 } from "@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 OrderBookApi5({ chainId, env });
+  envCache.set(chainId, orderBookApi);
+  orderBookApiCache.set(env, envCache);
+  return orderBookApi;
+}
+
+// src/tradingSdk.ts
+import { COW_PROTOCOL_VAULT_RELAYER_ADDRESS } from "@cowprotocol/sdk-config";
 var TradingSdk = class {
   constructor(traderParams = {}, options = {}, adapter) {
     this.traderParams = traderParams;
@@ -873,10 +1057,117 @@ var TradingSdk = class {
     );
   }
   async getPreSignTransaction(params) {
-    const adapter = getGlobalAdapter6();
     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 OrderSigningUtils4.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 ? getGlobalAdapter6().createSigner(params.signer) : getGlobalAdapter6().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 = getGlobalAdapter6();
+    const vaultRelayerAddress = 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 = getGlobalAdapter6();
+    const signer = resolveSigner(params.signer);
+    const vaultRelayerAddress = 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cowprotocol/sdk-trading",
-  "version": "0.3.2-beta.0",
+  "version": "0.4.0",
   "description": "CowProtocol trading",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -29,18 +29,18 @@
     "ts-jest": "^29.0.0",
     "tsx": "^4.19.4",
     "@cow-sdk/typescript-config": "0.0.0-beta.0",
-    "@cowprotocol/sdk-ethers-v5-adapter": "0.2.5-beta.0",
-    "@cowprotocol/sdk-ethers-v6-adapter": "0.2.5-beta.0",
-    "@cowprotocol/sdk-viem-adapter": "0.3.1-beta.0"
+    "@cowprotocol/sdk-ethers-v5-adapter": "0.1.2",
+    "@cowprotocol/sdk-ethers-v6-adapter": "0.1.2",
+    "@cowprotocol/sdk-viem-adapter": "0.1.2"
   },
   "dependencies": {
     "deepmerge": "^4.3.1",
-    "@cowprotocol/sdk-common": "0.5.0-beta.0",
-    "@cowprotocol/sdk-config": "0.3.3-beta.0",
-    "@cowprotocol/sdk-app-data": "4.1.7-beta.0",
-    "@cowprotocol/sdk-order-book": "0.3.1-beta.0",
-    "@cowprotocol/sdk-contracts-ts": "2.3.0-beta.0",
-    "@cowprotocol/sdk-order-signing": "0.2.8-beta.0"
+    "@cowprotocol/sdk-common": "0.2.1",
+    "@cowprotocol/sdk-config": "0.1.0",
+    "@cowprotocol/sdk-order-signing": "0.1.6",
+    "@cowprotocol/sdk-order-book": "0.1.2",
+    "@cowprotocol/sdk-contracts-ts": "0.4.0",
+    "@cowprotocol/sdk-app-data": "4.1.2"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",