@velora-dex/sdk 9.4.2 → 9.4.3-dev.1

package/src/methods/delta/preSignTWAPDeltaOrder.ts

@@ -0,0 +1,170 @@
+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}`);
+    }
+
+    // TwapOrder (SELL)
+    if (onChainOrderType === 'TWAPOrder' && 'totalSrcAmount' in orderData) {
+      const typedData = produceTWAPOrderTypedData({
+        orderInput: orderData,
+        chainId: options.chainId,
+        paraswapDeltaAddress: ParaswapDelta,
+        onChainOrderType,
+      });
+      return hashTWAPDeltaOrderTypedData(typedData);
+    }
+
+    // TWAPBuyOrder (BUY)
+    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,
+  });
+}

package/src/methods/delta/signTWAPDeltaOrder.ts

@@ -0,0 +1,32 @@
+import type { ConstructProviderFetchInput } from '../../types';
+import { SignableTWAPOrderData } from './helpers/buildTWAPOrderData';
+import { sanitizeTWAPOrderData } from './helpers/misc';
+
+type SignTWAPDeltaOrder = (
+  signableOrderData: SignableTWAPOrderData
+) => Promise<string>;
+
+export type SignTWAPDeltaOrderFunctions = {
+  signTWAPDeltaOrder: SignTWAPDeltaOrder;
+};
+
+export const constructSignTWAPDeltaOrder = (
+  options: Pick<
+    ConstructProviderFetchInput<any, 'signTypedDataCall'>,
+    'contractCaller'
+  >
+): SignTWAPDeltaOrderFunctions => {
+  const signTWAPDeltaOrder: SignTWAPDeltaOrder = async (typedData) => {
+    const typedDataOnly = {
+      ...typedData,
+      data: sanitizeTWAPOrderData(typedData.data),
+    } as SignableTWAPOrderData;
+    const signature = await options.contractCaller.signTypedDataCall(
+      typedDataOnly
+    );
+
+    return signature;
+  };
+
+  return { signTWAPDeltaOrder };
+};

package/src/sdk/partial.ts

@@ -15,6 +15,7 @@ import type { ApproveTokenForDeltaFunctions } from '../methods/delta/approveForD
 import type { PreSignDeltaOrderFunctions } from '../methods/delta/preSignDeltaOrder';
 import type { PreSignExternalDeltaOrderFunctions } from '../methods/delta/preSignExternalDeltaOrder';
 import type { DeltaTokenModuleFunctions } from '../methods/delta/deltaTokenModule';
+import type { PreSignTWAPDeltaOrderFunctions } from '../methods/delta/preSignTWAPDeltaOrder';
 import { API_URL, DEFAULT_VERSION } from '../constants';
 
 export type SDKConfig<TxResponse = any> = ConstructProviderFetchInput<
@@ -56,7 +57,8 @@ type InferWithTxResponse<
           ApproveTokenForDeltaFunctions<TxResponse>,
           PreSignDeltaOrderFunctions<TxResponse>,
           PreSignExternalDeltaOrderFunctions<TxResponse>,
-          DeltaTokenModuleFunctions<TxResponse>
+          DeltaTokenModuleFunctions<TxResponse>,
+          PreSignTWAPDeltaOrderFunctions<TxResponse>
         ]
         // then merge IntersectionOfReturns<Funcs> with them recursively
       >

package/src/constants.js

@@ -1,3 +0,0 @@
-export { SwapSide, ContractMethod, ContractMethodV5, ContractMethodV6, } from '@paraswap/core';
-export const API_URL = 'https://api.paraswap.io';
-export const DEFAULT_VERSION = '6.2';

package/src/gas.js

@@ -1 +0,0 @@
-export {};

package/src/index.js

@@ -1,73 +0,0 @@
-import { constructApproveToken, } from './methods/swap/approve';
-import { constructGetBalances, isAllowance, } from './methods/swap/balance';
-import { constructGetSpender, } from './methods/swap/spender';
-import { constructGetAdapters, } from './methods/swap/adapters';
-import { constructGetRate, } from './methods/swap/rates';
-import { constructSwapTx } from './methods/swap/swapTx';
-import { constructGetTokens } from './methods/swap/token';
-import { constructBuildTx } from './methods/swap/transaction';
-import { constructBuildLimitOrder, } from './methods/limitOrders/buildOrder';
-import { constructSignLimitOrder, } from './methods/limitOrders/signOrder';
-import { constructCancelLimitOrder, } from './methods/limitOrders/cancelOrder';
-import { constructFillOrderDirectly, } from './methods/limitOrders/fillOrderDirectly';
-import { constructGetLimitOrders, } from './methods/limitOrders/getOrders';
-import { constructPostLimitOrder, } from './methods/limitOrders/postOrder';
-import { constructApproveTokenForLimitOrder, } from './methods/limitOrders/approveForOrder';
-import { constructGetLimitOrdersContract, } from './methods/limitOrders/getOrdersContract';
-import { constructBuildLimitOrderTx, } from './methods/limitOrders/transaction';
-import { constructBuildNFTOrder, } from './methods/nftOrders/buildOrder';
-import { constructSignNFTOrder, } from './methods/nftOrders/signOrder';
-import { constructCancelNFTOrder, } from './methods/nftOrders/cancelOrder';
-import { constructGetNFTOrders, } from './methods/nftOrders/getOrders';
-import { constructPostNFTOrder, } from './methods/nftOrders/postOrder';
-import { constructApproveTokenForNFTOrder, } from './methods/nftOrders/approveForOrder';
-import { constructGetNFTOrdersContract, } from './methods/nftOrders/getOrdersContract';
-import { constructBuildNFTOrderTx, } from './methods/nftOrders/transaction';
-import { constructEthersContractCaller, constructEthersV5ContractCaller, constructEthersV6ContractCaller, constructWeb3ContractCaller, constructViemContractCaller, txParamsToViemTxParams, constructAxiosFetcher, constructFetchFetcher, isFetcherError, constructToken, } from './helpers';
-import { constructBuildDeltaOrder, } from './methods/delta/buildDeltaOrder';
-import { constructPostDeltaOrder, } from './methods/delta/postDeltaOrder';
-import { constructSignDeltaOrder, } from './methods/delta/signDeltaOrder';
-import { constructPreSignDeltaOrder, } from './methods/delta/preSignDeltaOrder';
-import { constructGetDeltaContract, } from './methods/delta/getDeltaContract';
-import { constructGetDeltaPrice, } from './methods/delta/getDeltaPrice';
-import { constructGetDeltaOrders, } from './methods/delta/getDeltaOrders';
-import { constructApproveTokenForDelta, } from './methods/delta/approveForDelta';
-import { constructGetPartnerFee, } from './methods/delta/getPartnerFee';
-import { constructGetBridgeInfo, } from './methods/delta/getBridgeInfo';
-import { constructIsTokenSupportedInDelta, } from './methods/delta/isTokenSupportedInDelta';
-import { constructGetQuote, } from './methods/quote/getQuote';
-import { constructCancelDeltaOrder, } from './methods/delta/cancelDeltaOrder';
-import { constructDeltaTokenModule, } from './methods/delta/deltaTokenModule';
-export { constructSwapSDK } from './methods/swap';
-export { constructAllLimitOrdersHandlers, constructSubmitLimitOrder, } from './methods/limitOrders';
-export { constructAllDeltaOrdersHandlers, constructSubmitDeltaOrder, } from './methods/delta';
-export * from './constants';
-// can import these individually
-// and use in constructPartialSDK only what you need
-// unused should tree-shake
-export { 
-// swap methods:
-constructApproveToken, constructGetBalances, // getAllowances is inside
-constructGetSpender, // this was getTokenTransferProxy
-constructGetTokens, constructBuildTx, constructGetAdapters, constructGetRate, constructSwapTx, 
-// limitOrders methods:
-constructBuildLimitOrder, constructSignLimitOrder, constructCancelLimitOrder, constructFillOrderDirectly, constructGetLimitOrders, constructPostLimitOrder, constructApproveTokenForLimitOrder, constructGetLimitOrdersContract, constructBuildLimitOrderTx, 
-// nftOrders methods
-constructBuildNFTOrder, constructSignNFTOrder, constructCancelNFTOrder, constructGetNFTOrders, constructPostNFTOrder, constructApproveTokenForNFTOrder, constructGetNFTOrdersContract, constructBuildNFTOrderTx, 
-// Delta methods
-constructBuildDeltaOrder, constructPostDeltaOrder, constructSignDeltaOrder, constructPreSignDeltaOrder, constructGetDeltaContract, constructGetDeltaPrice, constructGetDeltaOrders, constructCancelDeltaOrder, constructDeltaTokenModule, constructApproveTokenForDelta, 
-// Quote methods
-constructGetQuote, 
-// different helpers
-constructGetPartnerFee, constructGetBridgeInfo, constructIsTokenSupportedInDelta, constructEthersContractCaller, // same as constructEthersV5ContractCaller for backwards compatibility
-constructEthersV5ContractCaller, constructEthersV6ContractCaller, constructWeb3ContractCaller, constructViemContractCaller, txParamsToViemTxParams, constructAxiosFetcher, constructFetchFetcher, isFetcherError, isAllowance, constructToken, };
-export { constructPartialSDK } from './sdk/partial';
-export { constructFullSDK } from './sdk/full';
-export { constructSimpleSDK, } from './sdk/simple';
-// bundled methods for limitOrders
-export * from './methods/limitOrders';
-export * from './methods/limitOrders/helpers/types';
-// bundled methods for nftOrders
-export * from './methods/nftOrders';
-export * from './methods/nftOrders/helpers/types';
-export { AssetType } from './methods/nftOrders/helpers/misc';

package/src/types.js

@@ -1 +0,0 @@
-export {};