@paraspell/sdk-core 8.10.0 → 8.11.1

package/dist/index.cjs

@@ -3211,7 +3211,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:
@@ -3219,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';
@@ -3254,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({
@@ -3276,9 +3283,9 @@ var ParachainNode = /*#__PURE__*/function () {
                 pallet: pallet,
                 method: method
               }));
-            case 21:
+            case 24:
               if (!supportsPolkadotXCM(this)) {
-                _context.next = 34;
+                _context.next = 37;
                 break;
               }
               _options = {
@@ -3310,21 +3317,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();
           }
@@ -3339,8 +3346,8 @@ var ParachainNode = /*#__PURE__*/function () {
     key: "getRelayToParaOverrides",
     value: function getRelayToParaOverrides() {
       return {
-        section: 'reserve_transfer_assets',
-        includeFee: false
+        section: 'limited_reserve_transfer_assets',
+        includeFee: true
       };
     }
   }, {
@@ -3379,6 +3386,65 @@ var ParachainNode = /*#__PURE__*/function () {
     value: function getNativeAssetSymbol() {
       return assets.getNativeAssetSymbol(this.node);
     }
+  }, {
+    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 () {
@@ -3635,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);
 
@@ -3672,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);
 
@@ -3777,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);
 
@@ -4343,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);
 
@@ -4355,8 +4529,7 @@ var Astar = /*#__PURE__*/function (_ParachainNode) {
   return _createClass(Astar, [{
     key: "transferPolkadotXCM",
     value: function transferPolkadotXCM(input) {
-      // TESTED https://polkadot.subscan.io/xcm_message/polkadot-f2b697df74ebe4b62853fe81b8b7d0522464972d
-      return Promise.resolve(PolkadotXCMTransferImpl.transferPolkadotXCM(input, 'reserve_transfer_assets'));
+      return Promise.resolve(PolkadotXCMTransferImpl.transferPolkadotXCM(input, 'limited_reserve_transfer_assets', 'Unlimited'));
     }
   }, {
     key: "transferXTokens",
@@ -4373,6 +4546,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);
 
@@ -4391,6 +4588,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);
 
@@ -4405,6 +4612,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);
 
@@ -4489,6 +4701,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);
 
@@ -4607,6 +4837,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);
 
@@ -4750,6 +5004,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);
 
@@ -4779,6 +5038,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);
 
@@ -4808,6 +5091,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);
 
@@ -4840,11 +5128,50 @@ var Darwinia = /*#__PURE__*/function (_ParachainNode) {
   return _createClass(Darwinia, [{
     key: "transferPolkadotXCM",
     value: function transferPolkadotXCM(input) {
-      var scenario = input.scenario;
-      if (scenario === 'ParaToPara') {
+      var scenario = input.scenario,
+        asset = input.asset;
+      if (scenario === 'ParaToPara' && asset.symbol !== this.getNativeAssetSymbol()) {
         throw new ScenarioNotSupportedError(this.node, scenario);
       }
-      return Promise.resolve(PolkadotXCMTransferImpl.transferPolkadotXCM(input, 'reserve_transfer_assets'));
+      return Promise.resolve(PolkadotXCMTransferImpl.transferPolkadotXCM(input, 'limited_reserve_transfer_assets', 'Unlimited'));
+    }
+  }, {
+    key: "createCurrencySpec",
+    value: function createCurrencySpec(amount, scenario, version, _asset) {
+      if (scenario === 'ParaToPara') {
+        return createVersionedMultiAssets(version, amount, {
+          parents: sdkCommon.Parents.ZERO,
+          interior: {
+            X1: {
+              PalletInstance: 5
+            }
+          }
+        });
+      } else {
+        return _superPropGet(Darwinia, "createCurrencySpec", this, 3)([amount, scenario, version]);
+      }
+    }
+  }, {
+    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);
@@ -5057,6 +5384,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);
 
@@ -5186,6 +5537,43 @@ var Hydration = /*#__PURE__*/function (_ParachainNode) {
       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);
 Hydration.NATIVE_ASSET_ID = 0;
@@ -5197,16 +5585,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);
 
@@ -5239,22 +5653,34 @@ 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);
 
 var KiltSpiritnet = /*#__PURE__*/function (_ParachainNode) {
   function KiltSpiritnet() {
     _classCallCheck(this, KiltSpiritnet);
-    return _callSuper(this, KiltSpiritnet, ['KiltSpiritnet', 'kilt', 'polkadot', exports.Version.V2]);
+    return _callSuper(this, KiltSpiritnet, ['KiltSpiritnet', 'kilt', 'polkadot', exports.Version.V3]);
   }
   _inherits(KiltSpiritnet, _ParachainNode);
   return _createClass(KiltSpiritnet, [{
     key: "transferPolkadotXCM",
     value: function transferPolkadotXCM(input) {
-      if (input.scenario !== 'ParaToPara') {
-        throw new ScenarioNotSupportedError(this.node, input.scenario);
+      var scenario = input.scenario,
+        asset = input.asset;
+      if (scenario === 'ParaToPara' && asset.symbol !== this.getNativeAssetSymbol()) {
+        throw new ScenarioNotSupportedError(this.node, scenario, 'KiltSpiritnet only supports native asset ParaToPara transfers');
       }
-      return Promise.resolve(PolkadotXCMTransferImpl.transferPolkadotXCM(input, 'reserve_transfer_assets'));
+      return Promise.resolve(PolkadotXCMTransferImpl.transferPolkadotXCM(input, 'limited_reserve_transfer_assets', 'Unlimited'));
     }
   }, {
     key: "transferRelayToPara",
@@ -5271,16 +5697,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);
 
@@ -5308,6 +5760,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;
@@ -5355,6 +5831,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);
 
@@ -5401,6 +5899,11 @@ var Moonriver = /*#__PURE__*/function (_ParachainNode) {
         includeFee: true
       };
     }
+  }, {
+    key: "transferLocalNonNativeAsset",
+    value: function transferLocalNonNativeAsset(options) {
+      return getNode('Moonbeam').transferLocalNonNativeAsset(options);
+    }
   }]);
 }(ParachainNode);
 
