@paraspell/sdk-core 12.7.0 → 12.8.0

package/dist/index.d.ts

@@ -810,7 +810,10 @@ type TCreateBaseTransferXcmOptions<TRes> = {
     feeAssetInfo?: TAssetInfo;
     fees: TTransferFeeEstimates;
     recipientAddress: string;
+    senderAddress?: string;
     version: Version;
+    useJitWithdraw?: boolean;
+    useFeeAssetOnHops?: boolean;
     paraIdTo?: number;
     transactOptions?: TTransactOptions<TRes>;
 };
@@ -822,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;
@@ -837,6 +842,14 @@ type TCreateSwapXcmInternalOptions<TApi, TRes, TSigner> = WithApi<TCreateBaseSwa
     fees: TSwapFeeEstimates;
     paraIdTo?: number;
 };
+type TCreateEthBridgeInstructionsOptions<TApi, TRes, TSigner> = {
+    api: IPolkadotApi<TApi, TRes, TSigner>;
+    address: TAddress;
+    assetInfo: TAssetInfo;
+    senderAddress: string;
+    ahAddress?: string;
+    version: Version;
+};
 
 type TAssetClaimOptionsBase = {
     chain: TSubstrateChain;
@@ -2139,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}`>;
 
@@ -2363,4 +2376,4 @@ declare const pickCompatibleXcmVersion: (origin: TSubstrateChain, destination: T
 declare const pickRouterCompatibleXcmVersion: (origin: TSubstrateChain | undefined, exchangeChain: TSubstrateChain, destination: TChain | undefined) => Version;
 
 export { AmountTooLowError, AssetClaimBuilder, BaseAssetsPallet, BatchMode, BatchValidationError, BridgeHaltedError, Builder, DRY_RUN_CLIENT_TIMEOUT_MS, DryRunFailedError, ETH_MAINNET_CHAIN_ID, ETH_TESTNET_CHAIN_ID, FeatureTemporarilyDisabledError, GeneralBuilder, InvalidAddressError, MissingChainApiError, MissingParameterError, NoXCMSupportImplementedError, NumberFormatError, OverrideConflictError, PolkadotXcmError, PolkadotXcmExecutionError, ProviderUnavailableError, RELAY_LOCATION, RoutingResolutionError, RuntimeApiUnavailableError, ScenarioNotSupportedError, TRANSACT_ORIGINS, TX_CLIENT_TIMEOUT_MS, TransferToAhNotSupported, TypeAndThenUnavailableError, UnableToComputeError, UnsupportedOperationError, ValidationError, XTokensError, abstractDecimals, addEthereumBridgeFees, addXcmVersionHeader, applyDecimalAbstraction, assertAddressIsString, assertHasId, assertSender, assertSenderAddress, assertToIsString, blake2b256, blake2b512, calcPreviewMintAmount, claimAssets, compareAddresses, computeFeeFromDryRun, computeFeeFromDryRunPjs, computeOverridenAmount, constructTypeAndThenCall, convertSs58, createAsset, createAssetsFilter, createBaseExecuteXcm, createBeneficiaryLocXTokens, createBeneficiaryLocation, createChainClient, createClientCache, createClientPoolHelpers, createDestination, createDirectExecuteXcm, createExecuteCall, createExecuteExchangeXcm, createId, createTx, createTypeAndThenCall, createTypeThenAutoReserve, createVersionedAssets, createVersionedDestination, createX1Payload, deriveAccountId, dryRun, dryRunInternal, dryRunOrigin, encodeSs58, formatAssetIdToERC20, formatUnits, getAssetBalanceInternal, getAssetReserveChain, getBalance, getBalanceInternal, getBridgeStatus, getChain, getChainConfig, getChainLocation, getChainProviders, getChainVersion, getEthErc20Balance, getEvmPrivateKeyHex, getFailureInfo, getLocalTransferAmount, getMinTransferableAmount, getMinTransferableAmountInternal, getMoonbeamErc20Balance, getOriginXcmFee, getOriginXcmFeeEstimate, getOriginXcmFeeInternal, getParaEthTransferFees, getParaId, getRelayChainOf, getTChain, getTransferInfo, getTransferableAmount, getTransferableAmountInternal, getXcmFee, getXcmFeeEstimate, getXcmFeeInternal, getXcmFeeOnce, handleExecuteTransfer, handleSwapExecuteTransfer, handleToAhTeleport, isConfig, isSenderSigner, keyFromWs, localizeLocation, maybeOverrideAsset, maybeOverrideAssets, normalizeAmount, overrideTxAmount, padFee, padValueBy, parseUnits, pickCompatibleXcmVersion, pickRouterCompatibleXcmVersion, resolveDestChain, resolveModuleError, resolveParaId, resolveSendParams, reverseTransformLocation, selectXcmVersion, send, sortAssets, throwUnsupportedCurrency, transferMoonbeamEvm, transferMoonbeamToEth, traverseXcmHops, validateAddress, validateAssetSpecifiers, validateCurrency, validateDestination, validateDestinationAddress, validateTransact, verifyEdOnDestination, wrapTxBypass };
-export type { BuildHopInfoOptions, ClientCache, HopProcessParams, HopTraversalConfig, HopTraversalResult, IPolkadotApi, IPolkadotXCMTransfer, IXTokensTransfer, OneKey, TAddress, TApiOrUrl, TAssetClaimInternalOptions, TAssetClaimOptions, TAssetClaimOptionsBase, TBatchOptions, TBatchedSendOptions, TBifrostToken, TBridgeStatus, TBuildDestInfoOptions, TBuildInternalRes, TBuilderConfig, TBuilderInternalOptions, TBuilderOptions, TBypassOptions, TCacheItem, TChainConfig, TChainConfigMap, TChainEndpoint, TChainWithApi, TClientEntry, TClientKey, TConditionalXcmFeeDetail, TConditionalXcmFeeHopInfo, TCreateBaseSwapXcmOptions, TCreateBaseTransferXcmOptions, TCreateBeneficiaryOptions, TCreateBeneficiaryXTokensOptions, TCreateSwapXcmInternalOptions, TCreateSwapXcmOptions, TCreateTransferXcmOptions, TCreateTxsOptions, TDestWeight, TDestXcmFeeDetail, TDestination, TDryRunBaseOptions, TDryRunBypassOptions, TDryRunCallBaseOptions, TDryRunCallOptions, TDryRunChainFailure, TDryRunChainResult, TDryRunChainSuccess, TDryRunError, TDryRunOptions, TDryRunPreviewOptions, TDryRunResBase, TDryRunResult, TDryRunXcmBaseOptions, TDryRunXcmOptions, TEvmBuilderOptions, TEvmBuilderOptionsBase, TEvmChainFrom, TFeeType, TForeignAssetId, TForeignOrNativeAsset, TForeignOrTokenAsset, TGetAssetBalanceOptions, TGetAssetBalanceOptionsBase, TGetBalanceCommonOptions, TGetBalanceOptions, TGetBalanceOptionsBase, TGetFeeForDestChainBaseOptions, TGetFeeForDestChainOptions, TGetMinTransferableAmountOptions, TGetOriginXcmFeeBaseOptions, TGetOriginXcmFeeEstimateOptions, TGetOriginXcmFeeInternalOptions, TGetOriginXcmFeeOptions, TGetReverseTxFeeOptions, TGetTransferInfoOptions, TGetTransferInfoOptionsBase, TGetTransferableAmountOptions, TGetTransferableAmountOptionsBase, TGetXcmFeeBaseOptions, TGetXcmFeeBuilderOptions, TGetXcmFeeEstimateDetail, TGetXcmFeeEstimateOptions, TGetXcmFeeEstimateResult, TGetXcmFeeInternalOptions, TGetXcmFeeOptions, TGetXcmFeeResult, THopInfo, THopTransferInfo, TMantaAsset, TModuleError, TNativeTokenAsset, TNodleAsset, TOriginFeeDetails, TOtherReserveAsset, TPaymentInfo, TPolkadotXCMTransferOptions, TPolkadotXcmMethod, TProviderEntry, TReserveAsset, TResolveHopParams, TScenario, TSelfReserveAsset, TSendBaseOptions, TSendBaseOptionsWithSenderAddress, TSendInternalOptions, TSendOptions, TSender, TSerializeEthTransferOptions, TSerializedEthTransfer, TSerializedExtrinsics, TSerializedRuntimeApiQuery, TSerializedStateQuery, TSetBalanceRes, TSwapConfig, TSwapFeeEstimates, TTransactOptions, TTransactOrigin, TTransferFeeEstimates, TTransferInfo, TTransferLocalOptions, TTxFactory, TTypeAndThenCallContext, TTypeAndThenFees, TTypeAndThenOverrides, TUrl, TVerifyEdOnDestinationOptions, TVerifyEdOnDestinationOptionsBase, TWeight, TXTokensCurrencySelection, TXTokensMethod, TXTokensTransferOptions, TXcmAsset, TXcmFeeBase, TXcmFeeDetail, TXcmFeeDetailError, TXcmFeeDetailSuccess, TXcmFeeDetailWithFallback, TXcmFeeHopInfo, TXcmFeeHopResult, TXcmFeeSwapConfig, TXcmForeignAsset, TXcmPalletMethod, TXcmVersioned, TZeitgeistAsset, WithApi, WithRequiredSenderAddress };
+export type { BuildHopInfoOptions, ClientCache, HopProcessParams, HopTraversalConfig, HopTraversalResult, IPolkadotApi, IPolkadotXCMTransfer, IXTokensTransfer, OneKey, TAddress, TApiOrUrl, TAssetClaimInternalOptions, TAssetClaimOptions, TAssetClaimOptionsBase, TBatchOptions, TBatchedSendOptions, TBifrostToken, TBridgeStatus, TBuildDestInfoOptions, TBuildInternalRes, TBuilderConfig, TBuilderInternalOptions, TBuilderOptions, TBypassOptions, TCacheItem, TChainConfig, TChainConfigMap, TChainEndpoint, TChainWithApi, TClientEntry, TClientKey, TConditionalXcmFeeDetail, TConditionalXcmFeeHopInfo, TCreateBaseSwapXcmOptions, TCreateBaseTransferXcmOptions, TCreateBeneficiaryOptions, TCreateBeneficiaryXTokensOptions, TCreateEthBridgeInstructionsOptions, TCreateSwapXcmInternalOptions, TCreateSwapXcmOptions, TCreateTransferXcmOptions, TCreateTxsOptions, TDestWeight, TDestXcmFeeDetail, TDestination, TDryRunBaseOptions, TDryRunBypassOptions, TDryRunCallBaseOptions, TDryRunCallOptions, TDryRunChainFailure, TDryRunChainResult, TDryRunChainSuccess, TDryRunError, TDryRunOptions, TDryRunPreviewOptions, TDryRunResBase, TDryRunResult, TDryRunXcmBaseOptions, TDryRunXcmOptions, TEvmBuilderOptions, TEvmBuilderOptionsBase, TEvmChainFrom, TFeeType, TForeignAssetId, TForeignOrNativeAsset, TForeignOrTokenAsset, TGetAssetBalanceOptions, TGetAssetBalanceOptionsBase, TGetBalanceCommonOptions, TGetBalanceOptions, TGetBalanceOptionsBase, TGetFeeForDestChainBaseOptions, TGetFeeForDestChainOptions, TGetMinTransferableAmountOptions, TGetOriginXcmFeeBaseOptions, TGetOriginXcmFeeEstimateOptions, TGetOriginXcmFeeInternalOptions, TGetOriginXcmFeeOptions, TGetReverseTxFeeOptions, TGetTransferInfoOptions, TGetTransferInfoOptionsBase, TGetTransferableAmountOptions, TGetTransferableAmountOptionsBase, TGetXcmFeeBaseOptions, TGetXcmFeeBuilderOptions, TGetXcmFeeEstimateDetail, TGetXcmFeeEstimateOptions, TGetXcmFeeEstimateResult, TGetXcmFeeInternalOptions, TGetXcmFeeOptions, TGetXcmFeeResult, THopInfo, THopTransferInfo, TMantaAsset, TModuleError, TNativeTokenAsset, TNodleAsset, TOriginFeeDetails, TOtherReserveAsset, TPaymentInfo, TPolkadotXCMTransferOptions, TPolkadotXcmMethod, TProviderEntry, TReserveAsset, TResolveHopParams, TScenario, TSelfReserveAsset, TSendBaseOptions, TSendBaseOptionsWithSenderAddress, TSendInternalOptions, TSendOptions, TSender, TSerializeEthTransferOptions, TSerializedEthTransfer, TSerializedExtrinsics, TSerializedRuntimeApiQuery, TSerializedStateQuery, TSetBalanceRes, TSwapConfig, TSwapFeeEstimates, TTransactOptions, TTransactOrigin, TTransferFeeEstimates, TTransferInfo, TTransferLocalOptions, TTxFactory, TTypeAndThenCallContext, TTypeAndThenFees, TTypeAndThenOverrides, TUrl, TVerifyEdOnDestinationOptions, TVerifyEdOnDestinationOptionsBase, TWeight, TXTokensCurrencySelection, TXTokensMethod, TXTokensTransferOptions, TXcmAsset, TXcmFeeBase, TXcmFeeDetail, TXcmFeeDetailError, TXcmFeeDetailSuccess, TXcmFeeDetailWithFallback, TXcmFeeHopInfo, TXcmFeeHopResult, TXcmFeeSwapConfig, TXcmForeignAsset, TXcmPalletMethod, TXcmVersioned, TZeitgeistAsset, WithApi, WithRequiredSenderAddress };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { blake2b } from '@noble/hashes/blake2.js';
-import { isChainEvm, getAssetsObject, InvalidCurrencyError, isTAsset, findAssetInfoOrThrow, findNativeAssetInfoOrThrow, findAssetInfo, getExistentialDepositOrThrow, isSymbolMatch, getNativeAssetSymbol, getEdFromAssetOrThrow, hasDryRunSupport, findAssetOnDestOrThrow, findAssetInfoOnDest, isAssetEqual, isStableCoinAsset, isOverrideLocationSpecifier, extractAssetLocation, getRelayChainSymbol, isSymbolSpecifier, findNativeAssetInfo, isAssetXcEqual, normalizeLocation, normalizeSymbol, Native, hasXcmPaymentApiSupport, getOtherAssets } from '@paraspell/assets';
+import { isChainEvm, getAssetsObject, InvalidCurrencyError, isTAsset, findAssetInfoOrThrow, findNativeAssetInfoOrThrow, findAssetInfo, getExistentialDepositOrThrow, isSymbolMatch, getNativeAssetSymbol, getEdFromAssetOrThrow, hasDryRunSupport, findAssetOnDestOrThrow, findAssetInfoOnDest, isAssetEqual, isStableCoinAsset, isBridgedSystemAsset, isOverrideLocationSpecifier, extractAssetLocation, getRelayChainSymbol, isSymbolSpecifier, findNativeAssetInfo, isAssetXcEqual, normalizeLocation, normalizeSymbol, Native, hasXcmPaymentApiSupport, getOtherAssets } from '@paraspell/assets';
 export * from '@paraspell/assets';
 import { base58 } from '@scure/base';
 import { isAddress, isHex, getContract, createPublicClient, http, parseUnits as parseUnits$1, formatUnits as formatUnits$1, pad, toHex, getAddress, concat, keccak256 } from 'viem';
@@ -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
   }];
 };
 
@@ -4710,10 +4703,8 @@ var validateBridgeAsset = function validateBridgeAsset(origin, destination, asse
   }
   var nativeAsset = findNativeAssetInfoOrThrow(origin);
   var isNativeAsset = isAssetEqual(asset, nativeAsset);
-  var ecosystem = getRelayChainOf(destination).toLowerCase();
-  var isBridgedSystemAsset = asset.location.parents === Parents.TWO && deepEqual(getJunctionValue(asset.location, 'GlobalConsensus'), _defineProperty({}, ecosystem, null));
   var isBridgedStablecoin = isStableCoinAsset(asset);
-  if (!(isNativeAsset || isBridgedSystemAsset || isBridgedStablecoin)) {
+  if (!(isNativeAsset || isBridgedSystemAsset(asset, [getRelayChainOf(destination)]) || isBridgedStablecoin)) {
     throw new InvalidCurrencyError("Substrate bridge does not support currency ".concat(JSON.stringify(currency, replaceBigInt), "."));
   }
 };
@@ -5020,7 +5011,7 @@ var getParaEthTransferFees = /*#__PURE__*/function () {
   };
 }();
 
-var abi$1 = [
+var abi$2 = [
 	{
 		inputs: [
 			{
@@ -5130,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;
@@ -5154,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
@@ -5197,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);
   };
 }();
 
@@ -5573,7 +5617,7 @@ var createMainInstruction = function createMainInstruction(origin, asset, ethAss
     }
   };
 };
-var createCustomXcmOnDest = function createCustomXcmOnDest(_ref, origin, messageId, ethAsset) {
+var createEthereumBridgeInstructions = function createEthereumBridgeInstructions(_ref, origin, messageId, ethAsset) {
   var api = _ref.api,
     address = _ref.address,
     assetInfo = _ref.assetInfo,
@@ -5584,7 +5628,7 @@ var createCustomXcmOnDest = function createCustomXcmOnDest(_ref, origin, message
   if (isChainEvm(origin) && !ahAddress) {
     throw new MissingParameterError('ahAddress');
   }
-  return _defineProperty({}, version, [{
+  return [{
     SetAppendix: origin === 'Mythos' ? [] : [{
       DepositAsset: {
         assets: {
@@ -5599,7 +5643,24 @@ var createCustomXcmOnDest = function createCustomXcmOnDest(_ref, origin, message
     }]
   }, createMainInstruction(origin, assetInfo, ethAsset, address, messageId), {
     SetTopic: messageId
-  }]);
+  }];
+};
+var createCustomXcmOnDest = function createCustomXcmOnDest(options, origin, messageId, ethAsset) {
+  var api = options.api,
+    address = options.address,
+    assetInfo = options.assetInfo,
+    senderAddress = options.senderAddress,
+    ahAddress = options.ahAddress,
+    version = options.version;
+  var instructions = createEthereumBridgeInstructions({
+    api: api,
+    address: address,
+    assetInfo: assetInfo,
+    senderAddress: senderAddress,
+    ahAddress: ahAddress,
+    version: version
+  }, origin, messageId, ethAsset);
+  return _defineProperty({}, version, instructions);
 };
 
 var generateMessageId = /*#__PURE__*/function () {
@@ -8975,6 +9036,8 @@ var prepareExecuteContext = function prepareExecuteContext(_ref) {
   var assetLocalizedToReserve = createAsset(version, amount, localizeLocation(reserveChain !== null && reserveChain !== void 0 ? reserveChain : chain, assetInfo.location));
   var feeAsset = feeAssetInfo && !isAssetEqual(assetInfo, feeAssetInfo) ? createAsset(version, originFee, feeAssetInfo.location) : undefined;
   var feeAssetLocalized = feeAssetInfo && !isAssetEqual(assetInfo, feeAssetInfo) ? createAsset(version, originFee, localizeLocation(chain, feeAssetInfo.location)) : undefined;
+  var feeAssetLocalizedToDest = feeAssetInfo && !isAssetEqual(assetInfo, feeAssetInfo) ? createAsset(version, originFee, localizeLocation(destChain, feeAssetInfo.location)) : undefined;
+  var feeAssetLocalizedToReserve = feeAssetInfo && !isAssetEqual(assetInfo, feeAssetInfo) ? createAsset(version, originFee, localizeLocation(reserveChain !== null && reserveChain !== void 0 ? reserveChain : chain, feeAssetInfo.location)) : undefined;
   return {
     amount: amount,
     asset: asset,
@@ -8983,6 +9046,8 @@ var prepareExecuteContext = function prepareExecuteContext(_ref) {
     assetLocalizedToReserve: assetLocalizedToReserve,
     feeAsset: feeAsset,
     feeAssetLocalized: feeAssetLocalized,
+    feeAssetLocalizedToDest: feeAssetLocalizedToDest,
+    feeAssetLocalizedToReserve: feeAssetLocalizedToReserve,
     reserveChain: reserveChain
   };
 };
@@ -9028,6 +9093,7 @@ var createBaseExecuteXcm = function createBaseExecuteXcm(options) {
     version = options.version,
     paraIdTo = options.paraIdTo,
     transactOptions = options.transactOptions,
+    useFeeAssetOnHops = options.useFeeAssetOnHops,
     _options$suffixXcm = options.suffixXcm,
     suffixXcm = _options$suffixXcm === void 0 ? [] : _options$suffixXcm;
   var _prepareExecuteContex = prepareExecuteContext(options),
@@ -9036,18 +9102,30 @@ var createBaseExecuteXcm = function createBaseExecuteXcm(options) {
     assetLocalizedToReserve = _prepareExecuteContex.assetLocalizedToReserve,
     assetLocalizedToDest = _prepareExecuteContex.assetLocalizedToDest,
     feeAsset = _prepareExecuteContex.feeAsset,
+    feeAssetLocalizedToReserve = _prepareExecuteContex.feeAssetLocalizedToReserve,
+    feeAssetLocalizedToDest = _prepareExecuteContex.feeAssetLocalizedToDest,
     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.');
   }
   var transferType = getInstructionType(version, chain, destChain, reserveChain, transactOptions);
+  var routingAssetsFilter = feeAsset ? {
+    Wild: {
+      AllCounted: 2
+    }
+  } : createAssetsFilter(assetLocalized, version);
   var isReserveDest = reserveChain === destChain;
   var resolvedDepositInstruction = isReserveDest ? suffixXcm : [{
     DepositReserveAsset: {
       assets: createAssetsFilter(assetLocalizedToReserve, version),
       dest: createDestination(version, reserveChain !== null && reserveChain !== void 0 ? reserveChain : chain, destChain, paraIdTo),
-      xcm: [].concat(_toConsumableArray(createPayFees(version, updateAsset(assetLocalizedToDest, reserveFee === 1000n ? amount / 2n : amount - (feeAsset ? reserveFee : 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;
@@ -9058,9 +9136,9 @@ var createBaseExecuteXcm = function createBaseExecuteXcm(options) {
         mainInstructions = [{
           InitiateTransfer: {
             destination: destLocation,
-            remote_fees: _defineProperty({}, transferFilter, createAssetsFilter(assetLocalized, version)),
+            remote_fees: _defineProperty({}, transferFilter, routingAssetsFilter),
             preserve_origin: true,
-            assets: [_defineProperty({}, transferFilter, createAssetsFilter(assetLocalized, version))],
+            assets: [_defineProperty({}, transferFilter, routingAssetsFilter)],
             remote_xcm: [{
               RefundSurplus: undefined
             }].concat(_toConsumableArray(suffixXcm))
@@ -9072,9 +9150,9 @@ var createBaseExecuteXcm = function createBaseExecuteXcm(options) {
       // Use teleport for trusted chains
       mainInstructions = [{
         InitiateTeleport: {
-          assets: createAssetsFilter(assetLocalized, version),
+          assets: routingAssetsFilter,
           dest: destLocation,
-          xcm: [].concat(_toConsumableArray(createPayFees(version, updateAsset(assetLocalizedToDest, feeAsset ? amount : amount - originFee))), _toConsumableArray(suffixXcm))
+          xcm: [].concat(_toConsumableArray(createPayFees(version, hopFeeAssetToDest !== null && hopFeeAssetToDest !== void 0 ? hopFeeAssetToDest : updateAsset(assetLocalizedToDest, amount - originFeeDeduction))), _toConsumableArray(suffixXcm))
         }
       }];
       break;
@@ -9082,9 +9160,9 @@ var createBaseExecuteXcm = function createBaseExecuteXcm(options) {
       // Teleport to reserve chain first
       mainInstructions = [{
         InitiateTeleport: {
-          assets: createAssetsFilter(assetLocalized, version),
+          assets: routingAssetsFilter,
           dest: getChainLocation(chain, reserveChain),
-          xcm: [].concat(_toConsumableArray(createPayFees(version, updateAsset(assetLocalizedToReserve, feeAsset ? amount : amount - originFee))), _toConsumableArray(resolvedDepositInstruction))
+          xcm: [].concat(_toConsumableArray(createPayFees(version, hopFeeAssetToReserve !== null && hopFeeAssetToReserve !== void 0 ? hopFeeAssetToReserve : updateAsset(assetLocalizedToReserve, amount - originFeeDeduction))), _toConsumableArray(resolvedDepositInstruction))
         }
       }];
       break;
@@ -9092,12 +9170,11 @@ var createBaseExecuteXcm = function createBaseExecuteXcm(options) {
       // For non-trusted chains
       mainInstructions = [{
         InitiateReserveWithdraw: {
-          assets: createAssetsFilter(assetLocalized, version),
+          assets: routingAssetsFilter,
           reserve: getChainLocation(chain, reserveChain),
-          xcm: [].concat(_toConsumableArray(createPayFees(version,
-          // Decrease amount by 2 units becuase for some reason polkadot withdraws 2 units less
+          xcm: [].concat(_toConsumableArray(createPayFees(version, // Decrease amount by 2 units because for some reason polkadot withdraws 2 units less
           // than requested, so we need to account for that
-          updateAsset(assetLocalizedToReserve, amount - 2n))), _toConsumableArray(resolvedDepositInstruction))
+          hopFeeAssetToReserve !== null && hopFeeAssetToReserve !== void 0 ? hopFeeAssetToReserve : updateAsset(assetLocalizedToReserve, amount - 2n))), _toConsumableArray(resolvedDepositInstruction))
         }
       }];
       break;
@@ -9215,6 +9292,7 @@ var createExecuteExchangeXcm = function createExecuteExchangeXcm(input, origin,
 var prepareCommonExecuteXcm = function prepareCommonExecuteXcm(options, assetToDeposit) {
   var api = options.api,
     feeAsset = options.feeAssetInfo,
+    useJitWithdraw = options.useJitWithdraw,
     recipientAddress = options.recipientAddress,
     version = options.version;
   var context = prepareExecuteContext(options);
@@ -9226,7 +9304,7 @@ var prepareCommonExecuteXcm = function prepareCommonExecuteXcm(options, assetToD
   prefix.push({
     WithdrawAsset: withdrawAssets
   });
-  if (feeAsset) {
+  if (feeAsset && !useJitWithdraw) {
     prefix.push.apply(prefix, _toConsumableArray(createPayFees(version, feeAssetLocalized !== null && feeAssetLocalized !== void 0 ? feeAssetLocalized : assetLocalized, {
       refTime: 450n,
       proofSize: 0n
@@ -9399,7 +9477,7 @@ var isMultiHopSwap = function isMultiHopSwap(exchangeChain, assetFrom, assetTo)
 };
 
 var createExchangeInstructions = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(options, assetFrom, assetTo) {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(options, assetFrom, assetTo, hasSeparateFeeAsset) {
     var chain, exchangeChain, assetInfoFrom, assetInfoTo, version, calculateMinAmountOut, _options$fees, originReserveFee, exchangeFee, nativeSymbol, needsMultiHop, nativeAsset, nativeAmountOut, assetNative;
     return _regenerator().w(function (_context) {
       while (1) switch (_context.n) {
@@ -9418,7 +9496,7 @@ var createExchangeInstructions = /*#__PURE__*/function () {
             ExchangeAsset: {
               give: createAssetsFilter(assetFrom, version),
               want: [assetTo],
-              maximal: false
+              maximal: hasSeparateFeeAsset
             }
           }]);
         case 1:
@@ -9443,60 +9521,133 @@ var createExchangeInstructions = /*#__PURE__*/function () {
       }
     }, _callee);
   }));
-  return function createExchangeInstructions(_x, _x2, _x3) {
+  return function createExchangeInstructions(_x, _x2, _x3, _x4) {
     return _ref.apply(this, arguments);
   };
 }();
 var createSwapExecuteXcm = /*#__PURE__*/function () {
   var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(options) {
-    var api, chain, exchangeChain, destChain, assetInfoFrom, assetInfoTo, _options$fees2, originReserveFee, destReserveFee, recipientAddress, version, paraIdTo, assetFrom, amountOut, assetTo, assetToLocalizedToDest, _prepareCommonExecute, prefix, depositInstruction, exchangeInstructions, exchangeToDestXcm, finalXcm, fullXcm;
+    var _ref3, _ref4;
+    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, 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));
           amountOut = assetInfoTo.amount;
-          assetTo = createAsset(version, amountOut, localizeLocation(exchangeChain, assetInfoTo.location));
-          assetToLocalizedToDest = createAsset(version, amountOut, localizeLocation(destChain !== null && destChain !== void 0 ? destChain : exchangeChain, assetInfoTo.location));
+          assetTo = createAsset(version, amountOut, localizeLocation(exchangeChain, assetInfoTo.location)); // For Ethereum, localize to AssetHub since that's where instructions execute
+          assetToLocalizedToDest = createAsset(version, amountOut, localizeLocation((_ref3 = resolvedDestChain !== null && resolvedDestChain !== void 0 ? resolvedDestChain : destChain) !== null && _ref3 !== void 0 ? _ref3 : exchangeChain, assetInfoTo.location)); // For Ethereum destination, use DOT as feeAsset for bridge fees
+          ethBridgeFee = 0n; // Whether main asset IS DOT — no separate fee asset needed
+          isMainAssetDot = false;
+          if (!isEthereumDest) {
+            _context2.n = 3;
+            break;
+          }
+          nativeFeeAssetInfo = findNativeAssetInfoOrThrow(getRelayChainOf(chain !== null && chain !== void 0 ? chain : exchangeChain));
+          _context2.n = 1;
+          return api.createApiForChain('AssetHubPolkadot');
+        case 1:
+          ahApi = _context2.v;
+          _context2.n = 2;
+          return getParaEthTransferFees(ahApi);
+        case 2:
+          _yield$getParaEthTran = _context2.v;
+          _yield$getParaEthTran2 = _slicedToArray(_yield$getParaEthTran, 2);
+          bridgeFee = _yield$getParaEthTran2[0];
+          executionFee = _yield$getParaEthTran2[1];
+          ethBridgeFee = bridgeFee + executionFee;
+          isMainAssetDot = isAssetEqual(assetInfoFrom, nativeFeeAssetInfo);
+          if (!isMainAssetDot) {
+            ethFeeAssetInfo = nativeFeeAssetInfo;
+          }
+        case 3:
+          // 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: destChain !== null && destChain !== void 0 ? destChain : exchangeChain,
+            destChain: (_ref4 = resolvedDestChain !== null && resolvedDestChain !== void 0 ? resolvedDestChain : destChain) !== null && _ref4 !== void 0 ? _ref4 : exchangeChain,
             assetInfo: assetInfoFrom,
+            feeAssetInfo: resolvedFeeAssetInfo,
+            useJitWithdraw: isEthereumDest,
             recipientAddress: recipientAddress,
-            // Deal with this after feeAsset for swaps is supported
             fees: {
-              originFee: 0n,
+              originFee: hasSeparateFeeAsset ? ethBridgeFee || originFee : originFee,
               reserveFee: originReserveFee
             },
             version: version
           }, assetToLocalizedToDest), prefix = _prepareCommonExecute.prefix, depositInstruction = _prepareCommonExecute.depositInstruction;
-          _context2.n = 1;
-          return createExchangeInstructions(options, assetFrom, assetTo);
-        case 1:
+          _context2.n = 4;
+          return createExchangeInstructions(options, assetFrom, assetTo, isEthereumDest && hasSeparateFeeAsset);
+        case 4:
           exchangeInstructions = _context2.v;
-          exchangeToDestXcm = destChain ? createBaseExecuteXcm({
+          if (!isEthereumDest) {
+            _context2.n = 6;
+            break;
+          }
+          ethAsset = findAssetInfoOrThrow('Ethereum', {
+            symbol: assetInfoTo.symbol
+          }, null);
+          _context2.n = 5;
+          return generateMessageId(api, senderAddress, getParaId(chain !== null && chain !== void 0 ? chain : exchangeChain), ethAsset.assetId, recipientAddress, amountOut);
+        case 5:
+          messageId = _context2.v;
+          snowbridgeInstructions = createEthereumBridgeInstructions({
+            api: api,
+            address: recipientAddress,
+            assetInfo: assetInfoTo,
+            senderAddress: senderAddress,
+            version: version
+          }, chain !== null && chain !== void 0 ? chain : exchangeChain, messageId, ethAsset); // If exchange chain is already AssetHub, instructions run directly there
+          // Otherwise, route from exchange chain to AssetHub with bridge instructions as suffix
+          exchangeToDestXcm = exchangeChain === resolvedDestChain ? snowbridgeInstructions : createBaseExecuteXcm({
             chain: exchangeChain,
-            destChain: destChain,
+            destChain: resolvedDestChain,
             assetInfo: assetInfoTo,
-            paraIdTo: paraIdTo,
+            feeAssetInfo: ethFeeAssetInfo,
+            useFeeAssetOnHops: hasSeparateFeeAsset,
+            paraIdTo: getParaId(resolvedDestChain),
             version: version,
-            // Deal with this after feeAsset is supported
             fees: {
-              originFee: 0n,
+              originFee: hasSeparateFeeAsset ? ethBridgeFee : 0n,
               reserveFee: destReserveFee
             },
-            suffixXcm: [depositInstruction]
-          }) : [depositInstruction];
+            suffixXcm: snowbridgeInstructions
+          });
+          _context2.n = 7;
+          break;
+        case 6:
+          if (destChain) {
+            exchangeToDestXcm = createBaseExecuteXcm({
+              chain: exchangeChain,
+              destChain: destChain,
+              assetInfo: assetInfoTo,
+              paraIdTo: paraIdTo,
+              version: version,
+              // Deal with this after feeAsset is supported
+              fees: {
+                originFee: 0n,
+                reserveFee: destReserveFee
+              },
+              suffixXcm: [depositInstruction]
+            });
+          } else {
+            exchangeToDestXcm = [depositInstruction];
+          }
+        case 7:
           finalXcm = chain ? createBaseExecuteXcm({
             chain: chain,
             destChain: exchangeChain,
             assetInfo: assetInfoFrom,
+            feeAssetInfo: ethFeeAssetInfo,
+            useFeeAssetOnHops: hasSeparateFeeAsset,
             paraIdTo: getParaId(exchangeChain),
             version: version,
-            // Deal with this after feeAsset is supported
             fees: {
-              originFee: 0n,
+              originFee: hasSeparateFeeAsset ? ethBridgeFee : 0n,
               reserveFee: originReserveFee
             },
             suffixXcm: [].concat(_toConsumableArray(exchangeInstructions), _toConsumableArray(exchangeToDestXcm))
@@ -9506,7 +9657,7 @@ var createSwapExecuteXcm = /*#__PURE__*/function () {
       }
     }, _callee2);
   }));
-  return function createSwapExecuteXcm(_x4) {
+  return function createSwapExecuteXcm(_x5) {
     return _ref2.apply(this, arguments);
   };
 }();
@@ -9563,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
@@ -9670,16 +9822,19 @@ 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, 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:
           validateAmount(assetFrom.amount, MIN_FEE);
           version = pickRouterCompatibleXcmVersion(chain, exchangeChain, destChain);
+          isEthereumDest = destChain !== undefined && isExternalChain(destChain); // When main asset is DOT and dest is Ethereum, fees come from the same asset
+          // (no separate fee asset needed). Only skip fee validation when currencies differ.
+          hasSeparateFeeAsset = isEthereumDest && !isAssetEqual(assetFrom, findNativeAssetInfoOrThrow(getRelayChainOf(chain !== null && chain !== void 0 ? chain : exchangeChain)));
           internalOptions = _objectSpread2(_objectSpread2({}, options), {}, {
             version: version,
             paraIdTo: getParaId(destChain !== null && destChain !== void 0 ? destChain : exchangeChain)
@@ -9695,6 +9850,9 @@ var handleSwapExecuteTransfer = /*#__PURE__*/function () {
               location: assetFrom.location,
               amount: assetFrom.amount
             },
+            feeAsset: feeAssetInfo ? {
+              location: feeAssetInfo.location
+            } : undefined,
             swapConfig: {
               currencyTo: currencyTo,
               exchangeChain: exchangeChain,
@@ -9702,13 +9860,18 @@ 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
           };
           totalFeesPre = calculateTotalFees(chain, fees);
-          validateAmount(assetFrom.amount, totalFeesPre);
+          if (!hasSeparateFeeAsset) {
+            validateAmount(assetFrom.amount, totalFeesPre);
+          }
           // First dry run with dummy fees to extract actual fees
           _context3.n = 2;
           return createXcmAndCall(_objectSpread2(_objectSpread2({}, internalOptions), {}, {
@@ -9734,19 +9897,24 @@ 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;
           }
           totalFees = calculateTotalFees(chain, extractedFees);
-          validateAmount(assetFrom.amount, totalFees);
+          if (!hasSeparateFeeAsset) {
+            validateAmount(assetFrom.amount, totalFees);
+          }
           updatedAssetTo = assetTo;
           if (!chain) {
             _context3.n = 6;
             break;
           }
-          amountAvailableForSwap = assetFrom.amount - totalFees;
+          // When fees are paid from a separate asset (e.g. DOT for Ethereum),
+          // the full main asset amount is available for the swap
+          amountAvailableForSwap = hasSeparateFeeAsset ? assetFrom.amount : assetFrom.amount - totalFees;
           _context3.n = 5;
           return calculateMinAmountOut(amountAvailableForSwap);
         case 5:
@@ -11141,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;
@@ -11159,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);
@@ -12296,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",
@@ -13862,12 +14008,14 @@ var FungiblesPallet = /*#__PURE__*/function (_AssetsPallet) {
 
 var SIZE = 32;
 var BALANCE_SLOT = 0;
-var calculateMappingSlot = function calculateMappingSlot(key) {
+var BALANCE_SLOT_WORMHOLE = 5;
+var calculateMappingSlot = function calculateMappingSlot(key, assetId) {
   var normalizedKey = getAddress(key);
   var keyPadded = pad(normalizedKey, {
     size: SIZE
   });
-  var slotHex = pad(toHex(BALANCE_SLOT), {
+  var resolvedSlot = assetId !== null && assetId !== void 0 && assetId.startsWith('0x') ? BALANCE_SLOT_WORMHOLE : BALANCE_SLOT;
+  var slotHex = pad(toHex(resolvedSlot), {
     size: SIZE
   });
   var encoded = concat([keyPadded, slotHex]);
@@ -13889,7 +14037,7 @@ var SystemPallet = /*#__PURE__*/function (_BaseAssetsPallet) {
             case 0:
               assertHasId(assetInfo);
               contractAddr = formatAssetIdToERC20(assetInfo.assetId);
-              slot = calculateMappingSlot(address);
+              slot = calculateMappingSlot(address, assetInfo.assetId);
               amountEncoded = pad(toHex(assetInfo.amount + balance), {
                 size: SIZE
               });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paraspell/sdk-core",
-  "version": "12.7.0",
+  "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.0",
-    "@paraspell/sdk-common": "12.7.0",
-    "@paraspell/assets": "12.7.0"
+    "@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",