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

package/src/methods/delta/buildExternalDeltaOrder.ts

@@ -0,0 +1,124 @@
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import { constructGetDeltaContract } from './getDeltaContract';
+import type { DeltaPrice } from './getDeltaPrice';
+import { constructGetPartnerFee } from './getPartnerFee';
+import {
+  buildExternalOrderSignableData,
+  type BuildExternalOrderDataInput,
+  type SignableExternalOrderData,
+} from './helpers/buildExternalOrderData';
+import type { AmountsWithSlippage } from './helpers/types';
+import { SwapSideToOrderKind } from './helpers/types';
+import type { MarkOptional } from 'ts-essentials';
+import { resolvePartnerFee, resolveAmounts } from './helpers/misc';
+export type { SignableExternalOrderData } from './helpers/buildExternalOrderData';
+
+type BuildExternalDeltaOrderParamsBase = {
+  /** @description The address of the order owner */
+  owner: string;
+  /** @description The address of the external handler contract */
+  handler: string;
+  /** @description Protocol-specific encoded bytes for the external handler */
+  data: string;
+  /** @description The address of the src token */
+  srcToken: string;
+  /** @description The address of the dest token */
+  destToken: string;
+  /** @description The deadline for the order */
+  deadline?: number;
+  /** @description The nonce of the order */
+  nonce?: number | string;
+  /** @description Optional permit signature for the src token */
+  permit?: string;
+  /** @description Partner string */
+  partner?: string;
+  /** @description partner fee in basis points (bps), 50bps=0.5% */
+  partnerFeeBps?: number;
+  /** @description partner address */
+  partnerAddress?: string;
+  /** @description take surplus */
+  partnerTakesSurplus?: boolean;
+  /** @description A boolean indicating whether the surplus should be capped. True by default */
+  capSurplus?: boolean;
+  /** @description Metadata for the order, hex string */
+  metadata?: string;
+
+  /** @description price response received from /delta/prices (getDeltaPrice method) */
+  deltaPrice: MarkOptional<
+    Pick<
+      DeltaPrice,
+      'destAmount' | 'partner' | 'partnerFee' | 'destToken' | 'srcAmount'
+    >,
+    'partner' | 'partnerFee'
+  >;
+};
+
+export type BuildExternalDeltaOrderParams = BuildExternalDeltaOrderParamsBase &
+  AmountsWithSlippage;
+
+type BuildExternalDeltaOrder = (
+  buildOrderParams: BuildExternalDeltaOrderParams,
+  requestParams?: RequestParameters
+) => Promise<SignableExternalOrderData>;
+
+export type BuildExternalDeltaOrderFunctions = {
+  /** @description Build External Orders to be posted to Delta API for execution */
+  buildExternalDeltaOrder: BuildExternalDeltaOrder;
+};
+
+export const constructBuildExternalDeltaOrder = (
+  options: ConstructFetchInput
+): BuildExternalDeltaOrderFunctions => {
+  const { chainId } = options;
+
+  // cached internally
+  const { getDeltaContract } = constructGetDeltaContract(options);
+  // cached internally for `partner`
+  const { getPartnerFee } = constructGetPartnerFee(options);
+
+  const buildExternalDeltaOrder: BuildExternalDeltaOrder = async (
+    options,
+    requestParams
+  ) => {
+    const ParaswapDelta = await getDeltaContract(requestParams);
+    if (!ParaswapDelta) {
+      throw new Error(`Delta is not available on chain ${chainId}`);
+    }
+
+    const { partnerAddress, partnerFeeBps, partnerTakesSurplus } =
+      await resolvePartnerFee(options, getPartnerFee, requestParams);
+
+    const { srcAmount, destAmount, expectedAmount, swapSide } =
+      resolveAmounts(options);
+
+    const input: BuildExternalOrderDataInput = {
+      owner: options.owner,
+      handler: options.handler,
+      srcToken: options.srcToken,
+      destToken: options.deltaPrice.destToken,
+      srcAmount,
+      destAmount,
+      expectedAmount,
+      deadline: options.deadline,
+      nonce: options.nonce?.toString(10),
+      permit: options.permit,
+      kind: SwapSideToOrderKind[swapSide],
+      metadata: options.metadata,
+      data: options.data,
+
+      chainId,
+      paraswapDeltaAddress: ParaswapDelta,
+      partnerAddress,
+      partnerTakesSurplus,
+      partnerFeeBps,
+
+      capSurplus: options.capSurplus,
+    };
+
+    return buildExternalOrderSignableData(input);
+  };
+
+  return {
+    buildExternalDeltaOrder,
+  };
+};

