@velora-dex/sdk 9.4.2 → 9.5.0

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

@@ -0,0 +1,233 @@
+import { Domain } from '../../common/orders/buildOrderData';
+import {
+  Bridge,
+  TWAPDeltaOrder,
+  TWAPBuyDeltaOrder,
+  TWAPOnChainOrderType,
+  OnChainOrderMap,
+} from './types';
+import { DELTA_DEFAULT_EXPIRY, producePartnerAndFee } from './misc';
+
+const BRIDGE_EIP_712_TYPE = [
+  { name: 'protocolSelector', type: 'bytes4' },
+  { name: 'destinationChainId', type: 'uint256' },
+  { name: 'outputToken', type: 'address' },
+  { name: 'scalingFactor', type: 'int8' },
+  { name: 'protocolData', type: 'bytes' },
+];
+
+const TWAP_ORDER_EIP_712_TYPES = {
+  TWAPOrder: [
+    { name: 'owner', type: 'address' },
+    { name: 'beneficiary', type: 'address' },
+    { name: 'srcToken', type: 'address' },
+    { name: 'destToken', type: 'address' },
+    { name: 'nonce', type: 'uint256' },
+    { name: 'partnerAndFee', type: 'uint256' },
+    { name: 'deadline', type: 'uint64' },
+    { name: 'interval', type: 'uint64' },
+    { name: 'numSlices', type: 'uint32' },
+    { name: 'destAmountPerSlice', type: 'uint256' },
+    { name: 'totalSrcAmount', type: 'uint256' },
+    { name: 'permit', type: 'bytes' },
+    { name: 'metadata', type: 'bytes' },
+    { name: 'bridge', type: 'Bridge' },
+  ],
+  Bridge: BRIDGE_EIP_712_TYPE,
+};
+
+const TWAP_BUY_ORDER_EIP_712_TYPES = {
+  TWAPBuyOrder: [
+    { name: 'owner', type: 'address' },
+    { name: 'beneficiary', type: 'address' },
+    { name: 'srcToken', type: 'address' },
+    { name: 'destToken', type: 'address' },
+    { name: 'nonce', type: 'uint256' },
+    { name: 'partnerAndFee', type: 'uint256' },
+    { name: 'deadline', type: 'uint64' },
+    { name: 'interval', type: 'uint64' },
+    { name: 'numSlices', type: 'uint32' },
+    { name: 'totalDestAmount', type: 'uint256' },
+    { name: 'maxSrcAmount', type: 'uint256' },
+    { name: 'permit', type: 'bytes' },
+    { name: 'metadata', type: 'bytes' },
+    { name: 'bridge', type: 'Bridge' },
+  ],
+  Bridge: BRIDGE_EIP_712_TYPE,
+};
+
+export type SignableTWAPSellOrderData = {
+  types: typeof TWAP_ORDER_EIP_712_TYPES;
+  domain: Domain;
+  data: TWAPDeltaOrder;
+};
+
+export type SignableTWAPBuyOrderData = {
+  types: typeof TWAP_BUY_ORDER_EIP_712_TYPES;
+  domain: Domain;
+  data: TWAPBuyDeltaOrder;
+};
+
+export type SignableTWAPOrderData =
+  | SignableTWAPSellOrderData
+  | SignableTWAPBuyOrderData;
+
+type ProduceTWAPOrderTypedDataInput<T extends TWAPOnChainOrderType> = {
+  orderInput: OnChainOrderMap[T];
+  paraswapDeltaAddress: string;
+  chainId: number;
+  onChainOrderType: T;
+};
+
+export function produceTWAPOrderTypedData(
+  params: ProduceTWAPOrderTypedDataInput<'TWAPOrder'>
+): SignableTWAPSellOrderData;
+export function produceTWAPOrderTypedData(
+  params: ProduceTWAPOrderTypedDataInput<'TWAPBuyOrder'>
+): SignableTWAPBuyOrderData;
+export function produceTWAPOrderTypedData({
+  orderInput,
+  chainId,
+  paraswapDeltaAddress,
+  onChainOrderType,
+}: ProduceTWAPOrderTypedDataInput<TWAPOnChainOrderType>) {
+  const domain: Domain = {
+    name: 'Portikus',
+    version: '2.0.0',
+    chainId,
+    verifyingContract: paraswapDeltaAddress,
+  };
+
+  if (onChainOrderType === 'TWAPOrder') {
+    return {
+      types: TWAP_ORDER_EIP_712_TYPES,
+      domain,
+      data: orderInput,
+    };
+  }
+
+  return {
+    types: TWAP_BUY_ORDER_EIP_712_TYPES,
+    domain,
+    data: orderInput,
+  };
+}
+
+export type TWAPOrderCommonInput = {
+  owner: string;
+  beneficiary?: string;
+  srcToken: string;
+  destToken: string;
+  nonce?: string;
+  deadline?: number;
+  permit?: string;
+  metadata?: string;
+  interval: number;
+  numSlices: number;
+  bridge: Bridge;
+
+  partnerAddress: string;
+  paraswapDeltaAddress: string;
+  partnerFeeBps: number;
+  partnerTakesSurplus?: boolean;
+  capSurplus?: boolean;
+  chainId: number;
+};
+
+export type BuildTWAPSellOrderDataInput = TWAPOrderCommonInput & {
+  onChainOrderType: 'TWAPOrder';
+  destAmountPerSlice: string;
+  totalSrcAmount: string;
+};
+
+export type BuildTWAPBuyOrderDataInput = TWAPOrderCommonInput & {
+  onChainOrderType: 'TWAPBuyOrder';
+  totalDestAmount: string;
+  maxSrcAmount: string;
+};
+
+export type BuildTWAPOrderDataInput =
+  | BuildTWAPSellOrderDataInput
+  | BuildTWAPBuyOrderDataInput;
+
+export function buildTWAPSignableOrderData(
+  input: BuildTWAPOrderDataInput
+): SignableTWAPOrderData {
+  const {
+    owner,
+    beneficiary = owner,
+    srcToken,
+    destToken,
+    nonce = Date.now().toString(10),
+    permit = '0x',
+    metadata = '0x',
+    interval,
+    numSlices,
+    bridge,
+
+    partnerAddress,
+    partnerFeeBps,
+    partnerTakesSurplus = false,
+    capSurplus = true,
+    chainId,
+    paraswapDeltaAddress,
+    onChainOrderType,
+  } = input;
+
+  const deadline =
+    input.deadline ??
+    // all slices must execute before the deadline,
+    // so we add the total duration of the TWAP (interval * numSlices) to the current time,
+    // plus a buffer defined by DELTA_DEFAULT_EXPIRY
+    Math.floor(Date.now() / 1000 + interval * numSlices + DELTA_DEFAULT_EXPIRY);
+
+  const partnerAndFee = producePartnerAndFee({
+    partnerFeeBps,
+    partnerAddress,
+    partnerTakesSurplus,
+    capSurplus,
+  });
+
+  const commonFields = {
+    owner,
+    beneficiary,
+    srcToken,
+    destToken,
+    nonce,
+    partnerAndFee,
+    deadline,
+    interval,
+    numSlices,
+    permit,
+    metadata,
+    bridge,
+  };
+
+  if (onChainOrderType === 'TWAPOrder') {
+    const orderInput: TWAPDeltaOrder = {
+      ...commonFields,
+      destAmountPerSlice: input.destAmountPerSlice,
+      totalSrcAmount: input.totalSrcAmount,
+    };
+
+    return produceTWAPOrderTypedData({
+      orderInput,
+      chainId,
+      paraswapDeltaAddress,
+      onChainOrderType: 'TWAPOrder',
+    });
+  }
+
+  const orderInput: TWAPBuyDeltaOrder = {
+    ...commonFields,
+    totalDestAmount: input.totalDestAmount,
+    maxSrcAmount: input.maxSrcAmount,
+  };
+
+  return produceTWAPOrderTypedData({
+    orderInput,
+    chainId,
+    paraswapDeltaAddress,
+    onChainOrderType: 'TWAPBuyOrder',
+  });
+}

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

