@velora-dex/sdk 9.1.0 → 9.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velora-dex/sdk",
-  "version": "9.1.0",
+  "version": "9.2.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

@@ -161,6 +161,10 @@ import {
   constructSignDeltaOrder,
   SignDeltaOrderFunctions,
 } from './methods/delta/signDeltaOrder';
+import {
+  constructPreSignDeltaOrder,
+  PreSignDeltaOrderFunctions,
+} from './methods/delta/preSignDeltaOrder';
 import {
   GetDeltaContractFunctions,
   constructGetDeltaContract,
@@ -288,6 +292,7 @@ export {
   constructBuildDeltaOrder,
   constructPostDeltaOrder,
   constructSignDeltaOrder,
+  constructPreSignDeltaOrder,
   constructGetDeltaContract,
   constructGetDeltaPrice,
   constructGetDeltaOrders,
@@ -379,6 +384,7 @@ export type {
   PostDeltaOrderFunctions,
   PostDeltaOrderParams,
   SignDeltaOrderFunctions,
+  PreSignDeltaOrderFunctions,
   GetDeltaContractFunctions,
   GetDeltaPriceFunctions,
   GetDeltaOrdersFunctions,

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;

package/src/methods/delta/index.ts

@@ -46,6 +46,10 @@ 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 */
@@ -66,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,6 +106,7 @@ export type DeltaOrderHandlers<T> = SubmitDeltaOrderFuncs &
   IsTokenSupportedInDeltaFunctions &
   PostDeltaOrderFunctions &
   SignDeltaOrderFunctions &
+  PreSignDeltaOrderFunctions<T> &
   CancelDeltaOrderFunctions;
 
 /** @description construct SDK with every Delta Order-related method, fetching from API and Order signing */
@@ -124,6 +130,7 @@ export const constructAllDeltaOrdersHandlers = <TxResponse>(
 
   const deltaOrdersBuild = constructBuildDeltaOrder(options);
   const deltaOrdersSign = constructSignDeltaOrder(options);
+  const deltaOrdersPreSign = constructPreSignDeltaOrder(options);
   const deltaOrdersPost = constructPostDeltaOrder(options);
 
   const deltaOrdersCancel = constructCancelDeltaOrder(options);
@@ -139,6 +146,7 @@ export const constructAllDeltaOrdersHandlers = <TxResponse>(
     ...deltaOrdersSubmit,
     ...deltaOrdersBuild,
     ...deltaOrdersSign,
+    ...deltaOrdersPreSign,
     ...deltaOrdersPost,
     ...deltaOrdersCancel,
   };

package/src/methods/delta/preSignDeltaOrder.ts

@@ -0,0 +1,158 @@
+import { hashTypedData } from 'viem/utils';
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+  TxSendOverrides,
+} from '../../types';
+import {
+  produceDeltaOrderTypedData,
+  SignableDeltaOrderData,
+} from './helpers/buildDeltaOrderData';
+import { sanitizeDeltaOrderData } from './helpers/misc';
+import type { ExtractAbiMethodNames } from '../../helpers/misc';
+import { findPrimaryType } from '../../helpers/providers/helpers';
+import { constructGetDeltaContract } from './getDeltaContract';
+import type { DeltaAuctionOrder } from './helpers/types';
+
+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>;

package/src/sdk/partial.ts

@@ -12,6 +12,7 @@ import type { CancelNFTOrderFunctions } from '../methods/nftOrders/cancelOrder';
 import type { ApproveTokenForNFTOrderFunctions } from '../methods/nftOrders/approveForOrder';
 import type { FillOrderDirectlyFunctions } from '../methods/limitOrders/fillOrderDirectly';
 import type { ApproveTokenForDeltaFunctions } from '../methods/delta/approveForDelta';
+import type { PreSignDeltaOrderFunctions } from '../methods/delta/preSignDeltaOrder';
 import { API_URL, DEFAULT_VERSION } from '../constants';
 
 export type SDKConfig<TxResponse = any> = ConstructProviderFetchInput<
@@ -50,7 +51,8 @@ type InferWithTxResponse<
           ApproveTokenForLimitOrderFunctions<TxResponse>,
           CancelNFTOrderFunctions<TxResponse>,
           ApproveTokenForNFTOrderFunctions<TxResponse>,
-          ApproveTokenForDeltaFunctions<TxResponse>
+          ApproveTokenForDeltaFunctions<TxResponse>,
+          PreSignDeltaOrderFunctions<TxResponse>
         ]
         // then merge IntersectionOfReturns<Funcs> with them recursively
       >