@velora-dex/sdk 8.0.0 → 8.1.0

package/dist/sdk.esm.js

@@ -464,6 +464,7 @@ var FetcherError = /*#__PURE__*/function (_Error) {
       status = response.status;
     _this.status = status;
     _this.message = isDataWithError(data) ? data.error : message;
+    _this.message = isDataWithError2(data) ? "" + data.errorType + (data.description ? ": " + data.description : '') : _this.message;
     return _this;
   }
   _inheritsLoose(FetcherError, _Error);
@@ -476,6 +477,9 @@ function isObject(obj) {
 function isDataWithError(data) {
   return isObject(data) && typeof data['error'] === 'string';
 }
+function isDataWithError2(data) {
+  return isObject(data) && typeof data['errorType'] === 'string';
+}
 // checks that array has at least one element
 var isFilledArray = function isFilledArray(array) {
   return array.length > 0;
@@ -3818,6 +3822,8 @@ var ACROSS_WETH_ADDRESSES_MAP = {
   81457: '0x4300000000000000000000000000000000000004',
   // Blast Sepolia
   168587773: '0x4200000000000000000000000000000000000023',
+  // BSC
+  56: '0x2170Ed0880ac9A755fd29B2688956BD959F933F8',
   // Ink
   57073: '0x4200000000000000000000000000000000000006',
   // Ink Sepolia
@@ -3868,150 +3874,71 @@ var ETH_ADDRESS_LOWERCASE = /*#__PURE__*/ETH_ADDRESS.toLowerCase();
 function isETHaddress(tokenAddress) {
   return tokenAddress.toLowerCase() === ETH_ADDRESS_LOWERCASE;
 }
-function getDeltaBridgeAndDestToken(_x) {
-  return _getDeltaBridgeAndDestToken.apply(this, arguments);
+function getDeltaBridge(_x) {
+  return _getDeltaBridge.apply(this, arguments);
 }
-function _getDeltaBridgeAndDestToken() {
-  _getDeltaBridgeAndDestToken = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
-    var destTokenDestChain, destChainId, destTokenSrcChain, srcChainId, bridgeFee, beneficiaryType, getMulticallHandler, WETH_SRC_CHAIN, WETH_DEST_CHAIN, _bridge, _bridge2, _bridge3, _bridge4, _bridge5, bridge;
+function _getDeltaBridge() {
+  _getDeltaBridge = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
+    var destTokenDestChain, destChainId, bridgeFee, bridgeOutputToken, beneficiaryType, getMulticallHandler, outputToken, multiCallHandler, bridge;
     return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
         case 0:
-          destTokenDestChain = _ref.destTokenDestChain, destChainId = _ref.destChainId, destTokenSrcChain = _ref.destTokenSrcChain, srcChainId = _ref.srcChainId, bridgeFee = _ref.bridgeFee, beneficiaryType = _ref.beneficiaryType, getMulticallHandler = _ref.getMulticallHandler;
+          destTokenDestChain = _ref.destTokenDestChain, destChainId = _ref.destChainId, bridgeFee = _ref.bridgeFee, bridgeOutputToken = _ref.bridgeOutputToken, beneficiaryType = _ref.beneficiaryType, getMulticallHandler = _ref.getMulticallHandler;
           assert(beneficiaryType === 'EOA' || beneficiaryType === 'SmartContract', 'beneficiaryType must be EOA or SmartContract');
-          WETH_SRC_CHAIN = ACROSS_WETH_ADDRESSES_MAP[srcChainId];
-          WETH_DEST_CHAIN = ACROSS_WETH_ADDRESSES_MAP[destChainId];
-          if (!(!WETH_SRC_CHAIN || !WETH_DEST_CHAIN)) {
-            _context.next = 7;
-            break;
-          }
-          // this should never happen as we only expect crosschain Delta Orders for supported chains
-          _bridge = {
-            maxRelayerFee: bridgeFee,
-            destinationChainId: destChainId,
-            outputToken: destTokenDestChain,
-            multiCallHandler: ZERO_ADDRESS
-          };
-          return _context.abrupt("return", {
-            bridge: _bridge,
-            orderChanges: {
-              destToken: destTokenSrcChain
-            }
-          });
-        case 7:
-          if (!(beneficiaryType === 'EOA' && isETHaddress(destTokenDestChain))) {
-            _context.next = 10;
-            break;
+          outputToken = bridgeOutputToken.toLowerCase(); // for uniformity
+          multiCallHandler = ZERO_ADDRESS;
+          if (beneficiaryType === 'EOA' && isETHaddress(destTokenDestChain)) {
+            /*
+            if beneficiary is an EOA and destToken on destChain = ETH
+            order.destToken=ETH (deltaPrice already contains correct destToken)
+            order.bridge.outputToken=WETH_DEST_CHAIN (deltaPrice already contains correct bridge.outputToken)
+            order.bridge.multiCallHandler=NULL_ADDRESS
+            */
+            multiCallHandler = ZERO_ADDRESS;
           }
-          /*
-          if beneficiary is an EOA and destToken on destChain = ETH
-          order.destToken=ETH
-          order.bridge.outputToken=WETH_DEST_CHAIN
-          order.bridge.multiCallHandler=NULL_ADDRESS
-          */
-          _bridge2 = {
-            maxRelayerFee: bridgeFee,
-            destinationChainId: destChainId,
-            outputToken: WETH_DEST_CHAIN,
-            multiCallHandler: ZERO_ADDRESS
-          };
-          return _context.abrupt("return", {
-            bridge: _bridge2,
-            orderChanges: {
-              destToken: ETH_ADDRESS
-            }
-          });
-        case 10:
           if (!(beneficiaryType === 'EOA' && isAcrossWETH(destTokenDestChain, destChainId))) {
-            _context.next = 19;
+            _context.next = 9;
             break;
           }
-          _context.t0 = bridgeFee;
-          _context.t1 = destChainId;
-          _context.t2 = WETH_DEST_CHAIN;
-          _context.next = 16;
+          _context.next = 8;
           return getMulticallHandler(destChainId);
-        case 16:
-          _context.t3 = _context.sent;
-          _bridge3 = {
-            maxRelayerFee: _context.t0,
-            destinationChainId: _context.t1,
-            outputToken: _context.t2,
-            multiCallHandler: _context.t3
-          };
-          return _context.abrupt("return", {
-            bridge: _bridge3,
-            orderChanges: {
-              destToken: WETH_SRC_CHAIN
-            }
-          });
-        case 19:
+        case 8:
+          multiCallHandler = _context.sent;
+        case 9:
           if (!(beneficiaryType === 'SmartContract' && isETHaddress(destTokenDestChain))) {
-            _context.next = 28;
+            _context.next = 13;
             break;
           }
-          _context.t4 = bridgeFee;
-          _context.t5 = destChainId;
-          _context.t6 = WETH_DEST_CHAIN;
-          _context.next = 25;
+          _context.next = 12;
           return getMulticallHandler(destChainId);
-        case 25:
-          _context.t7 = _context.sent;
-          _bridge4 = {
-            maxRelayerFee: _context.t4,
-            destinationChainId: _context.t5,
-            outputToken: _context.t6,
-            multiCallHandler: _context.t7
-          };
-          return _context.abrupt("return", {
-            bridge: _bridge4,
-            orderChanges: {
-              destToken: ETH_ADDRESS
-            }
-          });
-        case 28:
-          if (!(beneficiaryType === 'SmartContract' && isAcrossWETH(destTokenDestChain, destChainId))) {
-            _context.next = 31;
-            break;
+        case 12:
+          multiCallHandler = _context.sent;
+        case 13:
+          if (beneficiaryType === 'SmartContract' && isAcrossWETH(destTokenDestChain, destChainId)) {
+            /*
+              if beneficiary is a contract and destToken on destChain = WETH
+              order.destToken=WETH (deltaPrice already contains correct destToken)
+              order.bridge.outputToken=WETH_DEST_CHAIN (deltaPrice already contains correct bridge.outputToken)
+              order.bridge.multiCallHandler=NULL_ADDRESS
+            */
+            multiCallHandler = ZERO_ADDRESS;
           }
-          /*
-            if beneficiary is a contract and destToken on destChain = WETH
-            order.destToken=WETH
-            order.bridge.outputToken=WETH_DEST_CHAIN
-            order.bridge.multiCallHandler=NULL_ADDRESS
-          */
-          _bridge5 = {
-            maxRelayerFee: bridgeFee,
-            destinationChainId: destChainId,
-            outputToken: WETH_DEST_CHAIN,
-            multiCallHandler: ZERO_ADDRESS
-          };
-          return _context.abrupt("return", {
-            bridge: _bridge5,
-            orderChanges: {
-              destToken: WETH_SRC_CHAIN
-            }
-          });
-        case 31:
           bridge = {
             maxRelayerFee: bridgeFee,
             destinationChainId: destChainId,
-            outputToken: destTokenDestChain,
-            multiCallHandler: ZERO_ADDRESS
+            outputToken: outputToken,
+            multiCallHandler: multiCallHandler
           };
           return _context.abrupt("return", {
-            bridge: bridge,
-            orderChanges: {
-              destToken: destTokenSrcChain
-            }
+            bridge: bridge
           });
-        case 33:
+        case 16:
         case "end":
           return _context.stop();
       }
     }, _callee);
   }));
-  return _getDeltaBridgeAndDestToken.apply(this, arguments);
+  return _getDeltaBridge.apply(this, arguments);
 }
 
 var constructBuildCrosschainOrderBridge = function constructBuildCrosschainOrderBridge(options) {
@@ -4021,12 +3948,13 @@ var constructBuildCrosschainOrderBridge = function constructBuildCrosschainOrder
     getMulticallHandlers = _constructGetMultical.getMulticallHandlers;
   var buildCrosschainOrderBridge = /*#__PURE__*/function () {
     var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref, requestParams) {
-      var destToken, destChainId, beneficiaryType, deltaPrice, getMulticallHandler, _yield$getDeltaBridge, bridge, orderChanges;
+      var destToken, destChainId, beneficiaryType, deltaPrice, getMulticallHandler, _yield$getDeltaBridge, bridge;
       return _regeneratorRuntime().wrap(function _callee2$(_context2) {
         while (1) switch (_context2.prev = _context2.next) {
           case 0:
             destToken = _ref.destToken, destChainId = _ref.destChainId, beneficiaryType = _ref.beneficiaryType, deltaPrice = _ref.deltaPrice;
-            assert(chainId !== destChainId, '`destChainId` must be different from `chainId` for crosschain Order.bridge');
+            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');
             getMulticallHandler = /*#__PURE__*/function () {
               var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(chainId) {
                 var multicallHandlersMap, multicallHandler;
@@ -4050,23 +3978,20 @@ var constructBuildCrosschainOrderBridge = function constructBuildCrosschainOrder
                 return _ref3.apply(this, arguments);
               };
             }();
-            _context2.next = 5;
-            return getDeltaBridgeAndDestToken({
+            _context2.next = 6;
+            return getDeltaBridge({
               destTokenDestChain: destToken,
               destChainId: destChainId,
-              destTokenSrcChain: deltaPrice.destToken,
-              srcChainId: chainId,
               bridgeFee: deltaPrice.bridgeFee,
+              bridgeOutputToken: deltaPrice.bridge.outputToken,
               beneficiaryType: beneficiaryType,
               getMulticallHandler: getMulticallHandler
             });
-          case 5:
+          case 6:
             _yield$getDeltaBridge = _context2.sent;
             bridge = _yield$getDeltaBridge.bridge;
-            orderChanges = _yield$getDeltaBridge.orderChanges;
             return _context2.abrupt("return", {
-              bridge: bridge,
-              orderChanges: orderChanges
+              bridge: bridge
             });
           case 9:
           case "end":
@@ -4102,8 +4027,8 @@ var constructBuildDeltaOrder = function constructBuildDeltaOrder(options) {
     buildCrosschainOrderBridge = _constructBuildCrossc.buildCrosschainOrderBridge;
   var buildDeltaOrder = /*#__PURE__*/function () {
     var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(options, requestParams) {
-      var _options$partnerFeeBp, _partialChangedOrder$, _partialChangedOrder, _options$nonce;
-      var ParaswapDelta, partnerAddress, partnerFeeBps, partnerTakesSurplus, feeOrTakeSurplusSupplied, _partnerAddress, _partnerFeeBps, _partnerTakesSurplus, partner, partnerFeeResponse, bridge, partialChangedOrder, _options$beneficiaryT, deltaPrice, _yield$buildCrosschai, constructedBridge, orderChanges, input;
+      var _options$partnerFeeBp, _options$nonce;
+      var ParaswapDelta, partnerAddress, partnerFeeBps, partnerTakesSurplus, feeOrTakeSurplusSupplied, _partnerAddress, _partnerFeeBps, _partnerTakesSurplus, partner, partnerFeeResponse, bridge, _options$beneficiaryT, deltaPrice, _yield$buildCrosschai, constructedBridge, input;
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
@@ -4141,19 +4066,19 @@ var constructBuildDeltaOrder = function constructBuildDeltaOrder(options) {
           case 17:
             ////// Bridge logic //////
             // Bridge is necessary for Crosschain Delta Orders
-            bridge = options.bridge;
-            partialChangedOrder = null; // give preference to user-provided bridge
+            bridge = options.bridge; // give preference to user-provided bridge
             if (bridge) {
-              _context.next = 33;
+              _context.next = 31;
               break;
             }
             if (!(options.destChainId && chainId !== options.destChainId)) {
-              _context.next = 32;
+              _context.next = 30;
               break;
             }
             // crosschain Delta Order
             deltaPrice = options.deltaPrice;
             assert(deltaPrice.bridgeFee, '`bridgeFee` is required in `deltaPrice` for crosschain Delta Orders');
+            assert(deltaPrice.bridge, '`bridge` is required in `deltaPrice` for crosschain Delta Orders');
             _context.next = 25;
             return buildCrosschainOrderBridge({
               destToken: options.destToken,
@@ -4161,27 +4086,26 @@ var constructBuildDeltaOrder = function constructBuildDeltaOrder(options) {
               beneficiaryType: (_options$beneficiaryT = options.beneficiaryType) != null ? _options$beneficiaryT : 'EOA',
               deltaPrice: {
                 bridgeFee: deltaPrice.bridgeFee,
-                destToken: deltaPrice.destToken
+                bridge: deltaPrice.bridge // already contains destChainId and outputToken
               }
             }, requestParams);
           case 25:
             _yield$buildCrosschai = _context.sent;
             constructedBridge = _yield$buildCrosschai.bridge;
-            orderChanges = _yield$buildCrosschai.orderChanges;
             bridge = constructedBridge;
-            partialChangedOrder = orderChanges;
-            _context.next = 33;
+            _context.next = 31;
             break;
-          case 32:
+          case 30:
             // 0-values bridge for same-chain Orders
             bridge = DEFAULT_BRIDGE;
-          case 33:
+          case 31:
             input = {
               owner: options.owner,
               beneficiary: options.beneficiary,
               srcToken: options.srcToken,
-              // for some cases of WETH<->ETH crosschain swaps, the destToken is to WETH or ETH
-              destToken: (_partialChangedOrder$ = (_partialChangedOrder = partialChangedOrder) == null ? void 0 : _partialChangedOrder.destToken) != null ? _partialChangedOrder$ : options.destToken,
+              // for some cases of WETH->ETH crosschain swaps, the destToken is changed to WETH or ETH,
+              // this is already reflected in deltaPrice
+              destToken: options.deltaPrice.destToken,
               srcAmount: options.srcAmount,
               destAmount: options.destAmount,
               expectedDestAmount: options.deltaPrice.destAmount,
@@ -4196,7 +4120,7 @@ var constructBuildDeltaOrder = function constructBuildDeltaOrder(options) {
               bridge: bridge
             };
             return _context.abrupt("return", buildDeltaSignableOrderData(input));
-          case 35:
+          case 33:
           case "end":
             return _context.stop();
         }