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

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

@@ -0,0 +1,227 @@
+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,
+  };
+}
+
+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),
+    deadline = Math.floor(Date.now() / 1000 + DELTA_DEFAULT_EXPIRY),
+    permit = '0x',
+    metadata = '0x',
+    interval,
+    numSlices,
+    bridge,
+
+    partnerAddress,
+    partnerFeeBps,
+    partnerTakesSurplus = false,
+    capSurplus = true,
+    chainId,
+    paraswapDeltaAddress,
+    onChainOrderType,
+  } = input;
+
+  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,6 +1,7 @@
 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';
@@ -44,7 +45,7 @@ type ApplySlippageInput = {
   increase: boolean;
 };
 
-function applySlippage({
+export function applySlippage({
   amount,
   slippageBps,
   increase,
@@ -244,3 +245,36 @@ 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) {
+    return {
+      ...common,
+      destAmountPerSlice: orderData.destAmountPerSlice,
+      totalSrcAmount: orderData.totalSrcAmount,
+    };
+  }
+
+  return {
+    ...common,
+    totalDestAmount: orderData.totalDestAmount,
+    maxSrcAmount: orderData.maxSrcAmount,
+  };
+}

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

@@ -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,50 @@ 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;
+} & 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,
+    });
+
+    return response;
+  };
+
+  return { submitTWAPDeltaOrder };
+};
+
 export type DeltaOrderHandlers<T> = SubmitDeltaOrderFuncs &
   ApproveTokenForDeltaFunctions<T> &
   BuildDeltaOrderFunctions &
@@ -181,7 +242,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 +284,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 +310,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 };
+};

package/src/methods/delta/preSignTWAPDeltaOrder.ts

@@ -0,0 +1,168 @@
+import { hashTypedData } from 'viem/utils';
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+  TxSendOverrides,
+} from '../../types';
+import {
+  produceTWAPOrderTypedData,
+  SignableTWAPOrderData,
+} from './helpers/buildTWAPOrderData';
+import { sanitizeTWAPOrderData } from './helpers/misc';
+import { PreSignatureModuleAbi } from './helpers/abi';
+import type { ExtractAbiMethodNames } from '../../helpers/misc';
+import { findPrimaryType } from '../../helpers/providers/helpers';
+import { constructGetDeltaContract } from './getDeltaContract';
+import type { TWAPDeltaOrder, TWAPBuyDeltaOrder } from './helpers/types';
+import { TypedDataField } from 'ethersV5';
+
+type HashTWAPDeltaOrderTypedData = (
+  signableOrderData: SignableTWAPOrderData
+) => string;
+
+type HashTWAPDeltaOrder = {
+  (
+    orderData: TWAPDeltaOrder,
+    onChainOrderType: 'TWAPOrder',
+    requestParams?: RequestParameters
+  ): Promise<string>;
+
+  (
+    orderData: TWAPBuyDeltaOrder,
+    onChainOrderType: 'TWAPBuyOrder',
+    requestParams?: RequestParameters
+  ): Promise<string>;
+};
+
+export type SetTWAPDeltaOrderPreSignature<T> = (
+  orderHash: string,
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type PreSignTWAPDeltaOrder<T> = (
+  signableOrderData: SignableTWAPOrderData,
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type PreSignTWAPDeltaOrderFunctions<T> = {
+  hashTWAPDeltaOrderTypedData: HashTWAPDeltaOrderTypedData;
+  hashTWAPDeltaOrder: HashTWAPDeltaOrder;
+  setTWAPDeltaOrderPreSignature: SetTWAPDeltaOrderPreSignature<T>;
+  preSignTWAPDeltaOrder: PreSignTWAPDeltaOrder<T>;
+};
+
+type AvailableMethods = ExtractAbiMethodNames<typeof PreSignatureModuleAbi>;
+
+export const constructPreSignTWAPDeltaOrder = <T>(
+  options: ConstructProviderFetchInput<T, 'transactCall'>
+): PreSignTWAPDeltaOrderFunctions<T> => {
+  const hashTWAPDeltaOrderTypedData: HashTWAPDeltaOrderTypedData = (
+    typedData
+  ) => {
+    const typedDataOnly = {
+      ...typedData,
+      data: sanitizeTWAPOrderData(typedData.data),
+    } as SignableTWAPOrderData;
+
+    const orderHash = produceTWAPOrderHash(typedDataOnly);
+
+    return orderHash;
+  };
+
+  const { getDeltaContract } = constructGetDeltaContract(options);
+
+  const hashTWAPDeltaOrder: HashTWAPDeltaOrder = async (
+    orderData,
+    onChainOrderType,
+    requestParams
+  ) => {
+    const ParaswapDelta = await getDeltaContract(requestParams);
+    if (!ParaswapDelta) {
+      throw new Error(`Delta is not available on chain ${options.chainId}`);
+    }
+
+    if (onChainOrderType === 'TWAPOrder' && 'totalSrcAmount' in orderData) {
+      const typedData = produceTWAPOrderTypedData({
+        orderInput: orderData,
+        chainId: options.chainId,
+        paraswapDeltaAddress: ParaswapDelta,
+        onChainOrderType,
+      });
+      return hashTWAPDeltaOrderTypedData(typedData);
+    }
+
+    if (onChainOrderType === 'TWAPBuyOrder' && 'maxSrcAmount' in orderData) {
+      const typedData = produceTWAPOrderTypedData({
+        orderInput: orderData,
+        chainId: options.chainId,
+        paraswapDeltaAddress: ParaswapDelta,
+        onChainOrderType,
+      });
+      return hashTWAPDeltaOrderTypedData(typedData);
+    }
+
+    throw new Error(
+      `Invalid order data for onChainOrderType ${onChainOrderType}`
+    );
+  };
+
+  const setTWAPDeltaOrderPreSignature: SetTWAPDeltaOrderPreSignature<
+    T
+  > = async (orderHash, overrides = {}, requestParams) => {
+    const ParaswapDelta = await getDeltaContract(requestParams);
+    if (!ParaswapDelta) {
+      throw new Error(`Delta is not available on chain ${options.chainId}`);
+    }
+
+    const res = await options.contractCaller.transactCall<AvailableMethods>({
+      address: ParaswapDelta,
+      abi: PreSignatureModuleAbi,
+      contractMethod: 'setPreSignature',
+      args: [orderHash, true],
+      overrides,
+    });
+
+    return res;
+  };
+
+  const preSignTWAPDeltaOrder: PreSignTWAPDeltaOrder<T> = async (
+    signableOrderData,
+    overrides = {},
+    requestParams
+  ) => {
+    const orderHash = hashTWAPDeltaOrderTypedData(signableOrderData);
+    const res = await setTWAPDeltaOrderPreSignature(
+      orderHash,
+      overrides,
+      requestParams
+    );
+    return res;
+  };
+
+  return {
+    hashTWAPDeltaOrderTypedData,
+    hashTWAPDeltaOrder,
+    setTWAPDeltaOrderPreSignature,
+    preSignTWAPDeltaOrder,
+  };
+};
+
+export function produceTWAPOrderHash(typedData: SignableTWAPOrderData): string {
+  const types = typedData.types as Record<
+    'TWAPOrder' | 'TWAPBuyOrder' | 'Bridge',
+    TypedDataField[]
+  >;
+  return hashTypedData({
+    domain: {
+      name: typedData.domain.name,
+      version: typedData.domain.version,
+      chainId: typedData.domain.chainId,
+      verifyingContract: typedData.domain.verifyingContract as `0x${string}`,
+    },
+    types,
+    primaryType: findPrimaryType(types),
+    message: typedData.data,
+  });
+}