@cowprotocol/sdk-trading 0.1.0-monorepo.0

package/dist/index.mjs

@@ -0,0 +1,1025 @@
+// src/postCoWProtocolTrade.ts
+import { SigningScheme as SigningScheme3 } from "@cowprotocol/sdk-order-book";
+
+// src/consts.ts
+import { EcdsaSigningScheme, SigningScheme } from "@cowprotocol/sdk-order-book";
+import { SupportedChainId } from "@cowprotocol/sdk-config";
+var DEFAULT_QUOTE_VALIDITY = 60 * 30;
+var DEFAULT_SLIPPAGE_BPS = 50;
+var ETH_FLOW_DEFAULT_SLIPPAGE_BPS = {
+  [SupportedChainId.MAINNET]: 200,
+  // 2%,
+  [SupportedChainId.ARBITRUM_ONE]: 50,
+  // 0.5%,
+  [SupportedChainId.BASE]: 50,
+  // 0.5%,
+  [SupportedChainId.GNOSIS_CHAIN]: 50,
+  // 0.5%,
+  [SupportedChainId.SEPOLIA]: 50,
+  // 0.5%,
+  [SupportedChainId.POLYGON]: 50,
+  // 0.5%,
+  [SupportedChainId.AVALANCHE]: 50
+  // 0.5%,
+};
+var SIGN_SCHEME_MAP = {
+  [EcdsaSigningScheme.EIP712]: SigningScheme.EIP712,
+  [EcdsaSigningScheme.ETHSIGN]: SigningScheme.ETHSIGN
+};
+var GAS_LIMIT_DEFAULT = BigInt(15e4);
+
+// src/postCoWProtocolTrade.ts
+import { OrderSigningUtils as OrderSigningUtils2 } from "@cowprotocol/sdk-order-signing";
+
+// src/getOrderToSign.ts
+import { BuyTokenDestination, getQuoteAmountsAndCosts, SellTokenSource } from "@cowprotocol/sdk-order-book";
+
+// src/utils/getPartnerFeeBps.ts
+function getPartnerFeeBps(partnerFee) {
+  if (!partnerFee) {
+    return void 0;
+  }
+  if ("volumeBps" in partnerFee) {
+    return partnerFee.volumeBps;
+  }
+  if (Array.isArray(partnerFee)) {
+    for (const fee of partnerFee) {
+      if ("volumeBps" in fee) {
+        return fee.volumeBps;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/getOrderToSign.ts
+function getOrderToSign({ from, networkCostsAmount = "0" }, limitOrderParams, appDataKeccak256) {
+  const {
+    sellAmount,
+    buyAmount,
+    sellToken,
+    sellTokenDecimals,
+    buyToken,
+    buyTokenDecimals,
+    kind,
+    partiallyFillable = false,
+    slippageBps = DEFAULT_SLIPPAGE_BPS,
+    partnerFee,
+    validFor
+  } = limitOrderParams;
+  const receiver = limitOrderParams.receiver || from;
+  const validTo = limitOrderParams.validTo || Math.floor(Date.now() / 1e3) + (validFor || DEFAULT_QUOTE_VALIDITY);
+  const orderParams = {
+    sellToken,
+    buyToken,
+    sellAmount,
+    buyAmount,
+    receiver,
+    validTo,
+    kind,
+    feeAmount: networkCostsAmount,
+    appData: appDataKeccak256,
+    partiallyFillable
+  };
+  const { afterSlippage } = getQuoteAmountsAndCosts({
+    orderParams,
+    slippagePercentBps: slippageBps,
+    partnerFeeBps: getPartnerFeeBps(partnerFee),
+    sellDecimals: sellTokenDecimals,
+    buyDecimals: buyTokenDecimals
+  });
+  return {
+    sellToken,
+    buyToken,
+    sellAmount: afterSlippage.sellAmount.toString(),
+    buyAmount: afterSlippage.buyAmount.toString(),
+    validTo,
+    kind,
+    partiallyFillable,
+    appData: appDataKeccak256,
+    receiver,
+    feeAmount: "0",
+    sellTokenBalance: SellTokenSource.ERC20,
+    buyTokenBalance: BuyTokenDestination.ERC20
+  };
+}
+
+// src/postSellNativeCurrencyOrder.ts
+import { getGlobalAdapter as getGlobalAdapter2 } from "@cowprotocol/sdk-common";
+import { SigningScheme as SigningScheme2 } from "@cowprotocol/sdk-order-book";
+
+// src/calculateUniqueOrderId.ts
+import { OrderSigningUtils } from "@cowprotocol/sdk-order-signing";
+import {
+  BARN_ETH_FLOW_ADDRESS,
+  ETH_FLOW_ADDRESS,
+  MAX_VALID_TO_EPOCH,
+  WRAPPED_NATIVE_CURRENCIES
+} from "@cowprotocol/sdk-config";
+async function calculateUniqueOrderId(chainId, order, checkEthFlowOrderExists, env) {
+  const { orderDigest, orderId } = await OrderSigningUtils.generateOrderId(
+    chainId,
+    {
+      ...order,
+      sellTokenBalance: order.sellTokenBalance,
+      buyTokenBalance: order.buyTokenBalance,
+      validTo: MAX_VALID_TO_EPOCH,
+      sellToken: WRAPPED_NATIVE_CURRENCIES[chainId].address
+    },
+    {
+      owner: env === "staging" ? BARN_ETH_FLOW_ADDRESS : ETH_FLOW_ADDRESS
+    }
+  );
+  if (checkEthFlowOrderExists && await checkEthFlowOrderExists(orderId, orderDigest)) {
+    console.error("ETH FLOW", "[calculateUniqueOrderId] \u274C Collision detected: " + orderId, {
+      sellAmount: order.sellAmount,
+      fee: order.feeAmount
+    });
+    return calculateUniqueOrderId(chainId, adjustAmounts(order), checkEthFlowOrderExists);
+  }
+  return orderId;
+}
+function adjustAmounts(order) {
+  const buyAmount = BigInt(order.buyAmount);
+  return { ...order, buyAmount: (buyAmount - BigInt(1)).toString() };
+}
+
+// src/getEthFlowTransaction.ts
+import { BARN_ETH_FLOW_ADDRESS as BARN_ETH_FLOW_ADDRESS2, ETH_FLOW_ADDRESS as ETH_FLOW_ADDRESS2 } from "@cowprotocol/sdk-config";
+
+// src/utils/misc.ts
+import { ETH_ADDRESS, WRAPPED_NATIVE_CURRENCIES as WRAPPED_NATIVE_CURRENCIES2 } from "@cowprotocol/sdk-config";
+function swapParamsToLimitOrderParams(params, quoteResponse) {
+  return {
+    ...params,
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    quoteId: quoteResponse.id,
+    sellAmount: quoteResponse.quote.sellAmount,
+    buyAmount: quoteResponse.quote.buyAmount
+  };
+}
+function getIsEthFlowOrder(params) {
+  return params.sellToken.toLowerCase() === ETH_ADDRESS.toLowerCase();
+}
+function calculateGasMargin(value) {
+  return value + value * BigInt(20) / BigInt(100);
+}
+function mapQuoteAmountsAndCosts(value, mapper) {
+  const {
+    costs: { networkFee, partnerFee }
+  } = value;
+  function serializeAmounts(value2) {
+    return {
+      sellAmount: mapper(value2.sellAmount),
+      buyAmount: mapper(value2.buyAmount)
+    };
+  }
+  return {
+    ...value,
+    costs: {
+      ...value.costs,
+      networkFee: {
+        ...networkFee,
+        amountInSellCurrency: mapper(networkFee.amountInSellCurrency),
+        amountInBuyCurrency: mapper(networkFee.amountInBuyCurrency)
+      },
+      partnerFee: {
+        ...partnerFee,
+        amount: mapper(partnerFee.amount)
+      }
+    },
+    beforeNetworkCosts: serializeAmounts(value.beforeNetworkCosts),
+    afterNetworkCosts: serializeAmounts(value.afterNetworkCosts),
+    afterPartnerFees: serializeAmounts(value.afterPartnerFees),
+    afterSlippage: serializeAmounts(value.afterSlippage)
+  };
+}
+function getTradeParametersAfterQuote({
+  quoteParameters,
+  sellToken
+}) {
+  return { ...quoteParameters, sellToken };
+}
+function adjustEthFlowOrderParams(chainId, params) {
+  return {
+    ...params,
+    sellToken: WRAPPED_NATIVE_CURRENCIES2[chainId].address,
+    slippageBps: typeof params.slippageBps === "number" ? params.slippageBps : ETH_FLOW_DEFAULT_SLIPPAGE_BPS[chainId]
+  };
+}
+
+// src/getEthFlowTransaction.ts
+import {
+  getGlobalAdapter,
+  ContractFactory
+} from "@cowprotocol/sdk-common";
+async function getEthFlowTransaction(appDataKeccak256, _params, chainId, additionalParams = {}, paramSigner) {
+  const signer = paramSigner ? getGlobalAdapter().createSigner(paramSigner) : getGlobalAdapter().signer;
+  const { networkCostsAmount = "0", checkEthFlowOrderExists } = additionalParams;
+  const from = await signer.getAddress();
+  const params = {
+    ..._params,
+    ...adjustEthFlowOrderParams(chainId, _params)
+  };
+  const { quoteId } = params;
+  const contract = getEthFlowContract(signer, params.env);
+  const orderToSign = getOrderToSign({ from, networkCostsAmount }, params, appDataKeccak256);
+  const orderId = await calculateUniqueOrderId(chainId, orderToSign, checkEthFlowOrderExists, params.env);
+  const ethOrderParams = {
+    buyToken: orderToSign.buyToken,
+    receiver: orderToSign.receiver,
+    sellAmount: orderToSign.sellAmount,
+    buyAmount: orderToSign.buyAmount,
+    feeAmount: orderToSign.feeAmount,
+    partiallyFillable: orderToSign.partiallyFillable,
+    quoteId,
+    appData: appDataKeccak256,
+    validTo: orderToSign.validTo.toString()
+  };
+  const estimatedGas = await contract.estimateGas.createOrder?.(ethOrderParams, { value: orderToSign.sellAmount }).catch((error) => {
+    console.error(error);
+    return GAS_LIMIT_DEFAULT;
+  }) || GAS_LIMIT_DEFAULT;
+  const data = contract.interface.encodeFunctionData("createOrder", [ethOrderParams]);
+  return {
+    orderId,
+    orderToSign,
+    transaction: {
+      data,
+      gasLimit: "0x" + calculateGasMargin(estimatedGas).toString(16),
+      to: contract.address,
+      value: "0x" + BigInt(orderToSign.sellAmount).toString(16)
+    }
+  };
+}
+function getEthFlowContract(signer, env) {
+  const address = env === "staging" ? BARN_ETH_FLOW_ADDRESS2 : ETH_FLOW_ADDRESS2;
+  return ContractFactory.createEthFlowContract(address, signer);
+}
+
+// src/postSellNativeCurrencyOrder.ts
+import { log } from "@cowprotocol/sdk-common";
+async function postSellNativeCurrencyOrder(orderBookApi, appData, _params, additionalParams = {}, paramSigner) {
+  const signer = paramSigner ? getGlobalAdapter2().createSigner(paramSigner) : getGlobalAdapter2().signer;
+  const { appDataKeccak256, fullAppData } = appData;
+  const { orderId, transaction, orderToSign } = await getEthFlowTransaction(
+    appDataKeccak256,
+    _params,
+    orderBookApi.context.chainId,
+    additionalParams,
+    signer
+  );
+  log("Uploading app-data");
+  await orderBookApi.uploadAppData(appDataKeccak256, fullAppData);
+  log("Sending on-chain order transaction");
+  const txReceipt = await signer.sendTransaction(transaction);
+  log(`On-chain order transaction sent, txHash: ${txReceipt.hash}, order: ${orderId}`);
+  return { txHash: txReceipt.hash, orderId, orderToSign, signature: "", signingScheme: SigningScheme2.EIP1271 };
+}
+
+// src/postCoWProtocolTrade.ts
+import { CowError, getGlobalAdapter as getGlobalAdapter4, log as log2 } from "@cowprotocol/sdk-common";
+
+// src/appDataUtils.ts
+import {
+  MetadataApi,
+  stringifyDeterministic
+} from "@cowprotocol/sdk-app-data";
+import { getGlobalAdapter as getGlobalAdapter3 } from "@cowprotocol/sdk-common";
+import deepmerge from "deepmerge";
+async function buildAppData({ slippageBps, appCode, orderClass: orderClassName, partnerFee }, advancedParams) {
+  const quoteParams = { slippageBips: slippageBps };
+  const orderClass = { orderClass: orderClassName };
+  const metadataApiSdk = new MetadataApi(getGlobalAdapter3());
+  const doc = await metadataApiSdk.generateAppDataDoc(
+    deepmerge(
+      {
+        appCode,
+        metadata: {
+          quote: quoteParams,
+          orderClass,
+          partnerFee
+        }
+      },
+      advancedParams || {}
+    )
+  );
+  const { fullAppData, appDataKeccak256 } = await generateAppDataFromDoc(doc);
+  return { doc, fullAppData, appDataKeccak256 };
+}
+async function generateAppDataFromDoc(doc) {
+  const adapter = getGlobalAdapter3();
+  const fullAppData = await stringifyDeterministic(doc);
+  const appDataKeccak256 = adapter.utils.keccak256(adapter.utils.toUtf8Bytes(fullAppData));
+  return { fullAppData, appDataKeccak256 };
+}
+async function mergeAppDataDoc(_doc, appDataOverride) {
+  const doc = appDataOverride.metadata?.hooks ? {
+    ..._doc,
+    metadata: {
+      ..._doc.metadata,
+      hooks: {}
+    }
+  } : _doc;
+  const appData = appDataOverride ? deepmerge(doc, appDataOverride) : doc;
+  const { fullAppData, appDataKeccak256 } = await generateAppDataFromDoc(appData);
+  return {
+    fullAppData,
+    appDataKeccak256,
+    doc: appData
+  };
+}
+
+// ../sdk/package.json
+var package_default = {
+  name: "@cowprotocol/cow-sdk",
+  version: "7.0.0-monorepo.0",
+  license: "(MIT OR Apache-2.0)",
+  description: "CowProtocol SDK - Complete umbrella package for CoW Protocol interactions",
+  main: "./dist/index.js",
+  module: "./dist/index.mjs",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    }
+  },
+  sideEffects: false,
+  files: [
+    "dist/**"
+  ],
+  scripts: {
+    build: "tsup src/index.ts --format esm,cjs --dts --treeshake",
+    postbuild: "cp package.json dist && pnpm copy-md-files",
+    "copy-md-files": 'npx cpx "**/*.md" dist',
+    lint: "eslint src/**/*.ts",
+    typecheck: "tsc --noEmit",
+    clean: "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  },
+  devDependencies: {
+    "@cow-sdk/typescript-config": "workspace:*",
+    "@types/node": "^20.17.31",
+    jest: "^29.7.0",
+    "ts-node": "^10.8.2",
+    tsup: "^7.2.0",
+    typescript: "^5.2.2"
+  },
+  dependencies: {
+    "@cowprotocol/sdk-app-data": "workspace:*",
+    "@cowprotocol/sdk-bridging": "workspace:*",
+    "@cowprotocol/sdk-common": "workspace:*",
+    "@cowprotocol/sdk-composable": "workspace:*",
+    "@cowprotocol/sdk-config": "workspace:*",
+    "@cowprotocol/sdk-contracts-ts": "workspace:*",
+    "@cowprotocol/sdk-cow-shed": "workspace:*",
+    "@cowprotocol/sdk-order-book": "workspace:*",
+    "@cowprotocol/sdk-order-signing": "workspace:*",
+    "@cowprotocol/sdk-subgraph": "workspace:*",
+    "@cowprotocol/sdk-trading": "workspace:*",
+    "@cowprotocol/sdk-weiroll": "workspace:*"
+  },
+  peerDependencies: {
+    "@openzeppelin/merkle-tree": "^1.x",
+    "cross-fetch": "^3.x",
+    "ipfs-only-hash": "^4.x",
+    multiformats: "^9.x"
+  },
+  peerDependenciesMeta: {
+    "cross-fetch": {
+      optional: false
+    },
+    "ipfs-only-hash": {
+      optional: true
+    },
+    multiformats: {
+      optional: true
+    },
+    "@openzeppelin/merkle-tree": {
+      optional: true
+    }
+  },
+  keywords: [
+    "cow",
+    "cow-protocol",
+    "sdk",
+    "crypto",
+    "typescript",
+    "subgraph"
+  ],
+  repository: {
+    type: "git",
+    url: "https://github.com/cowprotocol/cow-sdk.git",
+    directory: "packages/sdk"
+  },
+  bugs: {
+    url: "https://github.com/cowprotocol/cow-sdk/issues"
+  },
+  homepage: "https://github.com/cowprotocol/cow-sdk#readme"
+};
+
+// src/postCoWProtocolTrade.ts
+async function postCoWProtocolTrade(orderBookApi, paramAppData, params, additionalParams = {}, paramSigner) {
+  const adapter = getGlobalAdapter4();
+  const appData = await createAppDataWithUTM(paramAppData);
+  const signer = paramSigner ? adapter.createSigner(paramSigner) : adapter.signer;
+  const { networkCostsAmount = "0", signingScheme: _signingScheme = SigningScheme3.EIP712 } = additionalParams;
+  if (getIsEthFlowOrder(params)) {
+    const quoteId2 = params.quoteId;
+    if (typeof quoteId2 === "number") {
+      return postSellNativeCurrencyOrder(orderBookApi, appData, { ...params, quoteId: quoteId2 }, additionalParams, paramSigner);
+    } else {
+      throw new Error("quoteId is required for EthFlow orders");
+    }
+  }
+  const { quoteId = null, owner } = params;
+  const { appDataKeccak256, fullAppData } = appData;
+  const chainId = orderBookApi.context.chainId;
+  const from = owner || await signer.getAddress();
+  const orderToSign = getOrderToSign({ from, networkCostsAmount }, params, appData.appDataKeccak256);
+  log2("Signing order...");
+  const { signature, signingScheme } = await (async () => {
+    if (_signingScheme === SigningScheme3.PRESIGN) {
+      return { signature: from, signingScheme: SigningScheme3.PRESIGN };
+    } else {
+      const signingResult = await OrderSigningUtils2.signOrder(orderToSign, chainId, signer);
+      return { signature: signingResult.signature, signingScheme: SIGN_SCHEME_MAP[signingResult.signingScheme] };
+    }
+  })();
+  const orderBody = {
+    ...orderToSign,
+    from,
+    signature,
+    signingScheme,
+    quoteId,
+    appData: fullAppData,
+    appDataHash: appDataKeccak256
+  };
+  log2("Posting order...");
+  const orderId = await orderBookApi.sendOrder(orderBody);
+  log2(`Order created, id: ${orderId}`);
+  return { orderId, signature, signingScheme, orderToSign };
+}
+async function createAppDataWithUTM(originalAppData) {
+  if (disableUtm) {
+    return originalAppData;
+  }
+  let parsedData;
+  try {
+    parsedData = JSON.parse(originalAppData.fullAppData);
+  } catch {
+    try {
+      const unescapedData = originalAppData.fullAppData.replace(/\\"/g, '"');
+      parsedData = JSON.parse(unescapedData);
+    } catch (error) {
+      throw new CowError(`Failed to parse app data: ${originalAppData.fullAppData}: ${error}`);
+    }
+  }
+  const orderSpecificUtmContent = parsedData.utm?.utmContent;
+  const defaultUtmContent = "\u{1F42E} moo-ving to defi \u{1F42E}";
+  const utmContent2 = orderSpecificUtmContent || utmContent || defaultUtmContent;
+  const defaultUtm = {
+    utmCampaign: "developer-cohort",
+    utmContent: utmContent2,
+    utmMedium: `cow-sdk@${package_default.version}`,
+    utmSource: "cowmunity",
+    utmTerm: "js"
+  };
+  parsedData.utm = defaultUtm;
+  const { fullAppData, appDataKeccak256 } = await generateAppDataFromDoc(parsedData);
+  return {
+    ...originalAppData,
+    fullAppData,
+    appDataKeccak256
+  };
+}
+
+// src/getQuote.ts
+import { getGlobalAdapter as getGlobalAdapter5, log as log3 } from "@cowprotocol/sdk-common";
+import {
+  getQuoteAmountsAndCosts as getQuoteAmountsAndCosts2,
+  OrderBookApi as OrderBookApi3,
+  OrderQuoteSideKindBuy,
+  OrderQuoteSideKindSell,
+  PriceQuality,
+  SigningScheme as SigningScheme4
+} from "@cowprotocol/sdk-order-book";
+
+// src/getOrderTypedData.ts
+import { ORDER_TYPE_FIELDS } from "@cowprotocol/sdk-contracts-ts";
+
+// src/types.ts
+var ORDER_PRIMARY_TYPE = "Order";
+
+// src/getOrderTypedData.ts
+import { OrderSigningUtils as OrderSigningUtils3 } from "@cowprotocol/sdk-order-signing";
+var EIP712DomainTypes = [
+  { name: "name", type: "string" },
+  { name: "version", type: "string" },
+  { name: "chainId", type: "uint256" },
+  { name: "verifyingContract", type: "address" }
+];
+async function getOrderTypedData(chainId, orderToSign) {
+  const domain = await OrderSigningUtils3.getDomain(chainId);
+  return {
+    domain,
+    primaryType: ORDER_PRIMARY_TYPE,
+    types: {
+      [ORDER_PRIMARY_TYPE]: ORDER_TYPE_FIELDS,
+      EIP712Domain: EIP712DomainTypes
+    },
+    message: orderToSign
+  };
+}
+
+// src/suggestSlippageBps.ts
+import { percentageToBps } from "@cowprotocol/sdk-common";
+import { getQuoteAmountsWithCosts } from "@cowprotocol/sdk-order-book";
+
+// src/utils/slippage.ts
+var SCALE = 10n ** 6n;
+function getSlippagePercent(params) {
+  const { sellAmountBeforeNetworkCosts, sellAmountAfterNetworkCosts, slippage, isSell } = params;
+  const sellAmount = isSell ? sellAmountAfterNetworkCosts : sellAmountBeforeNetworkCosts;
+  if (sellAmount <= 0n) {
+    throw new Error("sellAmount must be greater than 0: " + sellAmount);
+  }
+  if (slippage < 0n) {
+    throw new Error("slippage must be non-negative: " + slippage);
+  }
+  if (isSell) {
+    const percentageInScale = SCALE - SCALE * (sellAmount - slippage) / sellAmount;
+    return Number(percentageInScale) / Number(SCALE);
+  } else {
+    const percentageInScale = SCALE * (sellAmount + slippage) / sellAmount - SCALE;
+    return Number(percentageInScale) / Number(SCALE);
+  }
+}
+
+// src/suggestSlippageFromFee.ts
+import { applyPercentage } from "@cowprotocol/sdk-common";
+function suggestSlippageFromFee(params) {
+  const { feeAmount, multiplyingFactorPercent } = params;
+  if (feeAmount < 0n) {
+    throw new Error("Fee amount must be non-negative: " + feeAmount);
+  }
+  if (multiplyingFactorPercent < 0) {
+    throw new Error("multiplyingFactorPercent must be non-negative: " + multiplyingFactorPercent);
+  }
+  return applyPercentage(feeAmount, multiplyingFactorPercent);
+}
+
+// src/suggestSlippageFromVolume.ts
+import { applyPercentage as applyPercentage2 } from "@cowprotocol/sdk-common";
+function suggestSlippageFromVolume(params) {
+  const { sellAmountBeforeNetworkCosts, sellAmountAfterNetworkCosts, isSell, slippagePercent } = params;
+  const sellAmount = isSell ? sellAmountAfterNetworkCosts : sellAmountBeforeNetworkCosts;
+  if (sellAmount <= 0n) {
+    throw new Error("sellAmount must be greater than 0: " + sellAmount);
+  }
+  if (slippagePercent < 0) {
+    throw new Error("slippagePercent must be non-negative: " + slippagePercent);
+  }
+  return applyPercentage2(sellAmount, slippagePercent);
+}
+
+// src/suggestSlippageBps.ts
+var MIN_SLIPPAGE_BPS = 50;
+var MAX_SLIPPAGE_BPS = 1e4;
+var SLIPPAGE_FEE_MULTIPLIER_PERCENT = 50;
+var SLIPPAGE_VOLUME_MULTIPLIER_PERCENT = 0.5;
+function suggestSlippageBps(params) {
+  const { quote, tradeParameters } = params;
+  const { sellTokenDecimals, buyTokenDecimals } = tradeParameters;
+  const { isSell, sellAmountBeforeNetworkCosts, sellAmountAfterNetworkCosts } = getQuoteAmountsWithCosts({
+    sellDecimals: sellTokenDecimals,
+    buyDecimals: buyTokenDecimals,
+    orderParams: quote.quote
+  });
+  const { feeAmount: feeAmountString } = quote.quote;
+  const feeAmount = BigInt(feeAmountString);
+  const slippageBpsFromFee = suggestSlippageFromFee({
+    feeAmount,
+    multiplyingFactorPercent: SLIPPAGE_FEE_MULTIPLIER_PERCENT
+  });
+  const slippageBpsFromVolume = suggestSlippageFromVolume({
+    isSell,
+    sellAmountBeforeNetworkCosts,
+    sellAmountAfterNetworkCosts,
+    slippagePercent: SLIPPAGE_VOLUME_MULTIPLIER_PERCENT
+  });
+  const totalSlippageBps = slippageBpsFromFee + slippageBpsFromVolume;
+  const slippagePercent = getSlippagePercent({
+    isSell,
+    sellAmountBeforeNetworkCosts,
+    sellAmountAfterNetworkCosts,
+    slippage: totalSlippageBps
+  });
+  const slippageBps = percentageToBps(slippagePercent);
+  return Math.max(Math.min(slippageBps, MAX_SLIPPAGE_BPS), MIN_SLIPPAGE_BPS);
+}
+
+// src/getQuote.ts
+var ETH_FLOW_AUX_QUOTE_PARAMS = {
+  signingScheme: SigningScheme4.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
+  verificationGasLimit: 0
+};
+async function getQuoteRaw(_tradeParameters, trader, advancedSettings, _orderBookApi) {
+  const { appCode, chainId, account: from } = trader;
+  const isEthFlow = getIsEthFlowOrder(_tradeParameters);
+  const tradeParameters = isEthFlow ? {
+    ..._tradeParameters,
+    ...adjustEthFlowOrderParams(chainId, _tradeParameters)
+  } : _tradeParameters;
+  const {
+    sellToken,
+    buyToken,
+    amount,
+    kind,
+    partnerFee,
+    validFor = DEFAULT_QUOTE_VALIDITY,
+    slippageBps,
+    env = "prod"
+  } = tradeParameters;
+  log3(
+    `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...");
+  const slippageBpsOrDefault = slippageBps ?? DEFAULT_SLIPPAGE_BPS;
+  const buildAppDataParams = {
+    slippageBps: slippageBpsOrDefault,
+    orderClass: "market",
+    appCode,
+    partnerFee
+  };
+  const appDataInfo = await buildAppData(buildAppDataParams, advancedSettings?.appData);
+  const { appDataKeccak256, fullAppData } = appDataInfo;
+  log3(`App data: appDataKeccak256=${appDataKeccak256} fullAppData=${fullAppData}`);
+  const quoteRequest = {
+    from,
+    sellToken,
+    buyToken,
+    receiver,
+    validFor,
+    appData: fullAppData,
+    appDataHash: appDataKeccak256,
+    priceQuality: PriceQuality.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...");
+  const quote = await orderBookApi.getQuote(quoteRequest);
+  const suggestedSlippageBps = suggestSlippageBps({ quote, tradeParameters, trader, advancedSettings });
+  if (slippageBps === void 0) {
+    if (suggestedSlippageBps > DEFAULT_SLIPPAGE_BPS) {
+      log3(
+        `Suggested slippage is greater than ${DEFAULT_SLIPPAGE_BPS} BPS (default), using the suggested slippage (${suggestedSlippageBps} BPS)`
+      );
+      const newAppDataInfo = await buildAppData(
+        {
+          ...buildAppDataParams,
+          slippageBps: suggestedSlippageBps
+        },
+        advancedSettings?.appData
+      );
+      log3(
+        `App data with new suggested slippage: appDataKeccak256=${newAppDataInfo.appDataKeccak256} fullAppData=${newAppDataInfo.fullAppData}`
+      );
+      return {
+        slippageBps: suggestedSlippageBps,
+        suggestedSlippageBps,
+        tradeParameters: { ..._tradeParameters, slippageBps: suggestedSlippageBps },
+        appDataInfo: newAppDataInfo,
+        // We reuse the quote, because the slippage has no fundamental impact on the quote
+        quote,
+        orderBookApi
+      };
+    } else {
+      log3(
+        `Suggested slippage is only ${suggestedSlippageBps} BPS. Using the default slippage (${DEFAULT_SLIPPAGE_BPS} BPS)`
+      );
+    }
+  }
+  return {
+    quote,
+    appDataInfo,
+    orderBookApi,
+    tradeParameters,
+    slippageBps: slippageBpsOrDefault,
+    suggestedSlippageBps
+  };
+}
+async function getQuote(_tradeParameters, trader, advancedSettings, _orderBookApi) {
+  const { quote, orderBookApi, tradeParameters, slippageBps, suggestedSlippageBps, appDataInfo } = await getQuoteRaw(
+    _tradeParameters,
+    trader,
+    advancedSettings,
+    _orderBookApi
+  );
+  const { partnerFee, sellTokenDecimals, buyTokenDecimals } = tradeParameters;
+  const { chainId, account: from } = trader;
+  const amountsAndCosts = getQuoteAmountsAndCosts2({
+    orderParams: quote.quote,
+    slippagePercentBps: slippageBps,
+    partnerFeeBps: getPartnerFeeBps(partnerFee),
+    sellDecimals: sellTokenDecimals,
+    buyDecimals: buyTokenDecimals
+  });
+  const orderToSign = getOrderToSign(
+    { from, networkCostsAmount: quote.quote.feeAmount },
+    swapParamsToLimitOrderParams(tradeParameters, quote),
+    appDataInfo.appDataKeccak256
+  );
+  const orderTypedData = await getOrderTypedData(chainId, orderToSign);
+  return {
+    result: {
+      tradeParameters,
+      suggestedSlippageBps,
+      amountsAndCosts,
+      orderToSign,
+      quoteResponse: quote,
+      appDataInfo,
+      orderTypedData
+    },
+    orderBookApi
+  };
+}
+async function getTrader(swapParameters) {
+  const signer = getGlobalAdapter5().signerOrNull();
+  const account = swapParameters.owner || await signer?.getAddress();
+  return {
+    chainId: swapParameters.chainId,
+    appCode: swapParameters.appCode,
+    account
+  };
+}
+async function getQuoteWithSigner(swapParameters, advancedSettings, orderBookApi) {
+  const adapter = getGlobalAdapter5();
+  const signer = swapParameters.signer ? adapter.createSigner(swapParameters.signer) : adapter.signer;
+  const trader = await getTrader(swapParameters);
+  const result = await getQuote(swapParameters, trader, advancedSettings, orderBookApi);
+  return {
+    result: {
+      ...result.result,
+      signer
+    },
+    orderBookApi: result.orderBookApi
+  };
+}
+
+// src/postSwapOrder.ts
+async function postSwapOrder(params, advancedSettings, orderBookApi) {
+  return postSwapOrderFromQuote(await getQuoteWithSigner(params, advancedSettings, orderBookApi), advancedSettings);
+}
+async function postSwapOrderFromQuote({
+  orderBookApi,
+  result: { signer, appDataInfo: _appDataInfo, quoteResponse, tradeParameters }
+}, advancedSettings) {
+  const params = swapParamsToLimitOrderParams(tradeParameters, quoteResponse);
+  const appDataOverride = advancedSettings?.appData;
+  const appDataInfo = appDataOverride ? await mergeAppDataDoc(_appDataInfo.doc, appDataOverride) : _appDataInfo;
+  const appDataSlippageOverride = appDataOverride?.metadata?.quote?.slippageBips;
+  const partnerFeeOverride = appDataOverride?.metadata?.partnerFee;
+  if (typeof appDataSlippageOverride !== "undefined") {
+    params.slippageBps = appDataSlippageOverride;
+  }
+  if (partnerFeeOverride) {
+    params.partnerFee = partnerFeeOverride;
+  }
+  if (advancedSettings?.quoteRequest) {
+    const { receiver, validTo, sellToken, buyToken } = advancedSettings.quoteRequest;
+    if (receiver)
+      params.receiver = receiver;
+    if (validTo)
+      params.validTo = validTo;
+    if (sellToken)
+      params.sellToken = sellToken;
+    if (buyToken)
+      params.buyToken = buyToken;
+  }
+  return postCoWProtocolTrade(
+    orderBookApi,
+    appDataInfo,
+    params,
+    {
+      signingScheme: advancedSettings?.quoteRequest?.signingScheme,
+      networkCostsAmount: quoteResponse.quote.feeAmount,
+      ...advancedSettings?.additionalParams
+    },
+    signer
+  );
+}
+
+// src/postLimitOrder.ts
+import { OrderBookApi as OrderBookApi4 } from "@cowprotocol/sdk-order-book";
+import { log as log4 } from "@cowprotocol/sdk-common";
+async function postLimitOrder(params, advancedSettings, _orderBookApi) {
+  const appDataSlippage = advancedSettings?.appData?.metadata?.quote?.slippageBips;
+  const partnerFeeOverride = advancedSettings?.appData?.metadata?.partnerFee;
+  if (typeof appDataSlippage !== "undefined") {
+    params.slippageBps = appDataSlippage;
+  }
+  if (partnerFeeOverride) {
+    params.partnerFee = partnerFeeOverride;
+  }
+  if (!params.slippageBps) {
+    params.slippageBps = 0;
+  }
+  if (!params.env) {
+    params.env = "prod";
+  }
+  const { appCode, chainId, sellToken, buyToken, sellAmount, buyAmount, partnerFee } = params;
+  log4(`Limit order ${sellAmount} ${sellToken} for ${buyAmount} ${buyToken} on chain ${chainId}`);
+  const orderBookApi = _orderBookApi || new OrderBookApi4({ chainId, env: params.env });
+  log4("Building app data...");
+  const appDataInfo = await buildAppData(
+    {
+      slippageBps: params.slippageBps,
+      orderClass: "limit",
+      appCode,
+      partnerFee
+    },
+    advancedSettings?.appData
+  );
+  return postCoWProtocolTrade(orderBookApi, appDataInfo, params, advancedSettings?.additionalParams, params.signer);
+}
+
+// src/getPreSignTransaction.ts
+import { COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS } from "@cowprotocol/sdk-config";
+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];
+  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
+    value: "0"
+  };
+}
+
+// src/tradingSdk.ts
+import { enableLogging, getGlobalAdapter as getGlobalAdapter6 } from "@cowprotocol/sdk-common";
+import { setGlobalAdapter } from "@cowprotocol/sdk-common";
+var utmContent = void 0;
+var disableUtm = false;
+var TradingSdk = class {
+  constructor(traderParams = {}, options = {}, adapter) {
+    this.traderParams = traderParams;
+    this.options = options;
+    if (options.enableLogging !== void 0) {
+      enableLogging(options.enableLogging);
+    }
+    if (adapter) {
+      setGlobalAdapter(adapter);
+    }
+    utmContent = options.utmContent;
+    disableUtm = options.disableUtm || false;
+  }
+  setTraderParams(params) {
+    this.traderParams = { ...this.traderParams, ...params };
+    return this;
+  }
+  async getQuote(params, advancedSettings) {
+    const quoteResults = await getQuoteWithSigner(this.mergeParams(params), advancedSettings, this.options.orderBookApi);
+    return {
+      quoteResults: quoteResults.result,
+      postSwapOrderFromQuote: (advancedSettings2) => postSwapOrderFromQuote(
+        {
+          ...quoteResults,
+          result: {
+            ...quoteResults.result,
+            tradeParameters: getTradeParametersAfterQuote({
+              quoteParameters: quoteResults.result.tradeParameters,
+              sellToken: params.sellToken
+            })
+          }
+        },
+        advancedSettings2
+      )
+    };
+  }
+  async getQuoteResults(params, advancedSettings) {
+    return getQuoteWithSigner(this.mergeParams(params), advancedSettings, this.options.orderBookApi);
+  }
+  async postSwapOrder(params, advancedSettings) {
+    return postSwapOrder(this.mergeParams(params), advancedSettings, this.options.orderBookApi);
+  }
+  async postLimitOrder(params, advancedSettings) {
+    return postLimitOrder(this.mergeParams(params), advancedSettings, this.options.orderBookApi);
+  }
+  /**
+   * Posts a sell order for native currency (e.g., ETH) using the EthFlow contract.
+   * This method creates an on-chain transaction for selling native tokens.
+   *
+   * @param params - The trade parameters including token addresses and amounts
+   * @param advancedSettings - Optional advanced settings for the swap
+   * @returns Promise resolving to the order posting result with transaction hash and order ID
+   *
+   * @example
+   * ```typescript
+   * const parameters: TradeParameters = {
+   *   kind: OrderKind.SELL,
+   *   sellToken: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', // Native ETH
+   *   sellTokenDecimals: 18,
+   *   buyToken: '0x0625afb445c3b6b7b929342a04a22599fd5dbb59',
+   *   buyTokenDecimals: 18,
+   *   amount: '100000000000000000', // 0.1 ETH
+   * }
+   *
+   * const { orderId, txHash } = await sdk.postSellNativeCurrencyOrder(parameters)
+   * ```
+   */
+  async postSellNativeCurrencyOrder(params, advancedSettings) {
+    const quoteResults = await getQuoteWithSigner(this.mergeParams(params), advancedSettings, this.options.orderBookApi);
+    const { tradeParameters, quoteResponse } = quoteResults.result;
+    return postSellNativeCurrencyOrder(
+      quoteResults.orderBookApi,
+      quoteResults.result.appDataInfo,
+      // Quote response always has an id
+      swapParamsToLimitOrderParams(
+        getTradeParametersAfterQuote({ quoteParameters: tradeParameters, sellToken: params.sellToken }),
+        quoteResponse
+      ),
+      advancedSettings?.additionalParams,
+      quoteResults.result.signer
+    );
+  }
+  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);
+  }
+  mergeParams(params) {
+    const { chainId, signer, appCode, env } = params;
+    const traderParams = {
+      chainId: chainId || this.traderParams.chainId,
+      signer: signer || this.traderParams.signer,
+      appCode: appCode || this.traderParams.appCode,
+      env: env || this.traderParams.env
+    };
+    assertTraderParams(traderParams);
+    return {
+      ...params,
+      ...traderParams
+    };
+  }
+};
+function assertTraderParams(params) {
+  if (!isTraderParameters(params)) {
+    throw new Error("Missing trader parameters: " + getMissingTraderParams(params).join(", "));
+  }
+}
+function getMissingTraderParams(params) {
+  const missingParams = [];
+  if (!params.chainId)
+    missingParams.push("chainId");
+  if (!params.signer)
+    missingParams.push("signer");
+  if (!params.appCode)
+    missingParams.push("appCode");
+  return missingParams;
+}
+function isTraderParameters(params) {
+  return getMissingTraderParams(params).length === 0;
+}
+export {
+  ORDER_PRIMARY_TYPE,
+  TradingSdk,
+  buildAppData,
+  calculateUniqueOrderId,
+  disableUtm,
+  generateAppDataFromDoc,
+  getEthFlowContract,
+  getEthFlowTransaction,
+  getOrderToSign,
+  getPartnerFeeBps,
+  getPreSignTransaction,
+  getQuote,
+  getQuoteWithSigner,
+  getTradeParametersAfterQuote,
+  mapQuoteAmountsAndCosts,
+  mergeAppDataDoc,
+  postCoWProtocolTrade,
+  postLimitOrder,
+  postSellNativeCurrencyOrder,
+  postSwapOrder,
+  postSwapOrderFromQuote,
+  suggestSlippageBps,
+  swapParamsToLimitOrderParams,
+  utmContent
+};