@velora-dex/sdk 9.0.0 → 9.2.0-dev.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velora-dex/sdk",
-  "version": "9.0.0",
+  "version": "9.2.0-dev.0",
   "main": "dist/index.js",
   "module": "dist/sdk.esm.js",
   "typings": "dist/index.d.ts",
@@ -68,8 +68,8 @@
     "typedoc-plugin-missing-exports": "^3.0.0",
     "typedoc-plugin-replace-text": "^4.0.0",
     "typescript": "^5.6.3",
-    "viem": "^2.21.39",
-    "wagmi": "^2.12.25",
+    "viem": "^2.39.0",
+    "wagmi": "^2.19.4",
     "web3": "^4.14.0"
   },
   "peerDependencies": {
@@ -94,7 +94,8 @@
   },
   "dependencies": {
     "@paraswap/core": "2.4.0",
-    "ts-essentials": "^10.0.3"
+    "ts-essentials": "^10.0.3",
+    "viem": "^2.21.0"
   },
   "author": "Velora",
   "description": "Velora SDK",

package/src/helpers/providers/helpers.ts

@@ -5,10 +5,10 @@ import { TypedDataField } from '../../methods/common/orders/buildOrderData';
 // may be overly strict, but reliable
 const baseTypeRegex = /^([^\x5b]*)(\x5b|$)/;
 