package/src/methods/delta/buildTWAPDeltaOrder.ts

@@ -0,0 +1,181 @@
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import { constructGetDeltaContract } from './getDeltaContract';
+import type { BridgePrice } from './getDeltaPrice';
+import { constructGetPartnerFee } from './getPartnerFee';
+import {
+  buildTWAPSignableOrderData,
+  type BuildTWAPOrderDataInput,
+  type SignableTWAPOrderData,
+} from './helpers/buildTWAPOrderData';
+import { applySlippage, resolvePartnerFee } from './helpers/misc';
+import type { MarkOptional } from 'ts-essentials';
+export type { SignableTWAPOrderData } from './helpers/buildTWAPOrderData';
+
+type BuildTWAPDeltaOrderParamsBase = {
+  /** @description The address of the order owner */
+  owner: string;
+  /** @description The address of the order beneficiary */
+  beneficiary?: string;
+  /** @description The address of the src token */
+  srcToken: string;
+  /** @description The address of the dest token. For Crosschain Order - destination token on the destination chain */
+  destToken: string;
+  /** @description The deadline for the order */
+  deadline?: number;
+  /** @description The nonce of the order */
+  nonce?: number | string;
+  /** @description Optional permit signature for the src token */
+  permit?: string;
+  /** @description Partner string */
+  partner?: string;
+  /** @description Destination Chain ID for Crosschain Orders */
+  destChainId?: number;
+  /** @description Seconds between slice executions (min 60) */
+  interval: number;
+  /** @description Number of slices (min 2) */
+  numSlices: number;
+  /** @description Slippage in basis points (bps). 10000 = 100%, 50 = 0.5% */
+  slippage?: number;
+
+  /** @description price response received from /delta/prices (getDeltaPrice method) for a single slice */
+  deltaPrice: MarkOptional<
+    Pick<
+      BridgePrice,
+      | 'destAmount'
+      | 'partner'
+      | 'partnerFee'
+      | 'destToken'
+      | 'srcAmount'
+      | 'bridge'
+    >,
+    'partner' | 'partnerFee'
+  >;
+
+  /** @description partner fee in basis points (bps), 50bps=0.5% */
+  partnerFeeBps?: number;
+  /** @description partner address */
+  partnerAddress?: string;
+  /** @description take surplus */
+  partnerTakesSurplus?: boolean;
+  /** @description A boolean indicating whether the surplus should be capped. True by default */
+  capSurplus?: boolean;
+  /** @description Metadata for the order, hex string */
+  metadata?: string;
+};
+
+export type BuildTWAPSellOrderParams = BuildTWAPDeltaOrderParamsBase & {
+  /** @description Must be "TWAPOrder" for sell orders */
+  onChainOrderType: 'TWAPOrder';
+  /** @description Total source token amount across all slices */
+  totalSrcAmount: string;
+};
+
+export type BuildTWAPBuyOrderParams = BuildTWAPDeltaOrderParamsBase & {
+  /** @description Must be "TWAPBuyOrder" for buy orders */
+  onChainOrderType: 'TWAPBuyOrder';
+  /** @description Total destination token amount to buy across all slices */
+  totalDestAmount: string;
+  /** @description Maximum source token amount willing to spend */
+  maxSrcAmount: string;
+};
+
+export type BuildTWAPDeltaOrderParams =
+  | BuildTWAPSellOrderParams
+  | BuildTWAPBuyOrderParams;
+
+type BuildTWAPDeltaOrder = (
+  buildOrderParams: BuildTWAPDeltaOrderParams,
+  requestParams?: RequestParameters
+) => Promise<SignableTWAPOrderData>;
+
+export type BuildTWAPDeltaOrderFunctions = {
+  /** @description Build TWAP Orders (sell or buy) to be posted to Delta API for execution */
+  buildTWAPDeltaOrder: BuildTWAPDeltaOrder;
+};
+
+export const constructBuildTWAPDeltaOrder = (
+  options: ConstructFetchInput
+): BuildTWAPDeltaOrderFunctions => {
+  const { chainId } = options;
+
+  const { getDeltaContract } = constructGetDeltaContract(options);
+  const { getPartnerFee } = constructGetPartnerFee(options);
+
+  const buildTWAPDeltaOrder: BuildTWAPDeltaOrder = async (
+    params,
+    requestParams
+  ) => {
+    const ParaswapDelta = await getDeltaContract(requestParams);
+    if (!ParaswapDelta) {
+      throw new Error(`Delta is not available on chain ${chainId}`);
+    }
+
+    const { partnerAddress, partnerFeeBps, partnerTakesSurplus } =
+      await resolvePartnerFee(params, getPartnerFee, requestParams);
+
+    const commonInput = {
+      owner: params.owner,
+      beneficiary: params.beneficiary,
+      srcToken: params.srcToken,
+      destToken: params.deltaPrice.destToken,
+      deadline: params.deadline,
+      nonce: params.nonce?.toString(10),
+      permit: params.permit,
+      metadata: params.metadata,
+      interval: params.interval,
+      numSlices: params.numSlices,
+      bridge: params.deltaPrice.bridge,
+
+      chainId,
+      paraswapDeltaAddress: ParaswapDelta,
+      partnerAddress,
+      partnerTakesSurplus,
+      partnerFeeBps,
+      capSurplus: params.capSurplus,
+    };
+
+    let input: BuildTWAPOrderDataInput;
+
+    if (params.onChainOrderType === 'TWAPOrder') {
+      const slippage = params.slippage ?? 0;
+      const destAmountPerSlice =
+        slippage > 0
+          ? applySlippage({
+              amount: params.deltaPrice.destAmount,
+              slippageBps: slippage,
+              increase: false,
+            })
+          : params.deltaPrice.destAmount;
+
+      input = {
+        ...commonInput,
+        onChainOrderType: 'TWAPOrder',
+        destAmountPerSlice,
+        totalSrcAmount: params.totalSrcAmount,
+      };
+    } else {
+      const slippage = params.slippage ?? 0;
+      const maxSrcAmount =
+        slippage > 0
+          ? applySlippage({
+              amount: params.maxSrcAmount,
+              slippageBps: slippage,
+              increase: true,
+            })
+          : params.maxSrcAmount;
+
+      input = {
+        ...commonInput,
+        onChainOrderType: 'TWAPBuyOrder',
+        totalDestAmount: params.totalDestAmount,
+        maxSrcAmount,
+      };
+    }
+
+    return buildTWAPSignableOrderData(input);
+  };
+
+  return {
+    buildTWAPDeltaOrder,
+  };
+};

