@velora-dex/sdk 9.3.6 → 9.4.1-dev.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velora-dex/sdk",
-  "version": "9.3.6",
+  "version": "9.4.1-dev.1",
   "main": "dist/index.js",
   "module": "dist/sdk.esm.js",
   "typings": "dist/index.d.ts",

package/src/constants.js

@@ -0,0 +1,3 @@
+export { SwapSide, ContractMethod, ContractMethodV5, ContractMethodV6, } from '@paraswap/core';
+export const API_URL = 'https://api.paraswap.io';
+export const DEFAULT_VERSION = '6.2';

package/src/examples/delta.ts

@@ -14,10 +14,13 @@ const fetcher = constructAxiosFetcher(axios);
 const provider = ethers.getDefaultProvider(1);
 const signer = Wallet.createRandom().connect(provider);
 const account = signer.address;
-const contractCaller = constructEthersContractCaller({
-  ethersProviderOrSigner: provider,
-  EthersContract: ethers.Contract,
-});
+const contractCaller = constructEthersContractCaller(
+  {
+    ethersProviderOrSigner: provider,
+    EthersContract: ethers.Contract,
+  },
+  account
+);
 
 // type AdaptersFunctions & ApproveTokenFunctions<ethers.ContractTransaction>
 const deltaSDK = constructPartialSDK(
@@ -51,14 +54,6 @@ async function simpleDeltaFlow() {
   const tx = await deltaSDK.approveTokenForDelta(amount, DAI_TOKEN);
   await tx.wait();
 
-  const slippagePercent = 0.5;
-  const destAmountAfterSlippage = BigInt(
-    // get rid of exponential notation
-
-    +(+deltaPrice.destAmount * (1 - slippagePercent / 100)).toFixed(0)
-    // get rid of decimals
-  ).toString(10);
-
   const deltaAuction = await deltaSDK.submitDeltaOrder({
     deltaPrice,
     owner: account,
@@ -67,7 +62,7 @@ async function simpleDeltaFlow() {
     srcToken: DAI_TOKEN,
     destToken: USDC_TOKEN,
     srcAmount: amount,
-    destAmount: destAmountAfterSlippage, // minimum acceptable destAmount
+    slippage: 50, // 50 bps = 0.5% slippage, destAmount auto-computed from deltaPrice
   });
 
   // poll if necessary
@@ -92,12 +87,6 @@ async function manualDeltaFlow() {
   const tx = await deltaSDK.approveTokenForDelta(amount, DAI_TOKEN);
   await tx.wait();
 
-  const slippagePercent = 0.5;
-  const destAmountAfterSlippage = (
-    +deltaPrice.destAmount *
-    (1 - slippagePercent / 100)
-  ).toString(10);
-
   const signableOrderData = await deltaSDK.buildDeltaOrder({
     deltaPrice,
     owner: account,
@@ -106,7 +95,7 @@ async function manualDeltaFlow() {
     srcToken: DAI_TOKEN,
     destToken: USDC_TOKEN,
     srcAmount: amount,
-    destAmount: destAmountAfterSlippage, // minimum acceptable destAmount
+    slippage: 50, // 50 bps = 0.5% slippage, destAmount auto-computed from deltaPrice
   });
 
   const signature = await deltaSDK.signDeltaOrder(signableOrderData);

package/src/examples/externalDelta.ts

@@ -0,0 +1,162 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import axios from 'axios';
+import { ethers, Wallet } from 'ethersV5';
+import {
+  constructPartialSDK,
+  constructEthersContractCaller,
+  constructAxiosFetcher,
+  constructAllDeltaOrdersHandlers,
+  SwapSide,
+} from '..';
+import { startStatusCheck } from './helpers/delta';
+
+const fetcher = constructAxiosFetcher(axios);
+
+const provider = ethers.getDefaultProvider(1); // Ethereum
+const signer = Wallet.createRandom().connect(provider);
+const account = signer.address;
+const contractCaller = constructEthersContractCaller(
+  {
+    ethersProviderOrSigner: signer,
+    EthersContract: ethers.Contract,
+  },
+  account
+);
+
+const deltaSDK = constructPartialSDK(
+  {
+    chainId: 1, // Ethereum
+    fetcher,
+    contractCaller,
+  },
+  constructAllDeltaOrdersHandlers
+);
+
+// Ethereum tokens
+const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+const WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+
+// Aave external handler on Ethereum (https://etherscan.io/address/0xb4a2c36668cf8b19fe08f263e3685a5e16e82912#code)
+// The handler contract is provided by the integrator and must implement IExternalProtocolHandler.
+// Different handlers serve different purposes and may have different prerequisites
+// (e.g. token approvals, credit delegation, position setup).
+const AAVE_HANDLER = '0xb4a2c36668cf8b19fe08f263e3685a5e16e82912';
+
+// Aave-specific order types passed as `data` field.
+// The `data` encoding is handler-specific — each handler defines its own format.
+const AaveOrderTypes = {
+  COLLATERAL_SWAP:
+    '0x0000000000000000000000000000000000000000000000000000000000000000',
+  DEBT_SWAP:
+    '0x0000000000000000000000000000000000000000000000000000000000000001',
+  REPAY_WITH_COLLATERAL:
+    '0x0000000000000000000000000000000000000000000000000000000000000002',
+};
+
+// Aave Collateral Swap: swap one collateral asset for another (SELL side)
+// Prerequisites: user must approve the source aToken to the handler
+async function collateralSwapFlow() {
+  const amount = ethers.utils.parseUnits('1', 6).toString(); // 1 USDC
+
+  const deltaPrice = await deltaSDK.getDeltaPrice({
+    srcToken: USDC,
+    destToken: WETH,
+    amount,
+    userAddress: account,
+    srcDecimals: 6,
+    destDecimals: 18,
+    side: SwapSide.SELL,
+  });
+
+  const signableOrderData = await deltaSDK.buildExternalDeltaOrder({
+    deltaPrice,
+    owner: account,
+    handler: AAVE_HANDLER,
+    data: AaveOrderTypes.COLLATERAL_SWAP,
+    srcToken: USDC,
+    destToken: WETH,
+    srcAmount: amount,
+    slippage: 50, // 0.5% slippage in bps
+  });
+
+  const signature = await deltaSDK.signExternalDeltaOrder(signableOrderData);
+
+  const deltaAuction = await deltaSDK.postExternalDeltaOrder({
+    order: signableOrderData.data,
+    signature,
+  });
+
+  startStatusCheck(() => deltaSDK.getDeltaOrderById(deltaAuction.id));
+}
+
+// Aave Debt Swap: swap one debt for another (BUY side)
+// Prerequisites: user must grant borrowAllowance on the source variable debt token to the handler
+async function debtSwapFlow() {
+  const debtAmount = ethers.utils.parseUnits('1', 6).toString(); // amount of debt to swap
+
+  const deltaPrice = await deltaSDK.getDeltaPrice({
+    srcToken: USDC,
+    destToken: WETH,
+    amount: debtAmount,
+    userAddress: account,
+    srcDecimals: 6,
+    destDecimals: 18,
+    side: SwapSide.BUY,
+  });
+
+  const signableOrderData = await deltaSDK.buildExternalDeltaOrder({
+    deltaPrice,
+    owner: account,
+    handler: AAVE_HANDLER,
+    data: AaveOrderTypes.DEBT_SWAP,
+    srcToken: USDC,
+    destToken: WETH,
+    destAmount: debtAmount,
+    slippage: 50, // 0.5% slippage in bps
+  });
+
+  const signature = await deltaSDK.signExternalDeltaOrder(signableOrderData);
+
+  const deltaAuction = await deltaSDK.postExternalDeltaOrder({
+    order: signableOrderData.data,
+    signature,
+  });
+
+  startStatusCheck(() => deltaSDK.getDeltaOrderById(deltaAuction.id));
+}
+
+// Aave Repay with Collateral: use collateral to repay debt (BUY side)
+// Prerequisites: user must approve the source aToken to the handler
+async function repayWithCollateralFlow() {
+  const collateralAmount = ethers.utils.parseUnits('1', 6).toString();
+
+  const deltaPrice = await deltaSDK.getDeltaPrice({
+    srcToken: USDC,
+    destToken: WETH,
+    amount: collateralAmount,
+    userAddress: account,
+    srcDecimals: 6,
+    destDecimals: 18,
+    side: SwapSide.BUY,
+  });
+
+  const signableOrderData = await deltaSDK.buildExternalDeltaOrder({
+    deltaPrice,
+    owner: account,
+    handler: AAVE_HANDLER,
+    data: AaveOrderTypes.REPAY_WITH_COLLATERAL,
+    srcToken: USDC,
+    destToken: WETH,
+    destAmount: collateralAmount,
+    slippage: 50, // 0.5% slippage in bps
+  });
+
+  const signature = await deltaSDK.signExternalDeltaOrder(signableOrderData);
+
+  const deltaAuction = await deltaSDK.postExternalDeltaOrder({
+    order: signableOrderData.data,
+    signature,
+  });
+
+  startStatusCheck(() => deltaSDK.getDeltaOrderById(deltaAuction.id));
+}

package/src/examples/helpers/delta.ts

@@ -1,20 +1,24 @@
-import { DeltaAuction, DeltaOrderFromAPI } from '../..';
+import { DeltaAuction } from '../..';
 
 function isExecutedDeltaAuction(
-  auction: Omit<DeltaAuction, 'signature'>,
+  auction: DeltaAuction,
   waitForCrosschain = true // only consider executed when destChain work is done
 ) {
   if (auction.status !== 'EXECUTED') return false;
 
   // crosschain Order is executed on destChain if bridgeStatus is filled
-  if (waitForCrosschain && auction.order.bridge.destinationChainId !== 0) {
+  if (
+    waitForCrosschain &&
+    auction.onChainOrderType === 'Order' &&
+    auction.order.bridge.destinationChainId !== 0
+  ) {
     return auction.bridgeStatus === 'filled';
   }
 
   return true;
 }
 
-type GetDeltaOrderFn = () => Promise<DeltaOrderFromAPI>;
+type GetDeltaOrderFn = () => Promise<DeltaAuction>;
 
 function fetchOrderPeriodically(getDeltaOrder: GetDeltaOrderFn) {
   const intervalId = setInterval(async () => {

package/src/gas.js

@@ -0,0 +1 @@
+export {};

package/src/index.js

@@ -0,0 +1,85 @@
+import { constructApproveToken, } from './methods/swap/approve';
+import { constructGetBalances, isAllowance, } from './methods/swap/balance';
+import { constructGetSpender, } from './methods/swap/spender';
+import { constructGetAdapters, } from './methods/swap/adapters';
+import { constructGetRate, } from './methods/swap/rates';
+import { constructSwapTx } from './methods/swap/swapTx';
+import { constructGetTokens } from './methods/swap/token';
+import { constructBuildTx } from './methods/swap/transaction';
+import { constructBuildLimitOrder, } from './methods/limitOrders/buildOrder';
+import { constructSignLimitOrder, } from './methods/limitOrders/signOrder';
+import { constructCancelLimitOrder, } from './methods/limitOrders/cancelOrder';
+import { constructFillOrderDirectly, } from './methods/limitOrders/fillOrderDirectly';
+import { constructGetLimitOrders, } from './methods/limitOrders/getOrders';
+import { constructPostLimitOrder, } from './methods/limitOrders/postOrder';
+import { constructApproveTokenForLimitOrder, } from './methods/limitOrders/approveForOrder';
+import { constructGetLimitOrdersContract, } from './methods/limitOrders/getOrdersContract';
+import { constructBuildLimitOrderTx, } from './methods/limitOrders/transaction';
+import { constructBuildNFTOrder, } from './methods/nftOrders/buildOrder';
+import { constructSignNFTOrder, } from './methods/nftOrders/signOrder';
+import { constructCancelNFTOrder, } from './methods/nftOrders/cancelOrder';
+import { constructGetNFTOrders, } from './methods/nftOrders/getOrders';
+import { constructPostNFTOrder, } from './methods/nftOrders/postOrder';
+import { constructApproveTokenForNFTOrder, } from './methods/nftOrders/approveForOrder';
+import { constructGetNFTOrdersContract, } from './methods/nftOrders/getOrdersContract';
+import { constructBuildNFTOrderTx, } from './methods/nftOrders/transaction';
+import { constructEthersContractCaller, constructEthersV5ContractCaller, constructEthersV6ContractCaller, constructWeb3ContractCaller, constructViemContractCaller, txParamsToViemTxParams, constructAxiosFetcher, constructFetchFetcher, isFetcherError, constructToken, } from './helpers';
+import { constructBuildDeltaOrder, } from './methods/delta/buildDeltaOrder';
+import { constructPostDeltaOrder, } from './methods/delta/postDeltaOrder';
+import { constructSignDeltaOrder, } from './methods/delta/signDeltaOrder';
+import { constructPreSignDeltaOrder, } from './methods/delta/preSignDeltaOrder';
+import { constructGetDeltaContract, } from './methods/delta/getDeltaContract';
+import { constructGetDeltaPrice, } from './methods/delta/getDeltaPrice';
+import { constructGetDeltaOrders, } from './methods/delta/getDeltaOrders';
+import { constructApproveTokenForDelta, } from './methods/delta/approveForDelta';
+import { constructGetPartnerFee, } from './methods/delta/getPartnerFee';
+import { constructGetBridgeInfo, } from './methods/delta/getBridgeInfo';
+import { constructIsTokenSupportedInDelta, } from './methods/delta/isTokenSupportedInDelta';
+import { constructBuildExternalDeltaOrder, } from './methods/delta/buildExternalDeltaOrder';
+import { constructSignExternalDeltaOrder, } from './methods/delta/signExternalDeltaOrder';
+import { constructPostExternalDeltaOrder, } from './methods/delta/postExternalDeltaOrder';
+import { constructPreSignExternalDeltaOrder, } from './methods/delta/preSignExternalDeltaOrder';
+import { constructBuildTWAPDeltaOrder, } from './methods/delta/buildTWAPDeltaOrder';
+import { constructSignTWAPDeltaOrder, } from './methods/delta/signTWAPDeltaOrder';
+import { constructPostTWAPDeltaOrder, } from './methods/delta/postTWAPDeltaOrder';
+import { constructPreSignTWAPDeltaOrder, } from './methods/delta/preSignTWAPDeltaOrder';
+import { constructGetQuote, } from './methods/quote/getQuote';
+import { constructCancelDeltaOrder, } from './methods/delta/cancelDeltaOrder';
+import { constructDeltaTokenModule, } from './methods/delta/deltaTokenModule';
+export { constructSwapSDK } from './methods/swap';
+export { constructAllLimitOrdersHandlers, constructSubmitLimitOrder, } from './methods/limitOrders';
+export { constructAllDeltaOrdersHandlers, constructSubmitDeltaOrder, constructSubmitExternalDeltaOrder, constructSubmitTWAPDeltaOrder, } from './methods/delta';
+export * from './constants';
+// can import these individually
+// and use in constructPartialSDK only what you need
+// unused should tree-shake
+export { 
+// swap methods:
+constructApproveToken, constructGetBalances, // getAllowances is inside
+constructGetSpender, // this was getTokenTransferProxy
+constructGetTokens, constructBuildTx, constructGetAdapters, constructGetRate, constructSwapTx, 
+// limitOrders methods:
+constructBuildLimitOrder, constructSignLimitOrder, constructCancelLimitOrder, constructFillOrderDirectly, constructGetLimitOrders, constructPostLimitOrder, constructApproveTokenForLimitOrder, constructGetLimitOrdersContract, constructBuildLimitOrderTx, 
+// nftOrders methods
+constructBuildNFTOrder, constructSignNFTOrder, constructCancelNFTOrder, constructGetNFTOrders, constructPostNFTOrder, constructApproveTokenForNFTOrder, constructGetNFTOrdersContract, constructBuildNFTOrderTx, 
+// Delta methods
+constructBuildDeltaOrder, constructPostDeltaOrder, constructSignDeltaOrder, constructPreSignDeltaOrder, constructGetDeltaContract, constructGetDeltaPrice, constructGetDeltaOrders, constructCancelDeltaOrder, constructDeltaTokenModule, constructApproveTokenForDelta, 
+// External Delta methods
+constructBuildExternalDeltaOrder, constructSignExternalDeltaOrder, constructPostExternalDeltaOrder, constructPreSignExternalDeltaOrder, 
+// TWAP Delta methods
+constructBuildTWAPDeltaOrder, constructSignTWAPDeltaOrder, constructPostTWAPDeltaOrder, constructPreSignTWAPDeltaOrder, 
+// Quote methods
+constructGetQuote, 
+// different helpers
+constructGetPartnerFee, constructGetBridgeInfo, constructIsTokenSupportedInDelta, constructEthersContractCaller, // same as constructEthersV5ContractCaller for backwards compatibility
+constructEthersV5ContractCaller, constructEthersV6ContractCaller, constructWeb3ContractCaller, constructViemContractCaller, txParamsToViemTxParams, constructAxiosFetcher, constructFetchFetcher, isFetcherError, isAllowance, constructToken, };
+export { constructPartialSDK } from './sdk/partial';
+export { constructFullSDK } from './sdk/full';
+export { constructSimpleSDK, } from './sdk/simple';
+// bundled methods for limitOrders
+export * from './methods/limitOrders';
+export * from './methods/limitOrders/helpers/types';
+// bundled methods for nftOrders
+export * from './methods/nftOrders';
+export * from './methods/nftOrders/helpers/types';
+export { AssetType } from './methods/nftOrders/helpers/misc';

package/src/index.ts

@@ -141,20 +141,30 @@ import type {
   DeltaAuctionOrder,
   DeltaAuction,
   DeltaAuctionStatus,
+  DeltaAuctionTransaction,
   BridgeMetadata,
   BridgeStatus,
   Bridge,
+  ExternalDeltaOrder,
+  TWAPDeltaOrder,
+  TWAPBuyDeltaOrder,
+  TWAPOnChainOrderType,
+  OnChainOrderType,
+  SwapSideUnion,
+  AmountsWithSlippage,
+  AmountsSellSlippage,
+  AmountsBuySlippage,
+  AmountsExplicit,
 } from './methods/delta/helpers/types';
 import {
   BuildDeltaOrderDataParams,
   BuildDeltaOrderFunctions,
   constructBuildDeltaOrder,
   SignableDeltaOrderData,
-  SwapSideUnion,
 } from './methods/delta/buildDeltaOrder';
 import {
   constructPostDeltaOrder,
-  DeltaOrderApiResponse,
+  DeltaOrderToPost,
   PostDeltaOrderFunctions,
   PostDeltaOrderParams,
 } from './methods/delta/postDeltaOrder';
@@ -203,6 +213,48 @@ import {
   IsTokenSupportedInDeltaFunctions,
 } from './methods/delta/isTokenSupportedInDelta';
 
+import {
+  constructBuildExternalDeltaOrder,
+  BuildExternalDeltaOrderFunctions,
+  BuildExternalDeltaOrderParams,
+} from './methods/delta/buildExternalDeltaOrder';
+import type { SignableExternalOrderData } from './methods/delta/helpers/buildExternalOrderData';
+import {
+  constructSignExternalDeltaOrder,
+  SignExternalDeltaOrderFunctions,
+} from './methods/delta/signExternalDeltaOrder';
+import {
+  constructPostExternalDeltaOrder,
+  PostExternalDeltaOrderFunctions,
+  PostExternalDeltaOrderParams,
+} from './methods/delta/postExternalDeltaOrder';
+import {
+  constructPreSignExternalDeltaOrder,
+  PreSignExternalDeltaOrderFunctions,
+} from './methods/delta/preSignExternalDeltaOrder';
+
+import {
+  BuildTWAPDeltaOrderParams,
+  BuildTWAPSellOrderParams,
+  BuildTWAPBuyOrderParams,
+  BuildTWAPDeltaOrderFunctions,
+  constructBuildTWAPDeltaOrder,
+} from './methods/delta/buildTWAPDeltaOrder';
+import type { SignableTWAPOrderData } from './methods/delta/helpers/buildTWAPOrderData';
+import {
+  constructSignTWAPDeltaOrder,
+  SignTWAPDeltaOrderFunctions,
+} from './methods/delta/signTWAPDeltaOrder';
+import {
+  constructPostTWAPDeltaOrder,
+  PostTWAPDeltaOrderFunctions,
+  PostTWAPDeltaOrderParams,
+} from './methods/delta/postTWAPDeltaOrder';
+import {
+  constructPreSignTWAPDeltaOrder,
+  PreSignTWAPDeltaOrderFunctions,
+} from './methods/delta/preSignTWAPDeltaOrder';
+
 import {
   constructGetQuote,
   GetQuoteFunctions,
@@ -223,6 +275,10 @@ import {
   DepositNativeAndPreSignParams,
   DepositNativeAndPreSignDeltaOrderParams,
 } from './methods/delta/deltaTokenModule';
+import {
+  CancelDeltaOrderData,
+  SignableCancelDeltaOrderData,
+} from './methods/delta/helpers/buildCancelDeltaOrderData';
 
 export { constructSwapSDK, SwapSDKMethods } from './methods/swap';
 
@@ -235,8 +291,12 @@ export {
 export {
   constructAllDeltaOrdersHandlers,
   constructSubmitDeltaOrder,
+  constructSubmitExternalDeltaOrder,
+  constructSubmitTWAPDeltaOrder,
   DeltaOrderHandlers,
   SubmitDeltaOrderParams,
+  SubmitExternalDeltaOrderParams,
+  SubmitTWAPDeltaOrderParams,
 } from './methods/delta';
 
 export type {
@@ -309,6 +369,16 @@ export {
   constructCancelDeltaOrder,
   constructDeltaTokenModule,
   constructApproveTokenForDelta,
+  // External Delta methods
+  constructBuildExternalDeltaOrder,
+  constructSignExternalDeltaOrder,
+  constructPostExternalDeltaOrder,
+  constructPreSignExternalDeltaOrder,
+  // TWAP Delta methods
+  constructBuildTWAPDeltaOrder,
+  constructSignTWAPDeltaOrder,
+  constructPostTWAPDeltaOrder,
+  constructPreSignTWAPDeltaOrder,
   // Quote methods
   constructGetQuote,
   // different helpers
@@ -381,9 +451,11 @@ export type {
   DeltaAuctionOrder,
   DeltaAuction,
   DeltaAuctionStatus,
+  DeltaAuctionTransaction,
   DeltaOrderFilterByStatus,
-  DeltaOrderApiResponse,
   DeltaOrderFromAPI,
+  CancelDeltaOrderData,
+  SignableCancelDeltaOrderData,
   // bridge part of DeltaOrder
   BridgeMetadata,
   BridgeStatus,
@@ -394,6 +466,7 @@ export type {
   BuildDeltaOrderDataParams,
   BuildDeltaOrderFunctions,
   SignableDeltaOrderData,
+  DeltaOrderToPost,
   PostDeltaOrderFunctions,
   PostDeltaOrderParams,
   SignDeltaOrderFunctions,
@@ -407,6 +480,33 @@ export type {
   CancelAndWithdrawDeltaOrderParams,
   DepositNativeAndPreSignParams,
   DepositNativeAndPreSignDeltaOrderParams,
+  // External Delta types
+  ExternalDeltaOrder,
+  TWAPDeltaOrder,
+  TWAPBuyDeltaOrder,
+  TWAPOnChainOrderType,
+  OnChainOrderType,
+  AmountsWithSlippage,
+  AmountsSellSlippage,
+  AmountsBuySlippage,
+  AmountsExplicit,
+  SignableExternalOrderData,
+  BuildExternalDeltaOrderParams,
+  BuildExternalDeltaOrderFunctions,
+  SignExternalDeltaOrderFunctions,
+  PostExternalDeltaOrderFunctions,
+  PostExternalDeltaOrderParams,
+  PreSignExternalDeltaOrderFunctions,
+  // TWAP Delta types
+  BuildTWAPDeltaOrderParams,
+  BuildTWAPSellOrderParams,
+  BuildTWAPBuyOrderParams,
+  BuildTWAPDeltaOrderFunctions,
+  SignableTWAPOrderData,
+  SignTWAPDeltaOrderFunctions,
+  PostTWAPDeltaOrderFunctions,
+  PostTWAPDeltaOrderParams,
+  PreSignTWAPDeltaOrderFunctions,
   // types for Quote methods
   GetQuoteFunctions,
   QuoteParams,

package/src/methods/delta/buildDeltaOrder.ts

@@ -1,8 +1,4 @@
-import type {
-  ConstructFetchInput,
-  EnumerateLiteral,
-  RequestParameters,
-} from '../../types';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
 import { constructGetDeltaContract } from './getDeltaContract';
 import type { BridgePrice } from './getDeltaPrice';
 import { constructGetPartnerFee } from './getPartnerFee';
@@ -11,15 +7,13 @@ import {
   type BuildDeltaOrderDataInput,
   type SignableDeltaOrderData,
 } from './helpers/buildDeltaOrderData';
+import type { AmountsWithSlippage } from './helpers/types';
 import { SwapSideToOrderKind } from './helpers/types';
-import { SwapSide } from '../../constants';
+import { resolvePartnerFee, resolveAmounts } from './helpers/misc';
 import type { MarkOptional } from 'ts-essentials';
-import { ZERO_ADDRESS } from '../common/orders/buildOrderData';
 export type { SignableDeltaOrderData } from './helpers/buildDeltaOrderData';
 
-export type SwapSideUnion = EnumerateLiteral<typeof SwapSide>;
-
-export type BuildDeltaOrderDataParams = {
+type BuildDeltaOrderDataParamsBase = {
   /** @description The address of the order owner */
   owner: string;
   /** @description The address of the order beneficiary */
@@ -28,10 +22,6 @@ export type BuildDeltaOrderDataParams = {
   srcToken: string; // lowercase
   /** @description The address of the dest token. For Crosschain Order - destination token on the destination chain */
   destToken: string; // lowercase
-  /** @description The amount of src token to swap */
-  srcAmount: string; // wei
-  /** @description The minimum amount of dest token to receive */
-  destAmount: string; // wei, deltaPrice.destAmount - slippage
   /** @description The deadline for the order */
   deadline?: number; // seconds
   /** @description The nonce of the order */
@@ -68,12 +58,13 @@ export type BuildDeltaOrderDataParams = {
   /** @description A boolean indicating whether the surplus should be capped. True by default */
   capSurplus?: boolean;
 
-  /** @description The side of the order. Default is SELL */
-  side?: SwapSideUnion;
   /** @description Metadata for the order, hex string */
   metadata?: string;
 };
 
+export type BuildDeltaOrderDataParams = BuildDeltaOrderDataParamsBase &
+  AmountsWithSlippage;
+
 type BuildDeltaOrder = (
   buildOrderParams: BuildDeltaOrderDataParams,
   requestParams?: RequestParameters
@@ -100,50 +91,11 @@ export const constructBuildDeltaOrder = (
       throw new Error(`Delta is not available on chain ${chainId}`);
     }
 
-    ////// Partner logic //////
-
-    // externally supplied partner fee data takes precedence
-    let partnerAddress = options.partnerAddress;
-    let partnerFeeBps =
-      options.partnerFeeBps ??
-      (options.deltaPrice.partnerFee
-        ? options.deltaPrice.partnerFee * 100
-        : undefined);
-    let partnerTakesSurplus = options.partnerTakesSurplus;
-
-    // if fee given, takeSurplus is ignored
-    const feeOrTakeSurplusSupplied =
-      partnerFeeBps !== undefined || partnerTakesSurplus !== undefined;
-
-    if (partnerAddress === undefined || feeOrTakeSurplusSupplied) {
-      const partner = options.partner || options.deltaPrice.partner;
-      if (!partner) {
-        // if no partner given in options or deltaPrice, default partnerAddress to zero,
-        // unless supplied explicitly
-        partnerAddress = partnerAddress ?? ZERO_ADDRESS;
-      } else {
-        const partnerFeeResponse = await getPartnerFee(
-          { partner },
-          requestParams
-        );
-
-        partnerAddress = partnerAddress ?? partnerFeeResponse.partnerAddress;
-        // deltaPrice.partnerFee and partnerFeeResponse.partnerFee should be the same, but give priority to externally provided
-        partnerFeeBps = partnerFeeBps ?? partnerFeeResponse.partnerFee;
-        partnerTakesSurplus =
-          partnerTakesSurplus ?? partnerFeeResponse.takeSurplus;
-      }
-    }
-
-    partnerFeeBps = partnerFeeBps ?? 0;
-    partnerTakesSurplus = partnerTakesSurplus ?? false;
-
-    const swapSide = options.side ?? SwapSide.SELL;
+    const { partnerAddress, partnerFeeBps, partnerTakesSurplus } =
+      await resolvePartnerFee(options, getPartnerFee, requestParams);
 
-    const expectedAmount =
-      swapSide === SwapSide.SELL
-        ? options.deltaPrice.destAmount
-        : options.deltaPrice.srcAmount;
+    const { srcAmount, destAmount, expectedAmount, swapSide } =
+      resolveAmounts(options);
 
     const input: BuildDeltaOrderDataInput = {
       owner: options.owner,
@@ -152,8 +104,8 @@ export const constructBuildDeltaOrder = (
       // for some cases of WETH->ETH crosschain swaps, the destToken is changed to WETH or ETH,
       // this is already reflected in deltaPrice
       destToken: options.deltaPrice.destToken,
-      srcAmount: options.srcAmount,
-      destAmount: options.destAmount,
+      srcAmount,
+      destAmount,
       expectedAmount,
       deadline: options.deadline,
       nonce: options.nonce?.toString(10),