@@ -5498,6 +6001,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);
 
@@ -5687,6 +6214,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);
 
@@ -5723,6 +6274,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);
 
@@ -5737,6 +6293,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);
 
@@ -5764,6 +6344,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);
 
@@ -5806,6 +6391,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);
 
@@ -5827,6 +6436,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;
@@ -5855,6 +6469,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);
 
@@ -6517,7 +7155,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') {
@@ -6646,7 +7284,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:
@@ -6655,12 +7293,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);
@@ -6668,21 +7300,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,
@@ -6696,11 +7353,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
@@ -6721,7 +7378,7 @@ var send = /*#__PURE__*/function () {
             pallet: pallet,
             method: method
           }));
-        case 25:
+        case 30:
         case "end":
           return _context.stop();
       }
@@ -6975,6 +7632,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:
@@ -6984,16 +7642,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();
           }
@@ -7335,8 +7994,8 @@ var getBalanceNative = /*#__PURE__*/function () {
 
 var getAssetBalanceInternal = /*#__PURE__*/function () {
   var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
-    var _yield$getBalanceFore;
-    var address, node, currency, api, isNativeSymbol;
+    var _findAsset, _yield$getBalanceFore;
+    var address, node, currency, api, asset, isNativeSymbol;
     return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
         case 0:
@@ -7344,52 +8003,59 @@ var getAssetBalanceInternal = /*#__PURE__*/function () {
           _context.next = 3;
           return api.init(node);
         case 3:
-          isNativeSymbol = 'symbol' in currency ? assets.getNativeAssetSymbol(node) === currency.symbol : false;
+          asset = (_findAsset = assets.findAsset(node, currency, null)) !== null && _findAsset !== void 0 ? _findAsset : node === 'AssetHubPolkadot' ? assets.findAsset('Ethereum', currency, null) : null;
+          if (asset) {
+            _context.next = 6;
+            break;
+          }
+          throw new assets.InvalidCurrencyError("Asset ".concat(JSON.stringify(currency), " not found on ").concat(node));
+        case 6:
+          isNativeSymbol = asset.symbol === assets.getNativeAssetSymbol(node);
           if (!(isNativeSymbol && node !== 'Interlay' && node !== 'Kintsugi')) {
-            _context.next = 10;
+            _context.next = 13;
             break;
           }
-          _context.next = 7;
+          _context.next = 10;
           return getBalanceNativeInternal({
             address: address,
             node: node,
             api: api
           });
-        case 7:
+        case 10:
           _context.t0 = _context.sent;
-          _context.next = 22;
+          _context.next = 25;
           break;
-        case 10:
-          _context.next = 12;
+        case 13:
+          _context.next = 15;
           return getBalanceForeignInternal({
             address: address,
             node: node,
             api: api,
             currency: currency
           });
-        case 12:
+        case 15:
           _context.t2 = _yield$getBalanceFore = _context.sent;
           _context.t1 = _context.t2 !== null;
           if (!_context.t1) {
-            _context.next = 16;
+            _context.next = 19;
             break;
           }
           _context.t1 = _yield$getBalanceFore !== void 0;
-        case 16:
+        case 19:
           if (!_context.t1) {
-            _context.next = 20;
+            _context.next = 23;
             break;
           }
           _context.t3 = _yield$getBalanceFore;
-          _context.next = 21;
+          _context.next = 24;
           break;
-        case 20:
+        case 23:
           _context.t3 = 0n;
-        case 21:
+        case 24:
           _context.t0 = _context.t3;
-        case 22:
+        case 25:
           return _context.abrupt("return", _context.t0);
-        case 23:
+        case 26:
         case "end":
           return _context.stop();
       }