@velora-dex/sdk 9.3.4-dev.3 → 9.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velora-dex/sdk",
-  "version": "9.3.4-dev.3",
+  "version": "9.3.4",
   "main": "dist/index.js",
   "module": "dist/sdk.esm.js",
   "typings": "dist/index.d.ts",

package/src/index.ts

@@ -216,6 +216,13 @@ import {
   CancelDeltaOrderFunctions,
   constructCancelDeltaOrder,
 } from './methods/delta/cancelDeltaOrder';
+import {
+  DeltaTokenModuleFunctions,
+  CancelAndWithdrawDeltaOrderParams,
+  constructDeltaTokenModule,
+  DepositNativeAndPreSignParams,
+  DepositNativeAndPreSignDeltaOrderParams,
+} from './methods/delta/deltaTokenModule';
 
 export { constructSwapSDK, SwapSDKMethods } from './methods/swap';
 
@@ -300,6 +307,7 @@ export {
   constructGetDeltaPrice,
   constructGetDeltaOrders,
   constructCancelDeltaOrder,
+  constructDeltaTokenModule,
   constructApproveTokenForDelta,
   // Quote methods
   constructGetQuote,
@@ -395,6 +403,10 @@ export type {
   GetDeltaOrdersFunctions,
   ApproveTokenForDeltaFunctions,
   CancelDeltaOrderFunctions,
+  DeltaTokenModuleFunctions,
+  CancelAndWithdrawDeltaOrderParams,
+  DepositNativeAndPreSignParams,
+  DepositNativeAndPreSignDeltaOrderParams,
   // types for Quote methods
   GetQuoteFunctions,
   QuoteParams,

package/src/methods/delta/constants.ts

@@ -0,0 +1,11 @@
+import { ZERO_ADDRESS } from '../common/orders/buildOrderData';
+import { Bridge } from './helpers/types';
+
+// for same-chain Orders, all 0 params
+export const DEFAULT_BRIDGE = {
+  protocolSelector: '0x00000000', // 4 bytes
+  destinationChainId: 0,
+  outputToken: ZERO_ADDRESS,
+  scalingFactor: 0,
+  protocolData: '0x',
+} as const satisfies Bridge;

package/src/methods/delta/deltaTokenModule.ts

@@ -0,0 +1,367 @@
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+  TxSendOverrides,
+} from '../../types';
+import { constructGetDeltaContract } from './getDeltaContract';
+import { sanitizeDeltaOrderData } from './helpers/misc';
+import { SignableDeltaOrderData } from './helpers/buildDeltaOrderData';
+import { produceDeltaOrderHash } from './preSignDeltaOrder';
+import type { ExtractAbiMethodNames } from '../../helpers/misc';
+import type { DeltaAuctionOrder } from './helpers/types';
+import { DEFAULT_BRIDGE } from './constants';
+
+export type CancelAndWithdrawDeltaOrderParams = {
+  order: DeltaAuctionOrder;
+  signature: string;
+  /** @description A boolean indicating whether the order is a fillable order. False by default */
+  isFillable?: boolean;
+};
+
+export type CancelAndWithdrawDeltaOrder<T> = (
+  params: CancelAndWithdrawDeltaOrderParams,
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type WithdrawDeltaNative<T> = (
+  amount: string,
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type DepositNativeAndPreSignParams = {
+  orderHash: string;
+  depositAmount: string;
+};
+
+export type DepositNativeAndPreSign<T> = (
+  params: DepositNativeAndPreSignParams,
+  overrides?: Omit<TxSendOverrides, 'value'>, // value is set internally based on depositAmount
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type DepositNativeAndPreSignDeltaOrderParams = Pick<
+  DepositNativeAndPreSignParams,
+  'depositAmount'
+> & {
+  signableOrderData: SignableDeltaOrderData;
+};
+
+export type DepositNativeAndPreSignDeltaOrder<T> = (
+  params: DepositNativeAndPreSignDeltaOrderParams,
+  overrides?: Omit<TxSendOverrides, 'value'>, // value is set internally based on depositAmount
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type DeltaTokenModuleFunctions<T> = {
+  /** @description Cancel an order on-chain and withdraw native ETH back to the owner */
+  cancelAndWithdrawDeltaOrder: CancelAndWithdrawDeltaOrder<T>;
+  /** @description Withdraw Delta Wrapped Native tokens as native ETH */
+  withdrawDeltaNative: WithdrawDeltaNative<T>;
+  /** @description Deposit native ETH and pre-sign a Delta order */
+  depositNativeAndPreSign: DepositNativeAndPreSign<T>;
+  /** @description Deposit native ETH and pre-sign a Delta order from signable order data */
+  depositNativeAndPreSignDeltaOrder: DepositNativeAndPreSignDeltaOrder<T>;
+};
+
+const DeltaTokenModuleAbi = [
+  {
+    type: 'function',
+    name: 'cancelAndWithdraw',
+    inputs: [
+      {
+        name: 'orderWithSig',
+        type: 'tuple',
+        internalType: 'struct OrderWithSig',
+        components: [
+          {
+            name: 'order',
+            type: 'tuple',
+            internalType: 'struct Order',
+            components: [
+              {
+                name: 'owner',
+                type: 'address',
+                internalType: 'address',
+              },
+              {
+                name: 'beneficiary',
+                type: 'address',
+                internalType: 'address',
+              },
+              {
+                name: 'srcToken',
+                type: 'address',
+                internalType: 'address',
+              },
+              {
+                name: 'destToken',
+                type: 'address',
+                internalType: 'address',
+              },
+              {
+                name: 'srcAmount',
+                type: 'uint256',
+                internalType: 'uint256',
+              },
+              {
+                name: 'destAmount',
+                type: 'uint256',
+                internalType: 'uint256',
+              },
+              {
+                name: 'expectedAmount',
+                type: 'uint256',
+                internalType: 'uint256',
+              },
+              {
+                name: 'deadline',
+                type: 'uint256',
+                internalType: 'uint256',
+              },
+              {
+                name: 'kind',
+                type: 'uint8',
+                internalType: 'enum OrderKind',
+              },
+              {
+                name: 'nonce',
+                type: 'uint256',
+                internalType: 'uint256',
+              },
+              {
+                name: 'partnerAndFee',
+                type: 'uint256',
+                internalType: 'uint256',
+              },
+              {
+                name: 'permit',
+                type: 'bytes',
+                internalType: 'bytes',
+              },
+              {
+                name: 'metadata',
+                type: 'bytes',
+                internalType: 'bytes',
+              },
+              {
+                name: 'bridge',
+                type: 'tuple',
+                internalType: 'struct Bridge',
+                components: [
+                  {
+                    name: 'protocolSelector',
+                    type: 'bytes4',
+                    internalType: 'bytes4',
+                  },
+                  {
+                    name: 'destinationChainId',
+                    type: 'uint256',
+                    internalType: 'uint256',
+                  },
+                  {
+                    name: 'outputToken',
+                    type: 'address',
+                    internalType: 'address',
+                  },
+                  {
+                    name: 'scalingFactor',
+                    type: 'int8',
+                    internalType: 'int8',
+                  },
+                  {
+                    name: 'protocolData',
+                    type: 'bytes',
+                    internalType: 'bytes',
+                  },
+                ],
+              },
+            ],
+          },
+          {
+            name: 'signature',
+            type: 'bytes',
+            internalType: 'bytes',
+          },
+          {
+            name: 'bridgeOverride',
+            type: 'tuple',
+            internalType: 'struct BridgeOverride',
+            components: [
+              {
+                name: 'protocolSelector',
+                type: 'bytes4',
+                internalType: 'bytes4',
+              },
+              {
+                name: 'protocolData',
+                type: 'bytes',
+                internalType: 'bytes',
+              },
+            ],
+          },
+          {
+            name: 'cosignature',
+            type: 'bytes',
+            internalType: 'bytes',
+          },
+        ],
+      },
+      {
+        name: 'isFillable',
+        type: 'bool',
+        internalType: 'bool',
+      },
+    ],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  {
+    type: 'function',
+    name: 'withdrawNative',
+    inputs: [
+      {
+        name: 'amount',
+        type: 'uint256',
+        internalType: 'uint256',
+      },
+    ],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  {
+    type: 'function',
+    name: 'depositNativeAndPreSign',
+    inputs: [
+      {
+        name: 'orderHash',
+        type: 'bytes32',
+        internalType: 'bytes32',
+      },
+    ],
+    outputs: [],
+    stateMutability: 'payable',
+  },
+] as const;
+
+type AvailableMethods = ExtractAbiMethodNames<typeof DeltaTokenModuleAbi>;
+
+// returns whatever `contractCaller` returns
+// to allow for better versatility
+export const constructDeltaTokenModule = <T>(
+  options: Pick<
+    ConstructProviderFetchInput<T, 'transactCall'>,
+    'contractCaller' | 'fetcher' | 'apiURL' | 'chainId'
+  >
+): DeltaTokenModuleFunctions<T> => {
+  // cached internally
+  const { getDeltaContract } = constructGetDeltaContract(options);
+
+  const cancelAndWithdrawDeltaOrder: CancelAndWithdrawDeltaOrder<T> = async (
+    { order, signature, isFillable = false },
+    overrides = {},
+    requestParams
+  ) => {
+    const ParaswapDelta = await getDeltaContract(requestParams);
+    if (!ParaswapDelta) {
+      throw new Error(`Delta is not available on chain ${options.chainId}`);
+    }
+
+    const orderWithSig = {
+      order,
+      signature,
+      // bridgeOverride and cosignature are not used by the contract,
+      // can always provide defaults
+      bridgeOverride: {
+        protocolData: DEFAULT_BRIDGE.protocolData,
+        protocolSelector: DEFAULT_BRIDGE.protocolSelector,
+      },
+      cosignature: '0x',
+    };
+
+    const res = await options.contractCaller.transactCall<AvailableMethods>({
+      address: ParaswapDelta,
+      abi: DeltaTokenModuleAbi,
+      contractMethod: 'cancelAndWithdraw',
+      args: [orderWithSig, isFillable],
+      overrides,
+    });
+
+    return res;
+  };
+
+  const withdrawDeltaNative: WithdrawDeltaNative<T> = async (
+    amount,
+    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: DeltaTokenModuleAbi,
+      contractMethod: 'withdrawNative',
+      args: [amount],
+      overrides,
+    });
+
+    return res;
+  };
+
+  const depositNativeAndPreSign: DepositNativeAndPreSign<T> = async (
+    { orderHash, depositAmount },
+    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: DeltaTokenModuleAbi,
+      contractMethod: 'depositNativeAndPreSign',
+      args: [orderHash],
+      overrides: {
+        ...overrides,
+        value: depositAmount,
+      },
+    });
+
+    return res;
+  };
+
+  const depositNativeAndPreSignDeltaOrder: DepositNativeAndPreSignDeltaOrder<
+    T
+  > = async (
+    { signableOrderData, depositAmount },
+    overrides = {},
+    requestParams
+  ) => {
+    // types allow to pass OrderData & extra_stuff, but tx will break like that
+    const typedDataOnly: SignableDeltaOrderData = {
+      ...signableOrderData,
+      data: sanitizeDeltaOrderData(signableOrderData.data),
+    };
+
+    const orderHash = produceDeltaOrderHash(typedDataOnly);
+    const res = await depositNativeAndPreSign(
+      { orderHash, depositAmount },
+      overrides,
+      requestParams
+    );
+    return res;
+  };
+
+  return {
+    cancelAndWithdrawDeltaOrder,
+    withdrawDeltaNative,
+    depositNativeAndPreSign,
+    depositNativeAndPreSignDeltaOrder,
+  };
+};

package/src/methods/delta/getDeltaPrice.ts

@@ -7,7 +7,6 @@ import type {
   EnumerateLiteral,
   RequestParameters,
 } from '../../types';
-import { ZERO_ADDRESS } from '../common/orders/buildOrderData';
 import { BridgePriceInfo } from './helpers/types';
 
 type SwapSideUnion = EnumerateLiteral<typeof SwapSide>;
@@ -56,15 +55,6 @@ type DeltaPriceQueryOptions = Omit<
   excludeBridges?: string;
 };
 
-// for same-chain Orders, all 0 params
-export const DEFAULT_BRIDGE = {
-  protocolSelector: '0x00000000', // 4 bytes
-  destinationChainId: 0,
-  outputToken: ZERO_ADDRESS,
-  scalingFactor: 0,
-  protocolData: '0x',
-} as const satisfies Bridge;
-
 export type DeltaPrice = {
   srcToken: string;
   destToken: string;
@@ -99,10 +89,6 @@ export type DeltaPrice = {
 
 type AvailableBridgePrice = Pick<
   DeltaPrice,
-  | 'srcAmount'
-  | 'srcAmountBeforeFee' // Available for BUY side
-  | 'srcUSD'
-  | 'srcUSDBeforeFee' // Available for BUY side
   | 'destToken'
   | 'destAmount'
   | 'destAmountBeforeFee' // Available for SELL side

package/src/methods/delta/index.ts

@@ -50,6 +50,10 @@ import {
   constructPreSignDeltaOrder,
   PreSignDeltaOrderFunctions,
 } from './preSignDeltaOrder';
+import {
+  DeltaTokenModuleFunctions,
+  constructDeltaTokenModule,
+} from './deltaTokenModule';
 
 export type SubmitDeltaOrderParams = BuildDeltaOrderDataParams & {
   /** @description designates the Order as being able to be partially filled, as opposed to fill-or-kill */
@@ -107,7 +111,8 @@ export type DeltaOrderHandlers<T> = SubmitDeltaOrderFuncs &
   PostDeltaOrderFunctions &
   SignDeltaOrderFunctions &
   PreSignDeltaOrderFunctions<T> &
-  CancelDeltaOrderFunctions;
+  CancelDeltaOrderFunctions &
+  DeltaTokenModuleFunctions<T>;
 
 /** @description construct SDK with every Delta Order-related method, fetching from API and Order signing */
 export const constructAllDeltaOrdersHandlers = <TxResponse>(
@@ -135,6 +140,8 @@ export const constructAllDeltaOrdersHandlers = <TxResponse>(
 
   const deltaOrdersCancel = constructCancelDeltaOrder(options);
 
+  const deltaTokenModule = constructDeltaTokenModule(options);
+
   return {
     ...deltaOrdersGetters,
     ...deltaOrdersContractGetter,
@@ -149,5 +156,6 @@ export const constructAllDeltaOrdersHandlers = <TxResponse>(
     ...deltaOrdersPreSign,
     ...deltaOrdersPost,
     ...deltaOrdersCancel,
+    ...deltaTokenModule,
   };
 };

package/src/sdk/partial.ts

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