@velora-dex/sdk 8.0.0 → 8.1.1-dev.0

package/src/methods/delta/cancelDeltaOrder.ts

@@ -0,0 +1,111 @@
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+} from '../../types';
+import { DeltaAuction } from './helpers/types';
+import {
+  buildCancelDeltaOrderSignableData,
+  CancelDeltaOrderData,
+} from './helpers/buildCancelDeltaOrderData';
+import { constructGetDeltaContract } from '../..';
+
+type SuccessResponse = { success: true };
+
+type CancelDeltaOrderRequestParams = {
+  orderIds: string[];
+  signature: string;
+};
+
+export type SignCancelDeltaOrderRequest = (
+  params: CancelDeltaOrderData,
+  requestParams?: RequestParameters
+) => Promise<string>;
+
+export type PostCancelDeltaOrderRequest = (
+  params: CancelDeltaOrderRequestParams,
+  requestParams?: RequestParameters
+) => Promise<SuccessResponse>;
+
+export type CancelDeltaOrder = (
+  params: Pick<DeltaAuction, 'id'>[],
+  requestParams?: RequestParameters
+) => Promise<SuccessResponse>;
+
+export type CancelDeltaOrderFunctions = {
+  signCancelLimitDeltaOrderRequest: SignCancelDeltaOrderRequest;
+  postCancelLimitDeltaOrderRequest: PostCancelDeltaOrderRequest;
+  /** @description Cancel a Limit Delta order */
+  cancelLimitDeltaOrders: CancelDeltaOrder;
+};
+
+export const constructCancelDeltaOrder = (
+  options: Pick<
+    ConstructProviderFetchInput<any, 'signTypedDataCall'>,
+    'contractCaller' | 'fetcher' | 'apiURL' | 'chainId'
+  >
+): CancelDeltaOrderFunctions => {
+  // cached internally
+  const { getDeltaContract } = constructGetDeltaContract(options);
+
+  const signCancelLimitDeltaOrderRequest: SignCancelDeltaOrderRequest = async (
+    params,
+    requestParams
+  ) => {
+    const ParaswapDelta = await getDeltaContract(requestParams);
+    if (!ParaswapDelta) {
+      throw new Error(`Delta is not available on chain ${options.chainId}`);
+    }
+
+    const typedData = buildCancelDeltaOrderSignableData({
+      orderInput: params,
+      paraswapDeltaAddress: ParaswapDelta,
+      chainId: options.chainId,
+    });
+    const signature = await options.contractCaller.signTypedDataCall(typedData);
+
+    return signature;
+  };
+
+  const postCancelLimitDeltaOrderRequest: PostCancelDeltaOrderRequest = async (
+    params,
+    requestParams
+  ) => {
+    const cancelUrl = `${options.apiURL}/delta/orders/cancel` as const;
+
+    const res = await options.fetcher<SuccessResponse>({
+      url: cancelUrl,
+      method: 'POST',
+      data: params,
+      requestParams,
+    });
+
+    return res;
+  };
+
+  const cancelLimitDeltaOrders: CancelDeltaOrder = async (
+    params,
+    requestParams
+  ) => {
+    const orderIds = params.map(({ id }) => id);
+    const signature = await signCancelLimitDeltaOrderRequest(
+      { orderIds },
+      requestParams
+    );
+
+    const res = await postCancelLimitDeltaOrderRequest(
+      {
+        orderIds,
+        signature,
+      },
+      requestParams
+    );
+
+    return res;
+  };
+
+  return {
+    signCancelLimitDeltaOrderRequest,
+    postCancelLimitDeltaOrderRequest,
+    cancelLimitDeltaOrders,
+  };
+};

package/src/methods/delta/getDeltaOrders.ts

@@ -26,6 +26,10 @@ type OrdersFilter = {
   page?: number;
   /** @description Pagination option, limit. Default 100 */
   limit?: number;
+  /** @description Filter by chainId, without this filter, orders from all chains are returned */
+  chainId?: number; // @TODO currently not working
+  /** @description Filter by type. MARKET, LIMIT, or ALL. Default is ALL */
+  type?: 'MARKET' | 'LIMIT' | 'ALL';
 };
 type OrderFiltersQuery = OrdersFilter;
 