@@ -1,9 +1,10 @@
 import { ZERO_ADDRESS } from '../../common/orders/buildOrderData';
 import type { SignableDeltaOrderData } from './buildDeltaOrderData';
 import type { SignableExternalOrderData } from './buildExternalOrderData';
+import type { SignableTWAPOrderData } from './buildTWAPOrderData';
 import type { GetPartnerFeeFunctions } from '../getPartnerFee';
 import type { RequestParameters } from '../../../types';
-import type { AmountsWithSlippage, SwapSideUnion } from './types';
+import type { DeltaAmountsWithSlippage, SwapSideUnion } from './types';
 import { SwapSide } from '../../../constants';
 import { assert } from 'ts-essentials';
 
@@ -44,7 +45,7 @@ type ApplySlippageInput = {
   increase: boolean;
 };
 
-function applySlippage({
+export function applySlippage({
   amount,
   slippageBps,
   increase,
@@ -122,7 +123,7 @@ export async function resolvePartnerFee(
   };
 }
 
-export type ResolveAmountsInput = AmountsWithSlippage & {
+export type ResolveAmountsInput = DeltaAmountsWithSlippage & {
   deltaPrice: { destAmount: string; srcAmount: string };
 };
 
@@ -244,3 +245,38 @@ export function sanitizeExternalOrderData({
     data,
   };
 }
+
+export function sanitizeTWAPOrderData(
+  orderData: SignableTWAPOrderData['data']
+): SignableTWAPOrderData['data'] {
+  const common = {
+    owner: orderData.owner,
+    beneficiary: orderData.beneficiary,
+    srcToken: orderData.srcToken,
+    destToken: orderData.destToken,
+    nonce: orderData.nonce,
+    partnerAndFee: orderData.partnerAndFee,
+    deadline: orderData.deadline,
+    interval: orderData.interval,
+    numSlices: orderData.numSlices,
+    permit: orderData.permit,
+    metadata: orderData.metadata,
+    bridge: orderData.bridge,
+  };
+
+  if ('destAmountPerSlice' in orderData) {
+    // TWAPOrder (SELL)
+    return {
+      ...common,
+      destAmountPerSlice: orderData.destAmountPerSlice,
+      totalSrcAmount: orderData.totalSrcAmount,
+    };
+  }
+
+  // TWAPBuyOrder (BUY)
+  return {
+    ...common,
+    totalDestAmount: orderData.totalDestAmount,
+    maxSrcAmount: orderData.maxSrcAmount,
+  };
+}

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

@@ -4,7 +4,7 @@ import { SwapSide } from '../../../constants';
 export type SwapSideUnion = EnumerateLiteral<typeof SwapSide>;
 
 /** @description SELL with slippage: srcAmount provided, destAmount auto-computed from deltaPrice.destAmount */
-export type AmountsSellSlippage = {
+export type DeltaAmountsSellSlippage = {
   /** @description Slippage in basis points (bps). 10000 = 100%, 50 = 0.5% */
   slippage: number;
   /** @description The amount of src token to swap */
@@ -14,7 +14,7 @@ export type AmountsSellSlippage = {
   side?: 'SELL';
 };
 /** @description BUY with slippage: destAmount provided, srcAmount auto-computed from deltaPrice.srcAmount */
-export type AmountsBuySlippage = {
+export type DeltaAmountsBuySlippage = {
   /** @description Slippage in basis points (bps). 10000 = 100%, 50 = 0.5% */
   slippage: number;
   /** @description The minimum amount of dest token to receive */
@@ -24,7 +24,7 @@ export type AmountsBuySlippage = {
   side?: 'BUY';
 };
 /** @description Explicit amounts, no slippage (backward-compatible) */
-export type AmountsExplicit = {
+export type DeltaAmountsExplicit = {
   slippage?: never;
   /** @description The amount of src token to swap */
   srcAmount: string;
@@ -34,10 +34,10 @@ export type AmountsExplicit = {
   side?: SwapSideUnion;
 };
 
-export type AmountsWithSlippage =
-  | AmountsSellSlippage
-  | AmountsBuySlippage
-  | AmountsExplicit;
+export type DeltaAmountsWithSlippage =
+  | DeltaAmountsSellSlippage
+  | DeltaAmountsBuySlippage
+  | DeltaAmountsExplicit;
 
 enum OrderKind {
   Sell = 0,
@@ -122,6 +122,48 @@ export type ExternalDeltaOrder = {
   data: string;
 };
 
+type TWAPDeltaOrderBase = {
+  /** @description The address of the order owner */
+  owner: string;
+  /** @description The address of the order beneficiary */
+  beneficiary: string; // beneficiary==owner if no transferTo
+  /** @description The address of the src token */
+  srcToken: string; // lowercase
+  /** @description The address of the dest token */
+  destToken: string; // lowercase
+  /** @description The nonce of the order */
+  nonce: string; // can be random, can even be Date.now()
+  /** @description Encoded partner address, fee bps, and flags for the order. partnerAndFee = (partner << 96) | (partnerTakesSurplus << 8) | fee in bps (max fee is 2%) */
+  partnerAndFee: string;
+  /** @description The deadline for the order */
+  deadline: number; // seconds
+  /** @description The interval between each slice execution */
+  interval: number; // seconds
+  /** @description The number of slices to execute */
+  numSlices: number;
+  /** @description Optional permit signature for the src token */
+  permit: string; //can be "0x"
+  /** @description Metadata for the order, hex string */
+  metadata: string;
+  /** @description The bridge input */
+  bridge: Bridge;
+};
+
+export type TWAPDeltaOrder = TWAPDeltaOrderBase & {
+  /** @description The amount of dest token to receive per slice */
+  destAmountPerSlice: string; // wei
+  /** @description The total amount of src token to swap */
+  totalSrcAmount: string; // wei
+  /** @description Optional permit signature for the src token */
+};
+
+export type TWAPBuyDeltaOrder = TWAPDeltaOrderBase & {
+  /** @description The total amount of dest token to buy across all slices */
+  totalDestAmount: string; // wei
+  /** @description The maximum amount of src token willing to spend */
+  maxSrcAmount: string; // wei
+};
+
 export type DeltaAuctionStatus =
   | 'NOT_STARTED'
   | 'AWAITING_PRE_SIGNATURE'
@@ -135,7 +177,7 @@ export type DeltaAuctionStatus =
   | 'SUSPENDED'
   | 'REFUNDED';
 
-type DeltaAuctionTransaction = {
+export type DeltaAuctionTransaction = {
   id: string;
   hash: string;
   orderId: string;
@@ -165,6 +207,8 @@ type DeltaAuctionTransaction = {
 export type OnChainOrderMap = {
   Order: DeltaAuctionOrder;
   ExternalOrder: ExternalDeltaOrder;
+  TWAPOrder: TWAPDeltaOrder;
+  TWAPBuyOrder: TWAPBuyDeltaOrder;
 };
 
 type DeltaAuctionBase = {
@@ -215,7 +259,13 @@ export type BridgeMetadata = {
 //                                                             refunded is basically failed
 export type BridgeStatus = 'pending' | 'filled' | 'expired' | 'refunded';
 
-export type OnChainOrderType = 'Order' | 'ExternalOrder';
+export type OnChainOrderType =
+  | 'Order'
+  | 'ExternalOrder'
+  | 'TWAPOrder'
+  | 'TWAPBuyOrder';
+
+export type TWAPOnChainOrderType = 'TWAPOrder' | 'TWAPBuyOrder';
 
 //// available on BridgePrice ////
 

package/src/methods/delta/index.ts

@@ -71,6 +71,23 @@ import {
   constructPreSignExternalDeltaOrder,
   PreSignExternalDeltaOrderFunctions,
 } from './preSignExternalDeltaOrder';
+import {
+  BuildTWAPDeltaOrderParams,
+  BuildTWAPDeltaOrderFunctions,
+  constructBuildTWAPDeltaOrder,
+} from './buildTWAPDeltaOrder';
+import {
+  constructSignTWAPDeltaOrder,
+  SignTWAPDeltaOrderFunctions,
+} from './signTWAPDeltaOrder';
+import {
+  constructPostTWAPDeltaOrder,
+  PostTWAPDeltaOrderFunctions,
+} from './postTWAPDeltaOrder';
+import {
+  constructPreSignTWAPDeltaOrder,
+  PreSignTWAPDeltaOrderFunctions,
+} from './preSignTWAPDeltaOrder';
 
 export type SubmitDeltaOrderParams = BuildDeltaOrderDataParams & {
   /** @description designates the Order as being able to be partially filled, as opposed to fill-or-kill */
@@ -163,6 +180,52 @@ export const constructSubmitExternalDeltaOrder = (
   return { submitExternalDeltaOrder };
 };
 
+export type SubmitTWAPDeltaOrderParams = BuildTWAPDeltaOrderParams & {
+  /** @description designates the Order as being able to be partially filled, as opposed to fill-or-kill */
+  partiallyFillable?: boolean;
+  /** @description Referrer address */
+  referrerAddress?: string;
+  degenMode?: boolean;
+} & Pick<DeltaOrderToPost, 'type' | 'includeAgents' | 'excludeAgents'>;
+
+type SubmitTWAPDeltaOrder = (
+  orderParams: SubmitTWAPDeltaOrderParams
+) => Promise<DeltaAuction<'TWAPOrder'> | DeltaAuction<'TWAPBuyOrder'>>;
+
+export type SubmitTWAPDeltaOrderFuncs = {
+  submitTWAPDeltaOrder: SubmitTWAPDeltaOrder;
+};
+
+export const constructSubmitTWAPDeltaOrder = (
+  options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
+): SubmitTWAPDeltaOrderFuncs => {
+  const { buildTWAPDeltaOrder } = constructBuildTWAPDeltaOrder(options);
+  const { signTWAPDeltaOrder } = constructSignTWAPDeltaOrder(options);
+  const { postTWAPDeltaOrder } = constructPostTWAPDeltaOrder(options);
+
+  const submitTWAPDeltaOrder: SubmitTWAPDeltaOrder = async (orderParams) => {
+    const orderData = await buildTWAPDeltaOrder(orderParams);
+    const signature = await signTWAPDeltaOrder(orderData);
+
+    const response = await postTWAPDeltaOrder({
+      signature,
+      partner: orderParams.partner,
+      order: orderData.data,
+      onChainOrderType: orderParams.onChainOrderType,
+      partiallyFillable: orderParams.partiallyFillable,
+      referrerAddress: orderParams.referrerAddress,
+      type: orderParams.type,
+      includeAgents: orderParams.includeAgents,
+      excludeAgents: orderParams.excludeAgents,
+      degenMode: orderParams.degenMode,
+    });
+
+    return response;
+  };
+
+  return { submitTWAPDeltaOrder };
+};
+
 export type DeltaOrderHandlers<T> = SubmitDeltaOrderFuncs &
   ApproveTokenForDeltaFunctions<T> &
   BuildDeltaOrderFunctions &
@@ -181,7 +244,12 @@ export type DeltaOrderHandlers<T> = SubmitDeltaOrderFuncs &
   BuildExternalDeltaOrderFunctions &
   SignExternalDeltaOrderFunctions &
   PostExternalDeltaOrderFunctions &
-  PreSignExternalDeltaOrderFunctions<T>;
+  PreSignExternalDeltaOrderFunctions<T> &
+  SubmitTWAPDeltaOrderFuncs &
+  BuildTWAPDeltaOrderFunctions &
+  SignTWAPDeltaOrderFunctions &
+  PostTWAPDeltaOrderFunctions &
+  PreSignTWAPDeltaOrderFunctions<T>;
 
 /** @description construct SDK with every Delta Order-related method, fetching from API and Order signing */
 export const constructAllDeltaOrdersHandlers = <TxResponse>(
@@ -218,6 +286,12 @@ export const constructAllDeltaOrdersHandlers = <TxResponse>(
   const externalDeltaOrdersPreSign =
     constructPreSignExternalDeltaOrder(options);
 
+  const twapDeltaOrdersSubmit = constructSubmitTWAPDeltaOrder(options);
+  const twapDeltaOrdersBuild = constructBuildTWAPDeltaOrder(options);
+  const twapDeltaOrdersSign = constructSignTWAPDeltaOrder(options);
+  const twapDeltaOrdersPost = constructPostTWAPDeltaOrder(options);
+  const twapDeltaOrdersPreSign = constructPreSignTWAPDeltaOrder(options);
+
   return {
     ...deltaOrdersGetters,
     ...deltaOrdersContractGetter,
@@ -238,5 +312,10 @@ export const constructAllDeltaOrdersHandlers = <TxResponse>(
     ...externalDeltaOrdersSign,
     ...externalDeltaOrdersPost,
     ...externalDeltaOrdersPreSign,
+    ...twapDeltaOrdersSubmit,
+    ...twapDeltaOrdersBuild,
+    ...twapDeltaOrdersSign,
+    ...twapDeltaOrdersPost,
+    ...twapDeltaOrdersPreSign,
   };
 };

package/src/methods/delta/postTWAPDeltaOrder.ts

@@ -0,0 +1,57 @@
+import { Prettify } from 'ts-essentials';
+import { API_URL } from '../../constants';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import type { DeltaAuction, TWAPOnChainOrderType } from './helpers/types';
+import type { DeltaOrderToPost } from './postDeltaOrder';
+import { constructSearchString } from '../../helpers/misc';
+
+export type PostTWAPDeltaOrderParams = Prettify<
+  Omit<
+    DeltaOrderToPost<'TWAPOrder'> | DeltaOrderToPost<'TWAPBuyOrder'>,
+    'chainId'
+  > & {
+    /** @description Must be "TWAPOrder" or "TWAPBuyOrder" */
+    onChainOrderType: TWAPOnChainOrderType;
+    degenMode?: boolean;
+  }
+>;
+
+type PostTWAPDeltaOrder = (
+  postData: PostTWAPDeltaOrderParams,
+  requestParams?: RequestParameters
+) => Promise<DeltaAuction<'TWAPOrder'> | DeltaAuction<'TWAPBuyOrder'>>;
+
+export type PostTWAPDeltaOrderFunctions = {
+  postTWAPDeltaOrder: PostTWAPDeltaOrder;
+};
+
+export const constructPostTWAPDeltaOrder = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): PostTWAPDeltaOrderFunctions => {
+  const postOrderUrl = `${apiURL}/delta/orders` as const;
+
+  const postTWAPDeltaOrder: PostTWAPDeltaOrder = (_postData, requestParams) => {
+    const { degenMode, ...postData } = _postData;
+    const deltaOrderToPost: DeltaOrderToPost<'TWAPOrder' | 'TWAPBuyOrder'> = {
+      ...postData,
+      chainId,
+    };
+
+    const search = constructSearchString<{ degenMode?: boolean }>({
+      degenMode,
+    });
+
+    const fetchURL = `${postOrderUrl}/${search}` as const;
+
+    return fetcher<DeltaAuction<'TWAPOrder'> | DeltaAuction<'TWAPBuyOrder'>>({
+      url: fetchURL,
+      method: 'POST',
+      data: deltaOrderToPost,
+      requestParams,
+    });
+  };
+
+  return { postTWAPDeltaOrder };
+};