@velora-dex/sdk 8.1.0 → 8.1.1-dev.1

package/package.json

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

package/src/helpers/providers/viem.ts

@@ -23,7 +23,10 @@ import { TransactionParams } from '../../methods/swap/transaction';
 
 export type MinViemClient = Partial<
   Pick<PublicActions<Transport, Chain>, 'readContract'> &
-    Pick<WalletActions<Chain>, 'writeContract' | 'signTypedData'>
+    Pick<
+      WalletActions<Chain>,
+      'writeContract' | 'signTypedData' | 'signMessage'
+    >
 > & { account?: Account };
 
 export const constructContractCaller = (

package/src/index.ts

@@ -206,6 +206,10 @@ import {
   QuoteWithMarketPrice,
   QuoteWithMarketPriceAsFallback,
 } from './methods/quote/getQuote';
+import {
+  CancelDeltaOrderFunctions,
+  constructCancelDeltaOrder,
+} from './methods/delta/cancelDeltaOrder';
 
 export { constructSwapSDK, SwapSDKMethods } from './methods/swap';
 
@@ -289,6 +293,7 @@ export {
   constructGetDeltaContract,
   constructGetDeltaPrice,
   constructGetDeltaOrders,
+  constructCancelDeltaOrder,
   constructApproveTokenForDelta,
   // Quote methods
   constructGetQuote,
@@ -378,6 +383,7 @@ export type {
   GetDeltaPriceFunctions,
   GetDeltaOrdersFunctions,
   ApproveTokenForDeltaFunctions,
+  CancelDeltaOrderFunctions,
   // types for Quote methods
   GetQuoteFunctions,
   QuoteParams,

package/src/methods/delta/buildCrosschainOrderBridge.ts

@@ -1,9 +1,9 @@
 import { assert } from 'ts-essentials';
 import type { ConstructFetchInput, RequestParameters } from '../../types';
 import { BridgePrice } from './getDeltaPrice';
-import { constructGetMulticallHandlers } from './getMulticallHandlers';
+// import { constructGetMulticallHandlers } from './getMulticallHandlers';
 import {
-  getDeltaBridge,
+  // getDeltaBridge,
   GetDeltaBridgeAndDestTokenOutput,
 } from './helpers/across';
 import { BeneficiaryType } from '../common/orders/types';
@@ -18,7 +18,7 @@ export type BuildCrosschainOrderBridgeParams = {
   beneficiaryType: BeneficiaryType;
 
   /** @description price response received from /delta/prices (getDeltaPrice method) */
-  deltaPrice: Pick<BridgePrice, 'bridgeFee' | 'bridge'>;
+  deltaPrice: BridgePrice;
 };
 
 type BuildCrosschainOrderBridge = (
@@ -39,7 +39,7 @@ export const constructBuildCrosschainOrderBridge = (
   const { chainId } = options;
 
   // cached internally for `multicall` contracts
-  const { getMulticallHandlers } = constructGetMulticallHandlers(options);
+  // const { getMulticallHandlers } = constructGetMulticallHandlers(options);
 
   const buildCrosschainOrderBridge: BuildCrosschainOrderBridge = async (
     { destToken, destChainId, beneficiaryType, deltaPrice },
@@ -55,7 +55,7 @@ export const constructBuildCrosschainOrderBridge = (
       '`destChainId` must match `deltaPrice.bridge.destinationChainId` for crosschain Order.bridge'
     );
 
-    const getMulticallHandler = async (chainId: number) => {
+    /* const getMulticallHandler = async (chainId: number) => {
       const multicallHandlersMap = await getMulticallHandlers(requestParams);
       const multicallHandler = multicallHandlersMap[chainId];
 
@@ -74,7 +74,16 @@ export const constructBuildCrosschainOrderBridge = (
       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,

package/src/methods/delta/buildDeltaOrder.ts

@@ -1,19 +1,23 @@
-import { assert } from 'ts-essentials';
-import type { ConstructFetchInput, RequestParameters } from '../../types';
-import { ZERO_ADDRESS } from '../common/orders/buildOrderData';
+import type {
+  ConstructFetchInput,
+  EnumerateLiteral,
+  RequestParameters,
+} from '../../types';
 import { constructGetDeltaContract } from './getDeltaContract';
-import { BridgePrice, DeltaPrice } from './getDeltaPrice';
+import { BridgePrice } from './getDeltaPrice';
 import { constructGetPartnerFee } from './getPartnerFee';
 import {
   buildDeltaSignableOrderData,
   type BuildDeltaOrderDataInput,
   type SignableDeltaOrderData,
 } from './helpers/buildDeltaOrderData';
-import { Bridge } from './helpers/types';
-import { constructBuildCrosschainOrderBridge } from './buildCrosschainOrderBridge';
+import { SwapSideToOrderKind } from './helpers/types';
 import { BeneficiaryType } from '../common/orders/types';
+import { SwapSide } from '../../constants';
 export type { SignableDeltaOrderData } from './helpers/buildDeltaOrderData';
 
+type SwapSideUnion = EnumerateLiteral<typeof SwapSide>;
+
 export type BuildDeltaOrderDataParams = {
   /** @description The address of the order owner */
   owner: string;
@@ -36,8 +40,6 @@ export type BuildDeltaOrderDataParams = {
   /** @description Partner string. */
   partner?: string;
 
-  /** @description The bridge input */
-  bridge?: Bridge;
   /** @description Destination Chain ID for Crosschain Orders */
   destChainId?: number;
   /** @description Whether the beneficiary is a contract. Needed to automatically fill in crosschain Bridge */
@@ -45,10 +47,14 @@ export type BuildDeltaOrderDataParams = {
 
   /** @description price response received from /delta/prices (getDeltaPrice method) */
   deltaPrice: Pick<
-    DeltaPrice,
-    'destAmount' | 'partner' | 'partnerFee' | 'destToken'
-  > &
-    Partial<Pick<BridgePrice, 'bridgeFee' | 'bridge'>>;
+    BridgePrice,
+    | 'destAmount'
+    | 'partner'
+    | 'partnerFee'
+    | 'destToken'
+    | 'srcAmount'
+    | 'bridge'
+  >;
 
   /** @description partner fee in basis points (bps), 50bps=0.5% */
   partnerFeeBps?: number;
@@ -56,6 +62,11 @@ export type BuildDeltaOrderDataParams = {
   partnerAddress?: string;
   /** @description take surplus */
   partnerTakesSurplus?: boolean;
+
+  /** @description The side of the order. Default is SELL */
+  side?: SwapSideUnion;
+  /** @description Metadata for the order, hex string */
+  metadata?: string;
 };
 
 type BuildDeltaOrder = (
@@ -68,14 +79,6 @@ export type BuildDeltaOrderFunctions = {
   buildDeltaOrder: BuildDeltaOrder;
 };
 
-// for same-chain Orders, all 0 params
-const DEFAULT_BRIDGE: Bridge = {
-  maxRelayerFee: '0',
-  destinationChainId: 0,
-  outputToken: ZERO_ADDRESS,
-  multiCallHandler: ZERO_ADDRESS,
-};
-
 export const constructBuildDeltaOrder = (
   options: ConstructFetchInput
 ): BuildDeltaOrderFunctions => {
@@ -86,9 +89,6 @@ export const constructBuildDeltaOrder = (
   // cached internally for `partner`
   const { getPartnerFee } = constructGetPartnerFee(options);
 
-  const { buildCrosschainOrderBridge } =
-    constructBuildCrosschainOrderBridge(options);
-
   const buildDeltaOrder: BuildDeltaOrder = async (options, requestParams) => {
     const ParaswapDelta = await getDeltaContract(requestParams);
     if (!ParaswapDelta) {
@@ -121,46 +121,12 @@ export const constructBuildDeltaOrder = (
         partnerTakesSurplus ?? partnerFeeResponse.takeSurplus;
     }
 
-    ////// Bridge logic //////
-
-    // Bridge is necessary for Crosschain Delta Orders
-    let bridge = options.bridge;
-
-    // give preference to user-provided bridge
-    if (!bridge) {
-      // no bridge passed in input
-
-      if (options.destChainId && chainId !== options.destChainId) {
-        // crosschain Delta Order
-        const deltaPrice = options.deltaPrice;
-        assert(
-          deltaPrice.bridgeFee,
-          '`bridgeFee` is required in `deltaPrice` for crosschain Delta Orders'
-        );
-        assert(
-          deltaPrice.bridge,
-          '`bridge` is required in `deltaPrice` for crosschain Delta Orders'
-        );
-
-        const { bridge: constructedBridge } = await buildCrosschainOrderBridge(
-          {
-            destToken: options.destToken,
-            destChainId: options.destChainId,
-            beneficiaryType: options.beneficiaryType ?? 'EOA',
-            deltaPrice: {
-              bridgeFee: deltaPrice.bridgeFee,
-              bridge: deltaPrice.bridge, // already contains destChainId and outputToken
-            },
-          },
-          requestParams
-        );
-
-        bridge = constructedBridge;
-      } else {
-        // 0-values bridge for same-chain Orders
-        bridge = DEFAULT_BRIDGE;
-      }
-    }
+    const swapSide = options.side ?? SwapSide.SELL;
+
+    const expectedAmount =
+      swapSide === SwapSide.SELL
+        ? options.deltaPrice.destAmount
+        : options.deltaPrice.srcAmount;
 
     const input: BuildDeltaOrderDataInput = {
       owner: options.owner,
@@ -171,10 +137,12 @@ export const constructBuildDeltaOrder = (
       destToken: options.deltaPrice.destToken,
       srcAmount: options.srcAmount,
       destAmount: options.destAmount,
-      expectedDestAmount: options.deltaPrice.destAmount,
+      expectedAmount,
       deadline: options.deadline,
       nonce: options.nonce?.toString(10),
       permit: options.permit,
+      kind: SwapSideToOrderKind[swapSide],
+      metadata: options.metadata,
 
       chainId,
       paraswapDeltaAddress: ParaswapDelta,
@@ -182,7 +150,7 @@ export const constructBuildDeltaOrder = (
       partnerTakesSurplus,
       partnerFeeBps,
 
-      bridge,
+      bridge: options.deltaPrice.bridge, // ZERO_BRIDGE for same-chain Orders
     };
 
     return buildDeltaSignableOrderData(input);

package/src/methods/delta/cancelDeltaOrder.ts

@@ -0,0 +1,109 @@
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+} from '../../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: CancelDeltaOrderData,
+  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 (
+    { orderIds },
+    requestParams
+  ) => {
+    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,7 +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 */
@@ -14,45 +22,72 @@ 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 Beneficiary Address */
+  beneficiary?: string; // beneficiary==owner if no transferTo
   /** @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;
-  bridge: Pick<Bridge, 'destinationChainId' | 'outputToken'>;
+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 = {
@@ -101,10 +136,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

@@ -181,7 +181,7 @@ export async function getDeltaBridge({
     destinationChainId: destChainId,
     outputToken,
     multiCallHandler,
-  };
+  } as any; // @TODO remove the whole getDeltaBridge() when API provides BridgePrice.bridge = whole Bridge object
 
   return {
     bridge,

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;
+}