@@ -34,15 +38,27 @@ type GetDeltaOrders = (
   requestParams?: RequestParameters
 ) => Promise<OrderFromAPI[]>;
 
+type GetRequiredBalanceParams = {
+  userAddress: Address;
+  tokenAddress?: Address;
+};
+
+type GetRequiredBalance = (
+  userParams: GetRequiredBalanceParams,
+  requestParams?: RequestParameters
+) => Promise<Record<string, string>>; // token -> balance in Limit Orders
+
 export type GetDeltaOrdersFunctions = {
   getDeltaOrderById: GetDeltaOrderById;
   getDeltaOrderByHash: GetDeltaOrderByHash;
   getDeltaOrders: GetDeltaOrders;
+  getRequiredBalanceForDeltaLimitOrders: GetRequiredBalance;
 };
 
 export const constructGetDeltaOrders = ({
   apiURL = API_URL,
   fetcher,
+  chainId,
 }: ConstructFetchInput): GetDeltaOrdersFunctions => {
   const baseUrl = `${apiURL}/delta/orders` as const;
 
@@ -81,6 +97,8 @@ export const constructGetDeltaOrders = ({
       userAddress: options.userAddress,
       page: options.page,
       limit: options.limit,
+      chainId: options.chainId,
+      type: options.type,
     });
 
     const fetchURL = `${baseUrl}${search}` as const;
@@ -94,9 +112,29 @@ export const constructGetDeltaOrders = ({
     return orders;
   };
 
+  const getRequiredBalanceForDeltaLimitOrders: GetRequiredBalance = async (
+    userParams,
+    requestParams
+  ) => {
+    const userURL =
+      `${baseUrl}/fillablebalance/${chainId}/${userParams.userAddress}` as const;
+    const fetchURL = userParams.tokenAddress
+      ? (`${userURL}/${userParams.tokenAddress}` as const)
+      : userURL;
+
+    const response = await fetcher<Record<string, string>>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return response;
+  };
+
   return {
     getDeltaOrderById,
     getDeltaOrderByHash,
     getDeltaOrders,
+    getRequiredBalanceForDeltaLimitOrders,
   };
 };

package/src/methods/delta/getDeltaPrice.ts

@@ -1,6 +1,15 @@
+import { Bridge } from '../..';
 import { API_URL, SwapSide } from '../../constants';
 import { constructSearchString } from '../../helpers/misc';
-import type { ConstructFetchInput, RequestParameters } from '../../types';
+import type {
+  ConstructFetchInput,
+  EnumerateLiteral,
+  RequestParameters,
+} from '../../types';
+import { ZERO_ADDRESS } from '../common/orders/buildOrderData';
+import { BridgePriceInfo } from './helpers/types';
+
+type SwapSideUnion = EnumerateLiteral<typeof SwapSide>;
 
 export type DeltaPriceParams = {
   /** @description Source Token Address. Not Native Token */
@@ -13,44 +22,70 @@ export type DeltaPriceParams = {
   srcDecimals: number;
   /** @description Destination Token Decimals */
   destDecimals: number;
-  // side?: SwapSide; // no BUY side for now
   /** @description User's Wallet Address */
   userAddress?: string;
   /** @description Partner string. */
   partner?: string;
   /** @description Destination Chain ID for Crosschain Orders */
   destChainId?: number;
+  /** @description SELL or BUY, default is SELL */
+  side?: SwapSideUnion;
+
+  includeAgents?: string[];
+  excludeAgents?: string[];
 };
 
-type DeltaPriceQueryOptions = DeltaPriceParams & {
+type DeltaPriceQueryOptions = Omit<
+  DeltaPriceParams,
+  'includeAgents' | 'excludeAgents'
+> & {
   chainId: number; // will return error from API on unsupported chains
-  side: SwapSide.SELL;
+  includeAgents?: string;
+  excludeAgents?: string;
 };
 
+// for same-chain Orders, all 0 params
+export const DEFAULT_BRIDGE = {
+  protocolSelector: '0x00000000', // 4 bytes
+  destinationChainId: 0,
+  outputToken: ZERO_ADDRESS,
+  scalingFactor: 0,
+  protocolData: '0x',
+} as const satisfies Bridge;
+
 export type DeltaPrice = {
   srcToken: string;
   destToken: string;
   srcAmount: string;
+  /** @description Available for BUY side */
+  srcAmountBeforeFee?: string;
   destAmount: string;
-  destAmountBeforeFee: string;
+  /** @description Available for SELL side */
+  destAmountBeforeFee?: string;
   gasCost: string;
   gasCostBeforeFee: string;
   gasCostUSD: string;
   gasCostUSDBeforeFee: string;
   srcUSD: string;
+  /** @description Available for BUY side */
+  srcUSDBeforeFee?: string;
   destUSD: string;
-  destUSDBeforeFee: string;
+  /** @description Available for SELL side */
+  destUSDBeforeFee?: string;
   partner: string;
   partnerFee: number; // in %
   hmac: string;
+  bridge: Bridge; // for single-chain DeltaPrice, it's DEFAULT_BRIDGE
 };
 
-export type BridgePrice = DeltaPrice & {
-  destAmountAfterBridge: string;
-  destUSDAfterBridge: string;
-  bridgeFee: string;
-  bridgeFeeUSD: string;
-  poolAddress: string;
+export type BridgePrice = Omit<DeltaPrice, 'bridge'> & {
+  // destAmountAfterBridge: string; // became bridgeInfo.destAmountAfterBridge
+  // destUSDAfterBridge: string; // became bridgeInfo.destUSDAfterBridge
+  // bridgeFee: string; // became bridgeInfo.fees[0].amount
+  // bridgeFeeUSD: string; // became bridgeInfo.fees[0].amountInUSD
+  // poolAddress: string;
+  bridge: Bridge;
+  bridgeInfo: BridgePriceInfo;
 };
 
 type DeltaPriceResponse = {
@@ -99,10 +134,20 @@ export const constructGetDeltaPrice = ({
     options: DeltaPriceParams,
     requestParams?: RequestParameters
   ): Promise<DeltaPrice | BridgePrice> {
+    const { includeAgents, excludeAgents, ...rest } = options;
+    const includeAgentsString = includeAgents
+      ? includeAgents.join(',')
+      : undefined;
+    const excludeAgentsString = excludeAgents
+      ? excludeAgents.join(',')
+      : undefined;
+
     const search = constructSearchString<DeltaPriceQueryOptions>({
-      ...options,
+      ...rest,
       chainId,
-      side: SwapSide.SELL, // so far SELL side only
+      side: options.side ?? SwapSide.SELL,
+      includeAgents: includeAgentsString,
+      excludeAgents: excludeAgentsString,
     });
 
     const fetchURL = `${pricesUrl}/${search}` as const;

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

@@ -1,7 +1,7 @@
 import { assert } from 'ts-essentials';
 import { ZERO_ADDRESS } from '../../common/orders/buildOrderData';
 import { BeneficiaryType } from '../../common/orders/types';
-import { Bridge, DeltaAuctionOrder } from './types';
+import { Bridge } from './types';
 
 export const ACROSS_WETH_ADDRESSES_MAP: Record<number, string> = {
   // Mainnet
@@ -32,6 +32,8 @@ export const ACROSS_WETH_ADDRESSES_MAP: Record<number, string> = {
   81457: '0x4300000000000000000000000000000000000004',
   // Blast Sepolia
   168587773: '0x4200000000000000000000000000000000000023',
+  // BSC
+  56: '0x2170Ed0880ac9A755fd29B2688956BD959F933F8',
   // Ink
   57073: '0x4200000000000000000000000000000000000006',
   // Ink Sepolia
@@ -98,11 +100,10 @@ export function isETHaddress(tokenAddress: string): boolean {
 // https://developers.velora.xyz/api/velora-api/velora-delta-api/build-a-delta-order-to-sign
 
 export type GetDeltaBridgeAndDestTokenInput = {
-  destTokenDestChain: string;
+  destTokenDestChain: string; // the token user wants to ultimately receive
   destChainId: number;
-  destTokenSrcChain: string;
-  srcChainId: 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>;
 };
@@ -110,16 +111,13 @@ export type GetDeltaBridgeAndDestTokenInput = {
 export type GetDeltaBridgeAndDestTokenOutput = {
   /** @description The bridge object to be used for Order.bridge */
   bridge: Bridge;
-  /** @description The changes to be made to the Order */
-  orderChanges: Pick<DeltaAuctionOrder, 'destToken'>;
 };
 
-export async function getDeltaBridgeAndDestToken({
+export async function getDeltaBridge({
   destTokenDestChain,
   destChainId,
-  destTokenSrcChain,
-  srcChainId,
   bridgeFee,
+  bridgeOutputToken,
   beneficiaryType,
   getMulticallHandler,
 }: GetDeltaBridgeAndDestTokenInput): Promise<GetDeltaBridgeAndDestTokenOutput> {
@@ -127,48 +125,20 @@ export async function getDeltaBridgeAndDestToken({
     beneficiaryType === 'EOA' || beneficiaryType === 'SmartContract',
     'beneficiaryType must be EOA or SmartContract'
   );
-  const WETH_SRC_CHAIN = ACROSS_WETH_ADDRESSES_MAP[srcChainId];
-
-  const WETH_DEST_CHAIN = ACROSS_WETH_ADDRESSES_MAP[destChainId];
-
-  if (!WETH_SRC_CHAIN || !WETH_DEST_CHAIN) {
-    // this should never happen as we only expect crosschain Delta Orders for supported chains
-    const bridge: Bridge = {
-      maxRelayerFee: bridgeFee,
-      destinationChainId: destChainId,
-      outputToken: destTokenDestChain,
-      multiCallHandler: ZERO_ADDRESS,
-    };
-
-    return {
-      bridge,
-      orderChanges: {
-        destToken: destTokenSrcChain,
-      },
-    };
-  }
+
+  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
-    order.bridge.outputToken=WETH_DEST_CHAIN
+    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
     */
 
-    const bridge: Bridge = {
-      maxRelayerFee: bridgeFee,
-      destinationChainId: destChainId,
-      outputToken: WETH_DEST_CHAIN,
-      multiCallHandler: ZERO_ADDRESS,
-    };
-
-    return {
-      bridge,
-      orderChanges: {
-        destToken: ETH_ADDRESS,
-      },
-    };
+    multiCallHandler = ZERO_ADDRESS;
   }
   if (
     beneficiaryType === 'EOA' &&
@@ -176,43 +146,21 @@ export async function getDeltaBridgeAndDestToken({
   ) {
     /*
     if beneficiary is an EOA and destToken on destChain = WETH
-    order.destToken=WETH
-    order.bridge.outputToken=WETH_DEST_CHAIN
+    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
     */
-    const bridge: Bridge = {
-      maxRelayerFee: bridgeFee,
-      destinationChainId: destChainId,
-      outputToken: WETH_DEST_CHAIN,
-      multiCallHandler: await getMulticallHandler(destChainId),
-    };
-    return {
-      bridge,
-      orderChanges: {
-        destToken: WETH_SRC_CHAIN,
-      },
-    };
+    multiCallHandler = await getMulticallHandler(destChainId);
   }
 
   if (beneficiaryType === 'SmartContract' && isETHaddress(destTokenDestChain)) {
     /* 
       if beneficiary is a contract and destToken on destChain = ETH
-      order.destToken=ETH
-      order.bridge.outputToken=WETH_DEST_CHAIN
+      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
       */
-    const bridge: Bridge = {
-      maxRelayerFee: bridgeFee,
-      destinationChainId: destChainId,
-      outputToken: WETH_DEST_CHAIN,
-      multiCallHandler: await getMulticallHandler(destChainId),
-    };
-    return {
-      bridge,
-      orderChanges: {
-        destToken: ETH_ADDRESS,
-      },
-    };
+    multiCallHandler = await getMulticallHandler(destChainId);
   }
 
   if (
@@ -221,35 +169,21 @@ export async function getDeltaBridgeAndDestToken({
   ) {
     /*
       if beneficiary is a contract and destToken on destChain = WETH
-      order.destToken=WETH
-      order.bridge.outputToken=WETH_DEST_CHAIN
+      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
     */
-    const bridge: Bridge = {
-      maxRelayerFee: bridgeFee,
-      destinationChainId: destChainId,
-      outputToken: WETH_DEST_CHAIN,
-      multiCallHandler: ZERO_ADDRESS,
-    };
-    return {
-      bridge,
-      orderChanges: {
-        destToken: WETH_SRC_CHAIN,
-      },
-    };
+    multiCallHandler = ZERO_ADDRESS;
   }
 
   const bridge: Bridge = {
     maxRelayerFee: bridgeFee,
     destinationChainId: destChainId,
-    outputToken: destTokenDestChain,
-    multiCallHandler: ZERO_ADDRESS,
-  };
+    outputToken,
+    multiCallHandler,
+  } as any; // @TODO remove the whole getDeltaBridge() when API provides BridgePrice.bridge = whole Bridge object
 
   return {
     bridge,
-    orderChanges: {
-      destToken: destTokenSrcChain,
-    },
   };
 }

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

@@ -0,0 +1,48 @@
+import { Domain } from '../../common/orders/buildOrderData';
+
+const ORDER_CANCELLATIONS_EIP_712_TYPES = {
+  OrderCancellations: [{ name: 'orderIds', type: 'string[]' }],
+};
+
+export type CancelDeltaOrderData = {
+  orderIds: string[];
+};
+
+export type SignableCancelDeltaOrderData = {
+  types: {
+    OrderCancellations: (typeof ORDER_CANCELLATIONS_EIP_712_TYPES)['OrderCancellations'];
+  };
+  domain: Domain;
+  data: CancelDeltaOrderData;
+};
+
+type BuildCancelDeltaOrderInput = {
+  orderInput: CancelDeltaOrderData;
+  paraswapDeltaAddress: string;
+  chainId: number;
+};
+
+export function buildCancelDeltaOrderSignableData({
+  orderInput,
+  chainId,
+  paraswapDeltaAddress,
+}: BuildCancelDeltaOrderInput): SignableCancelDeltaOrderData {
+  const typedData = {
+    types: {
+      OrderCancellations: ORDER_CANCELLATIONS_EIP_712_TYPES.OrderCancellations,
+    },
+    domain: {
+      name: 'Portikus',
+      version: '2.0.0',
+      chainId,
+      verifyingContract: paraswapDeltaAddress,
+    },
+    data: {
+      // explicityly pick only the necessary fields,
+      // otherwise signing will break if more is present
+      orderIds: orderInput.orderIds,
+    },
+  };
+
+  return typedData;
+}

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

@@ -1,7 +1,6 @@
 import { MarkOptional } from 'ts-essentials';
 import { Domain, ZERO_ADDRESS } from '../../common/orders/buildOrderData';
 import { Bridge, DeltaAuctionOrder } from './types';
-import { composeDeltaOrderPermit } from './composePermit';
 
 // Order(address owner,address beneficiary,address srcToken,address destToken,uint256 srcAmount,uint256 destAmount,uint256 deadline,uint256 nonce,bytes permit, bridge Bridge)";
 const SWAP_ORDER_EIP_712_TYPES = {
@@ -12,18 +11,36 @@ const SWAP_ORDER_EIP_712_TYPES = {
     { name: 'destToken', type: 'address' },
     { name: 'srcAmount', type: 'uint256' },
     { name: 'destAmount', type: 'uint256' },
-    { name: 'expectedDestAmount', type: 'uint256' },
+    { name: 'expectedAmount', type: 'uint256' },
     { name: 'deadline', type: 'uint256' },
+    { name: 'kind', type: 'uint8' },
     { name: 'nonce', type: 'uint256' },
     { name: 'partnerAndFee', type: 'uint256' },
     { name: 'permit', type: 'bytes' },
+    { name: 'metadata', type: 'bytes' },
     { name: 'bridge', type: 'Bridge' },
   ],
   Bridge: [
-    { name: 'maxRelayerFee', type: 'uint256' },
-    { name: 'destinationChainId', type: 'uint256' },
-    { name: 'outputToken', type: 'address' },
-    { name: 'multiCallHandler', type: 'address' },
+    {
+      name: 'protocolSelector',
+      type: 'bytes4',
+    },
+    {
+      name: 'destinationChainId',
+      type: 'uint256',
+    },
+    {
+      name: 'outputToken',
+      type: 'address',
+    },
+    {
+      name: 'scalingFactor',
+      type: 'int8',
+    },
+    {
+      name: 'protocolData',
+      type: 'bytes',
+    },
   ],
 };
 
@@ -69,7 +86,10 @@ export type DeltaOrderDataInput = MarkOptional<
   'beneficiary' | 'deadline' | 'nonce' | 'permit'
 >;
 
-export type BuildDeltaOrderDataInput = DeltaOrderDataInput & {
+export type BuildDeltaOrderDataInput = MarkOptional<
+  DeltaOrderDataInput,
+  'metadata'
+> & {
   partnerAddress: string;
   paraswapDeltaAddress: string;
   partnerFeeBps: number;
@@ -78,7 +98,7 @@ export type BuildDeltaOrderDataInput = DeltaOrderDataInput & {
   bridge: Bridge;
 };
 
-// default deadline = 1 hour from now (may be changed later)
+// default deadline = 1 hour for now (may be changed later)
 export const DELTA_DEFAULT_EXPIRY = 60 * 60; // seconds
 
 export function buildDeltaSignableOrderData({
@@ -89,13 +109,16 @@ export function buildDeltaSignableOrderData({
   destToken,
   srcAmount,
   destAmount,
-  expectedDestAmount,
+  expectedAmount,
 
   deadline = Math.floor(Date.now() / 1000 + DELTA_DEFAULT_EXPIRY),
   nonce = Date.now().toString(10), // random enough to not cause collisions
 
   permit = '0x',
 
+  kind,
+  metadata = '0x',
+
   partnerAddress,
   partnerFeeBps,
   partnerTakesSurplus = false,
@@ -111,16 +134,18 @@ export function buildDeltaSignableOrderData({
     destToken,
     srcAmount,
     destAmount,
-    expectedDestAmount,
+    expectedAmount,
     deadline,
     nonce,
-    permit: composeDeltaOrderPermit({ permit, nonce }),
+    permit,
     partnerAndFee: producePartnerAndFee({
       partnerFeeBps,
       partnerAddress,
       partnerTakesSurplus,
     }),
     bridge,
+    kind,
+    metadata,
   };
 
   return produceDeltaOrderTypedData({

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

@@ -7,12 +7,14 @@ export function sanitizeDeltaOrderData({
   destToken,
   srcAmount,
   destAmount,
-  expectedDestAmount,
+  expectedAmount,
   deadline,
   nonce,
   permit,
   partnerAndFee,
   bridge,
+  kind,
+  metadata,
 }: SignableDeltaOrderData['data'] &
   Record<string, any>): SignableDeltaOrderData['data'] {
   return {
@@ -22,11 +24,13 @@ export function sanitizeDeltaOrderData({
     destToken,
     srcAmount,
     destAmount,
-    expectedDestAmount,
+    expectedAmount,
     deadline,
     nonce,
     permit,
     partnerAndFee,
     bridge,
+    kind,
+    metadata,
   };
 }