@paraspell/sdk-core 12.7.1 → 12.8.0

package/dist/index.d.ts

@@ -825,12 +825,14 @@ type TCreateBaseSwapXcmOptions = {
     assetInfoFrom: WithAmount<TAssetInfo>;
     assetInfoTo: WithAmount<TAssetInfo>;
     currencyTo: TCurrencyInput;
+    feeAssetInfo?: TAssetInfo;
     senderAddress: string;
     recipientAddress: string;
     calculateMinAmountOut: (amountIn: bigint, assetTo?: TAssetInfo) => Promise<bigint>;
 };
 type TCreateSwapXcmOptions<TApi, TRes, TSigner> = WithApi<TCreateBaseSwapXcmOptions, TApi, TRes, TSigner>;
 type TSwapFeeEstimates = {
+    originFee: bigint;
     originReserveFee: bigint;
     exchangeFee: bigint;
     destReserveFee: bigint;
@@ -2150,7 +2152,7 @@ declare const wrapTxBypass: <TApi, TRes, TSigner>(dryRunOptions: TDryRunBypassOp
 
 declare const getParaEthTransferFees: <TApi, TRes, TSigner>(ahApi: IPolkadotApi<TApi, TRes, TSigner>, shouldDisconnect?: boolean) => Promise<[bigint, bigint]>;
 
-declare const transferMoonbeamEvm: <TApi, TRes, TSigner>({ api, from, to, signer, address, currency }: TEvmBuilderOptions<TApi, TRes, TSigner>) => Promise<string>;
+declare const transferMoonbeamEvm: <TApi, TRes, TSigner>(options: TEvmBuilderOptions<TApi, TRes, TSigner>) => Promise<string>;
 
 declare const transferMoonbeamToEth: <TApi, TRes, TSigner>(from: TSubstrateChain, { api, to, signer, address, ahAddress, currency }: TEvmBuilderOptions<TApi, TRes, TSigner>) => Promise<`0x${string}`>;
 

package/dist/index.mjs

@@ -1138,26 +1138,19 @@ var getAssetReserveChain = function getAssetReserveChain(chain, assetLocation) {
   return chain;
 };
 
-var createPayFees = function createPayFees(version, asset, weight) {
-  if (version < Version.V5) {
-    return [{
-      BuyExecution: {
-        fees: asset,
-        weight_limit: weight ? {
-          Limited: {
-            ref_time: weight.refTime,
-            proof_size: weight.proofSize
-          }
-        } : 'Unlimited'
-      }
-    }];
-  }
+// PayFees instruction is removed temporarily in favor of BuyExecution everywhere,
+// but we keep this function for now in case we need to add it back in the future
+var createPayFees = function createPayFees(_version, asset, weight) {
   return [{
-    PayFees: {
-      asset: asset
+    BuyExecution: {
+      fees: asset,
+      weight_limit: weight ? {
+        Limited: {
+          ref_time: weight.refTime,
+          proof_size: weight.proofSize
+        }
+      } : 'Unlimited'
     }
-  }, {
-    RefundSurplus: undefined
   }];
 };
 
@@ -5018,7 +5011,7 @@ var getParaEthTransferFees = /*#__PURE__*/function () {
   };
 }();
 
-var abi$1 = [
+var abi$2 = [
 	{
 		inputs: [
 			{
@@ -5128,18 +5121,62 @@ var getDestinationLocation = function getDestinationLocation(api, address, desti
   return [1, paraId ? ["0x0000000".concat(paraId.toString(16)), acc] : [acc]];
 };
 
+var abi$1 = [{
+  inputs: [{
+    internalType: 'address',
+    name: 'recipient_',
+    type: 'address'
+  }, {
+    internalType: 'uint256',
+    name: 'amount_',
+    type: 'uint256'
+  }],
+  name: 'transfer',
+  outputs: [{
+    internalType: 'bool',
+    name: '',
+    type: 'bool'
+  }],
+  stateMutability: 'nonpayable',
+  type: 'function'
+}];
+var transferMoonbeamLocal = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(client, assetInfo, _ref) {
+    var signer, address, contract;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          signer = _ref.signer, address = _ref.address;
+          assertHasId(assetInfo);
+          contract = getContract({
+            abi: abi$1,
+            address: assetInfo.assetId,
+            client: {
+              "public": client,
+              wallet: signer
+            }
+          });
+          return _context.a(2, contract.write.transfer([address, assetInfo.amount]));
+      }
+    }, _callee);
+  }));
+  return function transferMoonbeamLocal(_x, _x2, _x3) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
 var U_64_MAX = 18446744073709551615n;
 var CONTRACT_ADDRESS = '0x0000000000000000000000000000000000000804';
 var NATIVE_ASSET_ID = '0x0000000000000000000000000000000000000802';
 // Partially inspired by Moonbeam XCM-SDK
 var transferMoonbeamEvm = /*#__PURE__*/function () {
-  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(options) {
     var _usdtAsset$assetId;
-    var api, from, to, signer, address, currency, contract, foundAsset, amount, asset, destLocation, weight, createTx, multiCurrencySymbols, useMultiAssets, usdtAsset, tx, _t;
+    var api, from, to, signer, address, currency, foundAsset, amount, client, contract, asset, destLocation, weight, createTx, multiCurrencySymbols, useMultiAssets, usdtAsset, tx, _t;
     return _regenerator().w(function (_context) {
       while (1) switch (_context.n) {
         case 0:
-          api = _ref.api, from = _ref.from, to = _ref.to, signer = _ref.signer, address = _ref.address, currency = _ref.currency;
+          api = options.api, from = options.from, to = options.to, signer = options.signer, address = options.address, currency = options.currency;
           if (!Array.isArray(currency)) {
             _context.n = 1;
             break;
@@ -5152,35 +5189,44 @@ var transferMoonbeamEvm = /*#__PURE__*/function () {
           }
           throw new UnsupportedOperationError('Override location is not supported for EVM transfers');
         case 2:
+          foundAsset = findAssetInfoOrThrow(from, currency, to);
+          amount = abstractDecimals(currency.amount, foundAsset.decimals, api);
+          client = createPublicClient({
+            chain: signer.chain,
+            transport: http()
+          });
+          if (!(from === to)) {
+            _context.n = 3;
+            break;
+          }
+          return _context.a(2, transferMoonbeamLocal(client, _objectSpread2(_objectSpread2({}, foundAsset), {}, {
+            amount: amount
+          }), options));
+        case 3:
           contract = getContract({
-            abi: abi$1,
+            abi: abi$2,
             address: CONTRACT_ADDRESS,
             client: {
-              "public": createPublicClient({
-                chain: signer.chain,
-                transport: http()
-              }),
+              "public": client,
               wallet: signer
             }
           });
-          foundAsset = findAssetInfoOrThrow(from, currency, to);
-          amount = abstractDecimals(currency.amount, foundAsset.decimals, api);
           if (!(foundAsset.symbol === getNativeAssetSymbol(from))) {
-            _context.n = 3;
+            _context.n = 4;
             break;
           }
           asset = NATIVE_ASSET_ID;
-          _context.n = 5;
+          _context.n = 6;
           break;
-        case 3:
+        case 4:
           if (!(foundAsset.assetId === undefined)) {
-            _context.n = 4;
+            _context.n = 5;
             break;
           }
           throw new InvalidCurrencyError('Currency must be a foreign asset with valid assetId');
-        case 4:
-          asset = formatAssetIdToERC20(foundAsset.assetId);
         case 5:
+          asset = formatAssetIdToERC20(foundAsset.assetId);
+        case 6:
           destLocation = getDestinationLocation(api, address, to);
           weight = U_64_MAX; // Partially inspired by Moonbeam XCM-SDK
           // https://github.com/moonbeam-foundation/xcm-sdk/blob/ab835c15bf41612604b1c858d956a9f07705ed65/packages/sdk/src/contract/contracts/Xtokens/Xtokens.ts#L53
@@ -5195,30 +5241,30 @@ var transferMoonbeamEvm = /*#__PURE__*/function () {
           }, to);
           assertHasId(usdtAsset);
           if (!useMultiAssets) {
-            _context.n = 7;
+            _context.n = 8;
             break;
           }
-          _context.n = 6;
+          _context.n = 7;
           return createTx('transferMultiCurrencies', [[[asset, amount.toString()], [formatAssetIdToERC20((_usdtAsset$assetId = usdtAsset.assetId) !== null && _usdtAsset$assetId !== void 0 ? _usdtAsset$assetId : ''), '200000']], 1,
           // index of the fee asset
           destLocation, weight]);
-        case 6:
+        case 7:
           _t = _context.v;
-          _context.n = 9;
+          _context.n = 10;
           break;
-        case 7:
-          _context.n = 8;
-          return createTx('transfer', [asset, amount.toString(), destLocation, weight]);
         case 8:
-          _t = _context.v;
+          _context.n = 9;
+          return createTx('transfer', [asset, amount.toString(), destLocation, weight]);
         case 9:
+          _t = _context.v;
+        case 10:
           tx = _t;
           return _context.a(2, tx);
       }
     }, _callee);
   }));
   return function transferMoonbeamEvm(_x) {
-    return _ref2.apply(this, arguments);
+    return _ref.apply(this, arguments);
   };
 }();
 
@@ -9061,6 +9107,9 @@ var createBaseExecuteXcm = function createBaseExecuteXcm(options) {
     reserveChain = _prepareExecuteContex.reserveChain;
   var hopFeeAssetToReserve = useFeeAssetOnHops ? feeAssetLocalizedToReserve : undefined;
   var hopFeeAssetToDest = useFeeAssetOnHops ? feeAssetLocalizedToDest : undefined;
+  // When fees are paid in a separate asset, originFee is denominated in that asset's
+  // currency and must not be subtracted from the transfer amount.
+  var originFeeDeduction = feeAsset ? 0n : originFee;
   var destLocation = createDestination(version, chain, destChain, paraIdTo);
   if (chain !== 'AssetHubPolkadot' && reserveChain === undefined) {
     throw new UnsupportedOperationError('Sending local reserve assets with custom fee asset is not yet supported for this chain.');
@@ -9076,7 +9125,7 @@ var createBaseExecuteXcm = function createBaseExecuteXcm(options) {
     DepositReserveAsset: {
       assets: createAssetsFilter(assetLocalizedToReserve, version),
       dest: createDestination(version, reserveChain !== null && reserveChain !== void 0 ? reserveChain : chain, destChain, paraIdTo),
-      xcm: [].concat(_toConsumableArray(createPayFees(version, hopFeeAssetToDest !== null && hopFeeAssetToDest !== void 0 ? hopFeeAssetToDest : updateAsset(assetLocalizedToDest, reserveFee === 1000n ? amount / 2n : amount - originFee - reserveFee))), _toConsumableArray(suffixXcm))
+      xcm: [].concat(_toConsumableArray(createPayFees(version, hopFeeAssetToDest !== null && hopFeeAssetToDest !== void 0 ? hopFeeAssetToDest : updateAsset(assetLocalizedToDest, reserveFee === 1000n ? amount / 2n : amount - originFeeDeduction - reserveFee))), _toConsumableArray(suffixXcm))
     }
   }];
   var mainInstructions;
@@ -9103,7 +9152,7 @@ var createBaseExecuteXcm = function createBaseExecuteXcm(options) {
         InitiateTeleport: {
           assets: routingAssetsFilter,
           dest: destLocation,
-          xcm: [].concat(_toConsumableArray(createPayFees(version, hopFeeAssetToDest !== null && hopFeeAssetToDest !== void 0 ? hopFeeAssetToDest : updateAsset(assetLocalizedToDest, amount - originFee))), _toConsumableArray(suffixXcm))
+          xcm: [].concat(_toConsumableArray(createPayFees(version, hopFeeAssetToDest !== null && hopFeeAssetToDest !== void 0 ? hopFeeAssetToDest : updateAsset(assetLocalizedToDest, amount - originFeeDeduction))), _toConsumableArray(suffixXcm))
         }
       }];
       break;
@@ -9113,7 +9162,7 @@ var createBaseExecuteXcm = function createBaseExecuteXcm(options) {
         InitiateTeleport: {
           assets: routingAssetsFilter,
           dest: getChainLocation(chain, reserveChain),
-          xcm: [].concat(_toConsumableArray(createPayFees(version, hopFeeAssetToReserve !== null && hopFeeAssetToReserve !== void 0 ? hopFeeAssetToReserve : updateAsset(assetLocalizedToReserve, amount - originFee))), _toConsumableArray(resolvedDepositInstruction))
+          xcm: [].concat(_toConsumableArray(createPayFees(version, hopFeeAssetToReserve !== null && hopFeeAssetToReserve !== void 0 ? hopFeeAssetToReserve : updateAsset(assetLocalizedToReserve, amount - originFeeDeduction))), _toConsumableArray(resolvedDepositInstruction))
         }
       }];
       break;