package/src/methods/delta/getDeltaOrders.ts

@@ -5,9 +5,14 @@ import type {
   ConstructFetchInput,
   RequestParameters,
 } from '../../types';
-import type { DeltaAuction, DeltaAuctionStatus } from './helpers/types';
+import type {
+  DeltaAuction,
+  DeltaAuctionStatus,
+  OnChainOrderType,
+} from './helpers/types';
 
-export type DeltaOrderFromAPI = Omit<DeltaAuction, 'signature'>;
+/** @deprecated Use DeltaAuction directly */
+export type DeltaOrderFromAPI = DeltaAuction;
 
 export type DeltaOrderFilterByStatus =
   | DeltaAuctionStatus
@@ -20,14 +25,14 @@ export type DeltaOrderFilterByStatus =
 type GetDeltaOrderById = (
   orderId: string,
   requestParams?: RequestParameters
-) => Promise<DeltaOrderFromAPI>;
+) => Promise<DeltaAuction>;
 
 type GetDeltaOrderByHash = (
   orderHash: string,
   requestParams?: RequestParameters
-) => Promise<DeltaOrderFromAPI>;
+) => Promise<DeltaAuction>;
 
-type OrdersFilter = {
+type OrdersFilter<T extends OnChainOrderType = OnChainOrderType> = {
   /** @description Order.owner to fetch Delta Order for */
   userAddress: Address;
   /** @description Pagination option, page. Default 1 */
@@ -48,16 +53,23 @@ type OrdersFilter = {
   status?: DeltaOrderFilterByStatus[];
   /** @description Filter by type. MARKET, LIMIT. Orders with both types are returned if not specified */
   type?: 'MARKET' | 'LIMIT';
+  /** @description Filter by on-chain order type. Order, ExternalOrder. Orders of all types are returned if not specified */
+  onChainOrderType?: T;
 };
 type OrderFiltersQuery = Omit<OrdersFilter, 'chainId' | 'status'> & {
   chainId?: string;
   status?: string;
 };
 
-type GetDeltaOrders = (
-  options: OrdersFilter,
-  requestParams?: RequestParameters
-) => Promise<DeltaOrderFromAPI[]>;
+type GetDeltaOrders = {
+  <T extends OnChainOrderType>(
+    options: OrdersFilter<T> & { onChainOrderType: T },
+    requestParams?: RequestParameters
+  ): Promise<DeltaAuction<T>[]>;
+  (options: OrdersFilter, requestParams?: RequestParameters): Promise<
+    DeltaAuction[]
+  >;
+};
 
 type GetRequiredBalanceParams = {
   userAddress: Address;
@@ -89,7 +101,7 @@ export const constructGetDeltaOrders = ({
   ) => {
     const fetchURL = `${baseUrl}/${orderId}` as const;
 
-    const order = await fetcher<DeltaOrderFromAPI>({
+    const order = await fetcher<DeltaAuction>({
       url: fetchURL,
       method: 'GET',
       requestParams,
@@ -104,7 +116,7 @@ export const constructGetDeltaOrders = ({
   ) => {
     const fetchURL = `${baseUrl}/hash/${orderHash}` as const;
 
-    const order = await fetcher<DeltaOrderFromAPI>({
+    const order = await fetcher<DeltaAuction>({
       url: fetchURL,
       method: 'GET',
       requestParams,
@@ -113,7 +125,12 @@ export const constructGetDeltaOrders = ({
     return order;
   };
 
-  const getDeltaOrders: GetDeltaOrders = async (options, requestParams) => {
+  const getDeltaOrders: GetDeltaOrders = async <
+    T extends OnChainOrderType = OnChainOrderType
+  >(
+    options: OrdersFilter<T>,
+    requestParams?: RequestParameters
+  ) => {
     const chainIdString = options.chainId?.join(',');
     const statusString = options.status?.join(',');
 
@@ -122,13 +139,14 @@ export const constructGetDeltaOrders = ({
       page: options.page,
       limit: options.limit,
       type: options.type,
+      onChainOrderType: options.onChainOrderType,
       chainId: chainIdString,
       status: statusString,
     });
 
     const fetchURL = `${baseUrl}${search}` as const;
 
-    const orders = await fetcher<DeltaOrderFromAPI[]>({
+    const orders = await fetcher<DeltaAuction<T>[]>({
       url: fetchURL,
       method: 'GET',
       requestParams,

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

@@ -0,0 +1,20 @@
+export const PreSignatureModuleAbi = [
+  {
+    inputs: [
+      {
+        internalType: 'bytes32',
+        name: 'orderHash',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bool',
+        name: 'preSigned',
+        type: 'bool',
+      },
+    ],
+    name: 'setPreSignature',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const;

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

@@ -1,6 +1,7 @@
 import { MarkOptional } from 'ts-essentials';
-import { Domain, ZERO_ADDRESS } from '../../common/orders/buildOrderData';
+import { Domain } from '../../common/orders/buildOrderData';
 import { Bridge, DeltaAuctionOrder } from './types';
+import { DELTA_DEFAULT_EXPIRY, producePartnerAndFee } from './misc';
 
 // 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 = {
@@ -64,7 +65,7 @@ export function produceDeltaOrderTypedData({
   chainId,
   paraswapDeltaAddress,
 }: SignDeltaOrderInput): SignableDeltaOrderData {
-  const typedData = {
+  return {
     types: {
       Order: SWAP_ORDER_EIP_712_TYPES.Order,
       Bridge: SWAP_ORDER_EIP_712_TYPES.Bridge,
@@ -77,8 +78,6 @@ export function produceDeltaOrderTypedData({
     },
     data: orderInput,
   };
-
-  return typedData;
 }
 
 export type DeltaOrderDataInput = MarkOptional<
@@ -99,9 +98,6 @@ export type BuildDeltaOrderDataInput = MarkOptional<
   bridge: Bridge;
 };
 
-// default deadline = 1 hour for now (may be changed later)
-export const DELTA_DEFAULT_EXPIRY = 60 * 60; // seconds
-
 export function buildDeltaSignableOrderData({
   owner,
   beneficiary = owner,
@@ -157,31 +153,3 @@ export function buildDeltaSignableOrderData({
     paraswapDeltaAddress,
   });
 }
-
-type ProducePartnerAndFeeInput = {
-  partnerFeeBps: number;
-  partnerAddress: string;
-  partnerTakesSurplus: boolean;
-  capSurplus: boolean;
-};
-
-// fee and address are encoded together
-function producePartnerAndFee({
-  partnerFeeBps,
-  partnerAddress,
-  partnerTakesSurplus,
-  capSurplus,
-}: ProducePartnerAndFeeInput): string {
-  const capSurplusShifted = BigInt(capSurplus) << BigInt(9);
-  if (partnerAddress === ZERO_ADDRESS) {
-    return capSurplusShifted.toString(10);
-  } else {
-    const partnerAndFee =
-      (BigInt(partnerAddress) << BigInt(96)) |
-      BigInt(partnerFeeBps.toFixed(0)) |
-      (BigInt(partnerTakesSurplus) << BigInt(8)) |
-      capSurplusShifted;
-
-    return partnerAndFee.toString(10);
-  }
-}

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

@@ -0,0 +1,129 @@
+import { MarkOptional } from 'ts-essentials';
+import { Domain } from '../../common/orders/buildOrderData';
+import { ExternalDeltaOrder } from './types';
+import { DELTA_DEFAULT_EXPIRY, producePartnerAndFee } from './misc';
+
+const EXTERNAL_ORDER_EIP_712_TYPES = {
+  ExternalOrder: [
+    { name: 'owner', type: 'address' },
+    { name: 'handler', type: 'address' },
+    { name: 'srcToken', type: 'address' },
+    { name: 'destToken', type: 'address' },
+    { name: 'srcAmount', type: 'uint256' },
+    { name: 'destAmount', 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: 'data', type: 'bytes' },
+  ],
+};
+
+export type SignableExternalOrderData = {
+  types: {
+    ExternalOrder: typeof EXTERNAL_ORDER_EIP_712_TYPES.ExternalOrder;
+  };
+  domain: Domain;
+  data: ExternalDeltaOrder;
+};
+
+type SignExternalOrderInput = {
+  orderInput: ExternalDeltaOrder;
+  paraswapDeltaAddress: string;
+  chainId: number;
+};
+
+export function produceExternalOrderTypedData({
+  orderInput,
+  chainId,
+  paraswapDeltaAddress,
+}: SignExternalOrderInput): SignableExternalOrderData {
+  return {
+    types: {
+      ExternalOrder: EXTERNAL_ORDER_EIP_712_TYPES.ExternalOrder,
+    },
+    domain: {
+      name: 'Portikus',
+      version: '2.0.0',
+      chainId,
+      verifyingContract: paraswapDeltaAddress,
+    },
+    data: orderInput,
+  };
+}
+
+export type ExternalOrderDataInput = MarkOptional<
+  Omit<ExternalDeltaOrder, 'partnerAndFee'>,
+  'deadline' | 'nonce' | 'permit'
+>;
+
+export type BuildExternalOrderDataInput = MarkOptional<
+  ExternalOrderDataInput,
+  'metadata'
+> & {
+  partnerAddress: string;
+  paraswapDeltaAddress: string;
+  partnerFeeBps: number;
+  partnerTakesSurplus?: boolean;
+  capSurplus?: boolean;
+  chainId: number;
+};
+
+export function buildExternalOrderSignableData({
+  owner,
+  handler,
+
+  srcToken,
+  destToken,
+  srcAmount,
+  destAmount,
+  expectedAmount,
+
+  deadline = Math.floor(Date.now() / 1000 + DELTA_DEFAULT_EXPIRY),
+  nonce = Date.now().toString(10),
+
+  permit = '0x',
+
+  kind,
+  metadata = '0x',
+  data,
+
+  partnerAddress,
+  partnerFeeBps,
+  partnerTakesSurplus = false,
+  capSurplus = true,
+
+  chainId,
+  paraswapDeltaAddress,
+}: BuildExternalOrderDataInput): SignableExternalOrderData {
+  const orderInput: ExternalDeltaOrder = {
+    owner,
+    handler,
+    srcToken,
+    destToken,
+    srcAmount,
+    destAmount,
+    expectedAmount,
+    deadline,
+    nonce,
+    permit,
+    partnerAndFee: producePartnerAndFee({
+      partnerFeeBps,
+      partnerAddress,
+      partnerTakesSurplus,
+      capSurplus,
+    }),
+    kind,
+    metadata,
+    data,
+  };
+
+  return produceExternalOrderTypedData({
+    orderInput,
+    chainId,
+    paraswapDeltaAddress,
+  });
+}