@paraspell/sdk-core 8.10.0 → 8.11.0

package/dist/index.mjs

@@ -3212,7 +3212,7 @@ var ParachainNode = /*#__PURE__*/function () {
     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, _options, isEthAsset, isAHPOrigin, isAHPDest, isEthDest;
+        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:
@@ -3220,15 +3220,22 @@ var ParachainNode = /*#__PURE__*/function () {
               isRelayDestination = !isTMultiLocation(destination) && 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';
@@ -3255,15 +3262,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({
@@ -3277,9 +3284,9 @@ var ParachainNode = /*#__PURE__*/function () {
                 pallet: pallet,
                 method: method
               }));
-            case 21:
+            case 24:
               if (!supportsPolkadotXCM(this)) {
-                _context.next = 34;
+                _context.next = 37;
                 break;
               }
               _options = {
@@ -3311,21 +3318,21 @@ var ParachainNode = /*#__PURE__*/function () {
               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 = 29;
+                _context.next = 32;
                 break;
               }
               return _context.abrupt("return", this.transferEthAssetViaAH(_options));
-            case 29:
+            case 32:
               if (!(isEthAsset && isAHPDest && !isAHPOrigin && !isEthDest)) {
-                _context.next = 31;
+                _context.next = 34;
                 break;
               }
               return _context.abrupt("return", this.transferToEthereum(_options, true));
-            case 31:
-              return _context.abrupt("return", this.transferPolkadotXCM(_options));
             case 34:
+              return _context.abrupt("return", this.transferPolkadotXCM(_options));
+            case 37:
               throw new NoXCMSupportImplementedError(this._node);
-            case 35:
+            case 38:
             case "end":
               return _context.stop();
           }
@@ -3380,6 +3387,65 @@ var ParachainNode = /*#__PURE__*/function () {
     value: function getNativeAssetSymbol$1() {
       return getNativeAssetSymbol(this.node);
     }
+  }, {
+    key: "transferLocal",
+    value: function transferLocal(options) {
+      var asset = options.asset,
+        address = options.address;
+      if (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() && !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: 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 (!isForeignAsset(asset)) {
+        throw new InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new 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 () {
@@ -3636,16 +3702,61 @@ var Acala = /*#__PURE__*/function (_ParachainNode) {
   }
   _inherits(Acala, _ParachainNode);
   return _createClass(Acala, [{
-    key: "transferXTokens",
-    value: function transferXTokens(input) {
-      var asset = input.asset;
-      var currencySelection = isForeignAsset(asset) ? {
+    key: "getCurrencySelection",
+    value: function getCurrencySelection(asset) {
+      return 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 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);
 
@@ -3673,6 +3784,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 (!isForeignAsset(asset)) {
+        throw new InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new 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);
 
@@ -3778,6 +3913,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);
 
@@ -4344,6 +4484,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 (!isForeignAsset(asset)) {
+        throw new 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);
 
@@ -4374,6 +4548,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 (!isForeignAsset(asset)) {
+        throw new InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new 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);
 
@@ -4392,6 +4590,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);
 
@@ -4406,6 +4614,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);
 
@@ -4490,6 +4703,24 @@ var BifrostPolkadot = /*#__PURE__*/function (_ParachainNode) {
       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);
 
@@ -4608,6 +4839,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 (!isForeignAsset(asset)) {
+        throw new InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new 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);
 
@@ -4751,6 +5006,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);
 
@@ -4780,6 +5040,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 (!isForeignAsset(asset)) {
+        throw new InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new 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);
 
@@ -4809,6 +5093,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);
 
@@ -4847,6 +5136,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 (!isForeignAsset(asset)) {
+        throw new InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new 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);
 
@@ -5058,6 +5369,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 (!isForeignAsset(asset)) {
+        throw new InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.multiLocation === undefined) {
+        throw new 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);
 
@@ -5187,6 +5522,43 @@ var Hydration = /*#__PURE__*/function (_ParachainNode) {
       var isEthAsset = asset.multiLocation && findAssetByMultiLocation(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 (!isForeignAsset(asset)) {
+        throw new InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new 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);
 Hydration.NATIVE_ASSET_ID = 0;
@@ -5198,16 +5570,42 @@ var Interlay = /*#__PURE__*/function (_ParachainNode) {
   }
   _inherits(Interlay, _ParachainNode);
   return _createClass(Interlay, [{
-    key: "transferXTokens",
-    value: function transferXTokens(input) {
-      var asset = input.asset;
-      var currencySelection = isForeignAsset(asset) ? {
+    key: "getCurrencySelection",
+    value: function getCurrencySelection(asset) {
+      return 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);
 
@@ -5240,6 +5638,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);
 
@@ -5272,16 +5680,42 @@ var Kintsugi = /*#__PURE__*/function (_ParachainNode) {
   }
   _inherits(Kintsugi, _ParachainNode);
   return _createClass(Kintsugi, [{
-    key: "transferXTokens",
-    value: function transferXTokens(input) {
-      var asset = input.asset;
-      var currencySelection = isForeignAsset(asset) ? {
+    key: "getCurrencySelection",
+    value: function getCurrencySelection(asset) {
+      return 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);
 
@@ -5309,6 +5743,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 (!isForeignAsset(asset)) {
+        throw new InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new 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;
@@ -5356,6 +5814,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 (!isForeignAsset(asset)) {
+        throw new InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new 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);
 
@@ -5402,6 +5882,11 @@ var Moonriver = /*#__PURE__*/function (_ParachainNode) {
         includeFee: true
       };
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      return getNode('Moonbeam').transferLocalNonNativeAsset(options);
+    }
   }]);
 }(ParachainNode);
 
@@ -5499,6 +5984,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 (!isForeignAsset(asset)) {
+        throw new InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new 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);
 
@@ -5688,6 +6197,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 (!isForeignAsset(asset)) {
+        throw new InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new 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);
 
@@ -5724,6 +6257,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);
 
@@ -5738,6 +6276,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 (!isForeignAsset(asset)) {
+        throw new InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new 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);
 
@@ -5765,6 +6327,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);
 
@@ -5807,6 +6374,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 (!isForeignAsset(asset)) {
+        throw new InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new 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);
 
@@ -5828,6 +6419,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;
@@ -5856,6 +6452,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 (!isForeignAsset(asset)) {
+        throw new InvalidCurrencyError("Asset ".concat(JSON.stringify(asset), " is not a foreign asset"));
+      }
+      if (asset.assetId === undefined) {
+        throw new 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);
 
@@ -6518,7 +7138,7 @@ var validateCurrency = function validateCurrency(currency, feeAsset) {
   }
 };
 var validateDestination = function validateDestination(origin, destination) {
-  if (isRelayChain(origin) && !isTMultiLocation(destination) && isRelayChain(destination)) {
+  if (isRelayChain(origin) && !isTMultiLocation(destination) && 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') {
@@ -6647,7 +7267,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:
@@ -6656,12 +7276,6 @@ var send = /*#__PURE__*/function () {
           validateDestination(origin, destination);
           validateDestinationAddress(address, destination);
           if (senderAddress) validateAddress(senderAddress, origin, false);
-          if (!(isRelayChain(origin) && !isTMultiLocation(destination) && 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);
@@ -6669,21 +7283,46 @@ var send = /*#__PURE__*/function () {
           resolvedFeeAsset = feeAsset ? resolveFeeAsset(feeAsset, origin, destination, currency) : undefined;
           validateAssetSupport(options, assetCheckEnabled, isBridge, asset);
           if (!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 (!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,
@@ -6697,11 +7336,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
@@ -6722,7 +7361,7 @@ var send = /*#__PURE__*/function () {
             pallet: pallet,
             method: method
           }));
-        case 25:
+        case 30:
         case "end":
           return _context.stop();
       }
@@ -6976,6 +7615,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:
@@ -6985,16 +7625,17 @@ var GeneralBuilder = /*#__PURE__*/function () {
               }
               throw new Error('Transaction manager contains batched items. Use buildBatch() to process them.');
             case 2:
-              if (!(!isTMultiLocation(this._options.to) && isRelayChain(this._options.from) && isRelayChain(this._options.to))) {
-                _context2.next = 4;
+              _this$_options = this._options, from = _this$_options.from, to = _this$_options.to;
+              if (!(!isTMultiLocation(to) && isRelayChain(from) && 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();
           }