git.delta.rocks / unique-network / refs/commits / 6a580826c34a

--- a/.env
+++ b/.env
@@ -16,7 +16,7 @@
 
 KUSAMA_MAINNET_BRANCH=release-v1.0.0
 STATEMINE_BUILD_BRANCH=release-parachains-v9430
-KARURA_BUILD_BRANCH=release-karura-2.21.0
+KARURA_BUILD_BRANCH=xnft-poc
 MOONRIVER_BUILD_BRANCH=runtime-2500
 SHIDEN_BUILD_BRANCH=v5.18.0
 QUARTZ_MAINNET_BRANCH=release-v10010063

--- a/.github/workflows/ci-develop.yml
+++ b/.github/workflows/ci-develop.yml
@@ -35,6 +35,11 @@
     if: github.event.pull_request.draft == false && contains(github.event.pull_request.labels.*.name, 'CI-xcm')
     uses: ./.github/workflows/xcm.yml
     secrets: inherit
+
+  xnft:
+    if: github.event.pull_request.draft == false && contains(github.event.pull_request.labels.*.name, 'CI-xnft')
+    uses: ./.github/workflows/xnft.yml
+    secrets: inherit
     
   collator-selection:
     if: github.event.pull_request.draft == false && contains(github.event.pull_request.labels.*.name, 'CI-collator-selection')

--- a/.github/workflows/ci-master.yml
+++ b/.github/workflows/ci-master.yml
@@ -31,6 +31,10 @@
   xcm:
     uses: ./.github/workflows/xcm.yml
     secrets: inherit # pass all secrets from initial workflow to nested
+
+  xnft:
+    uses: ./.github/workflows/xnft.yml
+    secrets: inherit # pass all secrets from initial workflow to nested
     
   collator-selection:
     uses: ./.github/workflows/collator-selection.yml

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2567,15 +2567,15 @@
 
 [[package]]
 name = "data-encoding"
-version = "2.4.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2e66c9d817f1720209181c316d28635c050fa304f9c79e47a520882661b7308"
+checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5"
 
 [[package]]
 name = "data-encoding-macro"