@@ -9479,11 +9528,11 @@ var createExchangeInstructions = /*#__PURE__*/function () {
 var createSwapExecuteXcm = /*#__PURE__*/function () {
   var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(options) {
     var _ref3, _ref4;
-    var api, chain, exchangeChain, destChain, assetInfoFrom, assetInfoTo, _options$fees2, originReserveFee, destReserveFee, senderAddress, recipientAddress, version, paraIdTo, isEthereumDest, resolvedDestChain, assetFrom, amountOut, assetTo, assetToLocalizedToDest, ethFeeAssetInfo, ethBridgeFee, isMainAssetDot, nativeFeeAssetInfo, ahApi, _yield$getParaEthTran, _yield$getParaEthTran2, bridgeFee, executionFee, hasSeparateFeeAsset, _prepareCommonExecute, prefix, depositInstruction, exchangeInstructions, exchangeToDestXcm, ethAsset, messageId, snowbridgeInstructions, finalXcm, fullXcm;
+    var api, chain, exchangeChain, destChain, assetInfoFrom, assetInfoTo, feeAssetInfo, _options$fees2, originFee, originReserveFee, destReserveFee, senderAddress, recipientAddress, version, paraIdTo, isEthereumDest, resolvedDestChain, assetFrom, amountOut, assetTo, assetToLocalizedToDest, ethFeeAssetInfo, ethBridgeFee, isMainAssetDot, nativeFeeAssetInfo, ahApi, _yield$getParaEthTran, _yield$getParaEthTran2, bridgeFee, executionFee, resolvedFeeAssetInfo, hasSeparateFeeAsset, _prepareCommonExecute, prefix, depositInstruction, exchangeInstructions, exchangeToDestXcm, ethAsset, messageId, snowbridgeInstructions, finalXcm, fullXcm;
     return _regenerator().w(function (_context2) {
       while (1) switch (_context2.n) {
         case 0:
-          api = options.api, chain = options.chain, exchangeChain = options.exchangeChain, destChain = options.destChain, assetInfoFrom = options.assetInfoFrom, assetInfoTo = options.assetInfoTo, _options$fees2 = options.fees, originReserveFee = _options$fees2.originReserveFee, destReserveFee = _options$fees2.destReserveFee, senderAddress = options.senderAddress, recipientAddress = options.recipientAddress, version = options.version, paraIdTo = options.paraIdTo;
+          api = options.api, chain = options.chain, exchangeChain = options.exchangeChain, destChain = options.destChain, assetInfoFrom = options.assetInfoFrom, assetInfoTo = options.assetInfoTo, feeAssetInfo = options.feeAssetInfo, _options$fees2 = options.fees, originFee = _options$fees2.originFee, originReserveFee = _options$fees2.originReserveFee, destReserveFee = _options$fees2.destReserveFee, senderAddress = options.senderAddress, recipientAddress = options.recipientAddress, version = options.version, paraIdTo = options.paraIdTo;
           isEthereumDest = destChain !== undefined && isExternalChain(destChain); // For Ethereum destination, the actual hop target is AssetHub (bridge hub)
           resolvedDestChain = isEthereumDest ? "AssetHub".concat(getRelayChainOf(chain !== null && chain !== void 0 ? chain : exchangeChain)) : undefined;
           assetFrom = createAsset(version, assetInfoFrom.amount, localizeLocation(exchangeChain, assetInfoFrom.location));
@@ -9514,23 +9563,25 @@ var createSwapExecuteXcm = /*#__PURE__*/function () {
             ethFeeAssetInfo = nativeFeeAssetInfo;
           }
         case 3:
-          hasSeparateFeeAsset = isEthereumDest && !isMainAssetDot;
+          // Ethereum fee asset takes precedence over user-provided feeAssetInfo
+          resolvedFeeAssetInfo = ethFeeAssetInfo !== null && ethFeeAssetInfo !== void 0 ? ethFeeAssetInfo : feeAssetInfo;
+          hasSeparateFeeAsset = isEthereumDest && !isMainAssetDot || !!feeAssetInfo;
           _prepareCommonExecute = prepareCommonExecuteXcm({
             api: api,
             chain: chain !== null && chain !== void 0 ? chain : exchangeChain,
             destChain: (_ref4 = resolvedDestChain !== null && resolvedDestChain !== void 0 ? resolvedDestChain : destChain) !== null && _ref4 !== void 0 ? _ref4 : exchangeChain,
             assetInfo: assetInfoFrom,
-            feeAssetInfo: ethFeeAssetInfo,
+            feeAssetInfo: resolvedFeeAssetInfo,
             useJitWithdraw: isEthereumDest,
             recipientAddress: recipientAddress,
             fees: {
-              originFee: hasSeparateFeeAsset ? ethBridgeFee : 0n,
+              originFee: hasSeparateFeeAsset ? ethBridgeFee || originFee : originFee,
               reserveFee: originReserveFee
             },
             version: version
           }, assetToLocalizedToDest), prefix = _prepareCommonExecute.prefix, depositInstruction = _prepareCommonExecute.depositInstruction;
           _context2.n = 4;
-          return createExchangeInstructions(options, assetFrom, assetTo, hasSeparateFeeAsset);
+          return createExchangeInstructions(options, assetFrom, assetTo, isEthereumDest && hasSeparateFeeAsset);
         case 4:
           exchangeInstructions = _context2.v;
           if (!isEthereumDest) {
@@ -9663,6 +9714,7 @@ var findExchangeHopIndex = function findExchangeHopIndex(chain, dryRunResult, ex
 var extractFeesFromDryRun = function extractFeesFromDryRun(chain, dryRunResult, exchangeHopIndex, destChain) {
   var requireHopsSuccess = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
   var fees = {
+    originFee: 0n,
     originReserveFee: 0n,
     exchangeFee: 0n,
     destReserveFee: 0n
@@ -9770,11 +9822,11 @@ var createXcmAndCall = /*#__PURE__*/function () {
 }();
 var handleSwapExecuteTransfer = /*#__PURE__*/function () {
   var _ref3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(options) {
-    var api, chain, exchangeChain, destChain, assetFrom, assetTo, currencyTo, senderAddress, recipientAddress, calculateMinAmountOut, version, isEthereumDest, hasSeparateFeeAsset, internalOptions, dryRunParams, fees, totalFeesPre, _yield$createXcmAndCa, initialCall, firstDryRunResult, exchangeHopIndex, extractedFees, totalFees, updatedAssetTo, amountAvailableForSwap, recalculatedMinAmountOut, _yield$createXcmAndCa2, finalCall;
+    var api, chain, exchangeChain, destChain, assetFrom, assetTo, currencyTo, feeAssetInfo, senderAddress, recipientAddress, calculateMinAmountOut, version, isEthereumDest, hasSeparateFeeAsset, internalOptions, dryRunParams, FEE_ASSET_AMOUNT, dummyOriginFee, fees, totalFeesPre, _yield$createXcmAndCa, initialCall, firstDryRunResult, exchangeHopIndex, extractedFees, totalFees, updatedAssetTo, amountAvailableForSwap, recalculatedMinAmountOut, _yield$createXcmAndCa2, finalCall;
     return _regenerator().w(function (_context3) {
       while (1) switch (_context3.n) {
         case 0:
-          api = options.api, chain = options.chain, exchangeChain = options.exchangeChain, destChain = options.destChain, assetFrom = options.assetInfoFrom, assetTo = options.assetInfoTo, currencyTo = options.currencyTo, senderAddress = options.senderAddress, recipientAddress = options.recipientAddress, calculateMinAmountOut = options.calculateMinAmountOut;
+          api = options.api, chain = options.chain, exchangeChain = options.exchangeChain, destChain = options.destChain, assetFrom = options.assetInfoFrom, assetTo = options.assetInfoTo, currencyTo = options.currencyTo, feeAssetInfo = options.feeAssetInfo, senderAddress = options.senderAddress, recipientAddress = options.recipientAddress, calculateMinAmountOut = options.calculateMinAmountOut;
           _context3.n = 1;
           return api.init(chain !== null && chain !== void 0 ? chain : exchangeChain);
         case 1:
@@ -9798,6 +9850,9 @@ var handleSwapExecuteTransfer = /*#__PURE__*/function () {
               location: assetFrom.location,
               amount: assetFrom.amount
             },
+            feeAsset: feeAssetInfo ? {
+              location: feeAssetInfo.location
+            } : undefined,
             swapConfig: {
               currencyTo: currencyTo,
               exchangeChain: exchangeChain,
@@ -9805,7 +9860,10 @@ var handleSwapExecuteTransfer = /*#__PURE__*/function () {
             },
             useRootOrigin: true
           };
+          FEE_ASSET_AMOUNT = 100;
+          dummyOriginFee = feeAssetInfo ? parseUnits(FEE_ASSET_AMOUNT.toString(), feeAssetInfo.decimals) : 0n;
           fees = {
+            originFee: dummyOriginFee,
             originReserveFee: MIN_FEE,
             exchangeFee: 0n,
             destReserveFee: MIN_FEE
@@ -9839,7 +9897,8 @@ var handleSwapExecuteTransfer = /*#__PURE__*/function () {
           throw new AmountTooLowError("Asset amount is too low to cover the fees, please increase the amount.");
         case 4:
           exchangeHopIndex = findExchangeHopIndex(chain, firstDryRunResult, exchangeChain, destChain);
-          extractedFees = extractFeesFromDryRun(chain, firstDryRunResult, exchangeHopIndex, destChain, false);
+          extractedFees = extractFeesFromDryRun(chain, firstDryRunResult, exchangeHopIndex, destChain, false); // Set originFee from dry run origin fee (padded), same as handleExecuteTransfer
+          extractedFees.originFee = feeAssetInfo && firstDryRunResult.origin.success ? padValueBy(firstDryRunResult.origin.fee, FEE_PADDING_PERCENTAGE) : 0n;
           if (extractedFees.exchangeFee === 0n) {
             // We set the exchange fee to non-zero value to prevent creating dummy tx
             extractedFees.exchangeFee = MIN_FEE;
@@ -11250,11 +11309,11 @@ var Hydration = /*#__PURE__*/function (_Chain) {
     key: "transferPolkadotXCM",
     value: function () {
       var _transferPolkadotXCM = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(input) {
-        var api, destination, feeAsset, asset, overriddenAsset, isMoonbeamWhAsset, isNativeAsset, isNativeFeeAsset, _t;
+        var destination, asset, isMoonbeamWhAsset;
         return _regenerator().w(function (_context) {
           while (1) switch (_context.n) {
             case 0:
-              api = input.api, destination = input.destination, feeAsset = input.feeAssetInfo, asset = input.assetInfo, overriddenAsset = input.overriddenAsset;
+              destination = input.destination, asset = input.assetInfo;
               if (!(destination === 'Ethereum')) {
                 _context.n = 1;
                 break;
@@ -11268,28 +11327,6 @@ var Hydration = /*#__PURE__*/function (_Chain) {
               }
               return _context.a(2, this.transferMoonbeamWhAsset(input));
             case 2:
-              if (!feeAsset) {
-                _context.n = 5;
-                break;
-              }
-              if (!overriddenAsset) {
-                _context.n = 3;
-                break;
-              }
-              throw new InvalidCurrencyError('Cannot use overridden assets with XCM execute');
-            case 3:
-              isNativeAsset = isSymbolMatch(asset.symbol, this.getNativeAssetSymbol());
-              isNativeFeeAsset = isSymbolMatch(feeAsset.symbol, this.getNativeAssetSymbol());
-              if (!(!isNativeAsset || !isNativeFeeAsset)) {
-                _context.n = 5;
-                break;
-              }
-              _t = api;
-              _context.n = 4;
-              return handleExecuteTransfer(input);
-            case 4:
-              return _context.a(2, _t.deserializeExtrinsics.call(_t, _context.v));
-            case 5:
               return _context.a(2, transferPolkadotXcm(input));
           }
         }, _callee, this);
@@ -12405,7 +12442,7 @@ var Moonbeam = /*#__PURE__*/function (_Chain) {
   }, {
     key: "transferLocalNonNativeAsset",
     value: function transferLocalNonNativeAsset(_options) {
-      throw new ScenarioNotSupportedError("".concat(this.chain, " local transfers are temporarily disabled"));
+      throw new ScenarioNotSupportedError("".concat(this.chain, " local transfers are supported only from EVM Builder"));
     }
   }, {
     key: "getBalanceForeign",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paraspell/sdk-core",
-  "version": "12.7.1",
+  "version": "12.8.0",
   "description": "SDK core for ParaSpell XCM/XCMP tool for developers",
   "repository": {
     "type": "git",
@@ -26,9 +26,9 @@
     "@noble/hashes": "^2.0.1",
     "@scure/base": "^2.0.0",
     "viem": "2.45.0",
-    "@paraspell/pallets": "12.7.1",
-    "@paraspell/sdk-common": "12.7.1",
-    "@paraspell/assets": "12.7.1"
+    "@paraspell/pallets": "12.8.0",
+    "@paraspell/sdk-common": "12.8.0",
+    "@paraspell/assets": "12.8.0"
   },
   "devDependencies": {
     "@babel/plugin-syntax-import-attributes": "^7.28.6",