@velora-dex/sdk 9.0.0 → 9.2.0-dev.0

package/src/methods/limitOrders/helpers/types.ts

@@ -1,3 +1,4 @@
+import { OrderTransaction } from '../../common/orders/types';
 import type { OrderData } from './buildOrderData';
 
 export type LimitOrderType = 'LIMIT' | 'P2P';
@@ -36,10 +37,7 @@ export type LimitOrderState =
 
 export type LimitOrderEvent = '';
 
-export type LimitOrderTransaction = {
-  hash: string;
-  event_type: 'OrderFilled' | 'OrderCancelled';
-};
+export type LimitOrderTransaction = OrderTransaction;
 
 export type LimitOrderFromApi = {
   chainId: number;

package/src/methods/nftOrders/helpers/types.ts

@@ -1,11 +1,9 @@
 import type { Address } from '../../../types';
+import { OrderTransaction } from '../../common/orders/types';
 import type { NFTOrderData } from './buildOrderData';
 import type { AssetType } from './misc';
 
-export type NFTOrderTransaction = {
-  hash: string;
-  event_type: 'OrderFilled' | 'OrderCancelled';
-};
+export type NFTOrderTransaction = OrderTransaction;
 
 export type NFTOrderType = 'LIMIT' | 'P2P';
 

package/src/sdk/partial.ts

@@ -12,6 +12,7 @@ import type { CancelNFTOrderFunctions } from '../methods/nftOrders/cancelOrder';
 import type { ApproveTokenForNFTOrderFunctions } from '../methods/nftOrders/approveForOrder';
 import type { FillOrderDirectlyFunctions } from '../methods/limitOrders/fillOrderDirectly';
 import type { ApproveTokenForDeltaFunctions } from '../methods/delta/approveForDelta';
+import type { PreSignDeltaOrderFunctions } from '../methods/delta/preSignDeltaOrder';
 import { API_URL, DEFAULT_VERSION } from '../constants';
 
 export type SDKConfig<TxResponse = any> = ConstructProviderFetchInput<
@@ -50,7 +51,8 @@ type InferWithTxResponse<
           ApproveTokenForLimitOrderFunctions<TxResponse>,
           CancelNFTOrderFunctions<TxResponse>,
           ApproveTokenForNFTOrderFunctions<TxResponse>,
-          ApproveTokenForDeltaFunctions<TxResponse>
+          ApproveTokenForDeltaFunctions<TxResponse>,
+          PreSignDeltaOrderFunctions<TxResponse>
         ]
         // then merge IntersectionOfReturns<Funcs> with them recursively
       >

package/src/sdk/simple.ts

@@ -132,18 +132,10 @@ import {
   constructGetBridgeInfo,
   GetBridgeInfoFunctions,
 } from '../methods/delta/getBridgeInfo';
-import {
-  constructGetMulticallHandlers,
-  GetMulticallHandlersFunctions,
-} from '../methods/delta/getMulticallHandlers';
 import {
   constructIsTokenSupportedInDelta,
   IsTokenSupportedInDeltaFunctions,
 } from '../methods/delta/isTokenSupportedInDelta';
-import {
-  BuildCrosschainOrderBridgeFunctions,
-  constructBuildCrosschainOrderBridge,
-} from '../methods/delta/buildCrosschainOrderBridge';
 
 export type SwapFetchMethods = GetBalancesFunctions &
   GetTokensFunctions &
@@ -166,12 +158,10 @@ export type NFTOrdersFetchMethods = GetNFTOrdersContractFunctions &
   BuildNFTOrdersTxFunctions;
 
 export type DeltaFetchMethods = BuildDeltaOrderFunctions &
-  BuildCrosschainOrderBridgeFunctions &
   GetDeltaOrdersFunctions &
   GetDeltaPriceFunctions &
   GetDeltaContractFunctions &
   GetPartnerFeeFunctions &
-  GetMulticallHandlersFunctions &
   GetBridgeInfoFunctions &
   IsTokenSupportedInDeltaFunctions &
   PostDeltaOrderFunctions;