-version = "0.1.13"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c904b33cc60130e1aeea4956ab803d08a3f4a0ca82d64ed757afac3891f2bb99"
+checksum = "20c01c06f5f429efdf2bae21eb67c28b3df3cf85b7dd2d8ef09c0838dac5d33e"
 dependencies = [
  "data-encoding",
  "data-encoding-macro-internal",
@@ -2583,9 +2583,9 @@
 
 [[package]]
 name = "data-encoding-macro-internal"
-version = "0.1.11"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fdf3fce3ce863539ec1d7fd1b6dcc3c645663376b43ed376bbf887733e4f772"
+checksum = "0047d07f2c89b17dd631c80450d69841a6b5d7fb17278cbc43d7e4cfcf2576f3"
 dependencies = [
  "data-encoding",
  "syn 1.0.109",
@@ -4678,21 +4678,21 @@
 
 [[package]]
 name = "if-addrs"
-version = "0.7.0"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbc0fa01ffc752e9dbc72818cdb072cd028b86be5e09dd04c5a643704fe101a9"
+checksum = "cabb0019d51a643781ff15c9c8a3e5dedc365c47211270f4e8f82812fedd8f0a"
 dependencies = [
  "libc",
- "winapi",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "if-watch"
-version = "3.1.0"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbb892e5777fe09e16f3d44de7802f4daa7267ecbe8c466f19d94e25bb0c303e"
+checksum = "d6b0422c86d7ce0e97169cc42e04ae643caf278874a7a3c87b8150a220dc7e1e"
 dependencies = [
- "async-io 1.13.0",
+ "async-io 2.2.0",
  "core-foundation",
  "fnv",
  "futures",
@@ -6557,7 +6557,6 @@
  "impl-trait-for-tuples",
  "log",
  "num_enum",
- "orml-tokens",
  "orml-traits",
  "orml-vesting",
  "orml-xcm-support",
@@ -6706,26 +6705,9 @@
 ]
 
 [[package]]
-name = "orml-tokens"
-version = "0.5.0-dev"
-source = "git+https://github.com/uniquenetwork/open-runtime-module-library?branch=unique-polkadot-v1.3.0#6f36a9e79b75421ac56b259fd47d03db6c3e1603"
-dependencies = [
- "frame-support",
- "frame-system",
- "log",
- "orml-traits",
- "parity-scale-codec",
- "scale-info",
- "serde",
- "sp-arithmetic",
- "sp-runtime",
- "sp-std",
-]
-
-[[package]]
 name = "orml-traits"
-version = "0.5.0-dev"
-source = "git+https://github.com/uniquenetwork/open-runtime-module-library?branch=unique-polkadot-v1.3.0#6f36a9e79b75421ac56b259fd47d03db6c3e1603"
+version = "0.6.1"
+source = "git+https://github.com/uniquenetwork/open-runtime-module-library?branch=unique-polkadot-v1.3.0#99604b000be6252597cfcb82eee82554f6a07a0e"
 dependencies = [
  "frame-support",
  "impl-trait-for-tuples",
@@ -6744,8 +6726,8 @@
 
 [[package]]
 name = "orml-utilities"
-version = "0.5.0-dev"
-source = "git+https://github.com/uniquenetwork/open-runtime-module-library?branch=unique-polkadot-v1.3.0#6f36a9e79b75421ac56b259fd47d03db6c3e1603"
+version = "0.6.1"
+source = "git+https://github.com/uniquenetwork/open-runtime-module-library?branch=unique-polkadot-v1.3.0#99604b000be6252597cfcb82eee82554f6a07a0e"
 dependencies = [
  "frame-support",
  "parity-scale-codec",
@@ -6759,8 +6741,8 @@
 
 [[package]]
 name = "orml-vesting"
-version = "0.5.0-dev"
-source = "git+https://github.com/uniquenetwork/open-runtime-module-library?branch=unique-polkadot-v1.3.0#6f36a9e79b75421ac56b259fd47d03db6c3e1603"
+version = "0.6.1"
+source = "git+https://github.com/uniquenetwork/open-runtime-module-library?branch=unique-polkadot-v1.3.0#99604b000be6252597cfcb82eee82554f6a07a0e"
 dependencies = [
  "frame-support",
  "frame-system",
@@ -6774,8 +6756,8 @@
 
 [[package]]
 name = "orml-xcm-support"
-version = "0.5.0-dev"
-source = "git+https://github.com/uniquenetwork/open-runtime-module-library?branch=unique-polkadot-v1.3.0#6f36a9e79b75421ac56b259fd47d03db6c3e1603"
+version = "0.6.1"
+source = "git+https://github.com/uniquenetwork/open-runtime-module-library?branch=unique-polkadot-v1.3.0#99604b000be6252597cfcb82eee82554f6a07a0e"
 dependencies = [
  "frame-support",
  "orml-traits",
@@ -6788,8 +6770,8 @@
 
 [[package]]
 name = "orml-xtokens"
-version = "0.5.0-dev"
-source = "git+https://github.com/uniquenetwork/open-runtime-module-library?branch=unique-polkadot-v1.3.0#6f36a9e79b75421ac56b259fd47d03db6c3e1603"
+version = "0.6.1"
+source = "git+https://github.com/uniquenetwork/open-runtime-module-library?branch=unique-polkadot-v1.3.0#99604b000be6252597cfcb82eee82554f6a07a0e"
 dependencies = [
  "cumulus-primitives-core",
  "frame-support",
@@ -7446,7 +7428,6 @@
  "frame-support",
  "frame-system",
  "log",
- "orml-tokens",
  "pallet-balances",
  "pallet-common",
  "pallet-fungible",
@@ -10150,7 +10131,6 @@
  "impl-trait-for-tuples",
  "log",
  "num_enum",
- "orml-tokens",
  "orml-traits",
  "orml-vesting",
  "orml-xcm-support",
@@ -13695,9 +13675,9 @@
 
 [[package]]
 name = "spinners"
-version = "4.1.0"
+version = "4.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08615eea740067d9899969bc2891c68a19c315cb1f66640af9a9ecb91b13bcab"
+checksum = "a0ef947f358b9c238923f764c72a4a9d42f2d637c46e059dbd319d6e7cfb4f82"
 dependencies = [
  "lazy_static",
  "maplit",
@@ -15028,7 +15008,6 @@
  "impl-trait-for-tuples",
  "log",
  "num_enum",
- "orml-tokens",
  "orml-traits",
  "orml-vesting",
  "orml-xcm-support",

--- a/Cargo.toml
+++ b/Cargo.toml
@@ -199,7 +199,6 @@
 try-runtime-cli = "0.35.0"
 
 # ORML
-orml-tokens = { default-features = false, git = "https://github.com/uniquenetwork/open-runtime-module-library", branch = "unique-polkadot-v1.3.0" }
 orml-traits = { default-features = false, git = "https://github.com/uniquenetwork/open-runtime-module-library", branch = "unique-polkadot-v1.3.0" }
 orml-vesting = { default-features = false, git = "https://github.com/uniquenetwork/open-runtime-module-library", branch = "unique-polkadot-v1.3.0" }
 orml-xcm-support = { default-features = false, git = "https://github.com/uniquenetwork/open-runtime-module-library", branch = "unique-polkadot-v1.3.0" }

--- a/js-packages/playgrounds/types.ts
+++ b/js-packages/playgrounds/types.ts
@@ -160,7 +160,7 @@
   External = 1,
   /// Supports ERC721Metadata
   Erc721metadata = 64,
-  /// Tokens in foreign collections can be transferred, but not burnt
+  /// A collection of foreign assets
   Foreign = 128,
 }
 

--- a/js-packages/playgrounds/types.xcm.ts
+++ b/js-packages/playgrounds/types.xcm.ts
@@ -27,10 +27,3 @@
     conviction: number,
   },
 }
-
-export interface IForeignAssetMetadata {
-  name?: number | Uint8Array,
-  symbol?: string,
-  decimals?: number,
-  minimalBalance?: bigint,
-}
\ No newline at end of file

--- a/js-packages/playgrounds/unique.xcm.ts
+++ b/js-packages/playgrounds/unique.xcm.ts
@@ -2,7 +2,7 @@
 import type {IKeyringPair} from '@polkadot/types/types';
 import {ChainHelperBase, EthereumBalanceGroup, HelperGroup, SubstrateBalanceGroup, UniqueHelper} from './unique.js';
 import type {ILogger, TSigner, TSubstrateAccount} from './types.js';
-import type {AcalaAssetMetadata, DemocracyStandardAccountVote, IForeignAssetMetadata, MoonbeamAssetInfo} from './types.xcm.js';
+import type {AcalaAssetMetadata, DemocracyStandardAccountVote, MoonbeamAssetInfo} from './types.xcm.js';
 
 
 export class XcmChainHelper extends ChainHelperBase {
@@ -104,22 +104,17 @@
 }
 
 export class ForeignAssetsGroup extends HelperGroup<UniqueHelper> {
-  async register(signer: TSigner, ownerAddress: TSubstrateAccount, location: any, metadata: IForeignAssetMetadata) {
+  async register(signer: TSigner, assetId: any, name: string, tokenPrefix: string, mode: 'NFT' | { Fungible: number }) {
     await this.helper.executeExtrinsic(
       signer,
-      'api.tx.foreignAssets.registerForeignAsset',
-      [ownerAddress, location, metadata],
+      'api.tx.foreignAssets.forceRegisterForeignAsset',
+      [{V3: assetId}, this.helper.util.str2vec(name), tokenPrefix, mode],
       true,
     );
   }
 
-  async update(signer: TSigner, foreignAssetId: number, location: any, metadata: IForeignAssetMetadata) {
-    await this.helper.executeExtrinsic(
-      signer,
-      'api.tx.foreignAssets.updateForeignAsset',
-      [foreignAssetId, location, metadata],
-      true,
-    );
+  async foreignCollectionId(assetId: any) {
+    return (await this.helper.callRpc('api.query.foreignAssets.foreignAssetToCollection', [assetId])).toJSON();
   }
 }
 
@@ -256,6 +251,10 @@
     await this.helper.executeExtrinsic(signer, 'api.tx.assets.mint', [assetId, beneficiary, amount], true);
   }
 
+  async assetInfo(assetId: number | bigint) {
+    return (await this.helper.callRpc('api.query.assets.asset', [assetId])).toJSON();
+  }
+
   async account(assetId: string | number | bigint, address: string) {
     const accountAsset = (
       await this.helper.callRpc('api.query.assets.account', [assetId, address])

--- a/js-packages/tests/eth/api/CollectionHelpers.sol
+++ b/js-packages/tests/eth/api/CollectionHelpers.sol
@@ -132,7 +132,7 @@
 type CollectionFlags is uint8;
 
 library CollectionFlagsLib {
-	/// Tokens in foreign collections can be transferred, but not burnt
+	/// A collection of foreign assets
 	CollectionFlags constant foreignField = CollectionFlags.wrap(128);
 	/// Supports ERC721Metadata
 	CollectionFlags constant erc721metadataField = CollectionFlags.wrap(64);

--- a/js-packages/tests/pallet-presence.test.ts
+++ b/js-packages/tests/pallet-presence.test.ts
@@ -47,7 +47,6 @@
   'nonfungible',
   'charging',
   'configuration',
-  'tokens',
   'xtokens',
   'maintenance',
 ];

--- a/js-packages/tests/xcm/xcm.types.ts
+++ b/js-packages/tests/xcm/xcm.types.ts
@@ -505,4 +505,27 @@
       await expectFailedToTransact(helper, messageSent);
     });
   }
+
+  async registerRelayNativeTokenOnUnique(alice: IKeyringPair) {
+    return await usingPlaygrounds(async (helper) => {
+      const relayLocation = {
+        parents: 1,
+        interior: 'Here',
+      };
+      const relayAssetId = {Concrete: relayLocation};
+
+      const relayCollectionId = await helper.foreignAssets.foreignCollectionId(relayAssetId);
+      if(relayCollectionId == null) {
+        const name = 'Relay Tokens';
+        const tokenPrefix = 'xDOT';
+        const decimals = 10;
+        await helper.getSudo().foreignAssets.register(alice, relayAssetId, name, tokenPrefix, {Fungible: decimals});
+
+        return await helper.foreignAssets.foreignCollectionId(relayAssetId);
+      } else {
+        console.log('Relay foreign collection is already registered');
+        return relayCollectionId;
+      }
+    });
+  }
 }

--- a/js-packages/tests/xcm/xcmOpal.test.ts
+++ b/js-packages/tests/xcm/xcmOpal.test.ts
@@ -17,6 +17,7 @@
 import type {IKeyringPair} from '@polkadot/types/types';
 import config from '../config.js';
 import {itSub, expect, describeXCM, usingPlaygrounds, usingWestmintPlaygrounds, usingRelayPlaygrounds} from '../util/index.js';
+import {XcmTestHelper} from './xcm.types.js';
 
 const STATEMINE_CHAIN = +(process.env.RELAY_WESTMINT_ID || 1000);
 const UNIQUE_CHAIN = +(process.env.RELAY_OPAL_ID || 2095);
@@ -25,11 +26,11 @@
 const westmintUrl = config.westmintUrl;
 
 const STATEMINE_PALLET_INSTANCE = 50;
-const ASSET_ID = 100;
-const ASSET_METADATA_DECIMALS = 18;
-const ASSET_METADATA_NAME = 'USDT';
-const ASSET_METADATA_DESCRIPTION = 'USDT';
-const ASSET_METADATA_MINIMAL_BALANCE = 1n;
+const USDT_ASSET_ID = 100;
+const USDT_ASSET_METADATA_DECIMALS = 18;
+const USDT_ASSET_METADATA_NAME = 'USDT';
+const USDT_ASSET_METADATA_DESCRIPTION = 'USDT';
+const USDT_ASSET_METADATA_MINIMAL_BALANCE = 1n;
 
 const RELAY_DECIMALS = 12;
 const WESTMINT_DECIMALS = 12;
@@ -37,7 +38,9 @@
 const TRANSFER_AMOUNT = 1_000_000_000_000_000_000n;
 
 // 10,000.00 (ten thousands) USDT
-const ASSET_AMOUNT = 1_000_000_000_000_000_000_000n;
+const USDT_ASSET_AMOUNT = 1_000_000_000_000_000_000_000n;
+
+const testHelper = new XcmTestHelper('opal');
 
 describeXCM('[XCM] Integration test: Exchanging USDT with Westmint', () => {
   let alice: IKeyringPair;
@@ -57,57 +60,85 @@
   let balanceBobRelayTokenBefore: bigint;
   let balanceBobRelayTokenAfter: bigint;
 
+  let usdtCollectionId: number;
+  let relayCollectionId: number;
 
   before(async () => {
     await usingPlaygrounds(async (_helper, privateKey) => {
       alice = await privateKey('//Alice');
       bob = await privateKey('//Bob'); // funds donor
+
+      relayCollectionId = await testHelper.registerRelayNativeTokenOnUnique(alice);
     });
 
     await usingWestmintPlaygrounds(westmintUrl, async (helper) => {
-      // 350.00 (three hundred fifty) DOT
-      const fundingAmount = 3_500_000_000_000n;
+      const assetInfo = await helper.assets.assetInfo(USDT_ASSET_ID);
+      if(assetInfo == null) {
+        await helper.assets.create(
+          alice,
+          USDT_ASSET_ID,
+          alice.address,
+          USDT_ASSET_METADATA_MINIMAL_BALANCE,
+        );
+        await helper.assets.setMetadata(
+          alice,
+          USDT_ASSET_ID,
+          USDT_ASSET_METADATA_NAME,
+          USDT_ASSET_METADATA_DESCRIPTION,
+          USDT_ASSET_METADATA_DECIMALS,
+        );
+      } else {
+        console.log('The USDT asset is already registered on AssetHub');
+      }
+
+      await helper.assets.mint(
+        alice,
+        USDT_ASSET_ID,
+        alice.address,
+        USDT_ASSET_AMOUNT,
+      );
 
-      await helper.assets.create(alice, ASSET_ID, alice.address, ASSET_METADATA_MINIMAL_BALANCE);
-      await helper.assets.setMetadata(alice, ASSET_ID, ASSET_METADATA_NAME, ASSET_METADATA_DESCRIPTION, ASSET_METADATA_DECIMALS);
-      await helper.assets.mint(alice, ASSET_ID, alice.address, ASSET_AMOUNT);
+      const sovereignFundingAmount = 3_500_000_000n;
 
       // funding parachain sovereing account (Parachain: 2095)
       const parachainSovereingAccount = helper.address.paraSiblingSovereignAccount(UNIQUE_CHAIN);
-      await helper.balance.transferToSubstrate(bob, parachainSovereingAccount, fundingAmount);
+      await helper.balance.transferToSubstrate(bob, parachainSovereingAccount, sovereignFundingAmount);
     });
-
 
     await usingPlaygrounds(async (helper) => {
       const location = {
-        V2: {
-          parents: 1,
-          interior: {X3: [
-            {
-              Parachain: STATEMINE_CHAIN,
-            },
-            {
-              PalletInstance: STATEMINE_PALLET_INSTANCE,
-            },
-            {
-              GeneralIndex: ASSET_ID,
-            },
-          ]},
-        },
+        parents: 1,
+        interior: {X3: [
+          {
+            Parachain: STATEMINE_CHAIN,
+          },
+          {
+            PalletInstance: STATEMINE_PALLET_INSTANCE,
+          },
+          {
+            GeneralIndex: USDT_ASSET_ID,
+          },
+        ]},
       };
+      const assetId = {Concrete: location};
 
-      const metadata =
-      {
-        name: ASSET_ID,
-        symbol: ASSET_METADATA_NAME,
-        decimals: ASSET_METADATA_DECIMALS,
-        minimalBalance: ASSET_METADATA_MINIMAL_BALANCE,
-      };
-      await helper.getSudo().foreignAssets.register(alice, alice.address, location, metadata);
+      if(await helper.foreignAssets.foreignCollectionId(assetId) == null) {
+        const tokenPrefix = USDT_ASSET_METADATA_NAME;
+        await helper.getSudo().foreignAssets.register(
+          alice,
+          assetId,
+          USDT_ASSET_METADATA_NAME,
+          tokenPrefix,
+          {Fungible: USDT_ASSET_METADATA_DECIMALS},
+        );
+      } else {
+        console.log('Foreign collection is already registered on Opal');
+      }
+
       balanceOpalBefore = await helper.balance.getSubstrate(alice.address);
+      usdtCollectionId = await helper.foreignAssets.foreignCollectionId(assetId);
     });
 
-
     // Providing the relay currency to the unique sender account
     await usingRelayPlaygrounds(relayUrl, async (helper) => {
       const destination = {
@@ -189,7 +220,7 @@
                       PalletInstance: STATEMINE_PALLET_INSTANCE,
                     },
                     {
-                      GeneralIndex: ASSET_ID,
+                      GeneralIndex: USDT_ASSET_ID,
                     },
                   ]},
               },
@@ -216,19 +247,17 @@
       expect(balanceStmnBefore > balanceStmnAfter).to.be.true;
 
     });
-
 
     // ensure that asset has been delivered
     await helper.wait.newBlocks(3);
 
-    // expext collection id will be with id 1
-    const free = await helper.ft.getBalance(1, {Substrate: alice.address});
+    const free = await helper.ft.getBalance(usdtCollectionId, {Substrate: alice.address});
 
     balanceOpalAfter = await helper.balance.getSubstrate(alice.address);
 
     console.log(
       '[Westmint -> Opal] transaction fees on Opal: %s USDT',
-      helper.util.bigIntToDecimals(TRANSFER_AMOUNT - free, ASSET_METADATA_DECIMALS),
+      helper.util.bigIntToDecimals(TRANSFER_AMOUNT - free, USDT_ASSET_METADATA_DECIMALS),
     );
     console.log(
       '[Westmint -> Opal] transaction fees on Opal: %s OPL',
@@ -261,16 +290,11 @@
 
     const currencies: [any, bigint][] = [
       [
-        {
-          ForeignAssetId: 0,
-        },
-        //10_000_000_000_000_000n,
+        usdtCollectionId,
         TRANSFER_AMOUNT,
       ],
       [
-        {
-          NativeAssetId: 'Parent',
-        },
+        relayCollectionId,
         400_000_000_000_000n,
       ],
     ];
@@ -288,7 +312,7 @@
 
       // The USDT token never paid fees. Its amount not changed from begin value.
       // Also check that xcm transfer has been succeeded
-      expect((await helper.assets.account(ASSET_ID, alice.address))! == ASSET_AMOUNT).to.be.true;
+      expect((await helper.assets.account(USDT_ASSET_ID, alice.address))! == USDT_ASSET_AMOUNT).to.be.true;
     });
   });
 
@@ -296,7 +320,7 @@
     const TRANSFER_AMOUNT_RELAY = 50_000_000_000_000_000n;
 
     balanceBobBefore = await helper.balance.getSubstrate(bob.address);
-    balanceBobRelayTokenBefore = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});
+    balanceBobRelayTokenBefore = await helper.ft.getBalance(relayCollectionId, {Substrate: bob.address});
 
     // Providing the relay currency to the unique sender account
     await usingRelayPlaygrounds(relayUrl, async (helper) => {
@@ -345,7 +369,7 @@
     await helper.wait.newBlocks(3);
 
     balanceBobAfter = await helper.balance.getSubstrate(bob.address);
-    balanceBobRelayTokenAfter = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});
+    balanceBobRelayTokenAfter = await helper.ft.getBalance(relayCollectionId, {Substrate: bob.address});
 
     const wndFee = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;
     console.log(
@@ -383,9 +407,7 @@
 
     const currencies: any = [
       [
-        {
-          NativeAssetId: 'Parent',
-        },
+        relayCollectionId,
         50_000_000_000_000_000n,
       ],
     ];

--- a/js-packages/tests/xcm/xcmQuartz.test.ts
+++ b/js-packages/tests/xcm/xcmQuartz.test.ts
@@ -19,9 +19,8 @@
 import {DevUniqueHelper, Event} from '@unique/playgrounds/unique.dev.js';
 import {STATEMINE_CHAIN, QUARTZ_CHAIN, KARURA_CHAIN, MOONRIVER_CHAIN, SHIDEN_CHAIN, STATEMINE_DECIMALS, KARURA_DECIMALS, QTZ_DECIMALS, RELAY_DECIMALS, SHIDEN_DECIMALS, karuraUrl, moonriverUrl, relayUrl, shidenUrl, statemineUrl} from './xcm.types.js';
 import {hexToString} from '@polkadot/util';
-
+import {XcmTestHelper} from './xcm.types.js';
 
-
 const STATEMINE_PALLET_INSTANCE = 50;
 
 const TRANSFER_AMOUNT = 2000000000000000000000000n;
@@ -39,6 +38,8 @@
 
 const SAFE_XCM_VERSION = 2;
 
+const testHelper = new XcmTestHelper('quartz');
+
 describeXCM('[XCM] Integration test: Exchanging USDT with Statemine', () => {
   let alice: IKeyringPair;
   let bob: IKeyringPair;
@@ -57,6 +58,8 @@
   let balanceBobRelayTokenBefore: bigint;
   let balanceBobRelayTokenAfter: bigint;
 
+  let usdtCollectionId: number;
+  let relayCollectionId: number;
 
   before(async () => {
     await usingPlaygrounds(async (helper, privateKey) => {
@@ -65,6 +68,8 @@
 
       // Set the default version to wrap the first message to other chains.
       await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);
+
+      relayCollectionId = await testHelper.registerRelayNativeTokenOnUnique(alice);
     });
 
     await usingRelayPlaygrounds(relayUrl, async (helper) => {
@@ -74,21 +79,25 @@
     });
 
     await usingStateminePlaygrounds(statemineUrl, async (helper) => {
-      const sovereignFundingAmount = 3_500_000_000n;
+      const assetInfo = await helper.assets.assetInfo(USDT_ASSET_ID);
+      if(assetInfo == null) {
+        await helper.assets.create(
+          alice,
+          USDT_ASSET_ID,
+          alice.address,
+          USDT_ASSET_METADATA_MINIMAL_BALANCE,
+        );
+        await helper.assets.setMetadata(
+          alice,
+          USDT_ASSET_ID,
+          USDT_ASSET_METADATA_NAME,
+          USDT_ASSET_METADATA_DESCRIPTION,
+          USDT_ASSET_METADATA_DECIMALS,
+        );
+      } else {
+        console.log('The USDT asset is already registered on AssetHub');
+      }
 
-      await helper.assets.create(
-        alice,
-        USDT_ASSET_ID,
-        alice.address,
-        USDT_ASSET_METADATA_MINIMAL_BALANCE,
-      );
-      await helper.assets.setMetadata(
-        alice,
-        USDT_ASSET_ID,
-        USDT_ASSET_METADATA_NAME,
-        USDT_ASSET_METADATA_DESCRIPTION,
-        USDT_ASSET_METADATA_DECIMALS,
-      );
       await helper.assets.mint(
         alice,
         USDT_ASSET_ID,
@@ -96,6 +105,8 @@
         USDT_ASSET_AMOUNT,
       );
 
+      const sovereignFundingAmount = 3_500_000_000n;
+
       // funding parachain sovereing account on Statemine(t).
       // The sovereign account should be created before any action
       // (the assets pallet on Statemine(t) check if the sovereign account exists)
@@ -106,31 +117,30 @@
 
     await usingPlaygrounds(async (helper) => {
       const location = {
-        V2: {
-          parents: 1,
-          interior: {X3: [
-            {
-              Parachain: STATEMINE_CHAIN,
-            },
-            {
-              PalletInstance: STATEMINE_PALLET_INSTANCE,
-            },
-            {
-              GeneralIndex: USDT_ASSET_ID,
-            },
-          ]},
-        },
+        parents: 1,
+        interior: {X3: [
+          {
+            Parachain: STATEMINE_CHAIN,
+          },
+          {
+            PalletInstance: STATEMINE_PALLET_INSTANCE,
+          },
+          {
+            GeneralIndex: USDT_ASSET_ID,
+          },
+        ]},
       };
+      const assetId = {Concrete: location};
 
-      const metadata =
-      {
-        name: USDT_ASSET_ID,
-        symbol: USDT_ASSET_METADATA_NAME,
-        decimals: USDT_ASSET_METADATA_DECIMALS,
-        minimalBalance: USDT_ASSET_METADATA_MINIMAL_BALANCE,
-      };
-      await helper.getSudo().foreignAssets.register(alice, alice.address, location, metadata);
+      if(await helper.foreignAssets.foreignCollectionId(assetId) == null) {
+        const tokenPrefix = USDT_ASSET_METADATA_NAME;
+        await helper.getSudo().foreignAssets.register(alice, assetId, USDT_ASSET_METADATA_NAME, tokenPrefix, {Fungible: USDT_ASSET_METADATA_DECIMALS});
+      } else {
+        console.log('Foreign collection is already registered on Quartz');
+      }
+
       balanceQuartzBefore = await helper.balance.getSubstrate(alice.address);
+      usdtCollectionId = await helper.foreignAssets.foreignCollectionId(assetId);
     });
 
 
@@ -248,8 +258,7 @@
     // ensure that asset has been delivered
     await helper.wait.newBlocks(3);
 
-    // expext collection id will be with id 1
-    const free = await helper.ft.getBalance(1, {Substrate: alice.address});
+    const free = await helper.ft.getBalance(usdtCollectionId, {Substrate: alice.address});
 
     balanceQuartzAfter = await helper.balance.getSubstrate(alice.address);
 
@@ -288,15 +297,11 @@
     const relayFee = 400_000_000_000_000n;
     const currencies: [any, bigint][] = [
       [
-        {
-          ForeignAssetId: 0,
-        },
+        usdtCollectionId,
         TRANSFER_AMOUNT,
       ],
       [
-        {
-          NativeAssetId: 'Parent',
-        },
+        relayCollectionId,
         relayFee,
       ],
     ];
@@ -321,7 +326,7 @@
 
   itSub('Should connect and send Relay token to Quartz', async ({helper}) => {
     balanceBobBefore = await helper.balance.getSubstrate(bob.address);
-    balanceBobRelayTokenBefore = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});
+    balanceBobRelayTokenBefore = await helper.ft.getBalance(relayCollectionId, {Substrate: bob.address});
 
     await usingRelayPlaygrounds(relayUrl, async (helper) => {
       const destination = {
@@ -369,7 +374,7 @@
     await helper.wait.newBlocks(3);
 
     balanceBobAfter = await helper.balance.getSubstrate(bob.address);
-    balanceBobRelayTokenAfter = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});
+    balanceBobRelayTokenAfter = await helper.ft.getBalance(relayCollectionId, {Substrate: bob.address});
 
     const wndFeeOnQuartz = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;
     const wndDiffOnQuartz = balanceBobRelayTokenAfter - balanceBobRelayTokenBefore;
@@ -409,9 +414,7 @@
 
     const currencies: any = [
       [
-        {
-          NativeAssetId: 'Parent',
-        },
+        relayCollectionId,
         TRANSFER_AMOUNT_RELAY,
       ],
     ];
@@ -1018,9 +1021,7 @@
   });
 
   itSub('Should connect and send QTZ to Moonriver', async ({helper}) => {
-    const currencyId = {
-      NativeAssetId: 'Here',
-    };
+    const currencyId = 0;
     const dest = {
       V2: {
         parents: 1,

--- a/js-packages/tests/xcm/xcmUnique.test.ts
+++ b/js-packages/tests/xcm/xcmUnique.test.ts
@@ -20,7 +20,7 @@
 import {Event} from '@unique/playgrounds/unique.dev.js';
 import {hexToString, nToBigInt} from '@polkadot/util';
 import {ACALA_CHAIN, ASTAR_CHAIN, MOONBEAM_CHAIN, POLKADEX_CHAIN, SAFE_XCM_VERSION, STATEMINT_CHAIN, UNIQUE_CHAIN, expectFailedToTransact, expectUntrustedReserveLocationFail, uniqueAssetId, uniqueVersionedMultilocation} from './xcm.types.js';
-
+import {XcmTestHelper} from './xcm.types.js';
 
 const STATEMINT_PALLET_INSTANCE = 50;
 
@@ -50,6 +50,8 @@
 const USDT_ASSET_METADATA_MINIMAL_BALANCE = 1n;
 const USDT_ASSET_AMOUNT = 10_000_000_000_000_000_000_000_000n;
 
+const testHelper = new XcmTestHelper('unique');
+
 describeXCM('[XCM] Integration test: Exchanging USDT with Statemint', () => {
   let alice: IKeyringPair;
   let bob: IKeyringPair;
@@ -68,6 +70,8 @@
   let balanceBobRelayTokenBefore: bigint;
   let balanceBobRelayTokenAfter: bigint;
 
+  let usdtCollectionId: number;
+  let relayCollectionId: number;
 
   before(async () => {
     await usingPlaygrounds(async (helper, privateKey) => {
@@ -76,6 +80,8 @@
 
       // Set the default version to wrap the first message to other chains.
       await helper.getSudo().xcm.setSafeXcmVersion(alice, SAFE_XCM_VERSION);
+
+      relayCollectionId = await testHelper.registerRelayNativeTokenOnUnique(alice);
     });
 
     await usingRelayPlaygrounds(relayUrl, async (helper) => {
@@ -85,21 +91,25 @@
     });
 
     await usingStatemintPlaygrounds(statemintUrl, async (helper) => {
-      const sovereignFundingAmount = 3_500_000_000n;
+      const assetInfo = await helper.assets.assetInfo(USDT_ASSET_ID);
+      if(assetInfo == null) {
+        await helper.assets.create(
+          alice,
+          USDT_ASSET_ID,
+          alice.address,
+          USDT_ASSET_METADATA_MINIMAL_BALANCE,
+        );
+        await helper.assets.setMetadata(
+          alice,
+          USDT_ASSET_ID,
+          USDT_ASSET_METADATA_NAME,
+          USDT_ASSET_METADATA_DESCRIPTION,
+          USDT_ASSET_METADATA_DECIMALS,
+        );
+      } else {
+        console.log('The USDT asset is already registered on AssetHub');
+      }
 
-      await helper.assets.create(
-        alice,
-        USDT_ASSET_ID,
-        alice.address,
-        USDT_ASSET_METADATA_MINIMAL_BALANCE,
-      );
-      await helper.assets.setMetadata(
-        alice,
-        USDT_ASSET_ID,
-        USDT_ASSET_METADATA_NAME,
-        USDT_ASSET_METADATA_DESCRIPTION,
-        USDT_ASSET_METADATA_DECIMALS,
-      );
       await helper.assets.mint(
         alice,
         USDT_ASSET_ID,
@@ -107,6 +117,8 @@
         USDT_ASSET_AMOUNT,
       );
 
+      const sovereignFundingAmount = 3_500_000_000n;
+
       // funding parachain sovereing account on Statemint.
       // The sovereign account should be created before any action
       // (the assets pallet on Statemint check if the sovereign account exists)
@@ -117,31 +129,30 @@
 
     await usingPlaygrounds(async (helper) => {
       const location = {
-        V2: {
-          parents: 1,
-          interior: {X3: [
-            {
-              Parachain: STATEMINT_CHAIN,
-            },
-            {
-              PalletInstance: STATEMINT_PALLET_INSTANCE,
-            },
-            {
-              GeneralIndex: USDT_ASSET_ID,
-            },
-          ]},
-        },
+        parents: 1,
+        interior: {X3: [
+          {
+            Parachain: STATEMINT_CHAIN,
+          },
+          {
+            PalletInstance: STATEMINT_PALLET_INSTANCE,
+          },
+          {
+            GeneralIndex: USDT_ASSET_ID,
+          },
+        ]},
       };
+      const assetId = {Concrete: location};
 
-      const metadata =
-      {
-        name: USDT_ASSET_ID,
-        symbol: USDT_ASSET_METADATA_NAME,
-        decimals: USDT_ASSET_METADATA_DECIMALS,
-        minimalBalance: USDT_ASSET_METADATA_MINIMAL_BALANCE,
-      };
-      await helper.getSudo().foreignAssets.register(alice, alice.address, location, metadata);
+      if(await helper.foreignAssets.foreignCollectionId(assetId) == null) {
+        const tokenPrefix = USDT_ASSET_METADATA_NAME;
+        await helper.getSudo().foreignAssets.register(alice, assetId, USDT_ASSET_METADATA_NAME, tokenPrefix, {Fungible: USDT_ASSET_METADATA_DECIMALS});
+      } else {
+        console.log('Foreign collection is already registered on Unique');
+      }
+
       balanceUniqueBefore = await helper.balance.getSubstrate(alice.address);
+      usdtCollectionId = await helper.foreignAssets.foreignCollectionId(assetId);
     });
 
 
@@ -259,8 +270,7 @@
     // ensure that asset has been delivered
     await helper.wait.newBlocks(3);
 
-    // expext collection id will be with id 1
-    const free = await helper.ft.getBalance(1, {Substrate: alice.address});
+    const free = await helper.ft.getBalance(usdtCollectionId, {Substrate: alice.address});
 
     balanceUniqueAfter = await helper.balance.getSubstrate(alice.address);
 
@@ -299,15 +309,11 @@
     const relayFee = 400_000_000_000_000n;
     const currencies: [any, bigint][] = [
       [
-        {
-          ForeignAssetId: 0,
-        },
+        usdtCollectionId,
         TRANSFER_AMOUNT,
       ],
       [
-        {
-          NativeAssetId: 'Parent',
-        },
+        relayCollectionId,
         relayFee,
       ],
     ];
@@ -332,7 +338,7 @@
 
   itSub('Should connect and send Relay token to Unique', async ({helper}) => {
     balanceBobBefore = await helper.balance.getSubstrate(bob.address);
-    balanceBobRelayTokenBefore = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});
+    balanceBobRelayTokenBefore = await helper.ft.getBalance(relayCollectionId, {Substrate: bob.address});
 
     await usingRelayPlaygrounds(relayUrl, async (helper) => {
       const destination = {
@@ -380,7 +386,7 @@
     await helper.wait.newBlocks(3);
 
     balanceBobAfter = await helper.balance.getSubstrate(bob.address);
-    balanceBobRelayTokenAfter = await helper.tokens.accounts(bob.address, {NativeAssetId: 'Parent'});
+    balanceBobRelayTokenAfter = await helper.ft.getBalance(relayCollectionId, {Substrate: bob.address});
 
     const wndFeeOnUnique = balanceBobRelayTokenAfter - TRANSFER_AMOUNT_RELAY - balanceBobRelayTokenBefore;
     const wndDiffOnUnique = balanceBobRelayTokenAfter - balanceBobRelayTokenBefore;
@@ -420,9 +426,7 @@
 
     const currencies: any = [
       [
-        {
-          NativeAssetId: 'Parent',
-        },
+        relayCollectionId,
         TRANSFER_AMOUNT_RELAY,
       ],
     ];
@@ -1275,9 +1279,7 @@
   });
 
   itSub('Should connect and send UNQ to Moonbeam', async ({helper}) => {
-    const currencyId = {
-      NativeAssetId: 'Here',
-    };
+    const currencyId = 0;
     const dest = {
       V2: {
         parents: 1,

--- a/node/cli/src/chain_spec.rs
+++ b/node/cli/src/chain_spec.rs
@@ -167,7 +167,6 @@
 					.map(|k| (k, 1 << 100))
 					.collect(),
 			},
-			tokens: TokensConfig { balances: vec![] },
 			sudo: SudoConfig {
 				key: Some($root_key),
 			},
@@ -231,7 +230,6 @@
 					.map(|k| (k, 1 << 100))
 					.collect(),
 			},
-			tokens: TokensConfig { balances: vec![] },
 			sudo: SudoConfig {
 				key: Some($root_key),
 			},

--- a/pallets/balances-adapter/src/common.rs
+++ b/pallets/balances-adapter/src/common.rs
@@ -1,10 +1,16 @@
 use alloc::{vec, vec::Vec};
 use core::marker::PhantomData;
 
-use frame_support::{ensure, fail, weights::Weight};
+use frame_support::{
+	ensure, fail,
+	traits::tokens::{fungible::Mutate, Fortitude, Precision},
+	weights::Weight,
+};
 use pallet_balances::{weights::SubstrateWeight as BalancesWeight, WeightInfo};
-use pallet_common::{CommonCollectionOperations, CommonWeightInfo, Error as CommonError};
-use up_data_structs::TokenId;
+use pallet_common::{
+	erc::CrossAccountId, CommonCollectionOperations, CommonWeightInfo, Error as CommonError,
+};
+use up_data_structs::{budget::Budget, TokenId};
 
 use crate::{Config, NativeFungibleHandle, Pallet};
 
@@ -332,8 +338,8 @@
 		0
 	}
 
-	fn refungible_extensions(&self) -> Option<&dyn pallet_common::RefungibleExtensions<T>> {
-		None
+	fn xcm_extensions(&self) -> Option<&dyn pallet_common::XcmExtensions<T>> {
+		Some(self)
 	}
 
 	fn set_allowance_for_all(
@@ -360,3 +366,72 @@
 		fail!(<CommonError<T>>::UnsupportedOperation);
 	}
 }
+
+impl<T: Config> pallet_common::XcmExtensions<T> for NativeFungibleHandle<T> {
+	fn create_item_internal(
+		&self,
+		_depositor: &<T>::CrossAccountId,
+		to: <T>::CrossAccountId,
+		data: up_data_structs::CreateItemData,
+		_nesting_budget: &dyn Budget,
+	) -> Result<TokenId, sp_runtime::DispatchError> {
+		match &data {
+			up_data_structs::CreateItemData::Fungible(fungible_data) => {
+				T::Mutate::mint_into(
+					to.as_sub(),
+					fungible_data
+						.value
+						.try_into()
+						.map_err(|_| sp_runtime::ArithmeticError::Overflow)?,
+				)?;
+
+				Ok(TokenId::default())
+			}
+			_ => {
+				fail!(<CommonError<T>>::NotFungibleDataUsedToMintFungibleCollectionToken)
+			}
+		}
+	}
+
+	fn transfer_item_internal(
+		&self,
+		_depositor: &<T>::CrossAccountId,
+		from: &<T>::CrossAccountId,
+		to: &<T>::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+		_nesting_budget: &dyn Budget,
+	) -> sp_runtime::DispatchResult {
+		ensure!(
+			token == TokenId::default(),
+			<CommonError<T>>::FungibleItemsHaveNoId
+		);
+
+		<Pallet<T>>::transfer(from, to, amount)
+			.map(|_| ())
+			.map_err(|post_info| post_info.error)
+	}
+
+	fn burn_item_internal(
+		&self,
+		from: T::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+	) -> sp_runtime::DispatchResult {
+		ensure!(
+			token == TokenId::default(),
+			<CommonError<T>>::FungibleItemsHaveNoId
+		);
+
+		T::Mutate::burn_from(
+			from.as_sub(),
+			amount
+				.try_into()
+				.map_err(|_| sp_runtime::ArithmeticError::Overflow)?,
+			Precision::Exact,
+			Fortitude::Polite,
+		)?;
+
+		Ok(())
+	}
+}

--- a/pallets/common/src/benchmarking.rs
+++ b/pallets/common/src/benchmarking.rs
@@ -33,7 +33,7 @@
 	MAX_COLLECTION_NAME_LENGTH, MAX_PROPERTIES_PER_ITEM, MAX_TOKEN_PREFIX_LENGTH,
 };
 
-use crate::{BenchmarkPropertyWriter, CollectionHandle, Config, Pallet};
+use crate::{BenchmarkPropertyWriter, CollectionHandle, CollectionIssuer, Config, Pallet};
 
 const SEED: u32 = 1;
 
@@ -120,7 +120,9 @@
 	create_collection_raw(
 		owner,
 		CollectionMode::NFT,
-		|owner: T::CrossAccountId, data| <Pallet<T>>::init_collection(owner.clone(), owner, data),
+		|owner: T::CrossAccountId, data| {
+			<Pallet<T>>::init_collection(owner.clone(), CollectionIssuer::User(owner), data)
+		},
 		|h| h,
 	)
 }

--- a/pallets/common/src/dispatch.rs
+++ b/pallets/common/src/dispatch.rs
@@ -11,7 +11,7 @@
 use sp_weights::Weight;
 use up_data_structs::{CollectionId, CreateCollectionData};
 
-use crate::{pallet::Config, CommonCollectionOperations};
+use crate::{pallet::Config, CollectionIssuer, CommonCollectionOperations};
 
 // TODO: move to benchmarking
 /// Price of [`dispatch_tx`] call with noop `call` argument
@@ -69,13 +69,14 @@
 	/// Check if the collection is internal.
 	fn check_is_internal(&self) -> DispatchResult;
 
-	/// Create a collection. The collection will be created according to the value of [`data.mode`](CreateCollectionData::mode).
+	/// Create a regular collection. The collection will be created according to the value of [`data.mode`](CreateCollectionData::mode).
 	///
 	/// * `sender` - The user who will become the owner of the collection.
+	/// * `issuer` - An entity that creates the collection.
 	/// * `data` - Description of the created collection.
 	fn create(
 		sender: T::CrossAccountId,
-		payer: T::CrossAccountId,
+		issuer: CollectionIssuer<T::CrossAccountId>,
 		data: CreateCollectionData<T::CrossAccountId>,
 	) -> Result<CollectionId, DispatchError>;
 

--- a/pallets/common/src/lib.rs
+++ b/pallets/common/src/lib.rs
@@ -80,15 +80,16 @@
 use sp_std::vec::Vec;
 use sp_weights::Weight;
 use up_data_structs::{
-	budget::Budget, AccessMode, Collection, CollectionId, CollectionLimits, CollectionMode,
-	CollectionPermissions, CollectionProperties as CollectionPropertiesT, CollectionStats,
-	CreateCollectionData, CreateItemData, CreateItemExData, PhantomType, PropertiesError,
-	PropertiesPermissionMap, Property, PropertyKey, PropertyKeyPermission, PropertyPermission,
-	PropertyScope, PropertyValue, RpcCollection, RpcCollectionFlags, SponsoringRateLimit,
-	SponsorshipState, TokenChild, TokenData, TokenId, TokenOwnerError, TokenProperties,
-	TrySetProperty, COLLECTION_ADMINS_LIMIT, COLLECTION_NUMBER_LIMIT, CUSTOM_DATA_LIMIT,
-	FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP,
-	MAX_TOKEN_PREFIX_LENGTH, NFT_SPONSOR_TRANSFER_TIMEOUT, REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
+	budget::Budget, mapping::TokenAddressMapping, AccessMode, Collection, CollectionId,
+	CollectionLimits, CollectionMode, CollectionPermissions,
+	CollectionProperties as CollectionPropertiesT, CollectionStats, CreateCollectionData,
+	CreateItemData, CreateItemExData, PhantomType, PropertiesError, PropertiesPermissionMap,
+	Property, PropertyKey, PropertyKeyPermission, PropertyPermission, PropertyScope, PropertyValue,
+	RpcCollection, RpcCollectionFlags, SponsoringRateLimit, SponsorshipState, TokenChild,
+	TokenData, TokenId, TokenOwnerError, TokenProperties, TrySetProperty, COLLECTION_ADMINS_LIMIT,
+	COLLECTION_NUMBER_LIMIT, CUSTOM_DATA_LIMIT, FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
+	MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_TOKEN_PREFIX_LENGTH,
+	NFT_SPONSOR_TRANSFER_TIMEOUT, REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
 };
 use up_pov_estimate_rpc::PovInfo;
 
@@ -786,6 +787,9 @@
 
 		/// Fungible tokens hold no ID, and the default value of TokenId for a fungible collection is 0.
 		FungibleItemsHaveNoId,
+
+		/// Not Fungible item data used to mint in Fungible collection.
+		NotFungibleDataUsedToMintFungibleCollectionToken,
 	}
 
 	/// Storage of the count of created collections. Essentially contains the last collection ID.
@@ -940,6 +944,15 @@
 	}
 }
 
+/// An issuer of a collection.
+pub enum CollectionIssuer<CrossAccountId> {
+	/// A user who creates the collection.
+	User(CrossAccountId),
+
+	/// The internal mechanisms are creating the collection.
+	Internals,
+}
+
 fn check_token_permissions<T: Config>(
 	collection_admin_permitted: bool,
 	token_owner_permitted: bool,
@@ -1124,33 +1137,36 @@
 	/// Create new collection.
 	///
 	/// * `owner` - The owner of the collection.
-	/// * `data` - Description of the created collection.
-	/// * `flags` - Extra flags to store.
+	/// * `issuer` - An entity that creates the collection.
+	/// * `is_special_collection` -- Whether this collection is a special one, i.e. can have special flags set.
 	pub fn init_collection(
 		owner: T::CrossAccountId,
-		payer: T::CrossAccountId,
+		issuer: CollectionIssuer<T::CrossAccountId>,
 		data: CreateCollectionData<T::CrossAccountId>,
 	) -> Result<CollectionId, DispatchError> {
-		ensure!(data.flags.is_allowed_for_user(), <Error<T>>::NoPermission);
-		Self::init_collection_internal(owner, payer, data)
-	}
+		match issuer {
+			CollectionIssuer::User(payer) => {
+				ensure!(data.flags.is_allowed_for_user(), <Error<T>>::NoPermission);
+
+				// Take a (non-refundable) deposit of collection creation
+				let mut imbalance = <Debt<T::AccountId, <T as Config>::Currency>>::zero();
+				imbalance.subsume(<T as Config>::Currency::deposit(
+					&T::TreasuryAccountId::get(),
+					T::CollectionCreationPrice::get(),
+					Precision::Exact,
+				)?);
+				let credit = <T as Config>::Currency::settle(
+					payer.as_sub(),
+					imbalance,
+					Preservation::Preserve,
+				)
+				.map_err(|_| Error::<T>::NotSufficientFounds)?;
 
-	/// Initializes the collection with ForeignCollection flag. Returns [CollectionId] on success, [DispatchError] otherwise.
-	pub fn init_foreign_collection(
-		owner: T::CrossAccountId,
-		payer: T::CrossAccountId,
-		mut data: CreateCollectionData<T::CrossAccountId>,
-	) -> Result<CollectionId, DispatchError> {
-		data.flags.foreign = true;
-		let id = Self::init_collection_internal(owner, payer, data)?;
-		Ok(id)
-	}
+				debug_assert!(credit.peek().is_zero());
+			}
+			CollectionIssuer::Internals => {}
+		}
 
-	fn init_collection_internal(
-		owner: T::CrossAccountId,
-		payer: T::CrossAccountId,
-		data: CreateCollectionData<T::CrossAccountId>,
-	) -> Result<CollectionId, DispatchError> {
 		{
 			ensure!(
 				data.token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH as usize,
@@ -1225,21 +1241,6 @@
 		);
 		<AdminAmount<T>>::insert(id, admin_amount);
 
-		// Take a (non-refundable) deposit of collection creation
-		{
-			let mut imbalance = <Debt<T::AccountId, <T as Config>::Currency>>::zero();
-			imbalance.subsume(<T as Config>::Currency::deposit(
-				&T::TreasuryAccountId::get(),
-				T::CollectionCreationPrice::get(),
-				Precision::Exact,
-			)?);
-			let credit =
-				<T as Config>::Currency::settle(payer.as_sub(), imbalance, Preservation::Preserve)
-					.map_err(|_| Error::<T>::NotSufficientFounds)?;
-
-			debug_assert!(credit.peek().is_zero())
-		}
-
 		<CreatedCollectionCount<T>>::put(created_count);
 		<Pallet<T>>::deposit_event(Event::CollectionCreated(
 			id,
@@ -2293,7 +2294,14 @@
 	) -> u128;
 
 	/// Get extension for RFT collection.
-	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>>;
+	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {
+		None
+	}
+
+	/// Get XCM extensions.
+	fn xcm_extensions(&self) -> Option<&dyn XcmExtensions<T>> {
+		None
+	}
 
 	/// The `operator` is allowed to transfer all tokens of the `owner` on their behalf.
 	/// * `owner` - Token owner
@@ -2333,6 +2341,117 @@
 	) -> DispatchResultWithPostInfo;
 }
 
+/// XCM extensions for fungible and NFT collections
+pub trait XcmExtensions<T>
+where
+	T: Config,
+{
+	/// Does the token have children?
+	fn token_has_children(&self, _token: TokenId) -> bool {
+		false
+	}
+
+	/// Create a collection's item using a transaction.
+	///
+	/// This function performs additional XCM-related checks before the actual creation.
+	///
+	/// The `transactional` attribute is needed because the inbound XCM messages
+	/// are processed in a non-transactional context.
+	/// To perform the needed logic, we use the internal pallets' functions
+	/// that are not inherently safe to use outside a transaction.
+	///
+	/// This requirement is temporary until XCM message processing becomes transactional:
+	/// https://github.com/paritytech/polkadot-sdk/issues/490
+	#[transactional]
+	fn create_item(
+		&self,
+		depositor: &T::CrossAccountId,
+		to: T::CrossAccountId,
+		data: CreateItemData,
+		nesting_budget: &dyn Budget,
+	) -> Result<TokenId, DispatchError> {
+		if T::CrossTokenAddressMapping::is_token_address(&to) {
+			return unsupported!(T);
+		}
+
+		self.create_item_internal(depositor, to, data, nesting_budget)
+	}
+
+	/// Create a collection's item.
+	fn create_item_internal(
+		&self,
+		depositor: &T::CrossAccountId,
+		to: T::CrossAccountId,
+		data: CreateItemData,
+		nesting_budget: &dyn Budget,
+	) -> Result<TokenId, DispatchError>;
+
+	/// Transfer an item from the `from` account to the `to` account using a transaction.
+	///
+	/// This function performs additional XCM-related checks before the actual transfer.
+	///
+	/// The `transactional` attribute is needed because the inbound XCM messages
+	/// are processed in a non-transactional context.
+	/// To perform the needed logic, we use the internal pallets' functions
+	/// that are not inherently safe to use outside a transaction.
+	///
+	/// This requirement is temporary until XCM message processing becomes transactional:
+	/// https://github.com/paritytech/polkadot-sdk/issues/490
+	#[transactional]
+	fn transfer_item(
+		&self,
+		depositor: &T::CrossAccountId,
+		from: &T::CrossAccountId,
+		to: &T::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+		nesting_budget: &dyn Budget,
+	) -> DispatchResult {
+		if T::CrossTokenAddressMapping::is_token_address(to) {
+			return unsupported!(T);
+		}
+
+		if self.token_has_children(token) {
+			return unsupported!(T);
+		}
+
+		self.transfer_item_internal(depositor, from, to, token, amount, nesting_budget)
+	}
+
+	/// Transfer an item from the `from` account to the `to` account.
+	fn transfer_item_internal(
+		&self,
+		depositor: &T::CrossAccountId,
+		from: &T::CrossAccountId,
+		to: &T::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+		nesting_budget: &dyn Budget,
+	) -> DispatchResult;
+
+	/// Burn a collection's item using a transaction.
+	///
+	/// The `transactional` attribute is needed because the inbound XCM messages
+	/// are processed in a non-transactional context.
+	/// To perform the needed logic, we use the internal pallets' functions
+	/// that are not inherently safe to use outside a transaction.
+	///
+	/// This requirement is temporary until XCM message processing becomes transactional:
+	/// https://github.com/paritytech/polkadot-sdk/issues/490
+	#[transactional]
+	fn burn_item(&self, from: T::CrossAccountId, token: TokenId, amount: u128) -> DispatchResult {
+		self.burn_item_internal(from, token, amount)
+	}
+
+	/// Burn a collection's item.
+	fn burn_item_internal(
+		&self,
+		from: T::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+	) -> DispatchResult;
+}
+
 /// Merge [`DispatchResult`] with [`Weight`] into [`DispatchResultWithPostInfo`].
 ///
 /// Used for [`CommonCollectionOperations`] implementations and flexible enough to do so.

--- a/pallets/foreign-assets/Cargo.toml
+++ b/pallets/foreign-assets/Cargo.toml
@@ -12,7 +12,6 @@
 frame-support = { workspace = true }
 frame-system = { workspace = true }
 log = { workspace = true }
-orml-tokens = { workspace = true }
 pallet-balances = { features = ["insecure_zero_ed"], workspace = true }
 pallet-common = { workspace = true }
 pallet-fungible = { workspace = true }
@@ -30,7 +29,6 @@
 	"frame-support/std",
 	"frame-system/std",
 	"log/std",
-	"orml-tokens/std",
 	"pallet-balances/std",
 	"pallet-common/std",
 	"pallet-fungible/std",

--- a/pallets/foreign-assets/src/benchmarking.rs
+++ b/pallets/foreign-assets/src/benchmarking.rs
@@ -16,88 +16,36 @@
 
 #![allow(missing_docs)]
 
-use frame_benchmarking::{account, v2::*};
-use frame_support::traits::Currency;
+use frame_benchmarking::v2::*;
 use frame_system::RawOrigin;
-use sp_std::{boxed::Box, vec, vec::Vec};
-use staging_xcm::{opaque::latest::Junction::Parachain, v3::Junctions::X1, VersionedMultiLocation};
+use pallet_common::benchmarking::{create_data, create_u16_data};
+use sp_std::{boxed::Box, vec};
+use staging_xcm::prelude::*;
+use up_data_structs::{MAX_COLLECTION_NAME_LENGTH, MAX_TOKEN_PREFIX_LENGTH};
 
-use super::{Call, Config, Pallet};
-use crate::AssetMetadata;
+use super::{Call, Config, ForeignCollectionMode, Pallet};
 
-fn bounded<T: TryFrom<Vec<u8>>>(slice: &[u8]) -> T {
-	T::try_from(slice.to_vec())
-		.map_err(|_| "slice doesn't fit")
-		.unwrap()
-}
-
 #[benchmarks]
 mod benchmarks {
+
 	use super::*;
 
 	#[benchmark]
-	fn register_foreign_asset() -> Result<(), BenchmarkError> {
-		let owner: T::AccountId = account("user", 0, 1);
-		let location: VersionedMultiLocation = VersionedMultiLocation::from(X1(Parachain(1000)));
-		let metadata: AssetMetadata<
-			<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance,
-		> = AssetMetadata {
-			name: bounded(b"name"),
-			symbol: bounded(b"symbol"),
-			decimals: 18,
-			minimal_balance: 1u32.into(),
-		};
-		let mut balance: <<T as Config>::Currency as Currency<
-			<T as frame_system::Config>::AccountId,
-		>>::Balance = 4_000_000_000u32.into();
-		balance = balance * balance;
-		<T as Config>::Currency::make_free_balance_be(&owner, balance);
+	fn force_register_foreign_asset() -> Result<(), BenchmarkError> {
+		let location =
+			MultiLocation::from(X3(Parachain(1000), PalletInstance(42), GeneralIndex(1)));
+		let name = create_u16_data::<MAX_COLLECTION_NAME_LENGTH>();
+		let token_prefix = create_data::<MAX_TOKEN_PREFIX_LENGTH>();
+		let mode = ForeignCollectionMode::NFT;
 
 		#[extrinsic_call]
 		_(
 			RawOrigin::Root,
-			owner,
-			Box::new(location),
-			Box::new(metadata),
+			Box::new(location.into()),
+			name,
+			token_prefix,
+			mode,
 		);
-
-		Ok(())
-	}
-
-	#[benchmark]
-	fn update_foreign_asset() -> Result<(), BenchmarkError> {
-		let owner: T::AccountId = account("user", 0, 1);
-		let location: VersionedMultiLocation = VersionedMultiLocation::from(X1(Parachain(2000)));
-		let metadata: AssetMetadata<
-			<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance,
-		> = AssetMetadata {
-			name: bounded(b"name"),
-			symbol: bounded(b"symbol"),
-			decimals: 18,
-			minimal_balance: 1u32.into(),
-		};
-		let metadata2: AssetMetadata<
-			<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance,
-		> = AssetMetadata {
-			name: bounded(b"name2"),
-			symbol: bounded(b"symbol2"),
-			decimals: 18,
-			minimal_balance: 1u32.into(),
-		};
-		let mut balance: <<T as Config>::Currency as Currency<
-			<T as frame_system::Config>::AccountId,
-		>>::Balance = 4_000_000_000u32.into();
-		balance = balance * balance;
-		<T as Config>::Currency::make_free_balance_be(&owner, balance);
-		Pallet::<T>::register_foreign_asset(
-			RawOrigin::Root.into(),
-			owner,
-			Box::new(location.clone()),
-			Box::new(metadata),
-		)?;
-
-		#[extrinsic_call]
-		_(RawOrigin::Root, 0, Box::new(location), Box::new(metadata2));
 
 		Ok(())
 	}

14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17//! # Foreign assets17//! # Foreign Assets
18//!18//!
19//! - [`Config`]
20//! - [`Call`]
21//! - [`Pallet`]
22//!
23//! ## Overview19//! ## Overview
24//!20//!
25//! The foreign assests pallet provides functions for:21//! The Foreign Assets is a proxy that maps XCM operations to the Unique Network's pallets logic.
26//!
27//! - Local and foreign assets management. The foreign assets can be updated without runtime upgrade.
28//! - Bounds between asset and target collection for cross chain transfer and inner transfers.
29//!
30//! ## Overview
31//!
32//! Under construction
3322
34#![cfg_attr(not(feature = "std"), no_std)]23#![cfg_attr(not(feature = "std"), no_std)]
35#![allow(clippy::unused_unit)]24#![allow(clippy::unused_unit)]
3625
37use frame_support::{26use core::ops::Deref;
27
38	dispatch::DispatchResult,28use frame_support::{dispatch::DispatchResult, pallet_prelude::*, traits::EnsureOrigin, PalletId};
39	ensure,
40	pallet_prelude::*,
41	traits::{fungible, fungibles, Currency, EnsureOrigin},
42};
43use frame_system::pallet_prelude::*;29use frame_system::pallet_prelude::*;
44use pallet_common::erc::CrossAccountId;30use pallet_common::{
45use pallet_fungible::Pallet as PalletFungible;31	dispatch::CollectionDispatch, erc::CrossAccountId, XcmExtensions, NATIVE_FUNGIBLE_COLLECTION_ID,
46use scale_info::TypeInfo;
47use serde::{Deserialize, Serialize};
48use sp_runtime::{
49	traits::{One, Zero},
50	ArithmeticError,
51};32};
52use sp_std::{boxed::Box, vec::Vec};33use sp_runtime::traits::AccountIdConversion;
53use staging_xcm::{latest::MultiLocation, VersionedMultiLocation};34use sp_std::{boxed::Box, vec, vec::Vec};
54// NOTE: MultiLocation is used in storages, we will need to do migration if upgrade the
55// MultiLocation to the XCM v3.
56use staging_xcm::{35use staging_xcm::{
57	opaque::latest::{prelude::XcmError, Weight},36	opaque::latest::{prelude::XcmError, Weight},
58	v3::XcmContext,37	v3::{prelude::*, MultiAsset, XcmContext},
38	VersionedAssetId,
59};39};
60use staging_xcm_executor::{traits::WeightTrader, Assets};40use staging_xcm_executor::{
41	traits::{ConvertLocation, Error as XcmExecutorError, TransactAsset, WeightTrader},
42	Assets,
43};
61use up_data_structs::{CollectionId, CollectionMode, CreateCollectionData, TokenId};44use up_data_structs::{
45	budget::ZeroBudget, CollectionId, CollectionMode, CollectionName, CollectionTokenPrefix,
46	CreateCollectionData, CreateFungibleData, CreateItemData, TokenId,
47};
6248
63// TODO: Move to primitives
64// Id of native currency.
65// 0 - QTZ\UNQ
66// 1 - KSM\DOT
67#[derive(
68	Clone,
69	Copy,
70	Eq,
71	PartialEq,
72	PartialOrd,
73	Ord,
74	MaxEncodedLen,
75	RuntimeDebug,
76	Encode,
77	Decode,
78	TypeInfo,
79	Serialize,
80	Deserialize,
81)]
82pub enum NativeCurrency {
83	Here = 0,
84	Parent = 1,
85}
86
87#[derive(
88	Clone,
89	Copy,
90	Eq,
91	PartialEq,
92	PartialOrd,
93	Ord,
94	MaxEncodedLen,
95	RuntimeDebug,
96	Encode,
97	Decode,
98	TypeInfo,
99	Serialize,
100	Deserialize,
101)]
102pub enum AssetId {
103	ForeignAssetId(ForeignAssetId),
104	NativeAssetId(NativeCurrency),
105}
106
107pub trait TryAsForeign<T, F> {
108	fn try_as_foreign(asset: T) -> Option<F>;
109}
110
111impl TryAsForeign<AssetId, ForeignAssetId> for AssetId {
112	fn try_as_foreign(asset: AssetId) -> Option<ForeignAssetId> {
113		match asset {
114			Self::ForeignAssetId(id) => Some(id),
115			_ => None,
116		}
117	}
118}
119
120pub type ForeignAssetId = u32;
121pub type CurrencyId = AssetId;
122
123mod impl_fungibles;
124pub mod weights;49pub mod weights;
12550
126#[cfg(feature = "runtime-benchmarks")]51#[cfg(feature = "runtime-benchmarks")]
129pub use module::*;54pub use module::*;
130pub use weights::WeightInfo;55pub use weights::WeightInfo;
13156
132/// Type alias for currency balance.
133pub type BalanceOf<T> =
134	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
135
136/// A mapping between ForeignAssetId and AssetMetadata.
137pub trait AssetIdMapping<ForeignAssetId, MultiLocation, AssetMetadata> {
138	/// Returns the AssetMetadata associated with a given ForeignAssetId.
139	fn get_asset_metadata(foreign_asset_id: ForeignAssetId) -> Option<AssetMetadata>;
140	/// Returns the MultiLocation associated with a given ForeignAssetId.
141	fn get_multi_location(foreign_asset_id: ForeignAssetId) -> Option<MultiLocation>;
142	/// Returns the CurrencyId associated with a given MultiLocation.
143	fn get_currency_id(multi_location: MultiLocation) -> Option<CurrencyId>;
144}
145
146pub struct XcmForeignAssetIdMapping<T>(sp_std::marker::PhantomData<T>);
147
148impl<T: Config> AssetIdMapping<ForeignAssetId, MultiLocation, AssetMetadata<BalanceOf<T>>>
149	for XcmForeignAssetIdMapping<T>
150{
151	fn get_asset_metadata(foreign_asset_id: ForeignAssetId) -> Option<AssetMetadata<BalanceOf<T>>> {
152		log::trace!(target: "fassets::asset_metadatas", "call");
153		Pallet::<T>::asset_metadatas(AssetId::ForeignAssetId(foreign_asset_id))
154	}
155
156	fn get_multi_location(foreign_asset_id: ForeignAssetId) -> Option<MultiLocation> {
157		log::trace!(target: "fassets::get_multi_location", "call");
158		Pallet::<T>::foreign_asset_locations(foreign_asset_id)
159	}
160
161	fn get_currency_id(multi_location: MultiLocation) -> Option<CurrencyId> {
162		log::trace!(target: "fassets::get_currency_id", "call");
163		Pallet::<T>::location_to_currency_ids(multi_location).map(AssetId::ForeignAssetId)
164	}
165}
166
167#[frame_support::pallet]57#[frame_support::pallet]
168pub mod module {58pub mod module {
59	use pallet_common::CollectionIssuer;
60	use up_data_structs::CollectionDescription;
61
169	use super::*;62	use super::*;
17063
171	#[pallet::config]64	#[pallet::config]
172	pub trait Config:65	pub trait Config:
173		frame_system::Config66		frame_system::Config
174		+ pallet_common::Config67		+ pallet_common::Config
175		+ pallet_fungible::Config68		+ pallet_fungible::Config
176		+ orml_tokens::Config
177		+ pallet_balances::Config69		+ pallet_balances::Config
178	{70	{
179		/// The overarching event type.71		/// The overarching event type.
180		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;72		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
18173
182		/// Currency type for withdraw and balance storage.74		/// Origin for force registering of a foreign asset.
183		type Currency: Currency<Self::AccountId>;75		type ForceRegisterOrigin: EnsureOrigin<Self::RuntimeOrigin>;
18476
185		/// Required origin for registering asset.77		/// The ID of the foreign assets pallet.
186		type RegisterOrigin: EnsureOrigin<Self::RuntimeOrigin>;78		type PalletId: Get<PalletId>;
18779
80		/// Self-location of this parachain.
81		type SelfLocation: Get<MultiLocation>;
82
83		/// The converter from a MultiLocation to a CrossAccountId.
84		type LocationToAccountId: ConvertLocation<Self::CrossAccountId>;
85
188		/// Weight information for the extrinsics in this module.86		/// Weight information for the extrinsics in this module.
189		type WeightInfo: WeightInfo;87		type WeightInfo: WeightInfo;
190	}88	}
19189
192	pub type AssetName = BoundedVec<u8, ConstU32<32>>;
193	pub type AssetSymbol = BoundedVec<u8, ConstU32<7>>;
194
195	#[derive(Clone, Eq, PartialEq, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)]
196	pub struct AssetMetadata<Balance> {
197		pub name: AssetName,
198		pub symbol: AssetSymbol,
199		pub decimals: u8,
200		pub minimal_balance: Balance,
201	}
202
203	#[pallet::error]90	#[pallet::error]
204	pub enum Error<T> {91	pub enum Error<T> {
205		/// The given location could not be used (e.g. because it cannot be expressed in the92		/// The foreign asset is already registered.
206		/// desired version of XCM).93		ForeignAssetAlreadyRegistered,
207		BadLocation,94
208		/// MultiLocation existed95		/// The given asset ID could not be converted into the current XCM version.
209		MultiLocationExisted,
210		/// AssetId not exists
211		AssetIdNotExists,
212		/// AssetId exists
213		AssetIdExisted,96		BadForeignAssetId,
214	}97	}
21598
216	#[pallet::event]99	#[pallet::event]
217	#[pallet::generate_deposit(fn deposit_event)]100	#[pallet::generate_deposit(fn deposit_event)]
218	pub enum Event<T: Config> {101	pub enum Event<T: Config> {
219		/// The foreign asset registered.102		/// The foreign asset registered.
220		ForeignAssetRegistered {103		ForeignAssetRegistered {
221			asset_id: ForeignAssetId,104			collection_id: CollectionId,
222			asset_address: MultiLocation,105			asset_id: Box<VersionedAssetId>,
223			metadata: AssetMetadata<BalanceOf<T>>,
224		},106		},
225		/// The foreign asset updated.
226		ForeignAssetUpdated {
227			asset_id: ForeignAssetId,
228			asset_address: MultiLocation,
229			metadata: AssetMetadata<BalanceOf<T>>,
230		},
231		/// The asset registered.
232		AssetRegistered {
233			asset_id: AssetId,
234			metadata: AssetMetadata<BalanceOf<T>>,
235		},
236		/// The asset updated.
237		AssetUpdated {
238			asset_id: AssetId,
239			metadata: AssetMetadata<BalanceOf<T>>,
240		},
241	}107	}
242108
243	/// Next available Foreign AssetId ID.109	/// The corresponding collections of foreign assets.
244	///
245	/// NextForeignAssetId: ForeignAssetId
246	#[pallet::storage]110	#[pallet::storage]
247	#[pallet::getter(fn next_foreign_asset_id)]111	#[pallet::getter(fn foreign_asset_to_collection)]
248	pub type NextForeignAssetId<T: Config> = StorageValue<_, ForeignAssetId, ValueQuery>;112	pub type ForeignAssetToCollection<T: Config> =
249	/// The storages for MultiLocations.113		StorageMap<_, Twox64Concat, staging_xcm::v3::AssetId, CollectionId, OptionQuery>;
250	///
251	/// ForeignAssetLocations: map ForeignAssetId => Option<MultiLocation>
252	#[pallet::storage]
253	#[pallet::getter(fn foreign_asset_locations)]
254	pub type ForeignAssetLocations<T: Config> =
255		StorageMap<_, Twox64Concat, ForeignAssetId, staging_xcm::v3::MultiLocation, OptionQuery>;
256114
257	/// The storages for CurrencyIds.115	/// The corresponding foreign assets of collections.
258	///
259	/// LocationToCurrencyIds: map MultiLocation => Option<ForeignAssetId>
260	#[pallet::storage]116	#[pallet::storage]
261	#[pallet::getter(fn location_to_currency_ids)]117	#[pallet::getter(fn collection_to_foreign_asset)]
262	pub type LocationToCurrencyIds<T: Config> =118	pub type CollectionToForeignAsset<T: Config> =
263		StorageMap<_, Twox64Concat, staging_xcm::v3::MultiLocation, ForeignAssetId, OptionQuery>;119		StorageMap<_, Twox64Concat, CollectionId, staging_xcm::v3::AssetId, OptionQuery>;
264120
265	/// The storages for AssetMetadatas.121	/// The correponding NFT token id of reserve NFTs
266	///
267	/// AssetMetadatas: map AssetIds => Option<AssetMetadata>
268	#[pallet::storage]122	#[pallet::storage]
269	#[pallet::getter(fn asset_metadatas)]123	#[pallet::getter(fn foreign_reserve_asset_instance_to_token_id)]
270	pub type AssetMetadatas<T: Config> =124	pub type ForeignReserveAssetInstanceToTokenId<T: Config> = StorageDoubleMap<
271		StorageMap<_, Twox64Concat, AssetId, AssetMetadata<BalanceOf<T>>, OptionQuery>;125		Hasher1 = Twox64Concat,
126		Key1 = CollectionId,
127		Hasher2 = Blake2_128Concat,
128		Key2 = staging_xcm::v3::AssetInstance,
129		Value = TokenId,
130		QueryKind = OptionQuery,
131	>;
272132
273	/// The storages for assets to fungible collection binding133	/// The correponding reserve NFT of a token ID
274	///
275	#[pallet::storage]134	#[pallet::storage]
276	#[pallet::getter(fn asset_binding)]135	#[pallet::getter(fn token_id_to_foreign_reserve_asset_instance)]
277	pub type AssetBinding<T: Config> =136	pub type TokenIdToForeignReserveAssetInstance<T: Config> = StorageDoubleMap<
278		StorageMap<_, Twox64Concat, ForeignAssetId, CollectionId, OptionQuery>;137		Hasher1 = Twox64Concat,
138		Key1 = CollectionId,
139		Hasher2 = Blake2_128Concat,
140		Key2 = TokenId,
141		Value = staging_xcm::v3::AssetInstance,
142		QueryKind = OptionQuery,
143	>;
279144
280	#[pallet::pallet]145	#[pallet::pallet]
281	pub struct Pallet<T>(_);146	pub struct Pallet<T>(_);
284	impl<T: Config> Pallet<T> {149	impl<T: Config> Pallet<T> {
285		#[pallet::call_index(0)]150		#[pallet::call_index(0)]
286		#[pallet::weight(<T as Config>::WeightInfo::register_foreign_asset())]151		#[pallet::weight(<T as Config>::WeightInfo::register_foreign_asset())]
287		pub fn register_foreign_asset(152		pub fn force_register_foreign_asset(
288			origin: OriginFor<T>,153			origin: OriginFor<T>,
289			owner: T::AccountId,154			versioned_asset_id: Box<VersionedAssetId>,
155			name: CollectionName,
290			location: Box<VersionedMultiLocation>,156			token_prefix: CollectionTokenPrefix,
291			metadata: Box<AssetMetadata<BalanceOf<T>>>,157			mode: ForeignCollectionMode,
292		) -> DispatchResult {158		) -> DispatchResult {
293			T::RegisterOrigin::ensure_origin(origin.clone())?;159			T::ForceRegisterOrigin::ensure_origin(origin.clone())?;
294160
295			let location: MultiLocation = (*location)161			let asset_id: AssetId = versioned_asset_id
162				.as_ref()
163				.clone()
296				.try_into()164				.try_into()
297				.map_err(|()| Error::<T>::BadLocation)?;165				.map_err(|()| Error::<T>::BadForeignAssetId)?;
298166
299			let md = metadata.clone();167			ensure!(
168				!<ForeignAssetToCollection<T>>::contains_key(asset_id),
169				<Error<T>>::ForeignAssetAlreadyRegistered,
170			);
171
300			let name: Vec<u16> = md.name.into_iter().map(|x| x as u16).collect::<Vec<u16>>();172			let foreign_collection_owner = Self::pallet_account();
173
301			let mut description: Vec<u16> = "Foreign assets collection for "174			let description: CollectionDescription = "Foreign Assets Collection"
302				.encode_utf16()175				.encode_utf16()
303				.collect::<Vec<u16>>();176				.collect::<Vec<_>>()
304			description.append(&mut name.clone());177				.try_into()
178				.expect("description length < max description length; qed");
305179
306			let data: CreateCollectionData<T::CrossAccountId> = CreateCollectionData {180			let collection_id = T::CollectionDispatch::create(
307				name: name.try_into().unwrap(),181				foreign_collection_owner,
308				description: description.try_into().unwrap(),182				CollectionIssuer::Internals,
309				mode: CollectionMode::Fungible(md.decimals),183				CreateCollectionData {
310				..Default::default()184					name,
311			};185					token_prefix,
312			let owner = T::CrossAccountId::from_sub(owner);
313			let bounded_collection_id =186					description,
314				<PalletFungible<T>>::init_foreign_collection(owner.clone(), owner, data)?;187					mode: mode.into(),
315			let foreign_asset_id =188					..Default::default()
316				Self::do_register_foreign_asset(&location, &metadata, bounded_collection_id)?;189				},
190			)?;
317191
192			<ForeignAssetToCollection<T>>::insert(asset_id, collection_id);
193			<CollectionToForeignAsset<T>>::insert(collection_id, asset_id);
194
318			Self::deposit_event(Event::<T>::ForeignAssetRegistered {195			Self::deposit_event(Event::<T>::ForeignAssetRegistered {
319				asset_id: foreign_asset_id,196				collection_id,
320				asset_address: location,197				asset_id: versioned_asset_id,
321				metadata: *metadata,
322			});198			});
323			Ok(())
324		}
325199
326		#[pallet::call_index(1)]
327		#[pallet::weight(<T as Config>::WeightInfo::update_foreign_asset())]
328		pub fn update_foreign_asset(
329			origin: OriginFor<T>,
330			foreign_asset_id: ForeignAssetId,
331			location: Box<VersionedMultiLocation>,
332			metadata: Box<AssetMetadata<BalanceOf<T>>>,
333		) -> DispatchResult {
334			T::RegisterOrigin::ensure_origin(origin)?;
335
336			let location: MultiLocation = (*location)
337				.try_into()
338				.map_err(|()| Error::<T>::BadLocation)?;
339			Self::do_update_foreign_asset(foreign_asset_id, &location, &metadata)?;
340
341			Self::deposit_event(Event::<T>::ForeignAssetUpdated {
342				asset_id: foreign_asset_id,
343				asset_address: location,
344				metadata: *metadata,
345			});
346			Ok(())200			Ok(())
347		}201		}
348	}202	}
349}203}
350204
351impl<T: Config> Pallet<T> {205impl<T: Config> Pallet<T> {
352	fn get_next_foreign_asset_id() -> Result<ForeignAssetId, DispatchError> {206	fn pallet_account() -> T::CrossAccountId {
353		NextForeignAssetId::<T>::try_mutate(|current| -> Result<ForeignAssetId, DispatchError> {
354			let id = *current;207		let owner: T::AccountId = T::PalletId::get().into_account_truncating();
355			*current = current
356				.checked_add(One::one())
357				.ok_or(ArithmeticError::Overflow)?;
358			Ok(id)208		T::CrossAccountId::from_sub(owner)
359		})
360	}209	}
361210
362	fn do_register_foreign_asset(211	/// Converts a concrete asset ID (the asset multilocation) to a local collection on Unique Network.
363		location: &MultiLocation,212	///
213	/// The multilocation corresponds to a local collection if:
214	/// * It is `Here` location that corresponds to the native token of this parachain.
364		metadata: &AssetMetadata<BalanceOf<T>>,215	/// * It is `../Parachain(<Unique Network Para ID>)` that also corresponds to the native token of this parachain.
365		bounded_collection_id: CollectionId,216	/// * It is `../Parachain(<Unique Network Para ID>)/GeneralIndex(<Collection ID>)` that corresponds
366	) -> Result<ForeignAssetId, DispatchError> {217	/// to the collection with the ID equal to `<Collection ID>`. The `<Collection ID>` must be in the valid range,
367		let foreign_asset_id = Self::get_next_foreign_asset_id()?;218	/// otherwise `None` is returned.
219	/// * It is `GeneralIndex(<Collection ID>)`. Same as the last one above.
368		LocationToCurrencyIds::<T>::try_mutate(location, |maybe_currency_ids| -> DispatchResult {220	///
221	/// If the multilocation doesn't match the patterns listed above,
222	/// or the `<Collection ID>` points to a foreign collection,
369			ensure!(223	/// `None` is returned, identifying that the given multilocation doesn't correspond to a local collection.
370				maybe_currency_ids.is_none(),224	fn local_asset_id_to_collection(asset_id: &AssetId) -> Option<CollectionLocality> {
371				Error::<T>::MultiLocationExisted225		let AssetId::Concrete(asset_location) = asset_id else {
372			);
373			*maybe_currency_ids = Some(foreign_asset_id);226			return None;
374			// *maybe_currency_ids = Some(CurrencyId::ForeignAsset(foreign_asset_id));227		};
375228
376			ForeignAssetLocations::<T>::try_mutate(229		let self_location = T::SelfLocation::get();
377				foreign_asset_id,
378				|maybe_location| -> DispatchResult {
379					ensure!(maybe_location.is_none(), Error::<T>::MultiLocationExisted);
380					*maybe_location = Some(*location);
381230
382					AssetMetadatas::<T>::try_mutate(231		if *asset_location == Here.into() || *asset_location == self_location {
383						AssetId::ForeignAssetId(foreign_asset_id),
384						|maybe_asset_metadatas| -> DispatchResult {
385							ensure!(maybe_asset_metadatas.is_none(), Error::<T>::AssetIdExisted);232			return Some(CollectionLocality::Local(NATIVE_FUNGIBLE_COLLECTION_ID));
386							*maybe_asset_metadatas = Some(metadata.clone());
387							Ok(())233		}
388						},
389					)
390				},
391			)?;
392234
393			AssetBinding::<T>::try_mutate(foreign_asset_id, |collection_id| -> DispatchResult {235		let prefix = if asset_location.parents == 0 {
394				*collection_id = Some(bounded_collection_id);236			&Here
237		} else if asset_location.parents == self_location.parents {
395				Ok(())238			&self_location.interior
239		} else {
396			})240			return None;
397		})?;241		};
398242
399		Ok(foreign_asset_id)243		let GeneralIndex(collection_id) = asset_location.interior.match_and_split(prefix)? else {
244			return None;
245		};
246
247		let collection_id = CollectionId((*collection_id).try_into().ok()?);
248
249		Self::collection_to_foreign_asset(collection_id)
250			.is_none()
251			.then_some(CollectionLocality::Local(collection_id))
400	}252	}
401253
402	fn do_update_foreign_asset(254	/// Converts an asset ID to a Unique Network's collection locality (either foreign or a local one).
255	///
256	/// The function will check if the asset's reserve location has the corresponding
257	/// foreign collection on Unique Network,
258	/// and will return the "foreign" locality containing the collection ID if found.
259	///
260	/// If no corresponding foreign collection is found, the function will check
261	/// if the asset's reserve location corresponds to a local collection.
262	/// If the local collection is found, the "local" locality with the collection ID is returned.
263	///
264	/// If all of the above have failed, the `AssetIdConversionFailed` error will be returned.
265	fn asset_to_collection(asset_id: &AssetId) -> Result<CollectionLocality, XcmError> {
403		foreign_asset_id: ForeignAssetId,266		Self::foreign_asset_to_collection(asset_id)
267			.map(CollectionLocality::Foreign)
268			.or_else(|| Self::local_asset_id_to_collection(asset_id))
269			.ok_or_else(|| XcmExecutorError::AssetIdConversionFailed.into())
270	}
271
272	/// Converts an XCM asset instance of local collection to the Unique Network's token ID.
273	///
274	/// The asset instance corresponds to the Unique Network's token ID if it is in the following format:
275	/// `AssetInstance::Index(<token ID>)`.
276	///
277	/// If the asset instance is not in the valid format or the `<token ID>` can't fit into the valid token ID,
404		location: &MultiLocation,278	/// `None` will be returned.
279	///
280	/// Note: this function can return `Some` containing the token ID of a non-existing NFT.
281	/// It returns `None` when it failed to convert the `asset_instance` to a local ID.
282	fn local_asset_instance_to_token_id(asset_instance: &AssetInstance) -> Option<TokenId> {
283		match asset_instance {
284			AssetInstance::Index(token_id) => Some(TokenId((*token_id).try_into().ok()?)),
405		metadata: &AssetMetadata<BalanceOf<T>>,285			_ => None,
286		}
287	}
288
289	/// Obtains the token ID of the `asset_instance` in the collection.
290	///
291	/// Note: this function can return `Some` containing the token ID of a non-existing NFT.
292	/// It returns `None` when it failed to convert the `asset_instance` to a local ID.
293	fn asset_instance_to_token_id(
294		collection_locality: CollectionLocality,
295		asset_instance: &AssetInstance,
296	) -> Option<TokenId> {
297		match collection_locality {
298			CollectionLocality::Local(_) => Self::local_asset_instance_to_token_id(asset_instance),
299			CollectionLocality::Foreign(collection_id) => {
300				Self::foreign_reserve_asset_instance_to_token_id(collection_id, asset_instance)
301			}
302		}
303	}
304
305	/// Creates a foreign item in the the collection.
306	fn create_foreign_asset_instance(
307		xcm_ext: &dyn XcmExtensions<T>,
308		collection_id: CollectionId,
309		asset_instance: &AssetInstance,
310		to: T::CrossAccountId,
406	) -> DispatchResult {311	) -> DispatchResult {
407		ForeignAssetLocations::<T>::try_mutate(312		let derivative_token_id = xcm_ext.create_item(
408			foreign_asset_id,313			&Self::pallet_account(),
409			|maybe_multi_locations| -> DispatchResult {314			to,
410				let old_multi_locations = maybe_multi_locations315			CreateItemData::NFT(Default::default()),
411					.as_mut()
412					.ok_or(Error::<T>::AssetIdNotExists)?;316			&ZeroBudget,
317		)?;
413318
414				AssetMetadatas::<T>::try_mutate(319		<ForeignReserveAssetInstanceToTokenId<T>>::insert(
415					AssetId::ForeignAssetId(foreign_asset_id),320			collection_id,
416					|maybe_asset_metadatas| -> DispatchResult {321			asset_instance,
417						ensure!(322			derivative_token_id,
418							maybe_asset_metadatas.is_some(),
419							Error::<T>::AssetIdNotExists
420						);323		);
421324
422						// modify location325		<TokenIdToForeignReserveAssetInstance<T>>::insert(
423						if location != old_multi_locations {326			collection_id,
424							LocationToCurrencyIds::<T>::remove(*old_multi_locations);327			derivative_token_id,
425							LocationToCurrencyIds::<T>::try_mutate(328			asset_instance,
426								location,329		);
427								|maybe_currency_ids| -> DispatchResult {330
428									ensure!(331		Ok(())
429										maybe_currency_ids.is_none(),332	}
430										Error::<T>::MultiLocationExisted333
431									);334	/// Deposits an asset instance to the `to` account.
432									// *maybe_currency_ids = Some(CurrencyId::ForeignAsset(foreign_asset_id));335	///
433									*maybe_currency_ids = Some(foreign_asset_id);336	/// Either transfers an existing item from the pallet's account
434									Ok(())337	/// or creates a foreign item.
435								},338	fn deposit_asset_instance(
436							)?;339		xcm_ext: &dyn XcmExtensions<T>,
437						}340		collection_locality: CollectionLocality,
438						*maybe_asset_metadatas = Some(metadata.clone());341		asset_instance: &AssetInstance,
439						*old_multi_locations = *location;342		to: T::CrossAccountId,
440						Ok(())343	) -> XcmResult {
441					},344		let token_id = Self::asset_instance_to_token_id(collection_locality, asset_instance);
345
346		let deposit_result = match (collection_locality, token_id) {
347			(_, Some(token_id)) => {
348				let depositor = &Self::pallet_account();
349				let from = depositor;
350				let amount = 1;
351
352				xcm_ext.transfer_item(depositor, from, &to, token_id, amount, &ZeroBudget)
353			}
354			(CollectionLocality::Foreign(collection_id), None) => {
355				Self::create_foreign_asset_instance(xcm_ext, collection_id, asset_instance, to)
356			}
357			(CollectionLocality::Local(_), None) => {
358				return Err(XcmExecutorError::InstanceConversionFailed.into());
359			}
360		};
361
362		deposit_result
363			.map_err(|_| XcmError::FailedToTransactAsset("non-fungible item deposit failed"))
364	}
365
366	/// Withdraws an asset instance from the `from` account.
367	///
368	/// Transfers the asset instance to the pallet's account.
369	fn withdraw_asset_instance(
370		xcm_ext: &dyn XcmExtensions<T>,
371		collection_locality: CollectionLocality,
372		asset_instance: &AssetInstance,
373		from: T::CrossAccountId,
374	) -> XcmResult {
375		let token_id = Self::asset_instance_to_token_id(collection_locality, asset_instance)
376			.ok_or(XcmExecutorError::InstanceConversionFailed)?;
377
378		let depositor = &from;
379		let to = Self::pallet_account();
380		let amount = 1;
381		xcm_ext
382			.transfer_item(depositor, &from, &to, token_id, amount, &ZeroBudget)
383			.map_err(|_| XcmError::FailedToTransactAsset("non-fungible item withdraw failed"))?;
384
385		Ok(())
386	}
387}
388
389impl<T: Config> TransactAsset for Pallet<T> {
390	fn can_check_in(
391		_origin: &MultiLocation,
392		_what: &MultiAsset,
393		_context: &XcmContext,
394	) -> XcmResult {
395		Err(XcmError::Unimplemented)
396	}
397
398	fn check_in(_origin: &MultiLocation, _what: &MultiAsset, _context: &XcmContext) {}
399
400	fn can_check_out(
401		_dest: &MultiLocation,
402		_what: &MultiAsset,
403		_context: &XcmContext,
404	) -> XcmResult {
405		Err(XcmError::Unimplemented)
406	}
407
408	fn check_out(_dest: &MultiLocation, _what: &MultiAsset, _context: &XcmContext) {}
409
410	fn deposit_asset(
411		what: &MultiAsset,
412		to: &MultiLocation,
413		_context: Option<&XcmContext>,
414	) -> XcmResult {
415		let to = T::LocationToAccountId::convert_location(to)
416			.ok_or(XcmExecutorError::AccountIdConversionFailed)?;
417
418		let collection_locality = Self::asset_to_collection(&what.id)?;
419		let dispatch = T::CollectionDispatch::dispatch(*collection_locality)
420			.map_err(|_| XcmExecutorError::AssetIdConversionFailed)?;
421
422		let collection = dispatch.as_dyn();
423		let xcm_ext = collection.xcm_extensions().ok_or(XcmError::Unimplemented)?;
424
425		match what.fun {
426			Fungibility::Fungible(amount) => xcm_ext
427				.create_item(
428					&Self::pallet_account(),
429					to,
430					CreateItemData::Fungible(CreateFungibleData { value: amount }),
431					&ZeroBudget,
442				)432				)
443			},433				.map(|_| ())
434				.map_err(|_| XcmError::FailedToTransactAsset("fungible item deposit failed")),
435
444		)436			Fungibility::NonFungible(asset_instance) => {
437				Self::deposit_asset_instance(xcm_ext, collection_locality, &asset_instance, to)
438			}
439		}
445	}440	}
441
442	fn withdraw_asset(
443		what: &MultiAsset,
444		from: &MultiLocation,
445		_maybe_context: Option<&XcmContext>,
446	) -> Result<staging_xcm_executor::Assets, XcmError> {
447		let from = T::LocationToAccountId::convert_location(from)
448			.ok_or(XcmExecutorError::AccountIdConversionFailed)?;
449
450		let collection_locality = Self::asset_to_collection(&what.id)?;
451		let dispatch = T::CollectionDispatch::dispatch(*collection_locality)
452			.map_err(|_| XcmExecutorError::AssetIdConversionFailed)?;
453
454		let collection = dispatch.as_dyn();
455		let xcm_ext = collection.xcm_extensions().ok_or(XcmError::NoPermission)?;
456
457		match what.fun {
458			Fungibility::Fungible(amount) => xcm_ext
459				.burn_item(from, TokenId::default(), amount)
460				.map_err(|_| XcmError::FailedToTransactAsset("fungible item withdraw failed"))?,
461
462			Fungibility::NonFungible(asset_instance) => {
463				Self::withdraw_asset_instance(xcm_ext, collection_locality, &asset_instance, from)?;
464			}
465		}
466
467		Ok(what.clone().into())
468	}
469
470	fn internal_transfer_asset(
471		what: &MultiAsset,
472		from: &MultiLocation,
473		to: &MultiLocation,
474		_context: &XcmContext,
475	) -> Result<staging_xcm_executor::Assets, XcmError> {
476		let from = T::LocationToAccountId::convert_location(from)
477			.ok_or(XcmExecutorError::AccountIdConversionFailed)?;
478
479		let to = T::LocationToAccountId::convert_location(to)
480			.ok_or(XcmExecutorError::AccountIdConversionFailed)?;
481
482		let collection_locality = Self::asset_to_collection(&what.id)?;
483
484		let dispatch = T::CollectionDispatch::dispatch(*collection_locality)
485			.map_err(|_| XcmExecutorError::AssetIdConversionFailed)?;
486		let collection = dispatch.as_dyn();
487		let xcm_ext = collection.xcm_extensions().ok_or(XcmError::NoPermission)?;
488
489		let depositor = &from;
490
491		let token_id;
492		let amount;
493		let map_error: fn(DispatchError) -> XcmError;
494
495		match what.fun {
496			Fungibility::Fungible(fungible_amount) => {
497				token_id = TokenId::default();
498				amount = fungible_amount;
499				map_error = |_| XcmError::FailedToTransactAsset("fungible item transfer failed");
500			}
501
502			Fungibility::NonFungible(asset_instance) => {
503				token_id = Self::asset_instance_to_token_id(collection_locality, &asset_instance)
504					.ok_or(XcmExecutorError::InstanceConversionFailed)?;
505
506				amount = 1;
507				map_error = |_| XcmError::FailedToTransactAsset("non-fungible item transfer failed")
508			}
509		}
510
511		xcm_ext
512			.transfer_item(depositor, &from, &to, token_id, amount, &ZeroBudget)
513			.map_err(map_error)?;
514
515		Ok(what.clone().into())
516	}
446}517}
447518
448pub use frame_support::{519#[derive(Clone, Copy)]
449	traits::{
450		fungibles::Balanced, tokens::currency::Currency as CurrencyT, OnUnbalanced as OnUnbalancedT,520pub enum CollectionLocality {
451	},521	Local(CollectionId),
452	weights::{WeightToFee, WeightToFeePolynomial},522	Foreign(CollectionId),
453};523}
454524
455pub struct FreeForAll<525impl Deref for CollectionLocality {
456	WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,
457	AssetId: Get<MultiLocation>,526	type Target = CollectionId;
458	AccountId,
459	Currency: CurrencyT<AccountId>,
460	OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,
461>(
462	Weight,
463	Currency::Balance,
464	PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>,
465);
466527
467impl<528	fn deref(&self) -> &Self::Target {
468		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,529		match self {
530			Self::Local(id) => id,
469		AssetId: Get<MultiLocation>,531			Self::Foreign(id) => id,
470		AccountId,532		}
471		Currency: CurrencyT<AccountId>,533	}
534}
535
536pub struct CurrencyIdConvert<T: Config>(PhantomData<T>);
472		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,537impl<T: Config> sp_runtime::traits::Convert<CollectionId, Option<MultiLocation>>
473	> WeightTrader for FreeForAll<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>538	for CurrencyIdConvert<T>
474{539{
540	fn convert(collection_id: CollectionId) -> Option<MultiLocation> {
541		if collection_id == NATIVE_FUNGIBLE_COLLECTION_ID {
542			Some(T::SelfLocation::get())
543		} else {
544			<Pallet<T>>::collection_to_foreign_asset(collection_id)
545				.and_then(|asset_id| match asset_id {
546					AssetId::Concrete(location) => Some(location),
547					_ => None,
548				})
549				.or_else(|| {
550					T::SelfLocation::get()
551						.pushed_with_interior(GeneralIndex(collection_id.0.into()))
552						.ok()
553				})
554		}
555	}
556}
557
558#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]
559pub enum ForeignCollectionMode {
560	NFT,
561	Fungible(u8),
562}
563
564impl From<ForeignCollectionMode> for CollectionMode {
565	fn from(value: ForeignCollectionMode) -> Self {
566		match value {
567			ForeignCollectionMode::NFT => Self::NFT,
568			ForeignCollectionMode::Fungible(decimals) => Self::Fungible(decimals),
569		}
570	}
571}
572
573pub struct FreeForAll;
574
575impl WeightTrader for FreeForAll {
475	fn new() -> Self {576	fn new() -> Self {
476		Self(Weight::default(), Zero::zero(), PhantomData)577		Self
477	}578	}
478579
479	fn buy_weight(580	fn buy_weight(
484	) -> Result<Assets, XcmError> {585	) -> Result<Assets, XcmError> {
485		log::trace!(target: "fassets::weight", "buy_weight weight: {:?}, payment: {:?}", weight, payment);586		log::trace!(target: "fassets::weight", "buy_weight weight: {:?}, payment: {:?}", weight, payment);
486		Ok(payment)587		Ok(payment)
487	}
488}
489impl<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced> Drop
490	for FreeForAll<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>
491where
492	WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,
493	AssetId: Get<MultiLocation>,
494	Currency: CurrencyT<AccountId>,
495	OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,
496{
497	fn drop(&mut self) {
498		OnUnbalanced::on_unbalanced(Currency::issue(self.1));
499	}588	}
500}589}
501590

--- a/pallets/fungible/src/benchmarking.rs
+++ b/pallets/fungible/src/benchmarking.rs
@@ -15,7 +15,9 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 use frame_benchmarking::{account, v2::*};
-use pallet_common::{bench_init, benchmarking::create_collection_raw};
+use pallet_common::{
+	bench_init, benchmarking::create_collection_raw, CollectionIssuer, Pallet as PalletCommon,
+};
 use sp_std::prelude::*;
 use up_data_structs::{budget::Unlimited, CollectionMode, MAX_ITEMS_PER_BATCH};
 
@@ -30,7 +32,9 @@
 	create_collection_raw(
 		owner,
 		CollectionMode::Fungible(0),
-		|owner: T::CrossAccountId, data| <Pallet<T>>::init_collection(owner.clone(), owner, data),
+		|owner: T::CrossAccountId, data| {
+			<PalletCommon<T>>::init_collection(owner.clone(), CollectionIssuer::User(owner), data)
+		},
 		FungibleHandle::cast,
 	)
 }

--- a/pallets/fungible/src/common.rs
+++ b/pallets/fungible/src/common.rs
@@ -19,7 +19,7 @@
 use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight};
 use pallet_common::{
 	weights::WeightInfo as _, with_weight, CommonCollectionOperations, CommonWeightInfo,
-	Error as CommonError, RefungibleExtensions, SelfWeightOf as PalletCommonWeightOf,
+	Error as CommonError, SelfWeightOf as PalletCommonWeightOf, XcmExtensions,
 };
 use sp_runtime::{ArithmeticError, DispatchError};
 use sp_std::{vec, vec::Vec};
@@ -114,7 +114,7 @@
 				<Pallet<T>>::create_item(self, &sender, (to, fungible_data.value), nesting_budget),
 				<CommonWeights<T>>::create_item(&data),
 			),
-			_ => fail!(<Error<T>>::NotFungibleDataUsedToMintFungibleCollectionToken),
+			_ => fail!(<CommonError<T>>::NotFungibleDataUsedToMintFungibleCollectionToken),
 		}
 	}
 
@@ -133,7 +133,7 @@
 						.checked_add(data.value)
 						.ok_or(ArithmeticError::Overflow)?;
 				}
-				_ => fail!(<Error<T>>::NotFungibleDataUsedToMintFungibleCollectionToken),
+				_ => fail!(<CommonError<T>>::NotFungibleDataUsedToMintFungibleCollectionToken),
 			}
 		}
 
@@ -152,7 +152,7 @@
 		let weight = <CommonWeights<T>>::create_multiple_items_ex(&data);
 		let data = match data {
 			up_data_structs::CreateItemExData::Fungible(f) => f,
-			_ => fail!(<Error<T>>::NotFungibleDataUsedToMintFungibleCollectionToken),
+			_ => fail!(<CommonError<T>>::NotFungibleDataUsedToMintFungibleCollectionToken),
 		};
 
 		with_weight(
@@ -426,10 +426,6 @@
 			return 0;
 		}
 		<Allowance<T>>::get((self.id, sender, spender))
-	}
-
-	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {
-		None
 	}
 
 	fn total_pieces(&self, token: TokenId) -> Option<u128> {
@@ -439,6 +435,10 @@
 		<TotalSupply<T>>::try_get(self.id).ok()
 	}
 
+	fn xcm_extensions(&self) -> Option<&dyn XcmExtensions<T>> {
+		Some(self)
+	}
+
 	fn set_allowance_for_all(
 		&self,
 		_owner: T::CrossAccountId,
@@ -457,3 +457,57 @@
 		fail!(<Error<T>>::FungibleTokensAreAlwaysValid)
 	}
 }
+
+impl<T: Config> XcmExtensions<T> for FungibleHandle<T> {
+	fn create_item_internal(
+		&self,
+		depositor: &<T>::CrossAccountId,
+		to: <T>::CrossAccountId,
+		data: CreateItemData,
+		nesting_budget: &dyn Budget,
+	) -> Result<TokenId, sp_runtime::DispatchError> {
+		match &data {
+			up_data_structs::CreateItemData::Fungible(fungible_data) => {
+				<Pallet<T>>::create_multiple_items(
+					self,
+					depositor,
+					[(to, fungible_data.value)].into_iter().collect(),
+					nesting_budget,
+				)?
+			}
+			_ => fail!(<CommonError<T>>::NotFungibleDataUsedToMintFungibleCollectionToken),
+		}
+
+		Ok(TokenId::default())
+	}
+
+	fn transfer_item_internal(
+		&self,
+		depositor: &<T>::CrossAccountId,
+		from: &<T>::CrossAccountId,
+		to: &<T>::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+		nesting_budget: &dyn Budget,
+	) -> sp_runtime::DispatchResult {
+		ensure!(
+			token == TokenId::default(),
+			<CommonError<T>>::FungibleItemsHaveNoId
+		);
+
+		<Pallet<T>>::transfer_internal(self, depositor, from, to, amount, nesting_budget)
+			.map(|_| ())
+			.map_err(|post_info| post_info.error)
+	}
+
+	fn burn_item_internal(
+		&self,
+		from: <T>::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+	) -> sp_runtime::DispatchResult {
+		<Self as CommonCollectionOperations<T>>::burn_item(self, from, token, amount)
+			.map(|_| ())
+			.map_err(|post_info| post_info.error)
+	}
+}

--- a/pallets/fungible/src/lib.rs
+++ b/pallets/fungible/src/lib.rs
@@ -95,8 +95,8 @@
 use sp_runtime::{ArithmeticError, DispatchError, DispatchResult};
 use sp_std::{collections::btree_map::BTreeMap, vec::Vec};
 use up_data_structs::{
-	budget::Budget, mapping::TokenAddressMapping, AccessMode, CollectionId, CreateCollectionData,
-	Property, PropertyKey, TokenId,
+	budget::Budget, mapping::TokenAddressMapping, AccessMode, CollectionId, Property, PropertyKey,
+	TokenId,
 };
 use weights::WeightInfo;
 
@@ -121,8 +121,6 @@
 
 	#[pallet::error]
 	pub enum Error<T> {
-		/// Not Fungible item data used to mint in Fungible collection.
-		NotFungibleDataUsedToMintFungibleCollectionToken,
 		/// Tried to set data for fungible item.
 		FungibleItemsDontHaveData,
 		/// Fungible token does not support nesting.
@@ -212,24 +210,6 @@
 
 /// Pallet implementation for fungible assets
 impl<T: Config> Pallet<T> {
-	/// Initializes the collection. Returns [CollectionId] on success, [DispatchError] otherwise.
-	pub fn init_collection(
-		owner: T::CrossAccountId,
-		payer: T::CrossAccountId,
-		data: CreateCollectionData<T::CrossAccountId>,
-	) -> Result<CollectionId, DispatchError> {
-		<PalletCommon<T>>::init_collection(owner, payer, data)
-	}
-
-	/// Initializes the collection with ForeignCollection flag. Returns [CollectionId] on success, [DispatchError] otherwise.
-	pub fn init_foreign_collection(
-		owner: T::CrossAccountId,
-		payer: T::CrossAccountId,
-		data: CreateCollectionData<T::CrossAccountId>,
-	) -> Result<CollectionId, DispatchError> {
-		<PalletCommon<T>>::init_foreign_collection(owner, payer, data)
-	}
-
 	/// Destroys a collection.
 	pub fn destroy_collection(
 		collection: FungibleHandle<T>,
@@ -293,54 +273,11 @@
 		let balance = <Balance<T>>::get((collection.id, owner))
 			.checked_sub(amount)
 			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
-
-		// Foreign collection check
-		ensure!(!collection.flags.foreign, <CommonError<T>>::NoPermission);
 
 		if collection.permissions.access() == AccessMode::AllowList {
 			collection.check_allowlist(owner)?;
-		}
-
-		// =========
-
-		if balance == 0 {
-			<Balance<T>>::remove((collection.id, owner));
-			<PalletStructure<T>>::unnest_if_nested(owner, collection.id, TokenId::default());
-		} else {
-			<Balance<T>>::insert((collection.id, owner), balance);
 		}
-		<TotalSupply<T>>::insert(collection.id, total_supply);
-
-		<PalletEvm<T>>::deposit_log(
-			ERC20Events::Transfer {
-				from: *owner.as_eth(),
-				to: H160::default(),
-				value: amount.into(),
-			}
-			.to_log(collection_id_to_address(collection.id)),
-		);
-		<PalletCommon<T>>::deposit_event(CommonEvent::ItemDestroyed(
-			collection.id,
-			TokenId::default(),
-			owner.clone(),
-			amount,
-		));
-		Ok(())
-	}
 
-	/// Burns the specified amount of the token.
-	pub fn burn_foreign(
-		collection: &FungibleHandle<T>,
-		owner: &T::CrossAccountId,
-		amount: u128,
-	) -> DispatchResult {
-		let total_supply = <TotalSupply<T>>::get(collection.id)
-			.checked_sub(amount)
-			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
-
-		let balance = <Balance<T>>::get((collection.id, owner))
-			.checked_sub(amount)
-			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
 		// =========
 
 		if balance == 0 {
@@ -468,14 +405,25 @@
 	}
 
 	/// Minting tokens for multiple IDs.
-	/// It is a utility function used in [`create_multiple_items`][`Pallet::create_multiple_items`]
-	/// and [`create_multiple_items_foreign`][`Pallet::create_multiple_items_foreign`]
-	pub fn create_multiple_items_common(
+	/// See [`create_item`][`Pallet::create_item`] for more details.
+	pub fn create_multiple_items(
 		collection: &FungibleHandle<T>,
-		sender: &T::CrossAccountId,
+		depositor: &T::CrossAccountId,
 		data: BTreeMap<T::CrossAccountId, u128>,
 		nesting_budget: &dyn Budget,
 	) -> DispatchResult {
+		if !collection.is_owner_or_admin(depositor) {
+			ensure!(
+				collection.permissions.mint_mode(),
+				<CommonError<T>>::PublicMintingNotAllowed
+			);
+			collection.check_allowlist(depositor)?;
+
+			for (owner, _) in data.iter() {
+				collection.check_allowlist(owner)?;
+			}
+		}
+
 		let total_supply = data
 			.values()
 			.copied()
@@ -486,7 +434,7 @@
 
 		for (to, _) in data.iter() {
 			<PalletStructure<T>>::check_nesting(
-				sender,
+				depositor,
 				to,
 				collection.id,
 				TokenId::default(),
@@ -532,44 +480,7 @@
 
 		Ok(())
 	}
-
-	/// Minting tokens for multiple IDs.
-	/// See [`create_item`][`Pallet::create_item`] for more details.
-	pub fn create_multiple_items(
-		collection: &FungibleHandle<T>,
-		sender: &T::CrossAccountId,
-		data: BTreeMap<T::CrossAccountId, u128>,
-		nesting_budget: &dyn Budget,
-	) -> DispatchResult {
-		// Foreign collection check
-		ensure!(!collection.flags.foreign, <CommonError<T>>::NoPermission);
 
-		if !collection.is_owner_or_admin(sender) {
-			ensure!(
-				collection.permissions.mint_mode(),
-				<CommonError<T>>::PublicMintingNotAllowed
-			);
-			collection.check_allowlist(sender)?;
-
-			for (owner, _) in data.iter() {
-				collection.check_allowlist(owner)?;
-			}
-		}
-
-		Self::create_multiple_items_common(collection, sender, data, nesting_budget)
-	}
-
-	/// Minting tokens for multiple IDs.
-	/// See [`create_item_foreign`][`Pallet::create_item_foreign`] for more details.
-	pub fn create_multiple_items_foreign(
-		collection: &FungibleHandle<T>,
-		sender: &T::CrossAccountId,
-		data: BTreeMap<T::CrossAccountId, u128>,
-		nesting_budget: &dyn Budget,
-	) -> DispatchResult {
-		Self::create_multiple_items_common(collection, sender, data, nesting_budget)
-	}
-
 	fn set_allowance_unchecked(
 		collection: &FungibleHandle<T>,
 		owner: &T::CrossAccountId,
@@ -795,24 +706,6 @@
 		nesting_budget: &dyn Budget,
 	) -> DispatchResult {
 		Self::create_multiple_items(
-			collection,
-			sender,
-			[(data.0, data.1)].into_iter().collect(),
-			nesting_budget,
-		)
-	}
-
-	/// Creates fungible token.
-	///
-	/// - `data`: Contains user who will become the owners of the tokens and amount
-	///   of tokens he will receive.
-	pub fn create_item_foreign(
-		collection: &FungibleHandle<T>,
-		sender: &T::CrossAccountId,
-		data: CreateItemData<T>,
-		nesting_budget: &dyn Budget,
-	) -> DispatchResult {
-		Self::create_multiple_items_foreign(
 			collection,
 			sender,
 			[(data.0, data.1)].into_iter().collect(),

--- a/pallets/nonfungible/src/benchmarking.rs
+++ b/pallets/nonfungible/src/benchmarking.rs
@@ -18,6 +18,7 @@
 use pallet_common::{
 	bench_init,
 	benchmarking::{create_collection_raw, property_key, property_value},
+	CollectionIssuer, Pallet as PalletCommon,
 };
 use sp_std::prelude::*;
 use up_data_structs::{
@@ -56,7 +57,9 @@
 	create_collection_raw(
 		owner,
 		CollectionMode::NFT,
-		|owner: T::CrossAccountId, data| <Pallet<T>>::init_collection(owner.clone(), owner, data),
+		|owner: T::CrossAccountId, data| {
+			<PalletCommon<T>>::init_collection(owner.clone(), CollectionIssuer::User(owner), data)
+		},
 		NonfungibleHandle::cast,
 	)
 }

--- a/pallets/nonfungible/src/common.rs
+++ b/pallets/nonfungible/src/common.rs
@@ -19,8 +19,8 @@
 use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight};
 use pallet_common::{
 	weights::WeightInfo as _, with_weight, write_token_properties_total_weight,
-	CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions,
-	SelfWeightOf as PalletCommonWeightOf,
+	CommonCollectionOperations, CommonWeightInfo, SelfWeightOf as PalletCommonWeightOf,
+	XcmExtensions,
 };
 use pallet_structure::Pallet as PalletStructure;
 use sp_runtime::DispatchError;
@@ -533,10 +533,6 @@
 		} else {
 			0
 		}
-	}
-
-	fn refungible_extensions(&self) -> Option<&dyn RefungibleExtensions<T>> {
-		None
 	}
 
 	fn total_pieces(&self, token: TokenId) -> Option<u128> {
@@ -547,6 +543,10 @@
 		}
 	}
 
+	fn xcm_extensions(&self) -> Option<&dyn XcmExtensions<T>> {
+		Some(self)
+	}
+
 	fn set_allowance_for_all(
 		&self,
 		owner: T::CrossAccountId,
@@ -570,3 +570,53 @@
 		)
 	}
 }
+
+impl<T: Config> XcmExtensions<T> for NonfungibleHandle<T> {
+	fn token_has_children(&self, token: TokenId) -> bool {
+		<Pallet<T>>::token_has_children(self.id, token)
+	}
+
+	fn create_item_internal(
+		&self,
+		depositor: &<T>::CrossAccountId,
+		to: <T>::CrossAccountId,
+		data: up_data_structs::CreateItemData,
+		nesting_budget: &dyn Budget,
+	) -> Result<TokenId, sp_runtime::DispatchError> {
+		<Pallet<T>>::create_multiple_items(
+			self,
+			depositor,
+			vec![map_create_data::<T>(data, &to)?],
+			nesting_budget,
+		)?;
+
+		Ok(self.last_token_id())
+	}
+
+	fn transfer_item_internal(
+		&self,
+		depositor: &<T>::CrossAccountId,
+		from: &<T>::CrossAccountId,
+		to: &<T>::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+		nesting_budget: &dyn Budget,
+	) -> sp_runtime::DispatchResult {
+		ensure!(amount == 1, <Error<T>>::NonfungibleItemsHaveNoAmount);
+
+		<Pallet<T>>::transfer_internal(self, depositor, from, to, token, nesting_budget)
+			.map(|_| ())
+			.map_err(|post_info| post_info.error)
+	}
+
+	fn burn_item_internal(
+		&self,
+		from: T::CrossAccountId,
+		token: TokenId,
+		amount: u128,
+	) -> sp_runtime::DispatchResult {
+		ensure!(amount == 1, <Error<T>>::NonfungibleItemsHaveNoAmount);
+
+		<Pallet<T>>::burn(self, &from, token)
+	}
+}