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

package/dist/sdk.esm.js

@@ -1,6 +1,7 @@
 import { SwapSide, ContractMethod } from '@paraswap/core';
 export { ContractMethod, ContractMethodV5, ContractMethodV6, SwapSide } from '@paraswap/core';
 import { assert } from 'ts-essentials';
+import { hashTypedData } from 'viem/utils';
 
 function _assertThisInitialized(e) {
   if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
@@ -3728,8 +3729,8 @@ var constructBuildDeltaOrder = function constructBuildDeltaOrder(options) {
     getPartnerFee = _constructGetPartnerF.getPartnerFee;
   var buildDeltaOrder = /*#__PURE__*/function () {
     var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(options, requestParams) {
-      var _options$partnerFeeBp, _options$side, _options$nonce;
-      var ParaswapDelta, partnerAddress, partnerFeeBps, partnerTakesSurplus, feeOrTakeSurplusSupplied, _partnerAddress, _partnerFeeBps, _partnerTakesSurplus, partner, partnerFeeResponse, swapSide, expectedAmount, input;
+      var _options$partnerFeeBp, _partnerFeeBps2, _partnerTakesSurplus2, _options$side, _options$nonce;
+      var ParaswapDelta, partnerAddress, partnerFeeBps, partnerTakesSurplus, feeOrTakeSurplusSupplied, partner, _partnerAddress, _partnerAddress2, _partnerFeeBps, _partnerTakesSurplus, partnerFeeResponse, swapSide, expectedAmount, input;
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
@@ -3746,25 +3747,37 @@ var constructBuildDeltaOrder = function constructBuildDeltaOrder(options) {
             ////// Partner logic //////
             // externally supplied partner fee data takes precedence
             partnerAddress = options.partnerAddress;
-            partnerFeeBps = (_options$partnerFeeBp = options.partnerFeeBps) != null ? _options$partnerFeeBp : options.deltaPrice.partnerFee * 100;
+            partnerFeeBps = (_options$partnerFeeBp = options.partnerFeeBps) != null ? _options$partnerFeeBp : options.deltaPrice.partnerFee ? options.deltaPrice.partnerFee * 100 : undefined;
             partnerTakesSurplus = options.partnerTakesSurplus; // if fee given, takeSurplus is ignored
             feeOrTakeSurplusSupplied = partnerFeeBps !== undefined || partnerTakesSurplus !== undefined;
             if (!(partnerAddress === undefined || feeOrTakeSurplusSupplied)) {
-              _context.next = 17;
+              _context.next = 21;
               break;
             }
             partner = options.partner || options.deltaPrice.partner;
-            _context.next = 13;
+            if (partner) {
+              _context.next = 15;
+              break;
+            }
+            // if no partner given in options or deltaPrice, default partnerAddress to zero,
+            // unless supplied explicitly
+            partnerAddress = (_partnerAddress = partnerAddress) != null ? _partnerAddress : ZERO_ADDRESS;
+            _context.next = 21;
+            break;
+          case 15:
+            _context.next = 17;
             return getPartnerFee({
               partner: partner
             }, requestParams);
-          case 13:
+          case 17:
             partnerFeeResponse = _context.sent;
-            partnerAddress = (_partnerAddress = partnerAddress) != null ? _partnerAddress : partnerFeeResponse.partnerAddress;
+            partnerAddress = (_partnerAddress2 = partnerAddress) != null ? _partnerAddress2 : partnerFeeResponse.partnerAddress;
             // deltaPrice.partnerFee and partnerFeeResponse.partnerFee should be the same, but give priority to externally provided
             partnerFeeBps = (_partnerFeeBps = partnerFeeBps) != null ? _partnerFeeBps : partnerFeeResponse.partnerFee;
             partnerTakesSurplus = (_partnerTakesSurplus = partnerTakesSurplus) != null ? _partnerTakesSurplus : partnerFeeResponse.takeSurplus;
-          case 17:
+          case 21:
+            partnerFeeBps = (_partnerFeeBps2 = partnerFeeBps) != null ? _partnerFeeBps2 : 0;
+            partnerTakesSurplus = (_partnerTakesSurplus2 = partnerTakesSurplus) != null ? _partnerTakesSurplus2 : false;
             swapSide = (_options$side = options.side) != null ? _options$side : SwapSide.SELL;
             expectedAmount = swapSide === SwapSide.SELL ? options.deltaPrice.destAmount : options.deltaPrice.srcAmount;
             input = {
@@ -3790,7 +3803,7 @@ var constructBuildDeltaOrder = function constructBuildDeltaOrder(options) {
               bridge: options.deltaPrice.bridge // ZERO_BRIDGE for same-chain Orders
             };
             return _context.abrupt("return", buildDeltaSignableOrderData(input));
-          case 21:
+          case 27:
           case "end":
             return _context.stop();
         }
@@ -3805,62 +3818,6 @@ var constructBuildDeltaOrder = function constructBuildDeltaOrder(options) {
   };
 };
 
-var constructBuildCrosschainOrderBridge = function constructBuildCrosschainOrderBridge(options) {
-  var chainId = options.chainId;
-  // cached internally for `multicall` contracts
-  // const { getMulticallHandlers } = constructGetMulticallHandlers(options);
-  var buildCrosschainOrderBridge = /*#__PURE__*/function () {
-    var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref, requestParams) {
-      var destChainId, deltaPrice, bridge;
-      return _regeneratorRuntime().wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            destChainId = _ref.destChainId, deltaPrice = _ref.deltaPrice;
-            assert(chainId !== deltaPrice.bridge.destinationChainId, '`deltaPrice.bridge.destinationChainId` must be different from `chainId` for crosschain Order.bridge');
-            assert(destChainId === deltaPrice.bridge.destinationChainId, '`destChainId` must match `deltaPrice.bridge.destinationChainId` for crosschain Order.bridge');
-            /* const getMulticallHandler = async (chainId: number) => {
-              const multicallHandlersMap = await getMulticallHandlers(requestParams);
-              const multicallHandler = multicallHandlersMap[chainId];
-                   assert(
-                multicallHandler,
-                `Multicall handler not found for chain ${chainId}`
-              );
-                   return multicallHandler;
-            };
-                 const { bridge } = await getDeltaBridge({
-              destTokenDestChain: destToken,
-              destChainId,
-              bridgeFee: deltaPrice.bridgeFee,
-              bridgeOutputToken: deltaPrice.bridge.outputToken,
-              beneficiaryType,
-              getMulticallHandler,
-            }); */
-            // @TODO remove the whole buildCrosschainOrderBridge() when API provides BridgePrice.bridge = whole Bridge object
-            bridge = {
-              protocolSelector: '0x00000000',
-              scalingFactor: 0,
-              protocolData: '0x',
-              destinationChainId: deltaPrice.bridge.destinationChainId,
-              outputToken: deltaPrice.bridge.outputToken
-            };
-            return _context.abrupt("return", {
-              bridge: bridge
-            });
-          case 5:
-          case "end":
-            return _context.stop();
-        }
-      }, _callee);
-    }));
-    return function buildCrosschainOrderBridge(_x, _x2) {
-      return _ref2.apply(this, arguments);
-    };
-  }();
-  return {
-    buildCrosschainOrderBridge: buildCrosschainOrderBridge
-  };
-};
-
 var constructPostDeltaOrder = function constructPostDeltaOrder(_ref) {
   var _ref$apiURL = _ref.apiURL,
     apiURL = _ref$apiURL === void 0 ? API_URL : _ref$apiURL,
@@ -3949,6 +3906,153 @@ var constructSignDeltaOrder = function constructSignDeltaOrder(options) {
   };
 };
 
