@paraspell/sdk-core 8.9.10 → 8.11.0

package/dist/index.cjs

@@ -3,8 +3,8 @@
 var sdkCommon = require('@paraspell/sdk-common');
 var ethers = require('ethers');
 var assets = require('@paraspell/assets');
-var viem = require('viem');
 var pallets = require('@paraspell/pallets');
+var viem = require('viem');
 
 function _arrayLikeToArray(r, a) {
   (null == a || a > r.length) && (a = r.length);
@@ -824,156 +824,23 @@ var AssetClaimBuilder = /*#__PURE__*/function () {
   }]);
 }();
 
-var getParaEthTransferFees = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(ahApi) {
-    var DEFAULT_FEE, feeStorageItem, leFeeHex, bytes, reversedHex, validReversedHex, leFee, transferBridgeFee, transferAssethubExecutionFee, finalBridgeFee, finalAssethubExecutionFee;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          DEFAULT_FEE = 2750872500000n;
-          _context.next = 3;
-          return ahApi.getFromRpc('state', 'getStorage', '0x5fbc5c7ba58845ad1f1a9a7c5bc12fad');
-        case 3:
-          feeStorageItem = _context.sent;
-          leFeeHex = feeStorageItem.replace('0x', '');
-          _context.next = 7;
-          return ahApi.disconnect();
-        case 7:
-          bytes = leFeeHex.match(/.{1,2}/g) || [];
-          reversedHex = bytes.reverse().join('');
-          validReversedHex = reversedHex === '' ? '0' : reversedHex;
-          leFee = BigInt('0x' + validReversedHex);
-          transferBridgeFee = leFee === 0n ? DEFAULT_FEE : BigInt(leFee.toString());
-          transferAssethubExecutionFee = 2200000000n;
-          finalBridgeFee = transferBridgeFee * 110n / 100n;
-          finalAssethubExecutionFee = transferAssethubExecutionFee * 110n / 100n;
-          return _context.abrupt("return", [finalBridgeFee, finalAssethubExecutionFee]);
-        case 16:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee);
-  }));
-  return function getParaEthTransferFees(_x) {
-    return _ref.apply(this, arguments);
-  };
-}();
-
-var isEthersSigner = function isEthersSigner(signer) {
-  return _typeof(signer) === 'object' && signer !== null && 'provider' in signer;
-};
-var isEthersContract = function isEthersContract(contract) {
-  return !('abi' in contract);
-};
-
-var abi$1 = [
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "currencyAddress",
-				type: "address"
-			},
-			{
-				internalType: "uint256",
-				name: "amount",
-				type: "uint256"
-			},
-			{
-				components: [
-					{
-						internalType: "uint8",
-						name: "parents",
-						type: "uint8"
-					},
-					{
-						internalType: "bytes[]",
-						name: "interior",
-						type: "bytes[]"
-					}
-				],
-				internalType: "struct Xtokens.Multilocation",
-				name: "destination",
-				type: "tuple"
-			},
-			{
-				internalType: "uint64",
-				name: "weight",
-				type: "uint64"
-			}
-		],
-		name: "transfer",
-		outputs: [
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				components: [
-					{
-						internalType: "address",
-						name: "currencyAddress",
-						type: "address"
-					},
-					{
-						internalType: "uint256",
-						name: "amount",
-						type: "uint256"
-					}
-				],
-				internalType: "struct Xtokens.Currency[]",
-				name: "currencies",
-				type: "tuple[]"
-			},
-			{
-				internalType: "uint32",
-				name: "feeItem",
-				type: "uint32"
-			},
-			{
-				components: [
-					{
-						internalType: "uint8",
-						name: "parents",
-						type: "uint8"
-					},
-					{
-						internalType: "bytes[]",
-						name: "interior",
-						type: "bytes[]"
-					}
-				],
-				internalType: "struct Xtokens.Multilocation",
-				name: "destination",
-				type: "tuple"
-			},
-			{
-				internalType: "uint64",
-				name: "weight",
-				type: "uint64"
-			}
-		],
-		name: "transferMultiCurrencies",
-		outputs: [
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	}
-];
-
-// Inspired by Moonbeam XCM-SDK
-// https://github.com/moonbeam-foundation/xcm-sdk/blob/ab835c15bf41612604b1c858d956a9f07705ed65/packages/utils/src/format/asset.ts#L1
-var formatAssetIdToERC20 = function formatAssetIdToERC20(id) {
-  if (id.startsWith('0x')) {
-    return id;
-  }
-  if (!(/^\d{38,39}$/.test(id) || /^\d{4}$/.test(id))) {
-    throw new Error("Asset id: ".concat(id, " must be a string and have either 4 digits or 38-39 digits"));
+var DEFAULT_FEE_ASSET = 0;
+var ETH_PARA_ID = 1;
+var ETH_CHAIN_ID = BigInt(ETH_PARA_ID);
+var ETHEREUM_JUNCTION = {
+  GlobalConsensus: {
+    Ethereum: {
+      chainId: ETH_CHAIN_ID
+    }
   }
-  return "0xffffffff".concat(BigInt(id).toString(16).padStart(32, '0'));
 };
+var DOT_MULTILOCATION = {
+  parents: sdkCommon.Parents.ONE,
+  interior: 'Here'
+};
+var SYSTEM_NODES_POLKADOT = ['PeoplePolkadot', 'CoretimePolkadot', 'Collectives'];
+var SYSTEM_NODES_KUSAMA = ['PeopleKusama', 'CoretimeKusama'];
+var ASSET_HUB_EXECUTION_FEE = 2200000000n; // 0.22 DOT
 
 var AssetHubPolkadot$1 = {
 	name: "AssetHub",
@@ -2322,22 +2189,18 @@ var getNodeProviders = function getNodeProviders(node) {
   });
 };
 
-var DEFAULT_FEE_ASSET = 0;
-var ETH_PARA_ID = 1;
-var ETH_CHAIN_ID = BigInt(ETH_PARA_ID);
-var ETHEREUM_JUNCTION = {
-  GlobalConsensus: {
-    Ethereum: {
-      chainId: ETH_CHAIN_ID
-    }
+/**
+ * Retrieves the parachain ID for a specified node.
+ *
+ * @param node - The node for which to get the paraId.
+ * @returns The parachain ID of the node.
+ */
+var getParaId = function getParaId(node) {
+  if (node === 'Ethereum') {
+    return ETH_PARA_ID;
   }
+  return getNodeConfig(node).paraId;
 };
-var DOT_MULTILOCATION = {
-  parents: sdkCommon.Parents.ONE,
-  interior: 'Here'
-};
-var SYSTEM_NODES_POLKADOT = ['PeoplePolkadot', 'CoretimePolkadot', 'Collectives'];
-var SYSTEM_NODES_KUSAMA = ['PeopleKusama', 'CoretimeKusama'];
 
 var shuffleArray = function shuffleArray(array) {
   var copy = _toConsumableArray(array);
@@ -2858,6 +2721,26 @@ var BridgeHaltedError = /*#__PURE__*/function (_Error) {
   return _createClass(BridgeHaltedError);
 }(/*#__PURE__*/_wrapNativeSuper(Error));
 
+/**
+ * Error thrown when the Dry Run fails.
+ */
+var DryRunFailedError = /*#__PURE__*/function (_Error) {
+  /**
+   * Constructs a new DryRunFailedError.
+   *
+   * @param message - Optional custom error message.
+   */
+  function DryRunFailedError(reason) {
+    var _this;
+    _classCallCheck(this, DryRunFailedError);
+    _this = _callSuper(this, DryRunFailedError, ["Dry run failed: ".concat(reason)]);
+    _this.name = 'DryRunFailedError';
+    return _this;
+  }
+  _inherits(DryRunFailedError, _Error);
+  return _createClass(DryRunFailedError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+
 /**
  * Error thrown when nodes from different relay chains are incompatible.
  */
@@ -3168,7 +3051,7 @@ var createCustomXcmOnDest = function createCustomXcmOnDest(_ref, version, messag
   if (!ethAsset) {
     throw new assets.InvalidCurrencyError("Could not obtain Ethereum asset address for ".concat(JSON.stringify(asset)));
   }
-  var interior_sb = ethAsset.symbol === 'ETH' ? {
+  var interiorSb = ethAsset.symbol === 'ETH' ? {
     Here: null
   } : {
     X1: [{
@@ -3214,7 +3097,7 @@ var createCustomXcmOnDest = function createCustomXcmOnDest(_ref, version, messag
           fees: {
             id: {
               parents: sdkCommon.Parents.ZERO,
-              interior: interior_sb
+              interior: interiorSb
             },
             fun: {
               Fungible: 1n
@@ -3319,14 +3202,16 @@ var ParachainNode = /*#__PURE__*/function () {
     }
   }, {
     key: "canUseXTokens",
-    value: function canUseXTokens(_) {
-      return true;
+    value: function canUseXTokens(_ref) {
+      var asset = _ref.asset;
+      var isEthAsset = asset.multiLocation && assets.findAssetByMultiLocation(assets.getOtherAssets('Ethereum'), asset.multiLocation);
+      return !isEthAsset;
     }
   }, {
     key: "transfer",
     value: function () {
       var _transfer = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(options) {
-        var api, asset, feeAsset, address, destination, paraIdTo, overriddenAsset, version, senderAddress, pallet, method, isRelayDestination, scenario, paraId, versionOrDefault, isBifrostOrigin, isAssetHubDest, shouldUseMultiasset, input;
+        var api, asset, feeAsset, address, destination, paraIdTo, overriddenAsset, version, senderAddress, pallet, method, isRelayDestination, scenario, paraId, versionOrDefault, isLocalTransfer, isBifrostOrigin, isAssetHubDest, shouldUseMultiasset, input, _options, isEthAsset, isAHPOrigin, isAHPDest, isEthDest;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
@@ -3334,15 +3219,22 @@ var ParachainNode = /*#__PURE__*/function () {
               isRelayDestination = !sdkCommon.isTMultiLocation(destination) && sdkCommon.isRelayChain(destination);
               scenario = isRelayDestination ? 'ParaToRelay' : 'ParaToPara';
               paraId = resolveParaId(paraIdTo, destination);
-              if (!(destination === 'Polimec' && this.node !== 'AssetHubPolkadot' && this.node !== 'Hydration')) {
+              if (!(destination === 'Polimec' && this.node !== 'AssetHubPolkadot' && this.node !== 'Hydration' && this.node !== destination)) {
                 _context.next = 6;
                 break;
               }
               throw new Error('Sending assets to Polimec is supported only from AssetHubPolkadot and Hydration');
             case 6:
               versionOrDefault = version !== null && version !== void 0 ? version : this.version;
+              isLocalTransfer = this.node === destination;
+              if (!isLocalTransfer) {
+                _context.next = 10;
+                break;
+              }
+              return _context.abrupt("return", this.transferLocal(options));
+            case 10:
               if (!(supportsXTokens(this) && this.canUseXTokens(options))) {
-                _context.next = 17;
+                _context.next = 20;
                 break;
               }
               isBifrostOrigin = this.node === 'BifrostPolkadot' || this.node === 'BifrostKusama';
@@ -3369,15 +3261,15 @@ var ParachainNode = /*#__PURE__*/function () {
                 method: method
               };
               if (!shouldUseMultiasset) {
-                _context.next = 14;
+                _context.next = 17;
                 break;
               }
               return _context.abrupt("return", XTokensTransferImpl.transferXTokens(input, undefined));
-            case 14:
-              return _context.abrupt("return", this.transferXTokens(input));
             case 17:
+              return _context.abrupt("return", this.transferXTokens(input));
+            case 20:
               if (!supportsXTransfer(this)) {
-                _context.next = 21;
+                _context.next = 24;
                 break;
               }
               return _context.abrupt("return", this.transferXTransfer({
@@ -3391,12 +3283,12 @@ var ParachainNode = /*#__PURE__*/function () {
                 pallet: pallet,
                 method: method
               }));
-            case 21:
+            case 24:
               if (!supportsPolkadotXCM(this)) {
-                _context.next = 25;
+                _context.next = 37;
                 break;
               }
-              return _context.abrupt("return", this.transferPolkadotXCM({
+              _options = {
                 api: api,
                 header: this.createPolkadotXcmHeader(scenario, versionOrDefault, destination, paraId),
                 addressSelection: createVersionedBeneficiary({
@@ -3419,10 +3311,27 @@ var ParachainNode = /*#__PURE__*/function () {
                 senderAddress: senderAddress,
                 pallet: pallet,
                 method: method
-              }));
-            case 25:
+              }; // Handle common cases
+              isEthAsset = asset.multiLocation && assets.findAssetByMultiLocation(assets.getOtherAssets('Ethereum'), asset.multiLocation);
+              isAHPOrigin = this.node === 'AssetHubPolkadot' || this.node === 'AssetHubKusama';
+              isAHPDest = destination === 'AssetHubPolkadot' || destination === 'AssetHubKusama';
+              isEthDest = destination === 'Ethereum'; // Any origin to any dest via AH - DestinationReserve - multiple instructions
+              if (!(isEthAsset && !isAHPOrigin && !isAHPDest && !isEthDest)) {
+                _context.next = 32;
+                break;
+              }
+              return _context.abrupt("return", this.transferEthAssetViaAH(_options));
+            case 32:
+              if (!(isEthAsset && isAHPDest && !isAHPOrigin && !isEthDest)) {
+                _context.next = 34;
+                break;
+              }
+              return _context.abrupt("return", this.transferToEthereum(_options, true));
+            case 34:
+              return _context.abrupt("return", this.transferPolkadotXCM(_options));
+            case 37:
               throw new NoXCMSupportImplementedError(this._node);
-            case 26:
+            case 38:
             case "end":
               return _context.stop();
           }
@@ -3478,91 +3387,306 @@ var ParachainNode = /*#__PURE__*/function () {
       return assets.getNativeAssetSymbol(this.node);
     }
   }, {
-    key: "transferToEthereum",
+    key: "transferLocal",
+    value: function transferLocal(options) {
+      var asset = options.asset,
+        address = options.address;
+      if (sdkCommon.isTMultiLocation(address)) {
+        throw new InvalidAddressError('Multi-Location address is not supported for local transfers');
+      }
+      var validatedOptions = _objectSpread2(_objectSpread2({}, options), {}, {
+        address: address
+      });
+      var isNativeAsset = asset.symbol === this.getNativeAssetSymbol() && !assets.isForeignAsset(asset);
+      if (isNativeAsset) {
+        return this.transferLocalNativeAsset(validatedOptions);
+      } else {
+        return this.transferLocalNonNativeAsset(validatedOptions);
+      }
+    }
+  }, {
+    key: "transferLocalNativeAsset",
+    value: function transferLocalNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      return api.callTxMethod({
+        module: 'Balances',
+        section: 'transfer_keep_alive',
+        parameters: {
+          dest: assets.isNodeEvm(this.node) ? address : {
+            Id: address
+          },
+          value: BigInt(asset.amount)
+        }
+      });
+    }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no assetId"));
+      }
+      return api.callTxMethod({
+        module: 'Tokens',
+        section: 'transfer',
+        parameters: {
+          dest: {
+            Id: address
+          },
+          currency_id: BigInt(asset.assetId),
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
+  }, {
+    key: "transferEthAssetViaAH",
     value: function () {
-      var _transferToEthereum = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(input) {
-        var api, asset, scenario, version, destination, address, senderAddress, bridgeStatus, versionOrDefault, ethMultiAsset, ahApi, _yield$getParaEthTran, _yield$getParaEthTran2, bridgeFee, executionFee, fee, ethAsset, messageId, call;
+      var _transferEthAssetViaAH = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(input) {
+        var _feeAsset$multiLocati;
+        var api, asset, scenario, _input$version, version, destination, address, senderAddress, feeAsset, paraIdTo, ethMultiAsset, PARA_TO_PARA_FEE_DOT, AH_EXECUTION_FEE_PADDED, dryRunResult, dryRunFeePadded, destWithHeader, _extractVersionFromHe, _extractVersionFromHe2, dest, call;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
-              api = input.api, asset = input.asset, scenario = input.scenario, version = input.version, destination = input.destination, address = input.address, senderAddress = input.senderAddress;
-              _context2.next = 3;
-              return getBridgeStatus(api.clone());
+              api = input.api, asset = input.asset, scenario = input.scenario, _input$version = input.version, version = _input$version === void 0 ? exports.Version.V4 : _input$version, destination = input.destination, address = input.address, senderAddress = input.senderAddress, feeAsset = input.feeAsset, paraIdTo = input.paraIdTo;
+              if (asset.multiLocation) {
+                _context2.next = 3;
+                break;
+              }
+              throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no multiLocation"));
             case 3:
-              bridgeStatus = _context2.sent;
-              if (!(bridgeStatus !== 'Normal')) {
-                _context2.next = 6;
+              if (!(senderAddress === undefined)) {
+                _context2.next = 5;
                 break;
               }
-              throw new BridgeHaltedError();
-            case 6:
-              if (assets.isForeignAsset(asset)) {
-                _context2.next = 8;
+              throw new Error('Sender address is required for transfers to Ethereum');
+            case 5:
+              if (!sdkCommon.isTMultiLocation(address)) {
+                _context2.next = 7;
                 break;
               }
-              throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no assetId"));
-            case 8:
+              throw new Error('Multi-location address is not supported for Ethereum transfers');
+            case 7:
+              ethMultiAsset = createMultiAsset(version, asset.amount, asset.multiLocation);
+              PARA_TO_PARA_FEE_DOT = 500000000n; // 0.5 DOT
+              // Pad by 25%
+              AH_EXECUTION_FEE_PADDED = ASSET_HUB_EXECUTION_FEE * 125n / 100n; // Perform a dry run AH -> dest to calculate the BuyExecution amount
+              _context2.next = 12;
+              return Builder(api.clone()).from('AssetHubPolkadot').to(destination).currency({
+                symbol: 'DOT',
+                amount: AH_EXECUTION_FEE_PADDED
+              }).address(address).dryRun(senderAddress);
+            case 12:
+              dryRunResult = _context2.sent;
+              if (dryRunResult.success) {
+                _context2.next = 15;
+                break;
+              }
+              throw new DryRunFailedError(dryRunResult.failureReason);
+            case 15:
+              // Pad fee by 50%
+              dryRunFeePadded = BigInt(dryRunResult.fee) * BigInt(3) / BigInt(2);
+              destWithHeader = createPolkadotXcmHeader(scenario, version, destination, paraIdTo);
+              _extractVersionFromHe = extractVersionFromHeader(destWithHeader), _extractVersionFromHe2 = _slicedToArray(_extractVersionFromHe, 2), _extractVersionFromHe2[0], dest = _extractVersionFromHe2[1];
+              call = {
+                module: 'PolkadotXcm',
+                section: 'transfer_assets_using_type_and_then',
+                parameters: {
+                  dest: this.createPolkadotXcmHeader(scenario, version, destination, getParaId('AssetHubPolkadot')),
+                  assets: addXcmVersionHeader([].concat(_toConsumableArray(!feeAsset ? [createMultiAsset(version, PARA_TO_PARA_FEE_DOT, DOT_MULTILOCATION)] : []), [ethMultiAsset]), version),
+                  assets_transfer_type: 'DestinationReserve',
+                  remote_fees_id: addXcmVersionHeader((_feeAsset$multiLocati = feeAsset === null || feeAsset === void 0 ? void 0 : feeAsset.multiLocation) !== null && _feeAsset$multiLocati !== void 0 ? _feeAsset$multiLocati : DOT_MULTILOCATION, version),
+                  fees_transfer_type: 'DestinationReserve',
+                  custom_xcm_on_dest: addXcmVersionHeader([{
+                    SetAppendix: [{
+                      DepositAsset: {
+                        assets: {
+                          Wild: 'All'
+                        },
+                        beneficiary: createBeneficiaryMultiLocation({
+                          api: api,
+                          scenario: scenario,
+                          pallet: 'PolkadotXcm',
+                          recipientAddress: senderAddress,
+                          version: version
+                        })
+                      }
+                    }]
+                  }, {
+                    DepositReserveAsset: {
+                      assets: {
+                        Wild: 'All'
+                      },
+                      dest: dest,
+                      xcm: [{
+                        BuyExecution: {
+                          fees: {
+                            id: DOT_MULTILOCATION,
+                            fun: {
+                              Fungible: dryRunFeePadded
+                            }
+                          },
+                          weight_limit: 'Unlimited'
+                        }
+                      }, {
+                        DepositAsset: {
+                          assets: {
+                            Wild: 'All'
+                          },
+                          beneficiary: createBeneficiaryMultiLocation({
+                            api: api,
+                            scenario: scenario,
+                            pallet: 'PolkadotXcm',
+                            recipientAddress: address,
+                            version: version
+                          })
+                        }
+                      }]
+                    }
+                  }], version),
+                  weight_limit: 'Unlimited'
+                }
+              };
+              return _context2.abrupt("return", api.callTxMethod(call));
+            case 20:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function transferEthAssetViaAH(_x2) {
+        return _transferEthAssetViaAH.apply(this, arguments);
+      }
+      return transferEthAssetViaAH;
+    }()
+  }, {
+    key: "transferToEthereum",
+    value: function () {
+      var _transferToEthereum = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(input) {
+        var _feeAsset$multiLocati2;
+        var useOnlyDepositInstruction,
+          api,
+          asset,
+          scenario,
+          _input$version2,
+          version,
+          destination,
+          address,
+          senderAddress,
+          feeAsset,
+          bridgeStatus,
+          ethMultiAsset,
+          ahApi,
+          _yield$getParaEthTran,
+          _yield$getParaEthTran2,
+          bridgeFee,
+          executionFee,
+          PARA_TO_PARA_FEE_DOT,
+          fee,
+          ethAsset,
+          messageId,
+          call,
+          _args3 = arguments;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              useOnlyDepositInstruction = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : false;
+              api = input.api, asset = input.asset, scenario = input.scenario, _input$version2 = input.version, version = _input$version2 === void 0 ? exports.Version.V4 : _input$version2, destination = input.destination, address = input.address, senderAddress = input.senderAddress, feeAsset = input.feeAsset;
+              _context3.next = 4;
+              return getBridgeStatus(api.clone());
+            case 4:
+              bridgeStatus = _context3.sent;
+              if (!(bridgeStatus !== 'Normal')) {
+                _context3.next = 7;
+                break;
+              }
+              throw new BridgeHaltedError();
+            case 7:
+              if (asset.multiLocation) {
+                _context3.next = 9;
+                break;
+              }
+              throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no multiLocation"));
+            case 9:
               if (!(senderAddress === undefined)) {
-                _context2.next = 10;
+                _context3.next = 11;
                 break;
               }
               throw new Error('Sender address is required for transfers to Ethereum');
-            case 10:
+            case 11:
               if (!sdkCommon.isTMultiLocation(address)) {
-                _context2.next = 12;
+                _context3.next = 13;
                 break;
               }
               throw new Error('Multi-location address is not supported for Ethereum transfers');
-            case 12:
-              versionOrDefault = version !== null && version !== void 0 ? version : exports.Version.V4;
-              ethMultiAsset = createMultiAsset(versionOrDefault, asset.amount, asset.multiLocation);
-              _context2.next = 16;
+            case 13:
+              ethMultiAsset = createMultiAsset(version, asset.amount, asset.multiLocation);
+              _context3.next = 16;
               return api.createApiForNode('AssetHubPolkadot');
             case 16:
-              ahApi = _context2.sent;
-              _context2.next = 19;
+              ahApi = _context3.sent;
+              _context3.next = 19;
               return getParaEthTransferFees(ahApi);
             case 19:
-              _yield$getParaEthTran = _context2.sent;
+              _yield$getParaEthTran = _context3.sent;
               _yield$getParaEthTran2 = _slicedToArray(_yield$getParaEthTran, 2);
               bridgeFee = _yield$getParaEthTran2[0];
               executionFee = _yield$getParaEthTran2[1];
-              fee = (bridgeFee + executionFee).toString();
+              PARA_TO_PARA_FEE_DOT = 500000000; // 0.5 DOT
+              fee = useOnlyDepositInstruction ? PARA_TO_PARA_FEE_DOT : (bridgeFee + executionFee).toString();
               ethAsset = assets.findAssetByMultiLocation(assets.getOtherAssets('Ethereum'), asset.multiLocation);
               if (!(!ethAsset || !ethAsset.assetId)) {
-                _context2.next = 27;
+                _context3.next = 28;
                 break;
               }
               throw new assets.InvalidCurrencyError("Could not obtain Ethereum asset address for ".concat(JSON.stringify(asset)));
-            case 27:
-              _context2.next = 29;
+            case 28:
+              _context3.next = 30;
               return generateMessageId(api, senderAddress, getParaId(this.node), ethAsset.assetId, address, asset.amount);
-            case 29:
-              messageId = _context2.sent;
+            case 30:
+              messageId = _context3.sent;
               call = {
                 module: 'PolkadotXcm',
                 section: 'transfer_assets_using_type_and_then',
                 parameters: {
-                  dest: this.createPolkadotXcmHeader(scenario, versionOrDefault, destination, getParaId('AssetHubPolkadot')),
-                  assets: _defineProperty({}, versionOrDefault, [createMultiAsset(versionOrDefault, fee, DOT_MULTILOCATION), ethMultiAsset]),
+                  dest: this.createPolkadotXcmHeader(scenario, version, destination, getParaId('AssetHubPolkadot')),
+                  assets: addXcmVersionHeader([].concat(_toConsumableArray(!feeAsset ? [createMultiAsset(version, fee, DOT_MULTILOCATION)] : []), [ethMultiAsset]), version),
                   assets_transfer_type: 'DestinationReserve',
-                  remote_fees_id: _defineProperty({}, versionOrDefault, {
-                    parents: sdkCommon.Parents.ONE,
-                    interior: 'Here'
-                  }),
+                  remote_fees_id: addXcmVersionHeader((_feeAsset$multiLocati2 = feeAsset === null || feeAsset === void 0 ? void 0 : feeAsset.multiLocation) !== null && _feeAsset$multiLocati2 !== void 0 ? _feeAsset$multiLocati2 : DOT_MULTILOCATION, version),
                   fees_transfer_type: 'DestinationReserve',
-                  custom_xcm_on_dest: createCustomXcmOnDest(input, versionOrDefault, messageId),
+                  custom_xcm_on_dest: useOnlyDepositInstruction ? addXcmVersionHeader([{
+                    DepositAsset: {
+                      assets: {
+                        Wild: {
+                          AllCounted: 1
+                        }
+                      },
+                      beneficiary: createBeneficiaryMultiLocation({
+                        api: api,
+                        scenario: scenario,
+                        pallet: 'PolkadotXcm',
+                        recipientAddress: address,
+                        version: version
+                      })
+                    }
+                  }], version) : createCustomXcmOnDest(input, version, messageId),
                   weight_limit: 'Unlimited'
                 }
               };
-              return _context2.abrupt("return", api.callTxMethod(call));
-            case 32:
+              return _context3.abrupt("return", api.callTxMethod(call));
+            case 33:
             case "end":
-              return _context2.stop();
+              return _context3.stop();
           }
-        }, _callee2, this);
+        }, _callee3, this);
       }));
-      function transferToEthereum(_x2) {
+      function transferToEthereum(_x3) {
         return _transferToEthereum.apply(this, arguments);
       }
       return transferToEthereum;
@@ -3577,16 +3701,61 @@ var Acala = /*#__PURE__*/function (_ParachainNode) {
   }
   _inherits(Acala, _ParachainNode);
   return _createClass(Acala, [{
-    key: "transferXTokens",
-    value: function transferXTokens(input) {
-      var asset = input.asset;
-      var currencySelection = assets.isForeignAsset(asset) ? {
+    key: "getCurrencySelection",
+    value: function getCurrencySelection(asset) {
+      return assets.isForeignAsset(asset) ? {
         ForeignAsset: Number(asset.assetId)
       } : {
         Token: asset.symbol
       };
+    }
+  }, {
+    key: "transferXTokens",
+    value: function transferXTokens(input) {
+      var asset = input.asset;
+      var currencySelection = this.getCurrencySelection(asset);
       return XTokensTransferImpl.transferXTokens(input, currencySelection);
     }
+  }, {
+    key: "transferLocalNativeAsset",
+    value: function transferLocalNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      return api.callTxMethod({
+        module: 'Currencies',
+        section: 'transfer_native_currency',
+        parameters: {
+          dest: {
+            Id: address
+          },
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (asset.symbol.toLowerCase() === 'lcdot') {
+        throw new assets.InvalidCurrencyError('LcDOT local transfers are not supported');
+      }
+      return api.callTxMethod({
+        module: 'Currencies',
+        section: 'transfer',
+        parameters: {
+          dest: {
+            Id: address
+          },
+          currency_id: this.getCurrencySelection(_objectSpread2(_objectSpread2({}, asset), {}, {
+            symbol: asset.symbol === 'aSEED' ? 'AUSD' : asset.symbol
+          })),
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -3614,6 +3783,30 @@ var Altair = /*#__PURE__*/function (_ParachainNode) {
       var currencySelection = this.getCurrencySelection(asset);
       return XTokensTransferImpl.transferXTokens(input, currencySelection);
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no assetId"));
+      }
+      return api.callTxMethod({
+        module: 'Tokens',
+        section: 'transfer',
+        parameters: {
+          dest: {
+            Id: address
+          },
+          currency_id: this.getCurrencySelection(asset),
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -3719,6 +3912,11 @@ var AssetHubKusama = /*#__PURE__*/function (_ParachainNode) {
     value: function createCurrencySpec(amount, scenario, version, asset, isOverridenAsset) {
       return getNode('AssetHubPolkadot').createCurrencySpec(amount, scenario, version, asset, isOverridenAsset);
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      return getNode('AssetHubPolkadot').transferLocalNonNativeAsset(options);
+    }
   }]);
 }(ParachainNode);
 
@@ -3846,28 +4044,29 @@ var AssetHubPolkadot = /*#__PURE__*/function (_ParachainNode) {
     _classCallCheck(this, AssetHubPolkadot);
     _this = _callSuper(this, AssetHubPolkadot, ['AssetHubPolkadot', 'PolkadotAssetHub', 'polkadot', exports.Version.V3]);
     _this.handleBifrostEthTransfer = function (input) {
+      var useDOTAsFeeAsset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
       var api = input.api,
         scenario = input.scenario,
         _input$version = input.version,
-        version = _input$version === void 0 ? _this.version : _input$version,
+        version = _input$version === void 0 ? exports.Version.V4 : _input$version,
         destination = input.destination,
-        asset = input.asset;
+        asset = input.asset,
+        paraIdTo = input.paraIdTo;
       if (!assets.isForeignAsset(asset)) {
         throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
       }
       if (!asset.multiLocation) {
         throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no multiLocation"));
       }
+      var PARA_TO_PARA_FEE_DOT = 500000000n; // 0.5 DOT
       var call = {
         module: 'PolkadotXcm',
         section: 'transfer_assets_using_type_and_then',
         parameters: {
-          dest: _this.createPolkadotXcmHeader(scenario, version, destination, getParaId('BifrostPolkadot')),
-          assets: _defineProperty({}, version, [createMultiAsset(version, asset.amount, asset.multiLocation)]),
+          dest: _this.createPolkadotXcmHeader(scenario, version, destination, paraIdTo),
+          assets: addXcmVersionHeader([].concat(_toConsumableArray(useDOTAsFeeAsset ? [createMultiAsset(version, PARA_TO_PARA_FEE_DOT, DOT_MULTILOCATION)] : []), [createMultiAsset(version, asset.amount, asset.multiLocation)]), version),
           assets_transfer_type: 'LocalReserve',
-          remote_fees_id: _defineProperty({}, version, {
-            Concrete: asset.multiLocation
-          }),
+          remote_fees_id: addXcmVersionHeader(useDOTAsFeeAsset ? DOT_MULTILOCATION : asset.multiLocation, version),
           fees_transfer_type: 'LocalReserve',
           custom_xcm_on_dest: createCustomXcmToBifrost(input, version),
           weight_limit: 'Unlimited'
@@ -3909,14 +4108,14 @@ var AssetHubPolkadot = /*#__PURE__*/function (_ParachainNode) {
       throw new assets.InvalidCurrencyError("Polkadot <-> Kusama bridge does not support currency ".concat(input.asset.symbol));
     }
   }, {
-    key: "handleEthBridgeTransfer",
+    key: "handleEthBridgeNativeTransfer",
     value: function () {
-      var _handleEthBridgeTransfer = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(input) {
-        var api, scenario, destination, paraIdTo, address, asset, bridgeStatus, modifiedInput;
+      var _handleEthBridgeNativeTransfer = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(input) {
+        var api, _input$version2, version, scenario, destination, senderAddress, address, paraIdTo, asset, bridgeStatus, messageId, multiLocation, call;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              api = input.api, scenario = input.scenario, destination = input.destination, paraIdTo = input.paraIdTo, address = input.address, asset = input.asset;
+              api = input.api, _input$version2 = input.version, version = _input$version2 === void 0 ? exports.Version.V4 : _input$version2, scenario = input.scenario, destination = input.destination, senderAddress = input.senderAddress, address = input.address, paraIdTo = input.paraIdTo, asset = input.asset;
               _context.next = 3;
               return getBridgeStatus(api.clone());
             case 3:
@@ -3927,24 +4126,120 @@ var AssetHubPolkadot = /*#__PURE__*/function (_ParachainNode) {
               }
               throw new BridgeHaltedError();
             case 6:
-              if (ethers.ethers.isAddress(address)) {
+              if (!(senderAddress === undefined)) {
                 _context.next = 8;
                 break;
               }
+              throw new Error('Sender address is required for transfers to Ethereum');
+            case 8:
+              if (!sdkCommon.isTMultiLocation(address)) {
+                _context.next = 10;
+                break;
+              }
+              throw new Error('Multi-location address is not supported for Ethereum transfers');
+            case 10:
+              if (assets.isForeignAsset(asset)) {
+                _context.next = 12;
+                break;
+              }
+              throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+            case 12:
+              if (asset.multiLocation) {
+                _context.next = 14;
+                break;
+              }
+              throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no multiLocation"));
+            case 14:
+              _context.next = 16;
+              return generateMessageId(api, senderAddress, getParaId(this.node), JSON.stringify(asset.multiLocation), address, asset.amount);
+            case 16:
+              messageId = _context.sent;
+              multiLocation = asset.symbol === this.getNativeAssetSymbol() ? DOT_MULTILOCATION : asset.multiLocation;
+              call = {
+                module: 'PolkadotXcm',
+                section: 'transfer_assets_using_type_and_then',
+                parameters: {
+                  dest: createPolkadotXcmHeader(scenario, this.version, destination, paraIdTo, ETHEREUM_JUNCTION, sdkCommon.Parents.TWO),
+                  assets: addXcmVersionHeader([createMultiAsset(version, asset.amount, multiLocation)], version),
+                  assets_transfer_type: 'LocalReserve',
+                  remote_fees_id: addXcmVersionHeader(multiLocation, version),
+                  fees_transfer_type: 'LocalReserve',
+                  custom_xcm_on_dest: addXcmVersionHeader([{
+                    DepositAsset: {
+                      assets: {
+                        Wild: {
+                          AllCounted: 1
+                        }
+                      },
+                      beneficiary: createBeneficiaryMultiLocation({
+                        api: api,
+                        scenario: scenario,
+                        pallet: 'PolkadotXcm',
+                        recipientAddress: address,
+                        version: version
+                      })
+                    }
+                  }, {
+                    SetTopic: messageId
+                  }], version),
+                  weight_limit: 'Unlimited'
+                }
+              };
+              return _context.abrupt("return", api.callTxMethod(call));
+            case 20:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function handleEthBridgeNativeTransfer(_x) {
+        return _handleEthBridgeNativeTransfer.apply(this, arguments);
+      }
+      return handleEthBridgeNativeTransfer;
+    }()
+  }, {
+    key: "handleEthBridgeTransfer",
+    value: function () {
+      var _handleEthBridgeTransfer = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(input) {
+        var api, scenario, destination, paraIdTo, address, asset, bridgeStatus, modifiedInput;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              api = input.api, scenario = input.scenario, destination = input.destination, paraIdTo = input.paraIdTo, address = input.address, asset = input.asset;
+              _context2.next = 3;
+              return getBridgeStatus(api.clone());
+            case 3:
+              bridgeStatus = _context2.sent;
+              if (!(bridgeStatus !== 'Normal')) {
+                _context2.next = 6;
+                break;
+              }
+              throw new BridgeHaltedError();
+            case 6:
+              if (ethers.ethers.isAddress(address)) {
+                _context2.next = 8;
+                break;
+              }
               throw new Error('Only Ethereum addresses are supported for Ethereum transfers');
             case 8:
               if (assets.isForeignAsset(asset)) {
-                _context.next = 10;
+                _context2.next = 10;
                 break;
               }
               throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
             case 10:
               if (asset.multiLocation) {
-                _context.next = 12;
+                _context2.next = 12;
                 break;
               }
               throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no multiLocation"));
             case 12:
+              if (!(asset.symbol === this.getNativeAssetSymbol() || asset.symbol === assets.getNativeAssetSymbol('Kusama'))) {
+                _context2.next = 14;
+                break;
+              }
+              return _context2.abrupt("return", this.handleEthBridgeNativeTransfer(input));
+            case 14:
               modifiedInput = _objectSpread2(_objectSpread2({}, input), {}, {
                 header: createPolkadotXcmHeader(scenario, this.version, destination, paraIdTo, ETHEREUM_JUNCTION, sdkCommon.Parents.TWO),
                 addressSelection: createVersionedBeneficiary({
@@ -3957,14 +4252,14 @@ var AssetHubPolkadot = /*#__PURE__*/function (_ParachainNode) {
                 }),
                 currencySelection: createVersionedMultiAssets(exports.Version.V3, asset.amount, asset.multiLocation)
               });
-              return _context.abrupt("return", PolkadotXCMTransferImpl.transferPolkadotXCM(modifiedInput, 'transfer_assets', 'Unlimited'));
-            case 14:
+              return _context2.abrupt("return", PolkadotXCMTransferImpl.transferPolkadotXCM(modifiedInput, 'transfer_assets', 'Unlimited'));
+            case 16:
             case "end":
-              return _context.stop();
+              return _context2.stop();
           }
-        }, _callee, this);
+        }, _callee2, this);
       }));
-      function handleEthBridgeTransfer(_x) {
+      function handleEthBridgeTransfer(_x2) {
         return _handleEthBridgeTransfer.apply(this, arguments);
       }
       return handleEthBridgeTransfer;
@@ -4011,12 +4306,12 @@ var AssetHubPolkadot = /*#__PURE__*/function (_ParachainNode) {
         paraIdTo = input.paraIdTo,
         scenario = input.scenario,
         api = input.api,
-        _input$version2 = input.version,
-        version = _input$version2 === void 0 ? this.version : _input$version2,
+        _input$version3 = input.version,
+        version = _input$version3 === void 0 ? this.version : _input$version3,
         address = input.address;
       if ((((_asset$symbol = asset.symbol) === null || _asset$symbol === void 0 ? void 0 : _asset$symbol.toUpperCase()) === 'USDT' || ((_asset$symbol2 = asset.symbol) === null || _asset$symbol2 === void 0 ? void 0 : _asset$symbol2.toUpperCase()) === 'USDC') && destination === 'BifrostPolkadot') {
-        var _input$version3;
-        var versionOrDefault = (_input$version3 = input.version) !== null && _input$version3 !== void 0 ? _input$version3 : exports.Version.V2;
+        var _input$version4;
+        var versionOrDefault = (_input$version4 = input.version) !== null && _input$version4 !== void 0 ? _input$version4 : exports.Version.V2;
         return _objectSpread2(_objectSpread2({}, input), {}, {
           header: this.createPolkadotXcmHeader(scenario, versionOrDefault, destination, paraIdTo),
           addressSelection: createVersionedBeneficiary({
@@ -4047,14 +4342,14 @@ var AssetHubPolkadot = /*#__PURE__*/function (_ParachainNode) {
   }, {
     key: "handleExecuteTransfer",
     value: function () {
-      var _handleExecuteTransfer = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(input) {
+      var _handleExecuteTransfer = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(input) {
         var api, senderAddress, asset, MIN_FEE, maxU64, dummyTx, dryRunResult, feeDotShifted, toMl, feeConverted, feeConvertedPadded;
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
             case 0:
               api = input.api, senderAddress = input.senderAddress, asset = input.asset;
               if (senderAddress) {
-                _context2.next = 3;
+                _context3.next = 3;
                 break;
               }
               throw new Error('Please provide senderAddress');
@@ -4066,53 +4361,53 @@ var AssetHubPolkadot = /*#__PURE__*/function (_ParachainNode) {
                 refTime: maxU64,
                 proofSize: maxU64
               }, MIN_FEE);
-              _context2.next = 9;
+              _context3.next = 9;
               return api.getDryRun({
                 node: this.node,
                 tx: dummyTx,
                 address: senderAddress
               });
             case 9:
-              dryRunResult = _context2.sent;
+              dryRunResult = _context3.sent;
               if (dryRunResult.success) {
-                _context2.next = 12;
+                _context3.next = 12;
                 break;
               }
               throw new Error("Dry run failed: ".concat(dryRunResult.failureReason));
             case 12:
               if (dryRunResult.weight) {
-                _context2.next = 14;
+                _context3.next = 14;
                 break;
               }
               throw new Error('Dry run failed: weight not found');
             case 14:
               feeDotShifted = dryRunResult.fee / 10n;
               toMl = transformMultiLocation(asset.multiLocation);
-              _context2.next = 18;
+              _context3.next = 18;
               return api.quoteAhPrice(DOT_MULTILOCATION, toMl, feeDotShifted);
             case 18:
-              feeConverted = _context2.sent;
+              feeConverted = _context3.sent;
               if (feeConverted) {
-                _context2.next = 21;
+                _context3.next = 21;
                 break;
               }
               throw new Error("Pool DOT -> ".concat(asset.symbol, " not found."));
             case 21:
               if (!(BigInt(asset.amount) - feeConverted < 0)) {
-                _context2.next = 23;
+                _context3.next = 23;
                 break;
               }
               throw new Error("Insufficient balance. Fee: ".concat(feeConverted, ", Amount: ").concat(asset.amount));
             case 23:
               feeConvertedPadded = feeConverted * 3n / 2n; // increases fee by 50%
-              return _context2.abrupt("return", createExecuteXcm(input, dryRunResult.weight, feeConvertedPadded));
+              return _context3.abrupt("return", createExecuteXcm(input, dryRunResult.weight, feeConvertedPadded));
             case 25:
             case "end":
-              return _context2.stop();
+              return _context3.stop();
           }
-        }, _callee2, this);
+        }, _callee3, this);
       }));
-      function handleExecuteTransfer(_x2) {
+      function handleExecuteTransfer(_x3) {
         return _handleExecuteTransfer.apply(this, arguments);
       }
       return handleExecuteTransfer;
@@ -4143,15 +4438,13 @@ var AssetHubPolkadot = /*#__PURE__*/function (_ParachainNode) {
       if (destination === 'Mythos') {
         return Promise.resolve(this.handleMythosTransfer(input));
       }
-      var ethereumAssets = assets.getOtherAssets('Ethereum');
-      var isEthereumAsset = ethereumAssets.some(function (_ref3) {
-        var symbol = _ref3.symbol,
-          assetId = _ref3.assetId;
-        return asset.symbol === symbol && assets.isForeignAsset(asset) && asset.assetId === assetId;
-      });
+      var isEthereumAsset = asset.multiLocation && assets.findAssetByMultiLocation(assets.getOtherAssets('Ethereum'), asset.multiLocation);
       if (destination === 'BifrostPolkadot' && isEthereumAsset) {
         return Promise.resolve(this.handleBifrostEthTransfer(input));
       }
+      if (isEthereumAsset) {
+        return Promise.resolve(this.handleBifrostEthTransfer(input, true));
+      }
       var isSystemNode = !sdkCommon.isTMultiLocation(destination) && SYSTEM_NODES_POLKADOT.includes(destination);
       if (scenario === 'ParaToPara' && asset.symbol === 'DOT' && !assets.isForeignAsset(asset) && destination !== 'Hydration' && destination !== 'Polimec' && destination !== 'Moonbeam' && destination !== 'BifrostPolkadot' && destination !== 'PeoplePolkadot' && !isSystemNode) {
         throw new ScenarioNotSupportedError(this.node, scenario, 'Para to Para scenarios for DOT transfer from AssetHub are not supported, you have to transfer DOT to Relay chain and transfer to destination chain from Relay chain.');
@@ -4190,6 +4483,40 @@ var AssetHubPolkadot = /*#__PURE__*/function (_ParachainNode) {
         return _superPropGet(AssetHubPolkadot, "createCurrencySpec", this, 3)([amount, scenario, version, asset]);
       }
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId !== undefined) {
+        return api.callTxMethod({
+          module: 'Assets',
+          section: 'transfer',
+          parameters: {
+            id: Number(asset.assetId),
+            target: {
+              Id: address
+            },
+            amount: BigInt(asset.amount)
+          }
+        });
+      }
+      return api.callTxMethod({
+        module: 'ForeignAssets',
+        section: 'transfer',
+        parameters: {
+          id: asset.multiLocation,
+          target: {
+            Id: address
+          },
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -4220,6 +4547,30 @@ var Astar = /*#__PURE__*/function (_ParachainNode) {
       var asset = _ref.asset;
       return asset.symbol !== this.getNativeAssetSymbol();
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no assetId"));
+      }
+      return api.callTxMethod({
+        module: 'Assets',
+        section: 'transfer',
+        parameters: {
+          id: Number(asset.assetId),
+          target: {
+            Id: address
+          },
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -4238,6 +4589,16 @@ var Basilisk = /*#__PURE__*/function (_ParachainNode) {
       }
       return XTokensTransferImpl.transferXTokens(input, Number(asset.assetId));
     }
+  }, {
+    key: "transferLocalNativeAsset",
+    value: function transferLocalNativeAsset(options) {
+      return getNode('Hydration').transferLocalNativeAsset(options);
+    }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      return getNode('Hydration').transferLocalNonNativeAsset(options);
+    }
   }]);
 }(ParachainNode);
 
@@ -4252,6 +4613,11 @@ var BifrostKusama = /*#__PURE__*/function (_ParachainNode) {
     value: function transferXTokens(input) {
       return getNode('BifrostPolkadot').transferXTokens(input);
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      return getNode('BifrostPolkadot').transferLocalNonNativeAsset(options);
+    }
   }]);
 }(ParachainNode);
 
@@ -4331,9 +4697,29 @@ var BifrostPolkadot = /*#__PURE__*/function (_ParachainNode) {
     value: function canUseXTokens(_ref) {
       var asset = _ref.asset,
         destination = _ref.to;
+      var isEthAsset = asset.multiLocation && assets.findAssetByMultiLocation(assets.getOtherAssets('Ethereum'), asset.multiLocation);
+      if (isEthAsset) return false;
       if (destination === 'Ethereum') return false;
       return asset.symbol !== 'WETH' && asset.symbol !== 'DOT' || destination !== 'AssetHubPolkadot';
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      return api.callTxMethod({
+        module: 'Tokens',
+        section: 'transfer',
+        parameters: {
+          dest: {
+            Id: address
+          },
+          currency_id: this.getCurrencySelection(asset),
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -4452,6 +4838,30 @@ var Centrifuge = /*#__PURE__*/function (_ParachainNode) {
       var currencySelection = this.getCurrencySelection(asset);
       return XTokensTransferImpl.transferXTokens(input, currencySelection);
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no assetId"));
+      }
+      return api.callTxMethod({
+        module: 'Tokens',
+        section: 'transfer',
+        parameters: {
+          dest: {
+            Id: address
+          },
+          currency_id: this.getCurrencySelection(asset),
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -4595,6 +5005,11 @@ var Crab = /*#__PURE__*/function (_ParachainNode) {
         return _superPropGet(Crab, "createCurrencySpec", this, 3)([amount, scenario, version]);
       }
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      return getNode('Darwinia').transferLocalNonNativeAsset(options);
+    }
   }]);
 }(ParachainNode);
 
@@ -4624,6 +5039,30 @@ var Crust = /*#__PURE__*/function (_ParachainNode) {
       var currencySelection = this.getCurrencySelection(asset);
       return XTokensTransferImpl.transferXTokens(input, currencySelection);
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no assetId"));
+      }
+      return api.callTxMethod({
+        module: 'Assets',
+        section: 'transfer',
+        parameters: {
+          id: BigInt(asset.assetId),
+          target: {
+            Id: address
+          },
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -4653,6 +5092,11 @@ var CrustShadow = /*#__PURE__*/function (_ParachainNode) {
       var currencySelection = this.getCurrencySelection(asset);
       return XTokensTransferImpl.transferXTokens(input, currencySelection);
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      return getNode('Crust').transferLocalNonNativeAsset(options);
+    }
   }]);
 }(ParachainNode);
 
@@ -4691,6 +5135,28 @@ var Darwinia = /*#__PURE__*/function (_ParachainNode) {
       }
       return Promise.resolve(PolkadotXCMTransferImpl.transferPolkadotXCM(input, 'reserve_transfer_assets'));
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no assetId"));
+      }
+      return api.callTxMethod({
+        module: 'Assets',
+        section: 'transfer',
+        parameters: {
+          id: BigInt(asset.assetId),
+          target: address,
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -4902,6 +5368,30 @@ var Polimec = /*#__PURE__*/function (_ParachainNode) {
       }), version, 'Teleport');
       return call;
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.multiLocation === undefined) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no multi-location"));
+      }
+      return api.callTxMethod({
+        module: 'ForeignAssets',
+        section: 'transfer',
+        parameters: {
+          id: asset.multiLocation,
+          target: {
+            Id: address
+          },
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -5028,7 +5518,45 @@ var Hydration = /*#__PURE__*/function (_ParachainNode) {
     value: function canUseXTokens(_ref3) {
       var destination = _ref3.to,
         asset = _ref3.asset;
-      return destination !== 'Ethereum' && destination !== 'Polimec' && !(destination === 'AssetHubPolkadot' && asset.symbol === 'DOT');
+      var isEthAsset = asset.multiLocation && assets.findAssetByMultiLocation(assets.getOtherAssets('Ethereum'), asset.multiLocation);
+      return destination !== 'Ethereum' && destination !== 'Polimec' && !(destination === 'AssetHubPolkadot' && asset.symbol === 'DOT') && !isEthAsset;
+    }
+  }, {
+    key: "transferLocalNativeAsset",
+    value: function transferLocalNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      return api.callTxMethod({
+        module: 'Balances',
+        section: 'transfer_keep_alive',
+        parameters: {
+          dest: address,
+          value: BigInt(asset.amount)
+        }
+      });
+    }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no assetId"));
+      }
+      return api.callTxMethod({
+        module: 'Tokens',
+        section: 'transfer',
+        parameters: {
+          dest: address,
+          currency_id: Number(asset.assetId),
+          amount: BigInt(asset.amount)
+        }
+      });
     }
   }]);
 }(ParachainNode);
@@ -5041,16 +5569,42 @@ var Interlay = /*#__PURE__*/function (_ParachainNode) {
   }
   _inherits(Interlay, _ParachainNode);
   return _createClass(Interlay, [{
-    key: "transferXTokens",
-    value: function transferXTokens(input) {
-      var asset = input.asset;
-      var currencySelection = assets.isForeignAsset(asset) ? {
+    key: "getCurrencySelection",
+    value: function getCurrencySelection(asset) {
+      return assets.isForeignAsset(asset) ? {
         ForeignAsset: Number(asset.assetId)
       } : {
         Token: asset.symbol
       };
+    }
+  }, {
+    key: "transferXTokens",
+    value: function transferXTokens(input) {
+      var asset = input.asset;
+      var currencySelection = this.getCurrencySelection(asset);
       return XTokensTransferImpl.transferXTokens(input, currencySelection);
     }
+  }, {
+    key: "transferLocalNativeAsset",
+    value: function transferLocalNativeAsset(options) {
+      return this.transferLocalNonNativeAsset(options);
+    }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      return api.callTxMethod({
+        module: 'Tokens',
+        section: 'transfer',
+        parameters: {
+          dest: address,
+          currency_id: this.getCurrencySelection(asset),
+          value: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -5083,6 +5637,16 @@ var Karura = /*#__PURE__*/function (_ParachainNode) {
     value: function transferXTokens(input) {
       return getNode('Acala').transferXTokens(input);
     }
+  }, {
+    key: "transferLocalNativeAsset",
+    value: function transferLocalNativeAsset(options) {
+      return getNode('Acala').transferLocalNativeAsset(options);
+    }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      return getNode('Acala').transferLocalNonNativeAsset(options);
+    }
   }]);
 }(ParachainNode);
 
@@ -5115,16 +5679,42 @@ var Kintsugi = /*#__PURE__*/function (_ParachainNode) {
   }
   _inherits(Kintsugi, _ParachainNode);
   return _createClass(Kintsugi, [{
-    key: "transferXTokens",
-    value: function transferXTokens(input) {
-      var asset = input.asset;
-      var currencySelection = assets.isForeignAsset(asset) ? {
+    key: "getCurrencySelection",
+    value: function getCurrencySelection(asset) {
+      return assets.isForeignAsset(asset) ? {
         ForeignAsset: Number(asset.assetId)
       } : {
         Token: asset.symbol
       };
+    }
+  }, {
+    key: "transferXTokens",
+    value: function transferXTokens(input) {
+      var asset = input.asset;
+      var currencySelection = this.getCurrencySelection(asset);
       return XTokensTransferImpl.transferXTokens(input, currencySelection);
     }
+  }, {
+    key: "transferLocalNativeAsset",
+    value: function transferLocalNativeAsset(options) {
+      return this.transferLocalNonNativeAsset(options);
+    }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      return api.callTxMethod({
+        module: 'Tokens',
+        section: 'transfer',
+        parameters: {
+          dest: address,
+          currency_id: this.getCurrencySelection(asset),
+          value: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -5152,6 +5742,30 @@ var Manta = /*#__PURE__*/function (_ParachainNode) {
       };
       return XTokensTransferImpl.transferXTokens(input, currencySelection);
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no assetId"));
+      }
+      return api.callTxMethod({
+        module: 'Assets',
+        section: 'transfer',
+        parameters: {
+          id: BigInt(asset.assetId),
+          target: {
+            Id: address
+          },
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 Manta.NATIVE_ASSET_ID = 1n;
@@ -5199,6 +5813,28 @@ var Moonbeam = /*#__PURE__*/function (_ParachainNode) {
         includeFee: true
       };
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no assetId"));
+      }
+      return api.callTxMethod({
+        module: 'Assets',
+        section: 'transfer',
+        parameters: {
+          id: BigInt(asset.assetId),
+          target: address,
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -5245,6 +5881,11 @@ var Moonriver = /*#__PURE__*/function (_ParachainNode) {
         includeFee: true
       };
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      return getNode('Moonbeam').transferLocalNonNativeAsset(options);
+    }
   }]);
 }(ParachainNode);
 
@@ -5342,6 +5983,30 @@ var Peaq = /*#__PURE__*/function (_ParachainNode) {
     value: function transferRelayToPara() {
       throw new NodeNotSupportedError();
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no assetId"));
+      }
+      return api.callTxMethod({
+        module: 'Assets',
+        section: 'transfer',
+        parameters: {
+          id: BigInt(asset.assetId),
+          target: {
+            Id: address
+          },
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -5531,6 +6196,30 @@ var Phala = /*#__PURE__*/function (_ParachainNode) {
       }
       return XTransferTransferImpl.transferXTransfer(input);
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no assetId"));
+      }
+      return api.callTxMethod({
+        module: 'Assets',
+        section: 'transfer',
+        parameters: {
+          id: BigInt(asset.assetId),
+          target: {
+            Id: address
+          },
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -5567,6 +6256,11 @@ var RobonomicsKusama = /*#__PURE__*/function (_ParachainNode) {
     value: function transferPolkadotXCM(input) {
       return Promise.resolve(PolkadotXCMTransferImpl.transferPolkadotXCM(input, 'limited_reserve_transfer_assets', 'Unlimited'));
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      return getNode('RobonomicsPolkadot').transferLocalNonNativeAsset(options);
+    }
   }]);
 }(ParachainNode);
 
@@ -5581,6 +6275,30 @@ var RobonomicsPolkadot = /*#__PURE__*/function (_ParachainNode) {
     value: function transferPolkadotXCM(input) {
       return Promise.resolve(PolkadotXCMTransferImpl.transferPolkadotXCM(input, 'limited_reserve_transfer_assets', 'Unlimited'));
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no assetId"));
+      }
+      return api.callTxMethod({
+        module: 'Assets',
+        section: 'transfer',
+        parameters: {
+          id: BigInt(asset.assetId),
+          target: {
+            Id: address
+          },
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -5608,6 +6326,11 @@ var Shiden = /*#__PURE__*/function (_ParachainNode) {
       var asset = _ref.asset;
       return asset.symbol !== this.getNativeAssetSymbol();
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      return getNode('Astar').transferLocalNonNativeAsset(options);
+    }
   }]);
 }(ParachainNode);
 
@@ -5650,6 +6373,30 @@ var Turing = /*#__PURE__*/function (_ParachainNode) {
         useMultiAssetTransfer: true
       }), BigInt(asset.assetId));
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no assetId"));
+      }
+      return api.callTxMethod({
+        module: 'Currencies',
+        section: 'transfer',
+        parameters: {
+          dest: {
+            Id: address
+          },
+          currency_id: BigInt(asset.assetId),
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -5671,6 +6418,11 @@ var Unique = /*#__PURE__*/function (_ParachainNode) {
       }
       return XTokensTransferImpl.transferXTokens(input, Number(asset.assetId));
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(_options) {
+      throw new ScenarioNotSupportedError(this.node, 'ParaToPara', "".concat(this.node, " does not support foreign assets local transfers"));
+    }
   }]);
 }(ParachainNode);
 Unique.NATIVE_ASSET_ID = 0;
@@ -5699,6 +6451,30 @@ var Zeitgeist = /*#__PURE__*/function (_ParachainNode) {
       var currencySelection = this.getCurrencySelection(asset);
       return XTokensTransferImpl.transferXTokens(input, currencySelection);
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      var api = options.api,
+        asset = options.asset,
+        address = options.address;
+      if (!assets.isForeignAsset(asset)) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " has no assetId"));
+      }
+      return api.callTxMethod({
+        module: 'AssetManager',
+        section: 'transfer',
+        parameters: {
+          dest: {
+            Id: address
+          },
+          currency_id: this.getCurrencySelection(asset),
+          amount: BigInt(asset.amount)
+        }
+      });
+    }
   }]);
 }(ParachainNode);
 
@@ -5758,17 +6534,154 @@ var nodes = function nodes() {
   };
 };
 
-/**
- * Retrieves the parachain ID for a specified node.
- *
- * @param node - The node for which to get the paraId.
- * @returns The parachain ID of the node.
- */
-var getParaId = function getParaId(node) {
-  if (node === 'Ethereum') {
-    return ETH_PARA_ID;
+var getParaEthTransferFees = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(ahApi) {
+    var DEFAULT_FEE, feeStorageItem, leFeeHex, bytes, reversedHex, validReversedHex, leFee, transferBridgeFee, finalBridgeFee, finalAssethubExecutionFee;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          DEFAULT_FEE = 2750872500000n;
+          _context.next = 3;
+          return ahApi.getFromRpc('state', 'getStorage', '0x5fbc5c7ba58845ad1f1a9a7c5bc12fad');
+        case 3:
+          feeStorageItem = _context.sent;
+          leFeeHex = feeStorageItem.replace('0x', '');
+          _context.next = 7;
+          return ahApi.disconnect();
+        case 7:
+          bytes = leFeeHex.match(/.{1,2}/g) || [];
+          reversedHex = bytes.reverse().join('');
+          validReversedHex = reversedHex === '' ? '0' : reversedHex;
+          leFee = BigInt('0x' + validReversedHex);
+          transferBridgeFee = leFee === 0n ? DEFAULT_FEE : BigInt(leFee.toString());
+          finalBridgeFee = transferBridgeFee * 110n / 100n;
+          finalAssethubExecutionFee = ASSET_HUB_EXECUTION_FEE * 110n / 100n;
+          return _context.abrupt("return", [finalBridgeFee, finalAssethubExecutionFee]);
+        case 15:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function getParaEthTransferFees(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var isEthersSigner = function isEthersSigner(signer) {
+  return _typeof(signer) === 'object' && signer !== null && 'provider' in signer;
+};
+var isEthersContract = function isEthersContract(contract) {
+  return !('abi' in contract);
+};
+
+var abi$1 = [
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "currencyAddress",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			},
+			{
+				components: [
+					{
+						internalType: "uint8",
+						name: "parents",
+						type: "uint8"
+					},
+					{
+						internalType: "bytes[]",
+						name: "interior",
+						type: "bytes[]"
+					}
+				],
+				internalType: "struct Xtokens.Multilocation",
+				name: "destination",
+				type: "tuple"
+			},
+			{
+				internalType: "uint64",
+				name: "weight",
+				type: "uint64"
+			}
+		],
+		name: "transfer",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				components: [
+					{
+						internalType: "address",
+						name: "currencyAddress",
+						type: "address"
+					},
+					{
+						internalType: "uint256",
+						name: "amount",
+						type: "uint256"
+					}
+				],
+				internalType: "struct Xtokens.Currency[]",
+				name: "currencies",
+				type: "tuple[]"
+			},
+			{
+				internalType: "uint32",
+				name: "feeItem",
+				type: "uint32"
+			},
+			{
+				components: [
+					{
+						internalType: "uint8",
+						name: "parents",
+						type: "uint8"
+					},
+					{
+						internalType: "bytes[]",
+						name: "interior",
+						type: "bytes[]"
+					}
+				],
+				internalType: "struct Xtokens.Multilocation",
+				name: "destination",
+				type: "tuple"
+			},
+			{
+				internalType: "uint64",
+				name: "weight",
+				type: "uint64"
+			}
+		],
+		name: "transferMultiCurrencies",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	}
+];
+
+// Inspired by Moonbeam XCM-SDK
+// https://github.com/moonbeam-foundation/xcm-sdk/blob/ab835c15bf41612604b1c858d956a9f07705ed65/packages/utils/src/format/asset.ts#L1
+var formatAssetIdToERC20 = function formatAssetIdToERC20(id) {
+  if (id.startsWith('0x')) {
+    return id;
   }
-  return getNodeConfig(node).paraId;
+  if (!(/^\d{38,39}$/.test(id) || /^\d{4}$/.test(id))) {
+    throw new Error("Asset id: ".concat(id, " must be a string and have either 4 digits or 38-39 digits"));
+  }
+  return "0xffffffff".concat(BigInt(id).toString(16).padStart(32, '0'));
 };
 
 // Partially inspired by Moonbeam XCM-SDK
@@ -6224,7 +7137,7 @@ var validateCurrency = function validateCurrency(currency, feeAsset) {
   }
 };
 var validateDestination = function validateDestination(origin, destination) {
-  if (sdkCommon.isRelayChain(origin) && !sdkCommon.isTMultiLocation(destination) && sdkCommon.isRelayChain(destination)) {
+  if (sdkCommon.isRelayChain(origin) && !sdkCommon.isTMultiLocation(destination) && sdkCommon.isRelayChain(destination) && origin !== destination) {
     throw new IncompatibleNodesError('Direct relay chain to relay chain transfers are not supported. Please use Polkadot <-> Kusama bridge through AssetHub.');
   }
   if (destination === 'Ethereum' && origin !== 'AssetHubPolkadot' && origin !== 'Hydration' && origin !== 'BifrostPolkadot') {
@@ -6353,7 +7266,7 @@ var validateDestinationAddress = function validateDestinationAddress(address, de
 
 var send = /*#__PURE__*/function () {
   var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(options) {
-    var api, origin, currency, feeAsset, address, destination, paraIdTo, version, senderAddress, pallet, method, isBridge, assetCheckEnabled, asset, resolvedFeeAsset, overriddenAsset, resolvedAsset, originNode;
+    var api, origin, currency, feeAsset, address, destination, paraIdTo, version, senderAddress, pallet, method, isBridge, assetCheckEnabled, asset, resolvedFeeAsset, isLocalTransfer, overriddenAsset, resolvedAsset, originNode;
     return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
         case 0:
@@ -6362,12 +7275,6 @@ var send = /*#__PURE__*/function () {
           validateDestination(origin, destination);
           validateDestinationAddress(address, destination);
           if (senderAddress) validateAddress(senderAddress, origin, false);
-          if (!(sdkCommon.isRelayChain(origin) && !sdkCommon.isTMultiLocation(destination) && sdkCommon.isRelayChain(destination))) {
-            _context.next = 7;
-            break;
-          }
-          throw new Error('Relay chain to relay chain transfers are not supported.');
-        case 7:
           isBridge = isBridgeTransfer(origin, destination);
           assetCheckEnabled = determineAssetCheckEnabled(origin, currency);
           validateAssetSpecifiers(assetCheckEnabled, currency);
@@ -6375,21 +7282,46 @@ var send = /*#__PURE__*/function () {
           resolvedFeeAsset = feeAsset ? resolveFeeAsset(feeAsset, origin, destination, currency) : undefined;
           validateAssetSupport(options, assetCheckEnabled, isBridge, asset);
           if (!sdkCommon.isRelayChain(origin)) {
-            _context.next = 19;
+            _context.next = 24;
             break;
           }
           if (!(destination === 'Ethereum')) {
-            _context.next = 16;
+            _context.next = 14;
             break;
           }
           throw new Error('Transfers from relay chain to Ethereum are not supported.');
-        case 16:
+        case 14:
           if (asset) {
-            _context.next = 18;
+            _context.next = 16;
             break;
           }
           throw new Error('Asset is required for relay chain to relay chain transfers.');
-        case 18:
+        case 16:
+          isLocalTransfer = origin === destination;
+          if (!isLocalTransfer) {
+            _context.next = 23;
+            break;
+          }
+          if (!sdkCommon.isTMultiLocation(address)) {
+            _context.next = 20;
+            break;
+          }
+          throw new InvalidAddressError('Multi-Location address is not supported for local transfers.');
+        case 20:
+          _context.next = 22;
+          return api.init(origin);
+        case 22:
+          return _context.abrupt("return", api.callTxMethod({
+            module: 'Balances',
+            section: 'transfer_keep_alive',
+            parameters: {
+              dest: {
+                Id: address
+              },
+              value: 'multiasset' in currency ? 0n : BigInt(currency.amount)
+            }
+          }));
+        case 23:
           return _context.abrupt("return", transferRelayToPara({
             api: api,
             origin: origin,
@@ -6403,11 +7335,11 @@ var send = /*#__PURE__*/function () {
             pallet: pallet,
             method: method
           }));
-        case 19:
+        case 24:
           overriddenAsset = resolveOverriddenAsset(options, isBridge, assetCheckEnabled, resolvedFeeAsset);
-          _context.next = 22;
+          _context.next = 27;
           return api.init(origin);
-        case 22:
+        case 27:
           // In case asset check is disabled, we create asset object from currency symbol
           resolvedAsset = asset !== null && asset !== void 0 ? asset : {
             symbol: 'symbol' in currency ? currency.symbol : undefined
@@ -6428,7 +7360,7 @@ var send = /*#__PURE__*/function () {
             pallet: pallet,
             method: method
           }));
-        case 25:
+        case 30:
         case "end":
           return _context.stop();
       }
@@ -6682,6 +7614,7 @@ var GeneralBuilder = /*#__PURE__*/function () {
     key: "build",
     value: (function () {
       var _build = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+        var _this$_options, from, to;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
@@ -6691,16 +7624,17 @@ var GeneralBuilder = /*#__PURE__*/function () {
               }
               throw new Error('Transaction manager contains batched items. Use buildBatch() to process them.');
             case 2:
-              if (!(!sdkCommon.isTMultiLocation(this._options.to) && sdkCommon.isRelayChain(this._options.from) && sdkCommon.isRelayChain(this._options.to))) {
-                _context2.next = 4;
+              _this$_options = this._options, from = _this$_options.from, to = _this$_options.to;
+              if (!(!sdkCommon.isTMultiLocation(to) && sdkCommon.isRelayChain(from) && sdkCommon.isRelayChain(to) && from !== to)) {
+                _context2.next = 5;
                 break;
               }
               throw new Error('Transfers between relay chains are not yet supported.');
-            case 4:
+            case 5:
               return _context2.abrupt("return", send(_objectSpread2({
                 api: this.api
               }, this._options)));
-            case 5:
+            case 6:
             case "end":
               return _context2.stop();
           }
@@ -7545,6 +8479,7 @@ var verifyEdOnDestination = /*#__PURE__*/function () {
 exports.AssetClaimBuilder = AssetClaimBuilder;
 exports.BridgeHaltedError = BridgeHaltedError;
 exports.Builder = Builder;
+exports.DryRunFailedError = DryRunFailedError;
 exports.ETHEREUM_JUNCTION = ETHEREUM_JUNCTION;
 exports.ETH_CHAIN_ID = ETH_CHAIN_ID;
 exports.GeneralBuilder = GeneralBuilder;