-export function findPrimaryType(
-  types: Record<string, TypedDataField[]>
-): string {
-  const candidates = Object.keys(types);
+export function findPrimaryType<P extends string>(
+  types: Record<P, TypedDataField[]>
+): P {
+  const candidates = Object.keys(types) as P[];
   const candidatesSet = new Set(candidates);
 
   candidates.forEach((candidate) => {
@@ -21,7 +21,7 @@ export function findPrimaryType(
       if (!baseType) return;
 
       // if type was referred to as a child of another type, it can't be the primaryType
-      candidatesSet.delete(baseType);
+      candidatesSet.delete(baseType as P);
     });
   });
 

package/src/index.ts

@@ -151,12 +151,6 @@ import {
   SignableDeltaOrderData,
   SwapSideUnion,
 } from './methods/delta/buildDeltaOrder';
-import {
-  constructBuildCrosschainOrderBridge,
-  BuildCrosschainOrderBridgeFunctions,
-  BuildCrosschainOrderBridgeParams,
-  CrosschainOrderBridgeAndChanges,
-} from './methods/delta/buildCrosschainOrderBridge';
 import {
   constructPostDeltaOrder,
   DeltaOrderApiResponse,
@@ -167,6 +161,10 @@ import {
   constructSignDeltaOrder,
   SignDeltaOrderFunctions,
 } from './methods/delta/signDeltaOrder';
+import {
+  constructPreSignDeltaOrder,
+  PreSignDeltaOrderFunctions,
+} from './methods/delta/preSignDeltaOrder';
 import {
   GetDeltaContractFunctions,
   constructGetDeltaContract,
@@ -181,6 +179,7 @@ import {
 import {
   constructGetDeltaOrders,
   GetDeltaOrdersFunctions,
+  DeltaOrderFilterByStatus,
   DeltaOrderFromAPI,
 } from './methods/delta/getDeltaOrders';
 import {
@@ -196,11 +195,6 @@ import {
   GetBridgeInfoFunctions,
   BridgeInfo,
 } from './methods/delta/getBridgeInfo';
-import {
-  constructGetMulticallHandlers,
-  GetMulticallHandlersFunctions,
-  MulticallHandlersResponse,
-} from './methods/delta/getMulticallHandlers';
 import {
   constructIsTokenSupportedInDelta,
   IsTokenSupportedInDeltaFunctions,
@@ -296,9 +290,9 @@ export {
   constructBuildNFTOrderTx,
   // Delta methods
   constructBuildDeltaOrder,
-  constructBuildCrosschainOrderBridge,
   constructPostDeltaOrder,
   constructSignDeltaOrder,
+  constructPreSignDeltaOrder,
   constructGetDeltaContract,
   constructGetDeltaPrice,
   constructGetDeltaOrders,
@@ -310,7 +304,6 @@ export {
   constructGetPartnerFee,
   constructGetBridgeInfo,
   constructIsTokenSupportedInDelta,
-  constructGetMulticallHandlers,
   constructEthersContractCaller, // same as constructEthersV5ContractCaller for backwards compatibility
   constructEthersV5ContractCaller,
   constructEthersV6ContractCaller,
@@ -377,6 +370,7 @@ export type {
   DeltaAuctionOrder,
   DeltaAuction,
   DeltaAuctionStatus,
+  DeltaOrderFilterByStatus,
   DeltaOrderApiResponse,
   DeltaOrderFromAPI,
   // bridge part of DeltaOrder
@@ -387,12 +381,10 @@ export type {
   BuildDeltaOrderDataParams,
   BuildDeltaOrderFunctions,
   SignableDeltaOrderData,
-  BuildCrosschainOrderBridgeFunctions,
-  BuildCrosschainOrderBridgeParams,
-  CrosschainOrderBridgeAndChanges,
   PostDeltaOrderFunctions,
   PostDeltaOrderParams,
   SignDeltaOrderFunctions,
+  PreSignDeltaOrderFunctions,
   GetDeltaContractFunctions,
   GetDeltaPriceFunctions,
   GetDeltaOrdersFunctions,
@@ -413,8 +405,6 @@ export type {
   GetPartnerFeeFunctions,
   GetBridgeInfoFunctions,
   IsTokenSupportedInDeltaFunctions,
-  GetMulticallHandlersFunctions,
-  MulticallHandlersResponse,
   Token,
   Address,
   AddressOrSymbol,

package/src/methods/common/orders/types.ts

@@ -4,10 +4,3 @@ export type OrderTransaction = {
 };
 
 export type OrderType = 'LIMIT' | 'P2P';
-
-// display states such as EXPIRED and PARTIALLY_FILLLED derived on client side
-// returned by API but can be calculated too, EXPIRED == order.expiry < Date.now()/1000
-// PARTIALLY_FILLED == order.fillableBalance < order.makerAmount && order.fillableBalance !== '0'
-export type OrderState = 'PENDING' | 'FULFILLED' | 'CANCELLED' | 'EXPIRED';
-
-export type BeneficiaryType = 'EOA' | 'SmartContract';

package/src/methods/delta/buildDeltaOrder.ts

@@ -4,7 +4,7 @@ import type {
   RequestParameters,
 } from '../../types';
 import { constructGetDeltaContract } from './getDeltaContract';
-import { BridgePrice } from './getDeltaPrice';
+import type { BridgePrice } from './getDeltaPrice';
 import { constructGetPartnerFee } from './getPartnerFee';
 import {
   buildDeltaSignableOrderData,
@@ -12,8 +12,9 @@ import {
   type SignableDeltaOrderData,
 } from './helpers/buildDeltaOrderData';
 import { SwapSideToOrderKind } from './helpers/types';
-import { BeneficiaryType } from '../common/orders/types';
 import { SwapSide } from '../../constants';
+import type { MarkOptional } from 'ts-essentials';
+import { ZERO_ADDRESS } from '../common/orders/buildOrderData';
 export type { SignableDeltaOrderData } from './helpers/buildDeltaOrderData';
 
 export type SwapSideUnion = EnumerateLiteral<typeof SwapSide>;
@@ -42,18 +43,19 @@ export type BuildDeltaOrderDataParams = {
 
   /** @description Destination Chain ID for Crosschain Orders */
   destChainId?: number;
-  /** @description Whether the beneficiary is a contract. Needed to automatically fill in crosschain Bridge */
-  beneficiaryType?: BeneficiaryType;
 
   /** @description price response received from /delta/prices (getDeltaPrice method) */
-  deltaPrice: Pick<
-    BridgePrice,
-    | 'destAmount'
-    | 'partner'
-    | 'partnerFee'
-    | 'destToken'
-    | 'srcAmount'
-    | 'bridge'
+  deltaPrice: MarkOptional<
+    Pick<
+      BridgePrice,
+      | 'destAmount'
+      | 'partner'
+      | 'partnerFee'
+      | 'destToken'
+      | 'srcAmount'
+      | 'bridge'
+    >,
+    'partner' | 'partnerFee'
   >;
 
   /** @description partner fee in basis points (bps), 50bps=0.5% */
@@ -100,7 +102,10 @@ export const constructBuildDeltaOrder = (
     // externally supplied partner fee data takes precedence
     let partnerAddress = options.partnerAddress;
     let partnerFeeBps =
-      options.partnerFeeBps ?? options.deltaPrice.partnerFee * 100;
+      options.partnerFeeBps ??
+      (options.deltaPrice.partnerFee
+        ? options.deltaPrice.partnerFee * 100
+        : undefined);
     let partnerTakesSurplus = options.partnerTakesSurplus;
 
     // if fee given, takeSurplus is ignored
@@ -109,18 +114,27 @@ export const constructBuildDeltaOrder = (
 
     if (partnerAddress === undefined || feeOrTakeSurplusSupplied) {
       const partner = options.partner || options.deltaPrice.partner;
-      const partnerFeeResponse = await getPartnerFee(
-        { partner },
-        requestParams
-      );
-
-      partnerAddress = partnerAddress ?? partnerFeeResponse.partnerAddress;
-      // deltaPrice.partnerFee and partnerFeeResponse.partnerFee should be the same, but give priority to externally provided
-      partnerFeeBps = partnerFeeBps ?? partnerFeeResponse.partnerFee;
-      partnerTakesSurplus =
-        partnerTakesSurplus ?? partnerFeeResponse.takeSurplus;
+      if (!partner) {
+        // if no partner given in options or deltaPrice, default partnerAddress to zero,
+        // unless supplied explicitly
+        partnerAddress = partnerAddress ?? ZERO_ADDRESS;
+      } else {
+        const partnerFeeResponse = await getPartnerFee(
+          { partner },
+          requestParams
+        );
+
+        partnerAddress = partnerAddress ?? partnerFeeResponse.partnerAddress;
+        // deltaPrice.partnerFee and partnerFeeResponse.partnerFee should be the same, but give priority to externally provided
+        partnerFeeBps = partnerFeeBps ?? partnerFeeResponse.partnerFee;
+        partnerTakesSurplus =
+          partnerTakesSurplus ?? partnerFeeResponse.takeSurplus;
+      }
     }
 
+    partnerFeeBps = partnerFeeBps ?? 0;
+    partnerTakesSurplus = partnerTakesSurplus ?? false;
+
     const swapSide = options.side ?? SwapSide.SELL;
 
     const expectedAmount =

package/src/methods/delta/getDeltaOrders.ts

@@ -5,10 +5,18 @@ import type {
   ConstructFetchInput,
   RequestParameters,
 } from '../../types';
-import type { DeltaAuction } from './helpers/types';
+import type { DeltaAuction, DeltaAuctionStatus } from './helpers/types';
 
 export type DeltaOrderFromAPI = Omit<DeltaAuction, 'signature'>;
 
+export type DeltaOrderFilterByStatus =
+  | DeltaAuctionStatus
+  | 'INSUFFICIENT_BALANCE'
+  | 'INSUFFICIENT_ALLOWANCE'
+  | 'INVALIDATED'
+  | 'ACTIVE'
+  | 'INACTIVE';
+
 type GetDeltaOrderById = (
   orderId: string,
   requestParams?: RequestParameters
@@ -27,11 +35,24 @@ type OrdersFilter = {
   /** @description Pagination option, limit. Default 100 */
   limit?: number;
   /** @description Filter by chainId, without this filter, orders from all chains are returned */
-  chainId?: number; // @TODO currently not working
-  /** @description Filter by type. MARKET, LIMIT, or ALL. Default is ALL */
-  type?: 'MARKET' | 'LIMIT' | 'ALL';
+  chainId?: number[];
+  /**
+   * @description
+   * Filter by any known DeltaAuctionStatus and some custom statuses:
+   * - **INSUFFICIENT_BALANCE** —  returned as SUSPENDED from API
+   * - **INSUFFICIENT_ALLOWANCE** —  returned as SUSPENDED from API
+   * - **INVALIDATED** —  returned as FAILED from API
+   * - **ACTIVE** —  All orders with NOT_STARTED, RUNNING, EXECUTING or SUSPENDED statuses.
+   * - **INACTIVE** —  All orders with EXECUTED, FAILED, EXPIRED, CANCELLED or INVALIDATED statuses.
+   */
+  status?: DeltaOrderFilterByStatus[];
+  /** @description Filter by type. MARKET, LIMIT. Orders with both types are returned if not specified */
+  type?: 'MARKET' | 'LIMIT';
+};
+type OrderFiltersQuery = Omit<OrdersFilter, 'chainId' | 'status'> & {
+  chainId?: string;
+  status?: string;
 };
-type OrderFiltersQuery = OrdersFilter;
 
 type GetDeltaOrders = (
   options: OrdersFilter,
@@ -93,12 +114,16 @@ export const constructGetDeltaOrders = ({
   };
 
   const getDeltaOrders: GetDeltaOrders = async (options, requestParams) => {
+    const chainIdString = options.chainId?.join(',');
+    const statusString = options.status?.join(',');
+
     const search = constructSearchString<OrderFiltersQuery>({
       userAddress: options.userAddress,
       page: options.page,
       limit: options.limit,
-      chainId: options.chainId,
       type: options.type,
+      chainId: chainIdString,
+      status: statusString,
     });
 
     const fetchURL = `${baseUrl}${search}` as const;

package/src/methods/delta/getDeltaPrice.ts

@@ -64,6 +64,13 @@ export type DeltaPrice = {
   destAmount: string;
   /** @description Available for SELL side */
   destAmountBeforeFee?: string;
+  /** @description amount of the final outcome token */
+  receivedDestAmount: string;
+  receivedDestUSD: string;
+  /** @description Available for SELL side */
+  receivedDestAmountBeforeFee?: string;
+  /** @description Available for SELL side */
+  receivedDestUSDBeforeFee?: string;
   gasCost: string;
   gasCostBeforeFee: string;
   gasCostUSD: string;
@@ -80,6 +87,26 @@ export type DeltaPrice = {
   bridge: Bridge; // for single-chain DeltaPrice, it's DEFAULT_BRIDGE
 };
 
+type AvailableBridgePrice = Pick<
+  DeltaPrice,
+  | 'destToken'
+  | 'destAmount'
+  | 'destAmountBeforeFee'
+  | 'destUSD'
+  | 'destUSDBeforeFee'
+  | 'gasCostUSD'
+  | 'gasCost'
+  | 'gasCostUSDBeforeFee'
+  | 'gasCostBeforeFee'
+>;
+
+type AvailableBridge = AvailableBridgePrice & {
+  bridgeParams: {
+    bridge: Bridge;
+    bridgeInfo: BridgePriceInfo;
+  }[];
+};
+
 export type BridgePrice = Omit<DeltaPrice, 'bridge'> & {
   // destAmountAfterBridge: string; // became bridgeInfo.destAmountAfterBridge
   // destUSDAfterBridge: string; // became bridgeInfo.destUSDAfterBridge
@@ -88,6 +115,7 @@ export type BridgePrice = Omit<DeltaPrice, 'bridge'> & {
   // poolAddress: string;
   bridge: Bridge;
   bridgeInfo: BridgePriceInfo;
+  availableBridges: AvailableBridge[];
 };
 
 type DeltaPriceResponse = {

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

@@ -59,7 +59,7 @@ type SignDeltaOrderInput = {
   chainId: number;
 };
 
-function produceDeltaOrderTypedData({
+export function produceDeltaOrderTypedData({
   orderInput,
   chainId,
   paraswapDeltaAddress,

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

@@ -54,6 +54,7 @@ export type Bridge = {
 
 export type DeltaAuctionStatus =
   | 'NOT_STARTED'
+  | 'AWAITING_PRE_SIGNATURE'
   | 'RUNNING'
   | 'EXECUTING'
   | 'EXECUTED'
@@ -69,6 +70,7 @@ type DeltaAuctionTransaction = {
   bidId: string | null;
   blockNumber: number;
   blockHash: string;
+  blockTimestamp: string | null; // ISO string, null for older Orders
   gasUsed: bigint;
   gasPrice: bigint;
   blobGasUsed: bigint;
@@ -137,7 +139,18 @@ export type BridgeStatus = 'pending' | 'filled' | 'expired' | 'refunded';
 //// available on BridgePrice ////
 
 // so far
-type ProtocolName = 'Across' | 'StargateBus' | 'StargateTaxi';
+type ProtocolName =
+  | 'Across'
+  | 'StargateBus'
+  | 'StargateTaxi'
+  | 'StargateOftV2'
+  | 'Relay'
+  | 'CCTPFast'
+  | 'CCTPStandard'
+  | 'Celer'
+  | 'Canonical'
+  | 'Polygon'
+  | 'Arbitrum';
 
 type BridgeQuoteFee = {
   feeToken: string;

package/src/methods/delta/index.ts

@@ -38,22 +38,18 @@ import {
   constructGetBridgeInfo,
   GetBridgeInfoFunctions,
 } from './getBridgeInfo';
-import {
-  constructGetMulticallHandlers,
-  GetMulticallHandlersFunctions,
-} from './getMulticallHandlers';
 import {
   constructIsTokenSupportedInDelta,
   IsTokenSupportedInDeltaFunctions,
 } from './isTokenSupportedInDelta';
-import {
-  BuildCrosschainOrderBridgeFunctions,
-  constructBuildCrosschainOrderBridge,
-} from './buildCrosschainOrderBridge';
 import {
   CancelDeltaOrderFunctions,
   constructCancelDeltaOrder,
 } from './cancelDeltaOrder';
+import {
+  constructPreSignDeltaOrder,
+  PreSignDeltaOrderFunctions,
+} from './preSignDeltaOrder';
 
 export type SubmitDeltaOrderParams = BuildDeltaOrderDataParams & {
   /** @description designates the Order as being able to be partially filled, as opposed to fill-or-kill */
@@ -74,6 +70,7 @@ export const constructSubmitDeltaOrder = (
   options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
 ): SubmitDeltaOrderFuncs => {
   const { buildDeltaOrder } = constructBuildDeltaOrder(options);
+  // in the normal submitOrderFlow preSign tx is not involved
   const { signDeltaOrder } = constructSignDeltaOrder(options);
   const { postDeltaOrder } = constructPostDeltaOrder(options);
 
@@ -101,16 +98,15 @@ export const constructSubmitDeltaOrder = (
 export type DeltaOrderHandlers<T> = SubmitDeltaOrderFuncs &
   ApproveTokenForDeltaFunctions<T> &
   BuildDeltaOrderFunctions &
-  BuildCrosschainOrderBridgeFunctions &
   GetDeltaOrdersFunctions &
   GetDeltaPriceFunctions &
   GetDeltaContractFunctions &
   GetPartnerFeeFunctions &
-  GetMulticallHandlersFunctions &
   GetBridgeInfoFunctions &
   IsTokenSupportedInDeltaFunctions &
   PostDeltaOrderFunctions &
   SignDeltaOrderFunctions &
+  PreSignDeltaOrderFunctions<T> &
   CancelDeltaOrderFunctions;
 
 /** @description construct SDK with every Delta Order-related method, fetching from API and Order signing */
@@ -127,17 +123,14 @@ export const constructAllDeltaOrdersHandlers = <TxResponse>(
   const partnerFee = constructGetPartnerFee(options);
   const bridgeInfo = constructGetBridgeInfo(options);
   const isTokenSupportedInDelta = constructIsTokenSupportedInDelta(options);
-  const multicallHandlers = constructGetMulticallHandlers(options);
 
   const approveTokenForDelta = constructApproveTokenForDelta(options);
 
   const deltaOrdersSubmit = constructSubmitDeltaOrder(options);
 
-  const buildCrosschainOrderBridge =
-    constructBuildCrosschainOrderBridge(options);
-
   const deltaOrdersBuild = constructBuildDeltaOrder(options);
   const deltaOrdersSign = constructSignDeltaOrder(options);
+  const deltaOrdersPreSign = constructPreSignDeltaOrder(options);
   const deltaOrdersPost = constructPostDeltaOrder(options);
 
   const deltaOrdersCancel = constructCancelDeltaOrder(options);
@@ -149,13 +142,12 @@ export const constructAllDeltaOrdersHandlers = <TxResponse>(
     ...partnerFee,
     ...bridgeInfo,
     ...isTokenSupportedInDelta,
-    ...multicallHandlers,
     ...approveTokenForDelta,
     ...deltaOrdersSubmit,
     ...deltaOrdersBuild,
     ...deltaOrdersSign,
+    ...deltaOrdersPreSign,
     ...deltaOrdersPost,
     ...deltaOrdersCancel,
-    ...buildCrosschainOrderBridge,
   };
 };

package/src/methods/delta/preSignDeltaOrder.ts

@@ -0,0 +1,157 @@
+import { hashTypedData } from 'viem/utils';
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+  TxSendOverrides,
+} from '../../types';
+import {
+  produceDeltaOrderTypedData,
+  SignableDeltaOrderData,
+} from './helpers/buildDeltaOrderData';
+import { sanitizeDeltaOrderData } from './helpers/misc';
+import { constructGetDeltaContract, DeltaAuctionOrder } from '../..';
+import { ExtractAbiMethodNames } from '../../helpers/misc';
+import { findPrimaryType } from '../../helpers/providers/helpers';
+
+type HashDeltaOrderTypedData = (
+  signableOrderData: SignableDeltaOrderData
+) => string;
+
+type HashDeltaOrder = (
+  orderData: DeltaAuctionOrder,
+  requestParams?: RequestParameters
+) => Promise<string>;
+
+export type SetDeltaOrderPreSignature<T> = (
+  orderHash: string,
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type PreSignDeltaOrder<T> = (
+  signableOrderData: SignableDeltaOrderData,
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type PreSignDeltaOrderFunctions<T> = {
+  hashDeltaOrderTypedData: HashDeltaOrderTypedData;
+  hashDeltaOrder: HashDeltaOrder;
+  setDeltaOrderPreSignature: SetDeltaOrderPreSignature<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
+// to allow for better versatility
+export const constructPreSignDeltaOrder = <T>(
+  options: ConstructProviderFetchInput<T, 'transactCall'>
+): PreSignDeltaOrderFunctions<T> => {
+  const hashDeltaOrderTypedData: HashDeltaOrderTypedData = (typedData) => {
+    // types allow to pass OrderData & extra_stuff, but tx will break like that
+    const typedDataOnly: SignableDeltaOrderData = {
+      ...typedData,
+      data: sanitizeDeltaOrderData(typedData.data),
+    };
+
+    const orderHash = produceDeltaOrderHash(typedDataOnly);
+
+    return orderHash;
+  };
+  // cached internally
+  const { getDeltaContract } = constructGetDeltaContract(options);
+
+  const hashDeltaOrder: HashDeltaOrder = async (orderData, requestParams) => {
+    const ParaswapDelta = await getDeltaContract(requestParams);
+    if (!ParaswapDelta) {
+      throw new Error(`Delta is not available on chain ${options.chainId}`);
+    }
+
+    const typedData = produceDeltaOrderTypedData({
+      orderInput: orderData,
+      chainId: options.chainId,
+      paraswapDeltaAddress: ParaswapDelta,
+    });
+    return hashDeltaOrderTypedData(typedData);
+  };
+
+  const setDeltaOrderPreSignature: SetDeltaOrderPreSignature<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 preSignDeltaOrder: PreSignDeltaOrder<T> = async (
+    signableOrderData,
+    overrides = {},
+    requestParams
+  ) => {
+    const orderHash = hashDeltaOrderTypedData(signableOrderData);
+    const res = await setDeltaOrderPreSignature(
+      orderHash,
+      overrides,
+      requestParams
+    );
+    return res;
+  };
+
+  return {
+    hashDeltaOrderTypedData,
+    hashDeltaOrder,
+    setDeltaOrderPreSignature,
+    preSignDeltaOrder,
+  };
+};
+
+export function produceDeltaOrderHash(
+  typedData: SignableDeltaOrderData
+): 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,
+  });
+}

package/src/methods/delta/signDeltaOrder.ts

@@ -2,12 +2,6 @@ import type { ConstructProviderFetchInput } from '../../types';
 import { SignableDeltaOrderData } from './helpers/buildDeltaOrderData';
 import { sanitizeDeltaOrderData } from './helpers/misc';
 
-export type SignLimitOrderFunctions = {
-  signLimitOrder: (
-    signableOrderData: SignableDeltaOrderData
-  ) => Promise<string>;
-};
-
 type SignDeltaOrder = (
   signableOrderData: SignableDeltaOrderData
 ) => Promise<string>;