@@ -288,13 +278,11 @@ export function constructSimpleSDK(
     const delta = constructPartialSDK(
       config,
       constructBuildDeltaOrder,
-      constructBuildCrosschainOrderBridge,
       constructPostDeltaOrder,
       constructGetDeltaOrders,
       constructGetDeltaPrice,
       constructGetDeltaContract,
       constructGetPartnerFee,
-      constructGetMulticallHandlers,
       constructGetBridgeInfo,
       constructIsTokenSupportedInDelta
     );

package/dist/methods/delta/buildCrosschainOrderBridge.d.ts

@@ -1,23 +0,0 @@
-import type { ConstructFetchInput, RequestParameters } from '../../types';
-import { BridgePrice } from './getDeltaPrice';
-import { GetDeltaBridgeAndDestTokenOutput } from './helpers/across';
-import { BeneficiaryType } from '../common/orders/types';
-export type { SignableDeltaOrderData } from './helpers/buildDeltaOrderData';
-export type BuildCrosschainOrderBridgeParams = {
-    /** @description The address of the destination token on the destination chain */
-    destToken: string;
-    /** @description Destination Chain ID for Crosschain Orders */
-    destChainId: number;
-    /** @description Whether the beneficiary is a contract. Needed to automatically fill in crosschain Bridge */
-    beneficiaryType: BeneficiaryType;
-    /** @description price response received from /delta/prices (getDeltaPrice method) */
-    deltaPrice: BridgePrice;
-};
-type BuildCrosschainOrderBridge = (buildOrderParams: BuildCrosschainOrderBridgeParams, requestParams?: RequestParameters) => Promise<GetDeltaBridgeAndDestTokenOutput>;
-export { GetDeltaBridgeAndDestTokenOutput as CrosschainOrderBridgeAndChanges };
-export type BuildCrosschainOrderBridgeFunctions = {
-    /** @description Build Orders to be posted to Delta API for execution */
-    buildCrosschainOrderBridge: BuildCrosschainOrderBridge;
-};
-export declare const constructBuildCrosschainOrderBridge: (options: ConstructFetchInput) => BuildCrosschainOrderBridgeFunctions;
-//# sourceMappingURL=buildCrosschainOrderBridge.d.ts.map

package/dist/methods/delta/buildCrosschainOrderBridge.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildCrosschainOrderBridge.d.ts","sourceRoot":"","sources":["../../../src/methods/delta/buildCrosschainOrderBridge.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,OAAO,EAEL,gCAAgC,EACjC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,YAAY,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAE5E,MAAM,MAAM,gCAAgC,GAAG;IAC7C,iFAAiF;IACjF,SAAS,EAAE,MAAM,CAAC;IAClB,8DAA8D;IAC9D,WAAW,EAAE,MAAM,CAAC;IACpB,4GAA4G;IAC5G,eAAe,EAAE,eAAe,CAAC;IAEjC,qFAAqF;IACrF,UAAU,EAAE,WAAW,CAAC;CACzB,CAAC;AAEF,KAAK,0BAA0B,GAAG,CAChC,gBAAgB,EAAE,gCAAgC,EAClD,aAAa,CAAC,EAAE,iBAAiB,KAC9B,OAAO,CAAC,gCAAgC,CAAC,CAAC;AAE/C,OAAO,EAAE,gCAAgC,IAAI,+BAA+B,EAAE,CAAC;AAE/E,MAAM,MAAM,mCAAmC,GAAG;IAChD,wEAAwE;IACxE,0BAA0B,EAAE,0BAA0B,CAAC;CACxD,CAAC;AAEF,eAAO,MAAM,mCAAmC,YACrC,mBAAmB,KAC3B,mCA0DF,CAAC"}

package/dist/methods/delta/getMulticallHandlers.d.ts

@@ -1,9 +0,0 @@
-import type { Address, ConstructFetchInput, RequestParameters } from '../../types';
-export type MulticallHandlersResponse = Record<number, Address>;
-type GetMulticallHandlers = (requestParams?: RequestParameters) => Promise<MulticallHandlersResponse>;
-export type GetMulticallHandlersFunctions = {
-    getMulticallHandlers: GetMulticallHandlers;
-};
-export declare const constructGetMulticallHandlers: ({ apiURL, fetcher, }: ConstructFetchInput) => GetMulticallHandlersFunctions;
-export {};
-//# sourceMappingURL=getMulticallHandlers.d.ts.map

package/dist/methods/delta/getMulticallHandlers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getMulticallHandlers.d.ts","sourceRoot":"","sources":["../../../src/methods/delta/getMulticallHandlers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,OAAO,EACP,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAGrB,MAAM,MAAM,yBAAyB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEhE,KAAK,oBAAoB,GAAG,CAC1B,aAAa,CAAC,EAAE,iBAAiB,KAC9B,OAAO,CAAC,yBAAyB,CAAC,CAAC;AAExC,MAAM,MAAM,6BAA6B,GAAG;IAC1C,oBAAoB,EAAE,oBAAoB,CAAC;CAC5C,CAAC;AAEF,eAAO,MAAM,6BAA6B,yBAGvC,mBAAmB,KAAG,6BAqBxB,CAAC"}

package/dist/methods/delta/helpers/across.d.ts

@@ -1,19 +0,0 @@
-import { BeneficiaryType } from '../../common/orders/types';
-import { Bridge } from './types';
-export declare const ACROSS_WETH_ADDRESSES_MAP: Record<number, string>;
-export declare function isAcrossWETH(tokenAddress: string, chainId: number): boolean;
-export declare function isETHaddress(tokenAddress: string): boolean;
-export type GetDeltaBridgeAndDestTokenInput = {
-    destTokenDestChain: string;
-    destChainId: number;
-    bridgeFee: string;
-    bridgeOutputToken: string;
-    beneficiaryType: BeneficiaryType;
-    getMulticallHandler: (chainId: number) => Promise<string>;
-};
-export type GetDeltaBridgeAndDestTokenOutput = {
-    /** @description The bridge object to be used for Order.bridge */
-    bridge: Bridge;
-};
-export declare function getDeltaBridge({ destTokenDestChain, destChainId, bridgeFee, bridgeOutputToken, beneficiaryType, getMulticallHandler, }: GetDeltaBridgeAndDestTokenInput): Promise<GetDeltaBridgeAndDestTokenOutput>;
-//# sourceMappingURL=across.d.ts.map

package/dist/methods/delta/helpers/across.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"across.d.ts","sourceRoot":"","sources":["../../../../src/methods/delta/helpers/across.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEjC,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAuE5D,CAAC;AAEF,wBAAgB,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,WAKjE;AAQD,wBAAgB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAE1D;AAQD,MAAM,MAAM,+BAA+B,GAAG;IAC5C,kBAAkB,EAAE,MAAM,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,eAAe,CAAC;IACjC,mBAAmB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAC3D,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG;IAC7C,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAsB,cAAc,CAAC,EACnC,kBAAkB,EAClB,WAAW,EACX,SAAS,EACT,iBAAiB,EACjB,eAAe,EACf,mBAAmB,GACpB,EAAE,+BAA+B,GAAG,OAAO,CAAC,gCAAgC,CAAC,CAkE7E"}

package/src/methods/delta/buildCrosschainOrderBridge.ts

@@ -1,96 +0,0 @@
-import { assert } from 'ts-essentials';
-import type { ConstructFetchInput, RequestParameters } from '../../types';
-import { BridgePrice } from './getDeltaPrice';
-// import { constructGetMulticallHandlers } from './getMulticallHandlers';
-import {
-  // getDeltaBridge,
-  GetDeltaBridgeAndDestTokenOutput,
-} from './helpers/across';
-import { BeneficiaryType } from '../common/orders/types';
-export type { SignableDeltaOrderData } from './helpers/buildDeltaOrderData';
-
-export type BuildCrosschainOrderBridgeParams = {
-  /** @description The address of the destination token on the destination chain */
-  destToken: string; // lowercase
-  /** @description Destination Chain ID for Crosschain Orders */
-  destChainId: number;
-  /** @description Whether the beneficiary is a contract. Needed to automatically fill in crosschain Bridge */
-  beneficiaryType: BeneficiaryType;
-
-  /** @description price response received from /delta/prices (getDeltaPrice method) */
-  deltaPrice: BridgePrice;
-};
-
-type BuildCrosschainOrderBridge = (
-  buildOrderParams: BuildCrosschainOrderBridgeParams,
-  requestParams?: RequestParameters
-) => Promise<GetDeltaBridgeAndDestTokenOutput>;
-
-export { GetDeltaBridgeAndDestTokenOutput as CrosschainOrderBridgeAndChanges };
-
-export type BuildCrosschainOrderBridgeFunctions = {
-  /** @description Build Orders to be posted to Delta API for execution */
-  buildCrosschainOrderBridge: BuildCrosschainOrderBridge;
-};
-
-export const constructBuildCrosschainOrderBridge = (
-  options: ConstructFetchInput
-): BuildCrosschainOrderBridgeFunctions => {
-  const { chainId } = options;
-
-  // cached internally for `multicall` contracts
-  // const { getMulticallHandlers } = constructGetMulticallHandlers(options);
-
-  const buildCrosschainOrderBridge: BuildCrosschainOrderBridge = async (
-    { destToken, destChainId, beneficiaryType, deltaPrice },
-    requestParams
-  ) => {
-    assert(
-      chainId !== deltaPrice.bridge.destinationChainId,
-      '`deltaPrice.bridge.destinationChainId` must be different from `chainId` for crosschain Order.bridge'
-    );
-
-    assert(
-      destChainId === deltaPrice.bridge.destinationChainId,
-      '`destChainId` must match `deltaPrice.bridge.destinationChainId` for crosschain Order.bridge'
-    );
-
-    /* const getMulticallHandler = async (chainId: number) => {
-      const multicallHandlersMap = await getMulticallHandlers(requestParams);
-      const multicallHandler = multicallHandlersMap[chainId];
-
-      assert(
-        multicallHandler,
-        `Multicall handler not found for chain ${chainId}`
-      );
-
-      return multicallHandler;
-    };
-
-    const { bridge } = await getDeltaBridge({
-      destTokenDestChain: destToken,
-      destChainId,
-      bridgeFee: deltaPrice.bridgeFee,
-      bridgeOutputToken: deltaPrice.bridge.outputToken,
-      beneficiaryType,
-      getMulticallHandler,
-    }); */
-
-    // @TODO remove the whole buildCrosschainOrderBridge() when API provides BridgePrice.bridge = whole Bridge object
-    const bridge = {
-      protocolSelector: '0x00000000',
-      scalingFactor: 0,
-      protocolData: '0x',
-      destinationChainId: deltaPrice.bridge.destinationChainId,
-      outputToken: deltaPrice.bridge.outputToken,
-    };
-
-    return {
-      bridge,
-    };
-  };
-
-  return {
-    buildCrosschainOrderBridge,
-  };
-};

package/src/methods/delta/getMulticallHandlers.ts

@@ -1,44 +0,0 @@
-import { API_URL } from '../../constants';
-import { runOnceAndCache } from '../../helpers/misc';
-import type {
-  Address,
-  ConstructFetchInput,
-  RequestParameters,
-} from '../../types';
-
-// chainId -> multicallHandler
-export type MulticallHandlersResponse = Record<number, Address>;
-
-type GetMulticallHandlers = (
-  requestParams?: RequestParameters
-) => Promise<MulticallHandlersResponse>;
-
-export type GetMulticallHandlersFunctions = {
-  getMulticallHandlers: GetMulticallHandlers;
-};
-
-export const constructGetMulticallHandlers = ({
-  apiURL = API_URL,
-  fetcher,
-}: ConstructFetchInput): GetMulticallHandlersFunctions => {
-  const multicallHandlersUrl =
-    `${apiURL}/delta/prices/multicall-handlers` as const;
-
-  const _getMulticallHandlers: GetMulticallHandlers = async (requestParams) => {
-    const data = await fetcher<MulticallHandlersResponse>({
-      url: multicallHandlersUrl,
-      method: 'GET',
-      requestParams,
-    });
-
-    return data;
-  };
-
-  // cached for the same instance of `{getMulticallHandlers} = constructGetMulticallHandlers()`
-  // so should persist across same apiUrl & network (and response is even network agnostic)
-  const getMulticallHandlers = runOnceAndCache(_getMulticallHandlers);
-
-  return {
-    getMulticallHandlers,
-  };
-};

package/src/methods/delta/helpers/across.ts

@@ -1,189 +0,0 @@
-import { assert } from 'ts-essentials';
-import { ZERO_ADDRESS } from '../../common/orders/buildOrderData';
-import { BeneficiaryType } from '../../common/orders/types';
-import { Bridge } from './types';
-
-export const ACROSS_WETH_ADDRESSES_MAP: Record<number, string> = {
-  // Mainnet
-  1: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
-  // Sepolia
-  11155111: '0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14',
-  // Base
-  8453: '0x4200000000000000000000000000000000000006',
-  // Base Sepolia
-  84532: '0x4200000000000000000000000000000000000006',
-  // Optimism
-  10: '0x4200000000000000000000000000000000000006',
-  // Optimism Sepolia
-  11155420: '0x4200000000000000000000000000000000000006',
-  // Polygon
-  137: '0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619',
-  // Polygon Amoy
-  80002: '0x52eF3d68BaB452a294342DC3e5f464d7f610f72E',
-  // Aleph Zero
-  41455: '0xB3f0eE446723f4258862D949B4c9688e7e7d35d3',
-  // Arbitrum
-  42161: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
-  // Arbitrum Sepolia
-  421614: '0x980B62Da83eFf3D4576C647993b0c1D7faf17c73',
-  // Boba
-  288: '0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000',
-  // Blast
-  81457: '0x4300000000000000000000000000000000000004',
-  // Blast Sepolia
-  168587773: '0x4200000000000000000000000000000000000023',
-  // BSC
-  56: '0x2170Ed0880ac9A755fd29B2688956BD959F933F8',
-  // Ink
-  57073: '0x4200000000000000000000000000000000000006',
-  // Ink Sepolia
-  763373: '0x4200000000000000000000000000000000000006',
-  // Lens
-  232: '0xE5ecd226b3032910CEaa43ba92EE8232f8237553',
-  // Lens Sepolia
-  37111: '0xaA91D645D7a6C1aeaa5988e0547267B77d33fe16',
-  // Linea
-  59144: '0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f',
-  // Lisk
-  1135: '0x4200000000000000000000000000000000000006',
-  // Lisk Sepolia
-  4202: '0x4200000000000000000000000000000000000006',
-  // Mode
-  34443: '0x4200000000000000000000000000000000000006',
-  // Mode Sepolia
-  919: '0x4200000000000000000000000000000000000006',
-  // Redstone
-  690: '0x4200000000000000000000000000000000000006',
-  // Scroll
-  534352: '0x5300000000000000000000000000000000000004',
-  // Scroll Sepolia
-  534351: '0x5300000000000000000000000000000000000004',
-  // Soneium
-  1868: '0x4200000000000000000000000000000000000006',
-  // Tatara
-  129399: '0x17B8Ee96E3bcB3b04b3e8334de4524520C51caB4',
-  // Unichain
-  130: '0x4200000000000000000000000000000000000006',
-  // Unichain Sepolia
-  1301: '0x4200000000000000000000000000000000000006',
-  // World Chain
-  480: '0x4200000000000000000000000000000000000006',
-  // ZK Sync
-  324: '0x5AEa5775959fBC2557Cc8789bC1bf90A239D9a91',
-  // ZK Sync Sepolia
-  300: '0x2D6Db36B3117802E996f13073A08A685D3FeF7eD',
-  // Zora
-  7777777: '0x4200000000000000000000000000000000000006',
-};
-
-export function isAcrossWETH(tokenAddress: string, chainId: number) {
-  return (
-    ACROSS_WETH_ADDRESSES_MAP[chainId]?.toLowerCase() ===
-    tokenAddress.toLowerCase()
-  );
-}
-
-const ETH_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
-
-const ETH_ADDRESS_LOWERCASE = ETH_ADDRESS.toLowerCase() as Lowercase<
-  typeof ETH_ADDRESS
->;
-
-export function isETHaddress(tokenAddress: string): boolean {
-  return tokenAddress.toLowerCase() === ETH_ADDRESS_LOWERCASE;
-}
-
-// WETH > ETH Across logic
-// https://docs.across.to/introduction/technical-faq#what-is-the-behavior-of-eth-weth-in-transfers
-
-// Velora API ref
-// https://developers.velora.xyz/api/velora-api/velora-delta-api/build-a-delta-order-to-sign
-
-export type GetDeltaBridgeAndDestTokenInput = {
-  destTokenDestChain: string; // the token user wants to ultimately receive
-  destChainId: number;
-  bridgeFee: string;
-  bridgeOutputToken: string; // the token on the destination chain, in case of WETH -> ETH, will be different from destTokenDestChain and unwrapped
-  beneficiaryType: BeneficiaryType;
-  getMulticallHandler: (chainId: number) => Promise<string>;
-};
-
-export type GetDeltaBridgeAndDestTokenOutput = {
-  /** @description The bridge object to be used for Order.bridge */
-  bridge: Bridge;
-};
-
-export async function getDeltaBridge({
-  destTokenDestChain,
-  destChainId,
-  bridgeFee,
-  bridgeOutputToken,
-  beneficiaryType,
-  getMulticallHandler,
-}: GetDeltaBridgeAndDestTokenInput): Promise<GetDeltaBridgeAndDestTokenOutput> {
-  assert(
-    beneficiaryType === 'EOA' || beneficiaryType === 'SmartContract',
-    'beneficiaryType must be EOA or SmartContract'
-  );
-
-  const outputToken = bridgeOutputToken.toLowerCase(); // for uniformity
-
-  let multiCallHandler: string = ZERO_ADDRESS;
-
-  if (beneficiaryType === 'EOA' && isETHaddress(destTokenDestChain)) {
-    /*
-    if beneficiary is an EOA and destToken on destChain = ETH
-    order.destToken=ETH (deltaPrice already contains correct destToken)
-    order.bridge.outputToken=WETH_DEST_CHAIN (deltaPrice already contains correct bridge.outputToken)
-    order.bridge.multiCallHandler=NULL_ADDRESS
-    */
-
-    multiCallHandler = ZERO_ADDRESS;
-  }
-  if (
-    beneficiaryType === 'EOA' &&
-    isAcrossWETH(destTokenDestChain, destChainId)
-  ) {
-    /*
-    if beneficiary is an EOA and destToken on destChain = WETH
-    order.destToken=WETH (deltaPrice already contains correct destToken)
-    order.bridge.outputToken=WETH_DEST_CHAIN (deltaPrice already contains correct bridge.outputToken)
-    order.bridge.multiCallHandler=MULTI_CALL_HANDLER
-    */
-    multiCallHandler = await getMulticallHandler(destChainId);
-  }
-
-  if (beneficiaryType === 'SmartContract' && isETHaddress(destTokenDestChain)) {
-    /* 
-      if beneficiary is a contract and destToken on destChain = ETH
-      order.destToken=ETH (deltaPrice already contains correct destToken)
-      order.bridge.outputToken=WETH_DEST_CHAIN (deltaPrice already contains correct bridge.outputToken)
-      order.bridge.multiCallHandler=MULTI_CALL_HANDLER
-      */
-    multiCallHandler = await getMulticallHandler(destChainId);
-  }
-
-  if (
-    beneficiaryType === 'SmartContract' &&
-    isAcrossWETH(destTokenDestChain, destChainId)
-  ) {
-    /*
-      if beneficiary is a contract and destToken on destChain = WETH
-      order.destToken=WETH (deltaPrice already contains correct destToken)
-      order.bridge.outputToken=WETH_DEST_CHAIN (deltaPrice already contains correct bridge.outputToken)
-      order.bridge.multiCallHandler=NULL_ADDRESS
-    */
-    multiCallHandler = ZERO_ADDRESS;
-  }
-
-  const bridge: Bridge = {
-    maxRelayerFee: bridgeFee,
-    destinationChainId: destChainId,
-    outputToken,
-    multiCallHandler,
-  } as any; // @TODO remove the whole getDeltaBridge() when API provides BridgePrice.bridge = whole Bridge object
-
-  return {
-    bridge,
-  };
-}