+var PreSignatureModuleAbi = [{
+  inputs: [{
+    internalType: 'bytes32',
+    name: 'orderHash',
+    type: 'bytes32'
+  }, {
+    internalType: 'bool',
+    name: 'preSigned',
+    type: 'bool'
+  }],
+  name: 'setPreSignature',
+  outputs: [],
+  stateMutability: 'nonpayable',
+  type: 'function'
+}];
+// returns whatever `contractCaller` returns
+// to allow for better versatility
+var constructPreSignDeltaOrder = function constructPreSignDeltaOrder(options) {
+  var hashDeltaOrderTypedData = function hashDeltaOrderTypedData(typedData) {
+    // types allow to pass OrderData & extra_stuff, but tx will break like that
+    var typedDataOnly = _extends({}, typedData, {
+      data: sanitizeDeltaOrderData(typedData.data)
+    });
+    var orderHash = produceDeltaOrderHash(typedDataOnly);
+    return orderHash;
+  };
+  // cached internally
+  var _constructGetDeltaCon = constructGetDeltaContract(options),
+    getDeltaContract = _constructGetDeltaCon.getDeltaContract;
+  var hashDeltaOrder = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(orderData, requestParams) {
+      var ParaswapDelta, typedData;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return getDeltaContract(requestParams);
+          case 2:
+            ParaswapDelta = _context.sent;
+            if (ParaswapDelta) {
+              _context.next = 5;
+              break;
+            }
+            throw new Error("Delta is not available on chain " + options.chainId);
+          case 5:
+            typedData = produceDeltaOrderTypedData({
+              orderInput: orderData,
+              chainId: options.chainId,
+              paraswapDeltaAddress: ParaswapDelta
+            });
+            return _context.abrupt("return", hashDeltaOrderTypedData(typedData));
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function hashDeltaOrder(_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  var setDeltaOrderPreSignature = /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(orderHash, overrides, requestParams) {
+      var ParaswapDelta, res;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            if (overrides === void 0) {
+              overrides = {};
+            }
+            _context2.next = 3;
+            return getDeltaContract(requestParams);
+          case 3:
+            ParaswapDelta = _context2.sent;
+            if (ParaswapDelta) {
+              _context2.next = 6;
+              break;
+            }
+            throw new Error("Delta is not available on chain " + options.chainId);
+          case 6:
+            _context2.next = 8;
+            return options.contractCaller.transactCall({
+              address: ParaswapDelta,
+              abi: PreSignatureModuleAbi,
+              contractMethod: 'setPreSignature',
+              args: [orderHash, true],
+              overrides: overrides
+            });
+          case 8:
+            res = _context2.sent;
+            return _context2.abrupt("return", res);
+          case 10:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+    return function setDeltaOrderPreSignature(_x3, _x4, _x5) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+  var preSignDeltaOrder = /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(signableOrderData, overrides, requestParams) {
+      var orderHash, res;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            if (overrides === void 0) {
+              overrides = {};
+            }
+            orderHash = hashDeltaOrderTypedData(signableOrderData);
+            _context3.next = 4;
+            return setDeltaOrderPreSignature(orderHash, overrides, requestParams);
+          case 4:
+            res = _context3.sent;
+            return _context3.abrupt("return", res);
+          case 6:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }));
+    return function preSignDeltaOrder(_x6, _x7, _x8) {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+  return {
+    hashDeltaOrderTypedData: hashDeltaOrderTypedData,
+    hashDeltaOrder: hashDeltaOrder,
+    setDeltaOrderPreSignature: setDeltaOrderPreSignature,
+    preSignDeltaOrder: preSignDeltaOrder
+  };
+};
+function produceDeltaOrderHash(typedData) {
+  return hashTypedData({
+    domain: {
+      name: typedData.domain.name,
+      version: typedData.domain.version,
+      chainId: typedData.domain.chainId,
+      verifyingContract: typedData.domain.verifyingContract
+    },
+    types: typedData.types,
+    primaryType: findPrimaryType(typedData.types),
+    message: typedData.data
+  });
+}
+
 var _excluded = ["includeAgents", "excludeAgents"];
 var constructGetDeltaPrice = function constructGetDeltaPrice(_ref) {
   var _ref$apiURL = _ref.apiURL,
@@ -4058,28 +4162,32 @@ var constructGetDeltaOrders = function constructGetDeltaOrders(_ref) {
   }();
   var getDeltaOrders = /*#__PURE__*/function () {
     var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(options, requestParams) {
-      var search, fetchURL, orders;
+      var _options$chainId, _options$status;
+      var chainIdString, statusString, search, fetchURL, orders;
       return _regeneratorRuntime().wrap(function _callee3$(_context3) {
         while (1) switch (_context3.prev = _context3.next) {
           case 0:
+            chainIdString = (_options$chainId = options.chainId) == null ? void 0 : _options$chainId.join(',');
+            statusString = (_options$status = options.status) == null ? void 0 : _options$status.join(',');
             search = constructSearchString({
               userAddress: options.userAddress,
               page: options.page,
               limit: options.limit,
-              chainId: options.chainId,
-              type: options.type
+              type: options.type,
+              chainId: chainIdString,
+              status: statusString
             });
             fetchURL = "" + baseUrl + search;
-            _context3.next = 4;
+            _context3.next = 6;
             return fetcher({
               url: fetchURL,
               method: 'GET',
               requestParams: requestParams
             });
-          case 4:
+          case 6:
             orders = _context3.sent;
             return _context3.abrupt("return", orders);
-          case 6:
+          case 8:
           case "end":
             return _context3.stop();
         }
@@ -4199,44 +4307,6 @@ var constructGetBridgeInfo = function constructGetBridgeInfo(_ref) {
   };
 };
 
-var constructGetMulticallHandlers = function constructGetMulticallHandlers(_ref) {
-  var _ref$apiURL = _ref.apiURL,
-    apiURL = _ref$apiURL === void 0 ? API_URL : _ref$apiURL,
-    fetcher = _ref.fetcher;
-  var multicallHandlersUrl = apiURL + "/delta/prices/multicall-handlers";
-  var _getMulticallHandlers = /*#__PURE__*/function () {
-    var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(requestParams) {
-      var data;
-      return _regeneratorRuntime().wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            _context.next = 2;
-            return fetcher({
-              url: multicallHandlersUrl,
-              method: 'GET',
-              requestParams: requestParams
-            });
-          case 2:
-            data = _context.sent;
-            return _context.abrupt("return", data);
-          case 4:
-          case "end":
-            return _context.stop();
-        }
-      }, _callee);
-    }));
-    return function _getMulticallHandlers(_x) {
-      return _ref2.apply(this, arguments);
-    };
-  }();
-  // cached for the same instance of `{getMulticallHandlers} = constructGetMulticallHandlers()`
-  // so should persist across same apiUrl & network (and response is even network agnostic)
-  var getMulticallHandlers = runOnceAndCache(_getMulticallHandlers);
-  return {
-    getMulticallHandlers: getMulticallHandlers
-  };
-};
-
 var constructIsTokenSupportedInDelta = function constructIsTokenSupportedInDelta(_ref) {
   var _ref$apiURL = _ref.apiURL,
     apiURL = _ref$apiURL === void 0 ? API_URL : _ref$apiURL,
@@ -4595,6 +4665,7 @@ var constructAllLimitOrdersHandlers = function constructAllLimitOrdersHandlers(o
 var constructSubmitDeltaOrder = function constructSubmitDeltaOrder(options) {
   var _constructBuildDeltaO = constructBuildDeltaOrder(options),
     buildDeltaOrder = _constructBuildDeltaO.buildDeltaOrder;
+  // in the normal submitOrderFlow preSign tx is not involved
   var _constructSignDeltaOr = constructSignDeltaOrder(options),
     signDeltaOrder = _constructSignDeltaOr.signDeltaOrder;
   var _constructPostDeltaOr = constructPostDeltaOrder(options),
@@ -4649,15 +4720,14 @@ var constructAllDeltaOrdersHandlers = function constructAllDeltaOrdersHandlers(o
   var partnerFee = constructGetPartnerFee(options);
   var bridgeInfo = constructGetBridgeInfo(options);
   var isTokenSupportedInDelta = constructIsTokenSupportedInDelta(options);
-  var multicallHandlers = constructGetMulticallHandlers(options);
   var approveTokenForDelta = constructApproveTokenForDelta(options);
   var deltaOrdersSubmit = constructSubmitDeltaOrder(options);
-  var buildCrosschainOrderBridge = constructBuildCrosschainOrderBridge(options);
   var deltaOrdersBuild = constructBuildDeltaOrder(options);
   var deltaOrdersSign = constructSignDeltaOrder(options);
+  var deltaOrdersPreSign = constructPreSignDeltaOrder(options);
   var deltaOrdersPost = constructPostDeltaOrder(options);
   var deltaOrdersCancel = constructCancelDeltaOrder(options);
-  return _extends({}, deltaOrdersGetters, deltaOrdersContractGetter, deltaPrice, partnerFee, bridgeInfo, isTokenSupportedInDelta, multicallHandlers, approveTokenForDelta, deltaOrdersSubmit, deltaOrdersBuild, deltaOrdersSign, deltaOrdersPost, deltaOrdersCancel, buildCrosschainOrderBridge);
+  return _extends({}, deltaOrdersGetters, deltaOrdersContractGetter, deltaPrice, partnerFee, bridgeInfo, isTokenSupportedInDelta, approveTokenForDelta, deltaOrdersSubmit, deltaOrdersBuild, deltaOrdersSign, deltaOrdersPreSign, deltaOrdersPost, deltaOrdersCancel);
 };
 
 var constructSubmitNFTOrder = function constructSubmitNFTOrder(options) {
@@ -4825,7 +4895,7 @@ function constructSimpleSDK(options, providerOptions) {
     var _swap = constructPartialSDK(_config, constructGetBalances, constructGetTokens, constructGetSpender, constructBuildTx, constructGetAdapters, constructGetRate, constructSwapTx);
     var _limitOrders = constructPartialSDK(_config, constructBuildLimitOrder, constructPostLimitOrder, constructGetLimitOrders, constructGetLimitOrdersContract, constructBuildLimitOrderTx);
     var _nftOrders = constructPartialSDK(_config, constructBuildNFTOrder, constructPostNFTOrder, constructGetNFTOrders, constructGetNFTOrdersContract, constructBuildNFTOrderTx);
-    var _delta = constructPartialSDK(_config, constructBuildDeltaOrder, constructBuildCrosschainOrderBridge, constructPostDeltaOrder, constructGetDeltaOrders, constructGetDeltaPrice, constructGetDeltaContract, constructGetPartnerFee, constructGetMulticallHandlers, constructGetBridgeInfo, constructIsTokenSupportedInDelta);
+    var _delta = constructPartialSDK(_config, constructBuildDeltaOrder, constructPostDeltaOrder, constructGetDeltaOrders, constructGetDeltaPrice, constructGetDeltaContract, constructGetPartnerFee, constructGetBridgeInfo, constructIsTokenSupportedInDelta);
     var _quote = constructPartialSDK(_config, constructGetQuote);
     return {
       swap: _swap,
@@ -4968,5 +5038,5 @@ function constructSimpleContractCaller(providerOptions) {
   };
 }
 
-export { API_URL, AssetType, DEFAULT_VERSION, constructAllDeltaOrdersHandlers, constructAllLimitOrdersHandlers, constructAllNFTOrdersHandlers, constructApproveToken, constructApproveTokenForDelta, constructApproveTokenForLimitOrder, constructApproveTokenForNFTOrder, constructFetcher$2 as constructAxiosFetcher, constructBuildCrosschainOrderBridge, constructBuildDeltaOrder, constructBuildLimitOrder, constructBuildLimitOrderTx, constructBuildNFTOrder, constructBuildNFTOrderTx, constructBuildTx, constructCancelDeltaOrder, constructCancelLimitOrder, constructCancelNFTOrder, constructEthersV5ContractCaller as constructEthersContractCaller, constructEthersV5ContractCaller, constructContractCaller$2 as constructEthersV6ContractCaller, constructFetcher$1 as constructFetchFetcher, constructFillOrderDirectly, constructFullSDK, constructGetAdapters, constructGetBalances, constructGetBridgeInfo, constructGetDeltaContract, constructGetDeltaOrders, constructGetDeltaPrice, constructGetLimitOrders, constructGetLimitOrdersContract, constructGetMulticallHandlers, constructGetNFTOrders, constructGetNFTOrdersContract, constructGetPartnerFee, constructGetQuote, constructGetRate, constructGetSpender, constructGetTokens, constructIsTokenSupportedInDelta, constructPartialSDK, constructPostDeltaOrder, constructPostLimitOrder, constructPostNFTOrder, constructSignDeltaOrder, constructSignLimitOrder, constructSignNFTOrder, constructSimpleSDK, constructSubmitDeltaOrder, constructSubmitLimitOrder, constructSubmitNFTOrder, constructSwapSDK, constructSwapTx, constructToken, constructContractCaller as constructViemContractCaller, constructContractCaller$1 as constructWeb3ContractCaller, isAllowance, isFetcherError, txParamsToViemTxParams };
+export { API_URL, AssetType, DEFAULT_VERSION, constructAllDeltaOrdersHandlers, constructAllLimitOrdersHandlers, constructAllNFTOrdersHandlers, constructApproveToken, constructApproveTokenForDelta, constructApproveTokenForLimitOrder, constructApproveTokenForNFTOrder, constructFetcher$2 as constructAxiosFetcher, constructBuildDeltaOrder, constructBuildLimitOrder, constructBuildLimitOrderTx, constructBuildNFTOrder, constructBuildNFTOrderTx, constructBuildTx, constructCancelDeltaOrder, constructCancelLimitOrder, constructCancelNFTOrder, constructEthersV5ContractCaller as constructEthersContractCaller, constructEthersV5ContractCaller, constructContractCaller$2 as constructEthersV6ContractCaller, constructFetcher$1 as constructFetchFetcher, constructFillOrderDirectly, constructFullSDK, constructGetAdapters, constructGetBalances, constructGetBridgeInfo, constructGetDeltaContract, constructGetDeltaOrders, constructGetDeltaPrice, constructGetLimitOrders, constructGetLimitOrdersContract, constructGetNFTOrders, constructGetNFTOrdersContract, constructGetPartnerFee, constructGetQuote, constructGetRate, constructGetSpender, constructGetTokens, constructIsTokenSupportedInDelta, constructPartialSDK, constructPostDeltaOrder, constructPostLimitOrder, constructPostNFTOrder, constructPreSignDeltaOrder, constructSignDeltaOrder, constructSignLimitOrder, constructSignNFTOrder, constructSimpleSDK, constructSubmitDeltaOrder, constructSubmitLimitOrder, constructSubmitNFTOrder, constructSwapSDK, constructSwapTx, constructToken, constructContractCaller as constructViemContractCaller, constructContractCaller$1 as constructWeb3ContractCaller, isAllowance, isFetcherError, txParamsToViemTxParams };
 //# sourceMappingURL=sdk.esm.js.map