@velora-dex/sdk 8.1.0 → 8.1.1-dev.1

package/dist/sdk.cjs.development.js

@@ -702,7 +702,7 @@ var constructApproveToken = function constructApproveToken(options) {
   };
 };
 
-var _excluded$9 = ["tokenType", "mainConnector", "connectors", "network"];
+var _excluded$a = ["tokenType", "mainConnector", "connectors", "network"];
 var constructToken = function constructToken(tokenProps) {
   var _tokenProps$tokenType = tokenProps.tokenType,
     tokenType = _tokenProps$tokenType === void 0 ? 'ERC20' : _tokenProps$tokenType,
@@ -712,7 +712,7 @@ var constructToken = function constructToken(tokenProps) {
     connectorsInput = _tokenProps$connector === void 0 ? [] : _tokenProps$connector,
     _tokenProps$network = tokenProps.network,
     network = _tokenProps$network === void 0 ? 1 : _tokenProps$network,
-    rest = _objectWithoutPropertiesLoose(tokenProps, _excluded$9);
+    rest = _objectWithoutPropertiesLoose(tokenProps, _excluded$a);
   var connectors = connectorsInput.length > 0 ? connectorsInput : [mainConnector];
   return _extends({
     tokenType: tokenType,
@@ -910,12 +910,12 @@ var constructGetAdapters = function constructGetAdapters(_ref) {
   };
 };
 
-var _excluded$8 = ["options"],
+var _excluded$9 = ["options"],
   _excluded2$4 = ["excludeContractMethods", "includeContractMethods", "partner", "includeDEXS", "excludeDEXS", "excludePools"];
 function normalizeRateOptions(_ref) {
   var _ref$options = _ref.options,
     options = _ref$options === void 0 ? {} : _ref$options,
-    restInput = _objectWithoutPropertiesLoose(_ref, _excluded$8);
+    restInput = _objectWithoutPropertiesLoose(_ref, _excluded$9);
   var excludeContractMethods = options.excludeContractMethods,
     includeContractMethods = options.includeContractMethods,
     partner = options.partner,
@@ -944,7 +944,7 @@ function normalizeRateOptions(_ref) {
   return _extends({}, transformed, restOptions, restInput);
 }
 
-var _excluded$7 = ["srcToken", "destToken"],
+var _excluded$8 = ["srcToken", "destToken"],
   _excluded2$3 = ["route"];
 var INVALID_ROUTE = 'Invalid Route';
 var constructGetRate = function constructGetRate(_ref) {
@@ -961,7 +961,7 @@ var constructGetRate = function constructGetRate(_ref) {
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            srcToken = _ref2.srcToken, destToken = _ref2.destToken, rest = _objectWithoutPropertiesLoose(_ref2, _excluded$7);
+            srcToken = _ref2.srcToken, destToken = _ref2.destToken, rest = _objectWithoutPropertiesLoose(_ref2, _excluded$8);
             parsedOptions = normalizeRateOptions(rest); // always pass explicit type to make sure UrlSearchParams are correct
             search = constructSearchString(_extends({
               srcToken: srcToken,
@@ -1036,7 +1036,7 @@ var constructGetRate = function constructGetRate(_ref) {
   };
 };
 
-var _excluded$6 = ["srcToken", "destToken", "amount", "route"];
+var _excluded$7 = ["srcToken", "destToken", "amount", "route"];
 var constructSwapTx = function constructSwapTx(_ref) {
   var _ref$apiURL = _ref.apiURL,
     apiURL = _ref$apiURL === void 0 ? API_URL : _ref$apiURL,
@@ -1051,7 +1051,7 @@ var constructSwapTx = function constructSwapTx(_ref) {
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            srcToken = _ref2.srcToken, destToken = _ref2.destToken, amount = _ref2.amount, route = _ref2.route, rest = _objectWithoutPropertiesLoose(_ref2, _excluded$6);
+            srcToken = _ref2.srcToken, destToken = _ref2.destToken, amount = _ref2.amount, route = _ref2.route, rest = _objectWithoutPropertiesLoose(_ref2, _excluded$7);
             parsedOptions = normalizeRateOptions(rest);
             _route = route == null ? void 0 : route.join('-'); // always pass explicit type to make sure UrlSearchParams are correct
             search = constructSearchString(_extends({
@@ -2263,7 +2263,7 @@ var constructGetLimitOrdersContract = function constructGetLimitOrdersContract(o
   };
 };
 
-var _excluded$5 = ["srcToken", "destToken", "amount", "options"];
+var _excluded$6 = ["srcToken", "destToken", "amount", "options"];
 var constructBuildLimitOrderTx = function constructBuildLimitOrderTx(_ref) {
   var _ref$apiURL = _ref.apiURL,
     apiURL = _ref$apiURL === void 0 ? API_URL : _ref$apiURL,
@@ -2292,7 +2292,7 @@ var constructBuildLimitOrderTx = function constructBuildLimitOrderTx(_ref) {
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            srcToken = _ref2.srcToken, destToken = _ref2.destToken, amount = _ref2.amount, _ref2$options = _ref2.options, _options = _ref2$options === void 0 ? {} : _ref2$options, rest = _objectWithoutPropertiesLoose(_ref2, _excluded$5);
+            srcToken = _ref2.srcToken, destToken = _ref2.destToken, amount = _ref2.amount, _ref2$options = _ref2.options, _options = _ref2$options === void 0 ? {} : _ref2$options, rest = _objectWithoutPropertiesLoose(_ref2, _excluded$6);
             tsEssentials.assert(orders.length > 0, 'must pass at least 1 order');
             _checkAndParseOrders = checkAndParseOrders$1(orders), totalTakerAmount = _checkAndParseOrders.totalTakerAmount, takerAsset = _checkAndParseOrders.takerAsset;
             tsEssentials.assert(takerAsset.toLowerCase() === destToken.toLowerCase(), 'All orders must have the same takerAsset as destToken');
@@ -2659,7 +2659,7 @@ var constructApproveTokenForNFTOrder = function constructApproveTokenForNFTOrder
   };
 };
 
-var _excluded$4 = ["srcToken", "destToken", "amount", "options"];
+var _excluded$5 = ["srcToken", "destToken", "amount", "options"];
 var constructBuildNFTOrderTx = function constructBuildNFTOrderTx(_ref) {
   var _ref$apiURL = _ref.apiURL,
     apiURL = _ref$apiURL === void 0 ? API_URL : _ref$apiURL,
@@ -2688,7 +2688,7 @@ var constructBuildNFTOrderTx = function constructBuildNFTOrderTx(_ref) {
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            srcToken = _ref2.srcToken, destToken = _ref2.destToken, amount = _ref2.amount, _ref2$options = _ref2.options, _options = _ref2$options === void 0 ? {} : _ref2$options, rest = _objectWithoutPropertiesLoose(_ref2, _excluded$4);
+            srcToken = _ref2.srcToken, destToken = _ref2.destToken, amount = _ref2.amount, _ref2$options = _ref2.options, _options = _ref2$options === void 0 ? {} : _ref2$options, rest = _objectWithoutPropertiesLoose(_ref2, _excluded$5);
             tsEssentials.assert(orders.length > 0, 'must pass at least 1 order');
             _checkAndParseOrders = checkAndParseOrders(orders), totalTakerAmount = _checkAndParseOrders.totalTakerAmount, takerAsset = _checkAndParseOrders.takerAsset;
             tsEssentials.assert(takerAsset.toLowerCase() === destToken.toLowerCase(), 'All orders must have the same takerAsset as destToken');
@@ -2797,7 +2797,7 @@ function uintToAssetAddress(assetUint) {
   return '0x' + (BigInt(assetUint) & (BigInt(1) << BigInt(160)) - BigInt(1)).toString(16);
 }
 
-var _excluded$3 = ["requestParams"];
+var _excluded$4 = ["requestParams"];
 var constructFetcher$2 = function constructFetcher(axios, extra) {
   return /*#__PURE__*/function () {
     var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(params) {
@@ -2806,7 +2806,7 @@ var constructFetcher$2 = function constructFetcher(axios, extra) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
             _context.prev = 0;
-            requestParams = params.requestParams, rest = _objectWithoutPropertiesLoose(params, _excluded$3); // adding apiKey to headers if it's provided
+            requestParams = params.requestParams, rest = _objectWithoutPropertiesLoose(params, _excluded$4); // adding apiKey to headers if it's provided
             headers = extra != null && extra.apiKey ? _extends({
               'X-API-KEY': extra.apiKey
             }, rest.headers, requestParams == null ? void 0 : requestParams.headers) : _extends({}, rest.headers, requestParams == null ? void 0 : requestParams.headers);
@@ -2914,7 +2914,7 @@ var constructFetcher$1 = function constructFetcher(fetch, extra) {
   }();
 };
 
-var _excluded$2 = ["block", "gas"],
+var _excluded$3 = ["block", "gas"],
   _excluded2$2 = ["gas", "from"];
 var constructEthersV5ContractCaller = function constructEthersV5ContractCaller(_ref, account) {
   var providerOrSigner = _ref.ethersProviderOrSigner,
@@ -2930,7 +2930,7 @@ var constructEthersV5ContractCaller = function constructEthersV5ContractCaller(_
             contract = new Contract(address, abi, providerOrSigner);
             assertEthersContractHasMethodsV5(contract, contractMethod);
             // drop keys not in CallOverrides
-            block = overrides.block, gas = overrides.gas, restOverrides = _objectWithoutPropertiesLoose(overrides, _excluded$2); // reassign values to keys in CallOverrides
+            block = overrides.block, gas = overrides.gas, restOverrides = _objectWithoutPropertiesLoose(overrides, _excluded$3); // reassign values to keys in CallOverrides
             normalizedOverrides = _extends({}, restOverrides, {
               blockTag: block,
               gasLimit: gas
@@ -3037,7 +3037,7 @@ function assertEthersContractHasMethodsV5(contract) {
   tsEssentials.assert(ethersContractHasMethodsV5.apply(void 0, [contract].concat(methods)), "Contract must have methods: " + methods.join(', '));
 }
 
-var _excluded$1 = ["block", "gas"],
+var _excluded$2 = ["block", "gas"],
   _excluded2$1 = ["gas", "from"];
 var constructContractCaller$2 = function constructContractCaller(_ref, account) {
   var providerOrSigner = _ref.ethersV6ProviderOrSigner,
@@ -3050,7 +3050,7 @@ var constructContractCaller$2 = function constructContractCaller(_ref, account)
           case 0:
             address = params.address, abi = params.abi, contractMethod = params.contractMethod, args = params.args, overrides = params.overrides;
             contract = new Contract(address, abi, providerOrSigner); // drop keys not in CallOverrides
-            block = overrides.block, gas = overrides.gas, restOverrides = _objectWithoutPropertiesLoose(overrides, _excluded$1); // reassign values to keys in CallOverrides
+            block = overrides.block, gas = overrides.gas, restOverrides = _objectWithoutPropertiesLoose(overrides, _excluded$2); // reassign values to keys in CallOverrides
             normalizedOverrides = _extends({}, restOverrides, {
               blockTag: block,
               gasLimit: gas
@@ -3183,7 +3183,7 @@ function findPrimaryType(types) {
   return primaryType;
 }
 
-var _excluded = ["block", "gas", "value"],
+var _excluded$1 = ["block", "gas", "value"],
   _excluded2 = ["gas", "from", "value", "nonce"];
 var constructContractCaller$1 = function constructContractCaller(web3, account) {
   var staticCall = /*#__PURE__*/function () {
@@ -3199,7 +3199,7 @@ var constructContractCaller$1 = function constructContractCaller(web3, account)
             // FIXME abi types ethers dependant
             address);
             assertWeb3ContractHasMethods(contract, contractMethod);
-            gas = overrides.gas, value = overrides.value, restOverrides = _objectWithoutPropertiesLoose(overrides, _excluded);
+            gas = overrides.gas, value = overrides.value, restOverrides = _objectWithoutPropertiesLoose(overrides, _excluded$1);
             normalizedOverrides = _extends({}, restOverrides, {
               gas: gas == null ? void 0 : gas.toString(10),
               value: value == null ? void 0 : value.toString(10)
@@ -3569,62 +3569,6 @@ var constructGetPartnerFee = function constructGetPartnerFee(_ref) {
   };
 };
 
-function composeDeltaOrderPermit(_ref) {
-  var permit = _ref.permit,
-    nonce = _ref.nonce;
-  // Can be empty Permit if allowance is available for srcToken
-  if (permit === '0x' || permit === '0x01') {
-    // 0x01 is a special permit value that signifies existing Permit2 allowance.
-    return permit;
-  }
-  // In the Contract, specifically for Permit2 transferFrom, we have signature consisting of
-  // bytes32(permit2nonce) + bytes64(compacted signature) = bytes96 Permit2 Transfer format
-  if (permit.length >= 194) {
-    // "0x".length + 96bytes*2 = 194, means permit already concatenated with nonce
-    // or it's a different type of Permit all together
-    return permit;
-  }
-  return encodePermit2Transfer(BigInt(nonce), permit);
-}
-function uintTo32ByteArrayBuffer(nonce) {
-  // Create a 32-byte ArrayBuffer
-  var buffer = new Uint8Array(32);
-  // Convert nonce to hex string and pad it to 64 hex characters (32 bytes)
-  var nonceHex = nonce.toString(16).padStart(64, '0');
-  // Convert the hex string to bytes and fill the ArrayBuffer
-  for (var i = 0; i < 32; i++) {
-    buffer[i] = parseInt(nonceHex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return buffer;
-}
-function hexToByteArray(hexString) {
-  // Remove "0x" prefix if present
-  hexString = hexString.replace(/^0x/, '');
-  // Convert hex string to Uint8Array
-  var byteArray = new Uint8Array(hexString.length / 2);
-  for (var i = 0; i < hexString.length; i += 2) {
-    byteArray[i / 2] = parseInt(hexString.slice(i, i + 2), 16);
-  }
-  return byteArray;
-}
-function encodePermit2Transfer(nonce, signature) {
-  // Get 32-byte ArrayBuffer for nonce
-  var nonceBuffer = uintTo32ByteArrayBuffer(nonce);
-  // Convert signature hex string to Uint8Array (64 bytes)
-  var signatureBuffer = hexToByteArray(signature);
-  if (signatureBuffer.length !== 64) {
-    throw new Error('Signature must be exactly 64 bytes');
-  }
-  // Concatenate nonceBuffer and signatureBuffer
-  var packedBuffer = new Uint8Array(32 + 64);
-  packedBuffer.set(nonceBuffer, 0); // Copy nonceBuffer at the start
-  packedBuffer.set(signatureBuffer, 32); // Copy signatureBuffer after nonce
-  // Convert to hex string for output
-  return '0x' + Array.from(packedBuffer).map(function (b) {
-    return b.toString(16).padStart(2, '0');
-  }).join('');
-}
-
 // Order(address owner,address beneficiary,address srcToken,address destToken,uint256 srcAmount,uint256 destAmount,uint256 deadline,uint256 nonce,bytes permit, bridge Bridge)";
 var SWAP_ORDER_EIP_712_TYPES = {
   Order: [{
@@ -3646,11 +3590,14 @@ var SWAP_ORDER_EIP_712_TYPES = {
     name: 'destAmount',
     type: 'uint256'
   }, {
-    name: 'expectedDestAmount',
+    name: 'expectedAmount',
     type: 'uint256'
   }, {
     name: 'deadline',
     type: 'uint256'
+  }, {
+    name: 'kind',
+    type: 'uint8'
   }, {
     name: 'nonce',
     type: 'uint256'
@@ -3660,13 +3607,16 @@ var SWAP_ORDER_EIP_712_TYPES = {
   }, {
     name: 'permit',
     type: 'bytes'
+  }, {
+    name: 'metadata',
+    type: 'bytes'
   }, {
     name: 'bridge',
     type: 'Bridge'
   }],
   Bridge: [{
-    name: 'maxRelayerFee',
-    type: 'uint256'
+    name: 'protocolSelector',
+    type: 'bytes4'
   }, {
     name: 'destinationChainId',
     type: 'uint256'
@@ -3674,8 +3624,11 @@ var SWAP_ORDER_EIP_712_TYPES = {
     name: 'outputToken',
     type: 'address'
   }, {
-    name: 'multiCallHandler',
-    type: 'address'
+    name: 'scalingFactor',
+    type: 'int8'
+  }, {
+    name: 'protocolData',
+    type: 'bytes'
   }]
 };
 function produceDeltaOrderTypedData(_ref) {
@@ -3697,7 +3650,7 @@ function produceDeltaOrderTypedData(_ref) {
   };
   return typedData;
 }
-// default deadline = 1 hour from now (may be changed later)
+// default deadline = 1 hour for now (may be changed later)
 var DELTA_DEFAULT_EXPIRY = 60 * 60; // seconds
 function buildDeltaSignableOrderData(_ref2) {
   var owner = _ref2.owner,
@@ -3707,13 +3660,16 @@ function buildDeltaSignableOrderData(_ref2) {
     destToken = _ref2.destToken,
     srcAmount = _ref2.srcAmount,
     destAmount = _ref2.destAmount,
-    expectedDestAmount = _ref2.expectedDestAmount,
+    expectedAmount = _ref2.expectedAmount,
     _ref2$deadline = _ref2.deadline,
     deadline = _ref2$deadline === void 0 ? Math.floor(Date.now() / 1000 + DELTA_DEFAULT_EXPIRY) : _ref2$deadline,
     _ref2$nonce = _ref2.nonce,
     nonce = _ref2$nonce === void 0 ? Date.now().toString(10) : _ref2$nonce,
     _ref2$permit = _ref2.permit,
     permit = _ref2$permit === void 0 ? '0x' : _ref2$permit,
+    kind = _ref2.kind,
+    _ref2$metadata = _ref2.metadata,
+    metadata = _ref2$metadata === void 0 ? '0x' : _ref2$metadata,
     partnerAddress = _ref2.partnerAddress,
     partnerFeeBps = _ref2.partnerFeeBps,
     _ref2$partnerTakesSur = _ref2.partnerTakesSurplus,
@@ -3728,19 +3684,18 @@ function buildDeltaSignableOrderData(_ref2) {
     destToken: destToken,
     srcAmount: srcAmount,
     destAmount: destAmount,
-    expectedDestAmount: expectedDestAmount,
+    expectedAmount: expectedAmount,
     deadline: deadline,
     nonce: nonce,
-    permit: composeDeltaOrderPermit({
-      permit: permit,
-      nonce: nonce
-    }),
+    permit: permit,
     partnerAndFee: producePartnerAndFee({
       partnerFeeBps: partnerFeeBps,
       partnerAddress: partnerAddress,
       partnerTakesSurplus: partnerTakesSurplus
     }),
-    bridge: bridge
+    bridge: bridge,
+    kind: kind,
+    metadata: metadata
   };
   return produceDeltaOrderTypedData({
     orderInput: orderInput,
@@ -3758,266 +3713,14 @@ function producePartnerAndFee(_ref3) {
   return partnerAndFee.toString(10);
 }
 
-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 _SwapSideToOrderKind;
+var OrderKind;
+(function (OrderKind) {
+  OrderKind[OrderKind["Sell"] = 0] = "Sell";
+  OrderKind[OrderKind["Buy"] = 1] = "Buy";
+})(OrderKind || (OrderKind = {}));
+var SwapSideToOrderKind = (_SwapSideToOrderKind = {}, _SwapSideToOrderKind[core.SwapSide.SELL] = OrderKind.Sell, _SwapSideToOrderKind[core.SwapSide.BUY] = OrderKind.Buy, _SwapSideToOrderKind);
 
-var ACROSS_WETH_ADDRESSES_MAP = {
-  // Mainnet
-  1: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
-  // Sepolia
-  11155111: '0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14',
-  // Base
-  8453: '0x4200000000000000000000000000000000000006',
-  // Base Sepolia
-  84532: '0x4200000000000000000000000000000000000006',
-  // Optimism
-  10: '0x4200000000000000000000000000000000000006',
-  // Optimism Sepolia
-  11155420: '0x4200000000000000000000000000000000000006',
-  // Polygon
-  137: '0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619',
-  // Polygon Amoy
-  80002: '0x52eF3d68BaB452a294342DC3e5f464d7f610f72E',
-  // Aleph Zero
-  41455: '0xB3f0eE446723f4258862D949B4c9688e7e7d35d3',
-  // Arbitrum
-  42161: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
-  // Arbitrum Sepolia
-  421614: '0x980B62Da83eFf3D4576C647993b0c1D7faf17c73',
-  // Boba
-  288: '0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000',
-  // Blast
-  81457: '0x4300000000000000000000000000000000000004',
-  // Blast Sepolia
-  168587773: '0x4200000000000000000000000000000000000023',
-  // BSC
-  56: '0x2170Ed0880ac9A755fd29B2688956BD959F933F8',
-  // Ink
-  57073: '0x4200000000000000000000000000000000000006',
-  // Ink Sepolia
-  763373: '0x4200000000000000000000000000000000000006',
-  // Lens
-  232: '0xE5ecd226b3032910CEaa43ba92EE8232f8237553',
-  // Lens Sepolia
-  37111: '0xaA91D645D7a6C1aeaa5988e0547267B77d33fe16',
-  // Linea
-  59144: '0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f',
-  // Lisk
-  1135: '0x4200000000000000000000000000000000000006',
-  // Lisk Sepolia
-  4202: '0x4200000000000000000000000000000000000006',
-  // Mode
-  34443: '0x4200000000000000000000000000000000000006',
-  // Mode Sepolia
-  919: '0x4200000000000000000000000000000000000006',
-  // Redstone
-  690: '0x4200000000000000000000000000000000000006',
-  // Scroll
-  534352: '0x5300000000000000000000000000000000000004',
-  // Scroll Sepolia
-  534351: '0x5300000000000000000000000000000000000004',
-  // Soneium
-  1868: '0x4200000000000000000000000000000000000006',
-  // Tatara
-  129399: '0x17B8Ee96E3bcB3b04b3e8334de4524520C51caB4',
-  // Unichain
-  130: '0x4200000000000000000000000000000000000006',
-  // Unichain Sepolia
-  1301: '0x4200000000000000000000000000000000000006',
-  // World Chain
-  480: '0x4200000000000000000000000000000000000006',
-  // ZK Sync
-  324: '0x5AEa5775959fBC2557Cc8789bC1bf90A239D9a91',
-  // ZK Sync Sepolia
-  300: '0x2D6Db36B3117802E996f13073A08A685D3FeF7eD',
-  // Zora
-  7777777: '0x4200000000000000000000000000000000000006'
-};
-function isAcrossWETH(tokenAddress, chainId) {
-  var _ACROSS_WETH_ADDRESSE;
-  return ((_ACROSS_WETH_ADDRESSE = ACROSS_WETH_ADDRESSES_MAP[chainId]) == null ? void 0 : _ACROSS_WETH_ADDRESSE.toLowerCase()) === tokenAddress.toLowerCase();
-}
-var ETH_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
-var ETH_ADDRESS_LOWERCASE = /*#__PURE__*/ETH_ADDRESS.toLowerCase();
-function isETHaddress(tokenAddress) {
-  return tokenAddress.toLowerCase() === ETH_ADDRESS_LOWERCASE;
-}
-function getDeltaBridge(_x) {
-  return _getDeltaBridge.apply(this, arguments);
-}
-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, bridgeFee = _ref.bridgeFee, bridgeOutputToken = _ref.bridgeOutputToken, beneficiaryType = _ref.beneficiaryType, getMulticallHandler = _ref.getMulticallHandler;
-          tsEssentials.assert(beneficiaryType === 'EOA' || beneficiaryType === 'SmartContract', 'beneficiaryType must be EOA or SmartContract');
-          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 (!(beneficiaryType === 'EOA' && isAcrossWETH(destTokenDestChain, destChainId))) {
-            _context.next = 9;
-            break;
-          }
-          _context.next = 8;
-          return getMulticallHandler(destChainId);
-        case 8:
-          multiCallHandler = _context.sent;
-        case 9:
-          if (!(beneficiaryType === 'SmartContract' && isETHaddress(destTokenDestChain))) {
-            _context.next = 13;
-            break;
-          }
-          _context.next = 12;
-          return getMulticallHandler(destChainId);
-        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;
-          }
-          bridge = {
-            maxRelayerFee: bridgeFee,
-            destinationChainId: destChainId,
-            outputToken: outputToken,
-            multiCallHandler: multiCallHandler
-          };
-          return _context.abrupt("return", {
-            bridge: bridge
-          });
-        case 16:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee);
-  }));
-  return _getDeltaBridge.apply(this, arguments);
-}
-
-var constructBuildCrosschainOrderBridge = function constructBuildCrosschainOrderBridge(options) {
-  var chainId = options.chainId;
-  // cached internally for `multicall` contracts
-  var _constructGetMultical = constructGetMulticallHandlers(options),
-    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;
-      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;
-            tsEssentials.assert(chainId !== deltaPrice.bridge.destinationChainId, '`deltaPrice.bridge.destinationChainId` must be different from `chainId` for crosschain Order.bridge');
-            tsEssentials.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;
-                return _regeneratorRuntime().wrap(function _callee$(_context) {
-                  while (1) switch (_context.prev = _context.next) {
-                    case 0:
-                      _context.next = 2;
-                      return getMulticallHandlers(requestParams);
-                    case 2:
-                      multicallHandlersMap = _context.sent;
-                      multicallHandler = multicallHandlersMap[chainId];
-                      tsEssentials.assert(multicallHandler, "Multicall handler not found for chain " + chainId);
-                      return _context.abrupt("return", multicallHandler);
-                    case 6:
-                    case "end":
-                      return _context.stop();
-                  }
-                }, _callee);
-              }));
-              return function getMulticallHandler(_x3) {
-                return _ref3.apply(this, arguments);
-              };
-            }();
-            _context2.next = 6;
-            return getDeltaBridge({
-              destTokenDestChain: destToken,
-              destChainId: destChainId,
-              bridgeFee: deltaPrice.bridgeFee,
-              bridgeOutputToken: deltaPrice.bridge.outputToken,
-              beneficiaryType: beneficiaryType,
-              getMulticallHandler: getMulticallHandler
-            });
-          case 6:
-            _yield$getDeltaBridge = _context2.sent;
-            bridge = _yield$getDeltaBridge.bridge;
-            return _context2.abrupt("return", {
-              bridge: bridge
-            });
-          case 9:
-          case "end":
-            return _context2.stop();
-        }
-      }, _callee2);
-    }));
-    return function buildCrosschainOrderBridge(_x, _x2) {
-      return _ref2.apply(this, arguments);
-    };
-  }();
-  return {
-    buildCrosschainOrderBridge: buildCrosschainOrderBridge
-  };
-};
-
-// for same-chain Orders, all 0 params
-var DEFAULT_BRIDGE = {
-  maxRelayerFee: '0',
-  destinationChainId: 0,
-  outputToken: ZERO_ADDRESS,
-  multiCallHandler: ZERO_ADDRESS
-};
 var constructBuildDeltaOrder = function constructBuildDeltaOrder(options) {
   var chainId = options.chainId;
   // cached internally
@@ -4026,12 +3729,10 @@ var constructBuildDeltaOrder = function constructBuildDeltaOrder(options) {
   // cached internally for `partner`
   var _constructGetPartnerF = constructGetPartnerFee(options),
     getPartnerFee = _constructGetPartnerF.getPartnerFee;
-  var _constructBuildCrossc = constructBuildCrosschainOrderBridge(options),
-    buildCrosschainOrderBridge = _constructBuildCrossc.buildCrosschainOrderBridge;
   var buildDeltaOrder = /*#__PURE__*/function () {
     var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(options, requestParams) {
-      var _options$partnerFeeBp, _options$nonce;
-      var ParaswapDelta, partnerAddress, partnerFeeBps, partnerTakesSurplus, feeOrTakeSurplusSupplied, _partnerAddress, _partnerFeeBps, _partnerTakesSurplus, partner, partnerFeeResponse, bridge, _options$beneficiaryT, deltaPrice, _yield$buildCrosschai, constructedBridge, input;
+      var _options$partnerFeeBp, _options$side, _options$nonce;
+      var ParaswapDelta, partnerAddress, partnerFeeBps, partnerTakesSurplus, feeOrTakeSurplusSupplied, _partnerAddress, _partnerFeeBps, _partnerTakesSurplus, partner, partnerFeeResponse, swapSide, expectedAmount, input;
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
@@ -4067,41 +3768,8 @@ var constructBuildDeltaOrder = function constructBuildDeltaOrder(options) {
             partnerFeeBps = (_partnerFeeBps = partnerFeeBps) != null ? _partnerFeeBps : partnerFeeResponse.partnerFee;
             partnerTakesSurplus = (_partnerTakesSurplus = partnerTakesSurplus) != null ? _partnerTakesSurplus : partnerFeeResponse.takeSurplus;
           case 17:
-            ////// Bridge logic //////
-            // Bridge is necessary for Crosschain Delta Orders
-            bridge = options.bridge; // give preference to user-provided bridge
-            if (bridge) {
-              _context.next = 31;
-              break;
-            }
-            if (!(options.destChainId && chainId !== options.destChainId)) {
-              _context.next = 30;
-              break;
-            }
-            // crosschain Delta Order
-            deltaPrice = options.deltaPrice;
-            tsEssentials.assert(deltaPrice.bridgeFee, '`bridgeFee` is required in `deltaPrice` for crosschain Delta Orders');
-            tsEssentials.assert(deltaPrice.bridge, '`bridge` is required in `deltaPrice` for crosschain Delta Orders');
-            _context.next = 25;
-            return buildCrosschainOrderBridge({
-              destToken: options.destToken,
-              destChainId: options.destChainId,
-              beneficiaryType: (_options$beneficiaryT = options.beneficiaryType) != null ? _options$beneficiaryT : 'EOA',
-              deltaPrice: {
-                bridgeFee: deltaPrice.bridgeFee,
-                bridge: deltaPrice.bridge // already contains destChainId and outputToken
-              }
-            }, requestParams);
-          case 25:
-            _yield$buildCrosschai = _context.sent;
-            constructedBridge = _yield$buildCrosschai.bridge;
-            bridge = constructedBridge;
-            _context.next = 31;
-            break;
-          case 30:
-            // 0-values bridge for same-chain Orders
-            bridge = DEFAULT_BRIDGE;
-          case 31:
+            swapSide = (_options$side = options.side) != null ? _options$side : core.SwapSide.SELL;
+            expectedAmount = swapSide === core.SwapSide.SELL ? options.deltaPrice.destAmount : options.deltaPrice.srcAmount;
             input = {
               owner: options.owner,
               beneficiary: options.beneficiary,
@@ -4111,19 +3779,21 @@ var constructBuildDeltaOrder = function constructBuildDeltaOrder(options) {
               destToken: options.deltaPrice.destToken,
               srcAmount: options.srcAmount,
               destAmount: options.destAmount,
-              expectedDestAmount: options.deltaPrice.destAmount,
+              expectedAmount: expectedAmount,
               deadline: options.deadline,
               nonce: (_options$nonce = options.nonce) == null ? void 0 : _options$nonce.toString(10),
               permit: options.permit,
+              kind: SwapSideToOrderKind[swapSide],
+              metadata: options.metadata,
               chainId: chainId,
               paraswapDeltaAddress: ParaswapDelta,
               partnerAddress: partnerAddress,
               partnerTakesSurplus: partnerTakesSurplus,
               partnerFeeBps: partnerFeeBps,
-              bridge: bridge
+              bridge: options.deltaPrice.bridge // ZERO_BRIDGE for same-chain Orders
             };
             return _context.abrupt("return", buildDeltaSignableOrderData(input));
-          case 33:
+          case 21:
           case "end":
             return _context.stop();
         }
@@ -4138,6 +3808,62 @@ 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;
+            tsEssentials.assert(chainId !== deltaPrice.bridge.destinationChainId, '`deltaPrice.bridge.destinationChainId` must be different from `chainId` for crosschain Order.bridge');
+            tsEssentials.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,
@@ -4167,12 +3893,14 @@ function sanitizeDeltaOrderData(_ref) {
     destToken = _ref.destToken,
     srcAmount = _ref.srcAmount,
     destAmount = _ref.destAmount,
-    expectedDestAmount = _ref.expectedDestAmount,
+    expectedAmount = _ref.expectedAmount,
     deadline = _ref.deadline,
     nonce = _ref.nonce,
     permit = _ref.permit,
     partnerAndFee = _ref.partnerAndFee,
-    bridge = _ref.bridge;
+    bridge = _ref.bridge,
+    kind = _ref.kind,
+    metadata = _ref.metadata;
   return {
     owner: owner,
     beneficiary: beneficiary,
@@ -4180,12 +3908,14 @@ function sanitizeDeltaOrderData(_ref) {
     destToken: destToken,
     srcAmount: srcAmount,
     destAmount: destAmount,
-    expectedDestAmount: expectedDestAmount,
+    expectedAmount: expectedAmount,
     deadline: deadline,
     nonce: nonce,
     permit: permit,
     partnerAndFee: partnerAndFee,
-    bridge: bridge
+    bridge: bridge,
+    kind: kind,
+    metadata: metadata
   };
 }
 
@@ -4222,6 +3952,7 @@ var constructSignDeltaOrder = function constructSignDeltaOrder(options) {
   };
 };
 
+var _excluded = ["includeAgents", "excludeAgents"];
 var constructGetDeltaPrice = function constructGetDeltaPrice(_ref) {
   var _ref$apiURL = _ref.apiURL,
     apiURL = _ref$apiURL === void 0 ? API_URL : _ref$apiURL,
@@ -4233,25 +3964,31 @@ var constructGetDeltaPrice = function constructGetDeltaPrice(_ref) {
   }
   function _getDeltaPrice() {
     _getDeltaPrice = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(options, requestParams) {
-      var search, fetchURL, data;
+      var _options$side;
+      var includeAgents, excludeAgents, rest, includeAgentsString, excludeAgentsString, search, fetchURL, data;
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            search = constructSearchString(_extends({}, options, {
+            includeAgents = options.includeAgents, excludeAgents = options.excludeAgents, rest = _objectWithoutPropertiesLoose(options, _excluded);
+            includeAgentsString = includeAgents ? includeAgents.join(',') : undefined;
+            excludeAgentsString = excludeAgents ? excludeAgents.join(',') : undefined;
+            search = constructSearchString(_extends({}, rest, {
               chainId: chainId,
-              side: core.SwapSide.SELL // so far SELL side only
+              side: (_options$side = options.side) != null ? _options$side : core.SwapSide.SELL,
+              includeAgents: includeAgentsString,
+              excludeAgents: excludeAgentsString
             }));
             fetchURL = pricesUrl + "/" + search;
-            _context.next = 4;
+            _context.next = 7;
             return fetcher({
               url: fetchURL,
               method: 'GET',
               requestParams: requestParams
             });
-          case 4:
+          case 7:
             data = _context.sent;
             return _context.abrupt("return", data.price);
-          case 6:
+          case 9:
           case "end":
             return _context.stop();
         }
@@ -4267,7 +4004,8 @@ var constructGetDeltaPrice = function constructGetDeltaPrice(_ref) {
 var constructGetDeltaOrders = function constructGetDeltaOrders(_ref) {
   var _ref$apiURL = _ref.apiURL,
     apiURL = _ref$apiURL === void 0 ? API_URL : _ref$apiURL,
-    fetcher = _ref.fetcher;
+    fetcher = _ref.fetcher,
+    chainId = _ref.chainId;
   var baseUrl = apiURL + "/delta/orders";
   var getDeltaOrderById = /*#__PURE__*/function () {
     var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(orderId, requestParams) {
@@ -4330,7 +4068,9 @@ var constructGetDeltaOrders = function constructGetDeltaOrders(_ref) {
             search = constructSearchString({
               userAddress: options.userAddress,
               page: options.page,
-              limit: options.limit
+              limit: options.limit,
+              chainId: options.chainId,
+              type: options.type
             });
             fetchURL = "" + baseUrl + search;
             _context3.next = 4;
@@ -4352,10 +4092,38 @@ var constructGetDeltaOrders = function constructGetDeltaOrders(_ref) {
       return _ref4.apply(this, arguments);
     };
   }();
+  var getRequiredBalanceForDeltaLimitOrders = /*#__PURE__*/function () {
+    var _ref5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(userParams, requestParams) {
+      var userURL, fetchURL, response;
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            userURL = baseUrl + "/fillablebalance/" + chainId + "/" + userParams.userAddress;
+            fetchURL = userParams.tokenAddress ? userURL + "/" + userParams.tokenAddress : userURL;
+            _context4.next = 4;
+            return fetcher({
+              url: fetchURL,
+              method: 'GET',
+              requestParams: requestParams
+            });
+          case 4:
+            response = _context4.sent;
+            return _context4.abrupt("return", response);
+          case 6:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    }));
+    return function getRequiredBalanceForDeltaLimitOrders(_x7, _x8) {
+      return _ref5.apply(this, arguments);
+    };
+  }();
   return {
     getDeltaOrderById: getDeltaOrderById,
     getDeltaOrderByHash: getDeltaOrderByHash,
-    getDeltaOrders: getDeltaOrders
+    getDeltaOrders: getDeltaOrders,
+    getRequiredBalanceForDeltaLimitOrders: getRequiredBalanceForDeltaLimitOrders
   };
 };
 
@@ -4434,6 +4202,44 @@ 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,
@@ -4486,13 +4292,14 @@ var constructGetQuote = function constructGetQuote(_ref) {
   }
   function _getQuote() {
     _getQuote = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(options, requestParams) {
+      var _options$side;
       var search, fetchURL, data;
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
             search = constructSearchString(_extends({}, options, {
-              chainId: chainId
-              // side: SwapSide.SELL, // so far SELL side only for Delta
+              chainId: chainId,
+              side: (_options$side = options.side) != null ? _options$side : core.SwapSide.SELL
             }));
             fetchURL = pricesUrl + "/" + search;
             _context.next = 4;
@@ -4517,6 +4324,140 @@ var constructGetQuote = function constructGetQuote(_ref) {
   };
 };
 
+var ORDER_CANCELLATIONS_EIP_712_TYPES = {
+  OrderCancellations: [{
+    name: 'orderIds',
+    type: 'string[]'
+  }]
+};
+function buildCancelDeltaOrderSignableData(_ref) {
+  var orderInput = _ref.orderInput,
+    chainId = _ref.chainId,
+    paraswapDeltaAddress = _ref.paraswapDeltaAddress;
+  var typedData = {
+    types: {
+      OrderCancellations: ORDER_CANCELLATIONS_EIP_712_TYPES.OrderCancellations
+    },
+    domain: {
+      name: 'Portikus',
+      version: '2.0.0',
+      chainId: chainId,
+      verifyingContract: paraswapDeltaAddress
+    },
+    data: {
+      // explicityly pick only the necessary fields,
+      // otherwise signing will break if more is present
+      orderIds: orderInput.orderIds
+    }
+  };
+  return typedData;
+}
+
+var constructCancelDeltaOrder = function constructCancelDeltaOrder(options) {
+  // cached internally
+  var _constructGetDeltaCon = constructGetDeltaContract(options),
+    getDeltaContract = _constructGetDeltaCon.getDeltaContract;
+  var signCancelLimitDeltaOrderRequest = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(params, requestParams) {
+      var ParaswapDelta, typedData, signature;
+      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 = buildCancelDeltaOrderSignableData({
+              orderInput: params,
+              paraswapDeltaAddress: ParaswapDelta,
+              chainId: options.chainId
+            });
+            _context.next = 8;
+            return options.contractCaller.signTypedDataCall(typedData);
+          case 8:
+            signature = _context.sent;
+            return _context.abrupt("return", signature);
+          case 10:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function signCancelLimitDeltaOrderRequest(_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  var postCancelLimitDeltaOrderRequest = /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(params, requestParams) {
+      var cancelUrl, res;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            cancelUrl = options.apiURL + "/delta/orders/cancel";
+            _context2.next = 3;
+            return options.fetcher({
+              url: cancelUrl,
+              method: 'POST',
+              data: params,
+              requestParams: requestParams
+            });
+          case 3:
+            res = _context2.sent;
+            return _context2.abrupt("return", res);
+          case 5:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+    return function postCancelLimitDeltaOrderRequest(_x3, _x4) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+  var cancelLimitDeltaOrders = /*#__PURE__*/function () {
+    var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref3, requestParams) {
+      var orderIds, signature, res;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            orderIds = _ref3.orderIds;
+            _context3.next = 3;
+            return signCancelLimitDeltaOrderRequest({
+              orderIds: orderIds
+            }, requestParams);
+          case 3:
+            signature = _context3.sent;
+            _context3.next = 6;
+            return postCancelLimitDeltaOrderRequest({
+              orderIds: orderIds,
+              signature: signature
+            }, requestParams);
+          case 6:
+            res = _context3.sent;
+            return _context3.abrupt("return", res);
+          case 8:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }));
+    return function cancelLimitDeltaOrders(_x5, _x6) {
+      return _ref4.apply(this, arguments);
+    };
+  }();
+  return {
+    signCancelLimitDeltaOrderRequest: signCancelLimitDeltaOrderRequest,
+    postCancelLimitDeltaOrderRequest: postCancelLimitDeltaOrderRequest,
+    cancelLimitDeltaOrders: cancelLimitDeltaOrders
+  };
+};
+
 /** @description construct composable SDK with methods you choose yourself */
 var constructPartialSDK = function constructPartialSDK(config) {
   var _config$apiURL, _config$version;
@@ -4680,7 +4621,11 @@ var constructSubmitDeltaOrder = function constructSubmitDeltaOrder(options) {
               signature: signature,
               partner: orderParams.partner,
               order: orderData.data,
-              partiallyFillable: orderParams.partiallyFillable
+              partiallyFillable: orderParams.partiallyFillable,
+              referrerAddress: orderParams.referrerAddress,
+              type: orderParams.type,
+              includeAgents: orderParams.includeAgents,
+              excludeAgents: orderParams.excludeAgents
             });
           case 8:
             response = _context.sent;
@@ -4714,7 +4659,8 @@ var constructAllDeltaOrdersHandlers = function constructAllDeltaOrdersHandlers(o
   var deltaOrdersBuild = constructBuildDeltaOrder(options);
   var deltaOrdersSign = constructSignDeltaOrder(options);
   var deltaOrdersPost = constructPostDeltaOrder(options);
-  return _extends({}, deltaOrdersGetters, deltaOrdersContractGetter, deltaPrice, partnerFee, bridgeInfo, isTokenSupportedInDelta, multicallHandlers, approveTokenForDelta, deltaOrdersSubmit, deltaOrdersBuild, deltaOrdersSign, deltaOrdersPost, buildCrosschainOrderBridge);
+  var deltaOrdersCancel = constructCancelDeltaOrder(options);
+  return _extends({}, deltaOrdersGetters, deltaOrdersContractGetter, deltaPrice, partnerFee, bridgeInfo, isTokenSupportedInDelta, multicallHandlers, approveTokenForDelta, deltaOrdersSubmit, deltaOrdersBuild, deltaOrdersSign, deltaOrdersPost, deltaOrdersCancel, buildCrosschainOrderBridge);
 };
 
 var constructSubmitNFTOrder = function constructSubmitNFTOrder(options) {
@@ -5059,6 +5005,7 @@ exports.constructBuildLimitOrderTx = constructBuildLimitOrderTx;
 exports.constructBuildNFTOrder = constructBuildNFTOrder;
 exports.constructBuildNFTOrderTx = constructBuildNFTOrderTx;
 exports.constructBuildTx = constructBuildTx;
+exports.constructCancelDeltaOrder = constructCancelDeltaOrder;
 exports.constructCancelLimitOrder = constructCancelLimitOrder;
 exports.constructCancelNFTOrder = constructCancelNFTOrder;
 exports.constructEthersContractCaller = constructEthersV5ContractCaller;