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

package/src/methods/delta/index.ts

@@ -1,4 +1,5 @@
 import type { ConstructProviderFetchInput } from '../../types';
+import type { DeltaAuction } from './helpers/types';
 import {
   BuildDeltaOrderDataParams,
   BuildDeltaOrderFunctions,
@@ -6,7 +7,6 @@ import {
 } from './buildDeltaOrder';
 import {
   constructPostDeltaOrder,
-  DeltaOrderApiResponse,
   DeltaOrderToPost,
   PostDeltaOrderFunctions,
 } from './postDeltaOrder';
@@ -54,6 +54,40 @@ import {
   DeltaTokenModuleFunctions,
   constructDeltaTokenModule,
 } from './deltaTokenModule';
+import {
+  BuildExternalDeltaOrderParams,
+  BuildExternalDeltaOrderFunctions,
+  constructBuildExternalDeltaOrder,
+} from './buildExternalDeltaOrder';
+import {
+  constructSignExternalDeltaOrder,
+  SignExternalDeltaOrderFunctions,
+} from './signExternalDeltaOrder';
+import {
+  constructPostExternalDeltaOrder,
+  PostExternalDeltaOrderFunctions,
+} from './postExternalDeltaOrder';
+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 */
@@ -65,7 +99,7 @@ export type SubmitDeltaOrderParams = BuildDeltaOrderDataParams & {
 
 type SubmitDeltaOrder = (
   orderParams: SubmitDeltaOrderParams
-) => Promise<DeltaOrderApiResponse>;
+) => Promise<DeltaAuction<'Order'>>;
 
 export type SubmitDeltaOrderFuncs = {
   submitDeltaOrder: SubmitDeltaOrder;
@@ -101,6 +135,95 @@ export const constructSubmitDeltaOrder = (
   return { submitDeltaOrder };
 };
 
+export type SubmitExternalDeltaOrderParams = BuildExternalDeltaOrderParams & {
+  /** @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 SubmitExternalDeltaOrder = (
+  orderParams: SubmitExternalDeltaOrderParams
+) => Promise<DeltaAuction<'ExternalOrder'>>;
+
+export type SubmitExternalDeltaOrderFuncs = {
+  submitExternalDeltaOrder: SubmitExternalDeltaOrder;
+};
+
+export const constructSubmitExternalDeltaOrder = (
+  options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
+): SubmitExternalDeltaOrderFuncs => {
+  const { buildExternalDeltaOrder } = constructBuildExternalDeltaOrder(options);
+  const { signExternalDeltaOrder } = constructSignExternalDeltaOrder(options);
+  const { postExternalDeltaOrder } = constructPostExternalDeltaOrder(options);
+
+  const submitExternalDeltaOrder: SubmitExternalDeltaOrder = async (
+    orderParams
+  ) => {
+    const orderData = await buildExternalDeltaOrder(orderParams);
+    const signature = await signExternalDeltaOrder(orderData);
+
+    const response = await postExternalDeltaOrder({
+      signature,
+      partner: orderParams.partner,
+      order: orderData.data,
+      partiallyFillable: orderParams.partiallyFillable,
+      referrerAddress: orderParams.referrerAddress,
+      type: orderParams.type,
+      includeAgents: orderParams.includeAgents,
+      excludeAgents: orderParams.excludeAgents,
+    });
+
+    return response;
+  };
+
+  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 &
@@ -114,7 +237,17 @@ export type DeltaOrderHandlers<T> = SubmitDeltaOrderFuncs &
   SignDeltaOrderFunctions &
   PreSignDeltaOrderFunctions<T> &
   CancelDeltaOrderFunctions &
-  DeltaTokenModuleFunctions<T>;
+  DeltaTokenModuleFunctions<T> &
+  SubmitExternalDeltaOrderFuncs &
+  BuildExternalDeltaOrderFunctions &
+  SignExternalDeltaOrderFunctions &
+  PostExternalDeltaOrderFunctions &
+  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>(
@@ -144,6 +277,19 @@ export const constructAllDeltaOrdersHandlers = <TxResponse>(
 
   const deltaTokenModule = constructDeltaTokenModule(options);
 
+  const externalDeltaOrdersSubmit = constructSubmitExternalDeltaOrder(options);
+  const externalDeltaOrdersBuild = constructBuildExternalDeltaOrder(options);
+  const externalDeltaOrdersSign = constructSignExternalDeltaOrder(options);
+  const externalDeltaOrdersPost = constructPostExternalDeltaOrder(options);
+  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,
@@ -159,5 +305,15 @@ export const constructAllDeltaOrdersHandlers = <TxResponse>(
     ...deltaOrdersPost,
     ...deltaOrdersCancel,
     ...deltaTokenModule,
+    ...externalDeltaOrdersSubmit,
+    ...externalDeltaOrdersBuild,
+    ...externalDeltaOrdersSign,
+    ...externalDeltaOrdersPost,
+    ...externalDeltaOrdersPreSign,
+    ...twapDeltaOrdersSubmit,
+    ...twapDeltaOrdersBuild,
+    ...twapDeltaOrdersSign,
+    ...twapDeltaOrdersPost,
+    ...twapDeltaOrdersPreSign,
   };
 };

package/src/methods/delta/postDeltaOrder.ts

@@ -1,14 +1,18 @@
 import { API_URL } from '../../constants';
 import { constructSearchString } from '../../helpers/misc';
 import type { ConstructFetchInput, RequestParameters } from '../../types';
-import { DeltaAuctionOrder, DeltaAuction } from './helpers/types';
+import type {
+  DeltaAuction,
+  OnChainOrderMap,
+  OnChainOrderType,
+} from './helpers/types';
 
-export type DeltaOrderToPost = {
+export type DeltaOrderToPost<T extends OnChainOrderType = 'Order'> = {
   /** @description Partner string */
   partner?: string;
   /** @description Referrer address */
   referrerAddress?: string;
-  order: DeltaAuctionOrder;
+  order: OnChainOrderMap[T];
   /** @description Signature of the order from order.owner address. EOA signatures must be submitted in ERC-2098 Compact Representation. */
   signature: string;
   chainId: number;
@@ -26,16 +30,10 @@ export type PostDeltaOrderParams = Omit<DeltaOrderToPost, 'chainId'> & {
   degenMode?: boolean;
 };
 
-export type DeltaOrderApiResponse = Omit<DeltaAuction, 'transactions'> & {
-  orderVersion: string; // "2.0.0"
-  deltaGasOverhead: number; // @TODO may be removed
-  type: 'MARKET' | 'LIMIT';
-};
-
 type PostDeltaOrder = (
   postData: PostDeltaOrderParams,
   requestParams?: RequestParameters
-) => Promise<DeltaOrderApiResponse>;
+) => Promise<DeltaAuction<'Order'>>;
 
 export type PostDeltaOrderFunctions = {
   postDeltaOrder: PostDeltaOrder;
@@ -57,7 +55,7 @@ export const constructPostDeltaOrder = ({
     });
     const fetchURL = `${postOrderUrl}/${search}` as const;
 
-    return fetcher<DeltaOrderApiResponse>({
+    return fetcher<DeltaAuction<'Order'>>({
       url: fetchURL,
       method: 'POST',
       data: deltaOrderToPost,

package/src/methods/delta/postExternalDeltaOrder.ts

@@ -0,0 +1,45 @@
+import { API_URL } from '../../constants';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import type { DeltaAuction } from './helpers/types';
+import type { DeltaOrderToPost } from './postDeltaOrder';
+
+export type PostExternalDeltaOrderParams = Omit<
+  DeltaOrderToPost<'ExternalOrder'>,
+  'chainId'
+>;
+
+type PostExternalDeltaOrder = (
+  postData: PostExternalDeltaOrderParams,
+  requestParams?: RequestParameters
+) => Promise<DeltaAuction<'ExternalOrder'>>;
+
+export type PostExternalDeltaOrderFunctions = {
+  postExternalDeltaOrder: PostExternalDeltaOrder;
+};
+
+export const constructPostExternalDeltaOrder = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): PostExternalDeltaOrderFunctions => {
+  const postOrderUrl = `${apiURL}/delta/orders` as const;
+
+  const postExternalDeltaOrder: PostExternalDeltaOrder = (
+    postData,
+    requestParams
+  ) => {
+    const deltaOrderToPost: DeltaOrderToPost<'ExternalOrder'> = {
+      ...postData,
+      chainId,
+    };
+
+    return fetcher<DeltaAuction<'ExternalOrder'>>({
+      url: postOrderUrl,
+      method: 'POST',
+      data: deltaOrderToPost,
+      requestParams,
+    });
+  };
+
+  return { postExternalDeltaOrder };
+};

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/preSignDeltaOrder.ts

@@ -9,6 +9,7 @@ import {
   SignableDeltaOrderData,
 } from './helpers/buildDeltaOrderData';
 import { sanitizeDeltaOrderData } from './helpers/misc';
+import { PreSignatureModuleAbi } from './helpers/abi';
 import type { ExtractAbiMethodNames } from '../../helpers/misc';
 import { findPrimaryType } from '../../helpers/providers/helpers';
 import { constructGetDeltaContract } from './getDeltaContract';
@@ -42,27 +43,6 @@ export type PreSignDeltaOrderFunctions<T> = {
   preSignDeltaOrder: PreSignDeltaOrder<T>;
 };
 
-const PreSignatureModuleAbi = [
-  {
-    inputs: [
-      {
-        internalType: 'bytes32',
-        name: 'orderHash',
-        type: 'bytes32',
-      },
-      {
-        internalType: 'bool',
-        name: 'preSigned',
-        type: 'bool',
-      },
-    ],
-    name: 'setPreSignature',
-    outputs: [],
-    stateMutability: 'nonpayable',
-    type: 'function',
-  },
-] as const;
-
 type AvailableMethods = ExtractAbiMethodNames<typeof PreSignatureModuleAbi>;
 
 // returns whatever `contractCaller` returns

package/src/methods/delta/preSignExternalDeltaOrder.ts

@@ -0,0 +1,141 @@
+import { hashTypedData } from 'viem/utils';
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+  TxSendOverrides,
+} from '../../types';
+import {
+  produceExternalOrderTypedData,
+  SignableExternalOrderData,
+} from './helpers/buildExternalOrderData';
+import { sanitizeExternalOrderData } 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 { ExternalDeltaOrder } from './helpers/types';
+
+type HashExternalDeltaOrderTypedData = (
+  signableOrderData: SignableExternalOrderData
+) => string;
+
+type HashExternalDeltaOrder = (
+  orderData: ExternalDeltaOrder,
+  requestParams?: RequestParameters
+) => Promise<string>;
+
+export type SetExternalDeltaOrderPreSignature<T> = (
+  orderHash: string,
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type PreSignExternalDeltaOrder<T> = (
+  signableOrderData: SignableExternalOrderData,
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type PreSignExternalDeltaOrderFunctions<T> = {
+  hashExternalDeltaOrderTypedData: HashExternalDeltaOrderTypedData;
+  hashExternalDeltaOrder: HashExternalDeltaOrder;
+  setExternalDeltaOrderPreSignature: SetExternalDeltaOrderPreSignature<T>;
+  preSignExternalDeltaOrder: PreSignExternalDeltaOrder<T>;
+};
+
+type AvailableMethods = ExtractAbiMethodNames<typeof PreSignatureModuleAbi>;
+
+// returns whatever `contractCaller` returns
+// to allow for better versatility
+export const constructPreSignExternalDeltaOrder = <T>(
+  options: ConstructProviderFetchInput<T, 'transactCall'>
+): PreSignExternalDeltaOrderFunctions<T> => {
+  const hashExternalDeltaOrderTypedData: HashExternalDeltaOrderTypedData = (
+    typedData
+  ) => {
+    // types allow to pass OrderData & extra_stuff, but tx will break like that
+    const typedDataOnly: SignableExternalOrderData = {
+      ...typedData,
+      data: sanitizeExternalOrderData(typedData.data),
+    };
+
+    const orderHash = produceExternalOrderHash(typedDataOnly);
+
+    return orderHash;
+  };
+  // cached internally
+  const { getDeltaContract } = constructGetDeltaContract(options);
+
+  const hashExternalDeltaOrder: HashExternalDeltaOrder = async (
+    orderData,
+    requestParams
+  ) => {
+    const ParaswapDelta = await getDeltaContract(requestParams);
+    if (!ParaswapDelta) {
+      throw new Error(`Delta is not available on chain ${options.chainId}`);
+    }
+
+    const typedData = produceExternalOrderTypedData({
+      orderInput: orderData,
+      chainId: options.chainId,
+      paraswapDeltaAddress: ParaswapDelta,
+    });
+    return hashExternalDeltaOrderTypedData(typedData);
+  };
+
+  const setExternalDeltaOrderPreSignature: SetExternalDeltaOrderPreSignature<
+    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 preSignExternalDeltaOrder: PreSignExternalDeltaOrder<T> = async (
+    signableOrderData,
+    overrides = {},
+    requestParams
+  ) => {
+    const orderHash = hashExternalDeltaOrderTypedData(signableOrderData);
+    const res = await setExternalDeltaOrderPreSignature(
+      orderHash,
+      overrides,
+      requestParams
+    );
+    return res;
+  };
+
+  return {
+    hashExternalDeltaOrderTypedData,
+    hashExternalDeltaOrder,
+    setExternalDeltaOrderPreSignature,
+    preSignExternalDeltaOrder,
+  };
+};
+
+export function produceExternalOrderHash(
+  typedData: SignableExternalOrderData
+): string {
+  return hashTypedData({
+    domain: {
+      name: typedData.domain.name,
+      version: typedData.domain.version,
+      chainId: typedData.domain.chainId,
+      verifyingContract: typedData.domain.verifyingContract as `0x${string}`,
+    },
+    types: typedData.types,
+    primaryType: findPrimaryType(typedData.types),
+    message: typedData.data,
+  });
+}