git.delta.rocks / unique-network / refs/commits / b45c52c13630

--- /dev/null
+++ b/.docker/Dockerfile-acala.j2
@@ -0,0 +1,41 @@
+# ===== Rust builder =====
+FROM ubuntu:20.04 as rust-builder
+LABEL maintainer="Unique.Network"
+
+ENV CARGO_HOME="/cargo-home"
+ENV PATH="/cargo-home/bin:$PATH"
+ENV TZ=UTC
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+RUN apt-get update && \
+    apt-get install -y curl cmake pkg-config libssl-dev git clang llvm libudev-dev && \
+    apt-get clean && \
+    rm -r /var/lib/apt/lists/*
+
+RUN curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none
+
+RUN rustup toolchain uninstall $(rustup toolchain list) && \
+    rustup toolchain install {{ RUST_TOOLCHAIN }} && \
+    rustup default {{ RUST_TOOLCHAIN }} && \
+    rustup target list --installed && \
+    rustup show
+RUN rustup target add wasm32-unknown-unknown --toolchain {{ RUST_TOOLCHAIN }}
+
+RUN mkdir /unique_parachain
+WORKDIR /unique_parachain
+
+# ===== BUILD ACALA =====
+FROM rust-builder as builder-acala-bin
+
+WORKDIR /unique_parachain
+
+RUN git clone -b {{ ACALA_BUILD_BRANCH }} --depth 1 https://github.com/AcalaNetwork/Acala.git && \
+    cd Acala && \
+    make init && \
+    make build-release
+
+# ===== BIN ======
+
+FROM ubuntu:20.04 as builder-acala
+
+COPY --from=builder-acala-bin /unique_parachain/Acala/target/production/acala /unique_parachain/Acala/target/production/acala

--- /dev/null
+++ b/.docker/Dockerfile-cumulus.j2
@@ -0,0 +1,40 @@
+# ===== Rust builder =====
+FROM ubuntu:20.04 as rust-builder
+LABEL maintainer="Unique.Network"
+
+ENV CARGO_HOME="/cargo-home"
+ENV PATH="/cargo-home/bin:$PATH"
+ENV TZ=UTC
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+RUN apt-get update && \
+    apt-get install -y curl cmake pkg-config libssl-dev git clang llvm libudev-dev && \
+    apt-get clean && \
+    rm -r /var/lib/apt/lists/*
+
+RUN curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none
+
+RUN rustup toolchain uninstall $(rustup toolchain list) && \
+    rustup toolchain install {{ RUST_TOOLCHAIN }} && \
+    rustup default {{ RUST_TOOLCHAIN }} && \
+    rustup target list --installed && \
+    rustup show
+RUN rustup target add wasm32-unknown-unknown --toolchain {{ RUST_TOOLCHAIN }}
+
+RUN mkdir /unique_parachain
+WORKDIR /unique_parachain
+
+# ===== BUILD CUMULUS =====
+FROM rust-builder as builder-cumulus-bin
+
+WORKDIR /unique_parachain
+
+RUN git clone -b {{ CUMULUS_BUILD_BRANCH }} --depth 1 https://github.com/paritytech/cumulus.git && \
+    cd cumulus && \
+    cargo build --release
+
+# ===== BIN ======
+
+FROM ubuntu:20.04 as builder-cumulus
+
+COPY --from=builder-cumulus-bin /unique_parachain/cumulus/target/release/polkadot-parachain /unique_parachain/cumulus/target/release/polkadot-parachain

--- /dev/null
+++ b/.docker/Dockerfile-moonbeam.j2
@@ -0,0 +1,41 @@
+# ===== Rust builder =====
+FROM ubuntu:20.04 as rust-builder
+LABEL maintainer="Unique.Network"
+
+ENV CARGO_HOME="/cargo-home"
+ENV PATH="/cargo-home/bin:$PATH"
+ENV TZ=UTC
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+RUN apt-get update && \
+    apt-get install -y curl cmake pkg-config libssl-dev git clang llvm libudev-dev && \
+    apt-get clean && \
+    rm -r /var/lib/apt/lists/*
+
+RUN curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none
+
+RUN rustup toolchain uninstall $(rustup toolchain list) && \
+    rustup toolchain install {{ RUST_TOOLCHAIN }} && \
+    rustup default {{ RUST_TOOLCHAIN }} && \
+    rustup target list --installed && \
+    rustup show
+RUN rustup target add wasm32-unknown-unknown --toolchain {{ RUST_TOOLCHAIN }}
+
+RUN mkdir /unique_parachain
+WORKDIR /unique_parachain
+
+
+# ===== BUILD MOONBEAM =====
+FROM rust-builder as builder-moonbeam-bin
+
+WORKDIR /unique_parachain
+
+RUN git clone -b {{ MOONBEAM_BUILD_BRANCH }} --depth 1 https://github.com/PureStake/moonbeam.git && \
+    cd moonbeam && \
+    cargo build --release
+
+# ===== BIN ======
+
+FROM ubuntu:20.04 as builder-moonbeam
+
+COPY --from=builder-moonbeam-bin /unique_parachain/moonbeam/target/release/moonbeam /unique_parachain/moonbeam/target/release/moonbeam
\ No newline at end of file

--- /dev/null
+++ b/.docker/Dockerfile-polkadot.j2
@@ -0,0 +1,40 @@
+# ===== Rust builder =====
+FROM ubuntu:20.04 as rust-builder
+LABEL maintainer="Unique.Network"
+
+ENV CARGO_HOME="/cargo-home"
+ENV PATH="/cargo-home/bin:$PATH"
+ENV TZ=UTC
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+RUN apt-get update && \
+    apt-get install -y curl cmake pkg-config libssl-dev git clang llvm libudev-dev && \
+    apt-get clean && \
+    rm -r /var/lib/apt/lists/*
+
+RUN curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none
+
+RUN rustup toolchain uninstall $(rustup toolchain list) && \
+    rustup toolchain install {{ RUST_TOOLCHAIN }} && \
+    rustup default {{ RUST_TOOLCHAIN }} && \
+    rustup target list --installed && \
+    rustup show
+RUN rustup target add wasm32-unknown-unknown --toolchain {{ RUST_TOOLCHAIN }}
+
+RUN mkdir /unique_parachain
+WORKDIR /unique_parachain
+
+# ===== BUILD POLKADOT =====
+FROM rust-builder as builder-polkadot-bin
+
+WORKDIR /unique_parachain
+
+RUN git clone -b {{ POLKADOT_BUILD_BRANCH }} --depth 1 https://github.com/paritytech/polkadot.git && \
+    cd polkadot && \
+    cargo build --release
+
+# ===== BIN ======
+
+FROM ubuntu:20.04 as builder-polkadot
+
+COPY --from=builder-polkadot-bin /unique_parachain/polkadot/target/release/polkadot /unique_parachain/polkadot/target/release/polkadot

--- /dev/null
+++ b/.docker/Dockerfile-xcm.j2
@@ -0,0 +1,85 @@
+# ===== Rust builder =====
+FROM ubuntu:20.04 as rust-builder
+LABEL maintainer="Unique.Network"
+
+ENV CARGO_HOME="/cargo-home"
+ENV PATH="/cargo-home/bin:$PATH"
+ENV TZ=UTC
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+RUN apt-get update && \
+    apt-get install -y curl cmake pkg-config libssl-dev git clang llvm libudev-dev && \
+    apt-get clean && \
+    rm -r /var/lib/apt/lists/*
+
+RUN curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none
+
+RUN rustup toolchain uninstall $(rustup toolchain list) && \
+    rustup toolchain install {{ RUST_TOOLCHAIN }} && \
+    rustup default {{ RUST_TOOLCHAIN }} && \
+    rustup target list --installed && \
+    rustup show
+RUN rustup target add wasm32-unknown-unknown --toolchain {{ RUST_TOOLCHAIN }}
+
+RUN mkdir /unique_parachain
+WORKDIR /unique_parachain
+
+# ===== BUILD ======
+FROM rust-builder as builder-unique
+
+ARG PROFILE=release
+
+WORKDIR /unique_parachain
+
+COPY ./xcm-config/launch-config-xcm-{{ NETWORK }}.json ./launch-config-xcm-{{ NETWORK }}.json
+COPY ./xcm-config/5validators.jsonnet ./5validators.jsonnet
+COPY ./xcm-config/minBondFix.jsonnet ./minBondFix.jsonnet
+
+RUN git clone -b {{ BRANCH }} https://github.com/UniqueNetwork/unique-chain.git && \
+    cd unique-chain && \
+    cargo build --features={{ FEATURE }} --$PROFILE
+
+# ===== RUN ======
+
+FROM ubuntu:20.04
+
+RUN apt-get -y update && \
+      apt-get -y install curl git && \
+      curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash && \
+      export NVM_DIR="$HOME/.nvm" && \
+      [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" && \
+      nvm install v16.16.0 && \
+      nvm use v16.16.0
+
+RUN git clone https://github.com/uniquenetwork/polkadot-launch -b {{ POLKADOT_LAUNCH_BRANCH }}
+
+RUN export NVM_DIR="$HOME/.nvm" && \
+    [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" && \
+    cd /polkadot-launch && \
+    npm install --global yarn && \
+    yarn install
+
+COPY --from=builder-unique /unique_parachain/launch-config-xcm-{{ NETWORK }}.json /polkadot-launch/
+COPY --from=builder-unique /unique_parachain/5validators.jsonnet /polkadot-launch/5validators.jsonnet
+COPY --from=builder-unique /unique_parachain/minBondFix.jsonnet /polkadot-launch/minBondFix.jsonnet
+
+COPY --from=builder-unique /unique_parachain/unique-chain/target/release/unique-collator /unique-chain/target/release/
+
+COPY --from=uniquenetwork/builder-polkadot:{{ POLKADOT_BUILD_BRANCH }} /unique_parachain/polkadot/target/release/polkadot /polkadot/target/release/
+COPY --from=uniquenetwork/builder-moonbeam:{{ MOONBEAM_BUILD_BRANCH }} /unique_parachain/moonbeam/target/release/moonbeam /moonbeam/target/release/
+COPY --from=uniquenetwork/builder-cumulus:{{ CUMULUS_BUILD_BRANCH }} /unique_parachain/cumulus/target/release/polkadot-parachain /cumulus/target/release/cumulus
+COPY --from=uniquenetwork/builder-acala:{{ ACALA_BUILD_BRANCH }} /unique_parachain/Acala/target/production/acala /acala/target/release/
+COPY --from=uniquenetwork/builder-chainql:latest /chainql/target/release/chainql /chainql/target/release/
+
+EXPOSE 9844
+EXPOSE 9933
+EXPOSE 9944
+EXPOSE 9946
+EXPOSE 9947
+EXPOSE 9948
+
+CMD export NVM_DIR="$HOME/.nvm" PATH="$PATH:/chainql/target/release" && \
+    [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" && \
+    cd /polkadot-launch && \
+    yarn start launch-config-xcm-{{ NETWORK }}.json
+

--- /dev/null
+++ b/.docker/docker-compose.tmp-xcm-tests.j2
@@ -0,0 +1,25 @@
+version: "3.5"
+
+services:
+  xcm_nodes:
+    image: uniquenetwork/xcm-{{ NETWORK }}-testnet-local:latest
+    container_name: xcm-{{ NETWORK }}-testnet-local
+    expose:
+      - 9844
+      - 9933
+      - 9944
+      - 9946
+      - 9947
+      - 9948
+    ports:
+      - 127.0.0.1:9844:9844
+      - 127.0.0.1:9933:9933      
+      - 127.0.0.1:9944:9944
+      - 127.0.0.1:9946:9946
+      - 127.0.0.1:9947:9947
+      - 127.0.0.1:9948:9948
+    logging:
+      options:
+        max-size: "1m"
+        max-file: "3"
+

--- /dev/null
+++ b/.docker/xcm-config/5validators.jsonnet
@@ -0,0 +1,50 @@
+
+function(spec)
+  spec {
+    genesis+: {
+      runtime+: {
+        staking+: {
+          validatorCount: 5,
+          invulnerables: [
+            '5GNJqTPyNqANBkUVMN1LPPrxXnFouWXoe2wNSmmEoLctxiZY',
+            '5HpG9w8EBLe5XCrbczpwq5TSXvedjrBGCwqxK1iQ7qUsSWFc',
+            '5Ck5SLSHYac6WFt5UZRSsdJjwmpSZq85fd5TRNAdZQVzEAPT',
+            '5HKPmK9GYtE1PSLsS1qiYU9xQ9Si1NcEhdeCq9sw5bqu4ns8',
+            '5FCfAonRZgTFrTd9HREEyeJjDpT397KMzizE6T3DvebLFE7n',
+          ],
+          stakers: [
+            [
+              '5GNJqTPyNqANBkUVMN1LPPrxXnFouWXoe2wNSmmEoLctxiZY',
+              '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
+              100000000000000,
+              'Validator',
+            ],
+            [
+              '5HpG9w8EBLe5XCrbczpwq5TSXvedjrBGCwqxK1iQ7qUsSWFc',
+              '5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty',
+              100000000000000,
+              'Validator',
+            ],
+            [
+              '5Ck5SLSHYac6WFt5UZRSsdJjwmpSZq85fd5TRNAdZQVzEAPT',
+              '5FLSigC9HGRKVhB9FiEo4Y3koPsNmBmLJbpXg2mp1hXcS59Y',
+              100000000000000,
+              'Validator',
+            ],
+            [
+              '5HKPmK9GYtE1PSLsS1qiYU9xQ9Si1NcEhdeCq9sw5bqu4ns8',
+              '5DAAnrj7VHTznn2AWBemMuyBwZWs6FNFjdyVXUeYum3PTXFy',
+              100000000000000,
+              'Validator',
+            ],
+            [
+              '5FCfAonRZgTFrTd9HREEyeJjDpT397KMzizE6T3DvebLFE7n',
+              '5HGjWAeFDfFCWPsjFQdVV2Msvz2XtMktvgocEZcCj68kUMaw',
+              100000000000000,
+              'Validator',
+            ],
+          ],
+        },
+      },
+    },
+  }

--- /dev/null
+++ b/.docker/xcm-config/launch-config-xcm-opal.json
@@ -0,0 +1,134 @@
+{
+    "relaychain": {
+        "bin": "/polkadot/target/release/polkadot",
+        "chain": "westend-local",
+        "chainInitializer": [
+                "chainql",
+                "--tla-code=spec=import '${spec}'",
+                "5validators.jsonnet"
+            ],	
+        "nodes": [
+            {
+                "name": "alice",
+                "wsPort": 9844,
+                "rpcPort": 9843,
+                "port": 30444,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "bob",
+                "wsPort": 9855,
+                "rpcPort": 9854,
+                "port": 30555,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "charlie",
+                "wsPort": 9866,
+                "rpcPort": 9865,
+                "port": 30666,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "dave",
+                "wsPort": 9877,
+                "rpcPort": 9876,
+                "port": 30777,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "eve",
+                "wsPort": 9888,
+                "rpcPort": 9887,
+                "port": 30888,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            }
+
+        ],
+        "genesis": {
+            "runtime": {
+                "runtime_genesis_config": {
+                    "parachainsConfiguration": {
+                        "config": {
+                            "validation_upgrade_frequency": 1,
+                            "validation_upgrade_delay": 1
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "parachains": [
+        {
+            "bin": "/unique-chain/target/release/unique-collator",
+            "id": "2095",
+            "balance": "1000000000000000000000000",
+            "nodes": [
+                {
+                    "port": 31200,
+                    "wsPort": 9944,
+                    "rpcPort": 9933,
+                    "name": "alice",
+                    "flags": [
+                       "--unsafe-rpc-external",
+                       "--unsafe-ws-external"
+		    ]
+                }
+            ]
+        },
+        {
+            "bin": "/cumulus/target/release/cumulus",
+            "id": "1000",
+            "chain": "westmint-local",
+            "balance": "1000000000000000000000000",
+            "nodes": [
+                {
+                    "wsPort": 9948,
+                    "port": 31204,
+                    "name": "alice",
+                    "flags": [
+                       "--unsafe-rpc-external",
+                       "--unsafe-ws-external"
+                    ]
+                }
+            ]
+        }
+    ],
+    "simpleParachains": [],
+    "hrmpChannels": [
+        {
+            "sender": 2095,
+            "recipient": 1000,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 1000,
+            "recipient": 2095,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        }
+    ],
+    "finalization": false
+}
+

--- /dev/null
+++ b/.docker/xcm-config/launch-config-xcm-quartz.json
@@ -0,0 +1,199 @@
+{
+    "relaychain": {
+        "bin": "/polkadot/target/release/polkadot",
+        "chain": "westend-local",
+        "chainInitializer": [
+                "chainql",
+                "--tla-code=spec=import '${spec}'",
+                "5validators.jsonnet"
+            ],	
+        "nodes": [
+            {
+                "name": "alice",
+                "wsPort": 9844,
+                "rpcPort": 9843,
+                "port": 30444,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "bob",
+                "wsPort": 9855,
+                "rpcPort": 9854,
+                "port": 30555,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "charlie",
+                "wsPort": 9866,
+                "rpcPort": 9865,
+                "port": 30666,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "dave",
+                "wsPort": 9877,
+                "rpcPort": 9876,
+                "port": 30777,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "eve",
+                "wsPort": 9888,
+                "rpcPort": 9887,
+                "port": 30888,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            }
+
+        ],
+        "genesis": {
+            "runtime": {
+                "runtime_genesis_config": {
+                    "parachainsConfiguration": {
+                        "config": {
+                            "validation_upgrade_frequency": 1,
+                            "validation_upgrade_delay": 1
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "parachains": [
+        {
+            "bin": "/unique-chain/target/release/unique-collator",
+            "id": "2095",
+            "balance": "1000000000000000000000000",
+            "nodes": [
+                {
+                    "port": 31200,
+                    "wsPort": 9944,
+                    "rpcPort": 9933,
+                    "name": "alice",
+                    "flags": [
+                       "--unsafe-rpc-external",
+                       "--unsafe-ws-external"
+		    ]
+                }
+            ]
+        },
+        {
+            "bin": "/acala/target/release/acala",
+            "id": "2000",
+            "chain":  "karura-dev",
+            "balance": "1000000000000000000000",
+            "nodes": [
+                {
+                    "wsPort": 9946,
+                    "port": 31202,
+                    "name": "alice",
+                    "flags": [
+                       "--unsafe-rpc-external",
+                       "--unsafe-ws-external"
+                     ]
+                }
+              ]
+        },
+        {
+            "bin": "/moonbeam/target/release/moonbeam",
+            "id": 2023,
+            "balance": "1000000000000000000000",
+            "chain": "moonriver-local",
+            "chainInitializer": [
+                "chainql",
+                "--tla-code=spec=import '${spec}'",
+                "minBondFix.jsonnet"
+            ],		    
+            "nodes": [
+                {
+                    "wsPort": 9947,
+                    "port": 31203,
+                    "name": "alice",
+                    "flags": [
+                       "--unsafe-rpc-external",
+                       "--unsafe-ws-external",
+                        "--",
+                        "--execution=wasm"
+                    ]
+                }
+            ]
+        },
+        {
+            "bin": "/cumulus/target/release/cumulus",
+            "id": "1000",
+            "chain": "statemine-local",
+            "balance": "1000000000000000000000000",
+            "nodes": [
+                {
+                    "wsPort": 9948,
+                    "port": 31204,
+                    "name": "alice",
+                    "flags": [
+                       "--unsafe-rpc-external",
+                       "--unsafe-ws-external"
+                    ]
+                }
+            ]
+        }
+    ],
+    "simpleParachains": [],
+    "hrmpChannels": [
+        {
+            "sender": 2095,
+            "recipient": 2000,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 2000,
+            "recipient": 2095,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 2095,
+            "recipient": 2023,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 2023,
+            "recipient": 2095,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 2095,
+            "recipient": 1000,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 1000,
+            "recipient": 2095,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        }
+    ],
+    "finalization": false
+}
+

--- /dev/null
+++ b/.docker/xcm-config/launch-config-xcm-unique-rococo.json
@@ -0,0 +1,207 @@
+{
+    "relaychain": {
+        "bin": "/polkadot/target/release/polkadot",
+        "chain": "rococo-local",
+        "chainInitializer": [
+                "chainql",
+                "--tla-code=spec=import '${spec}'",
+                "5validators.jsonnet"
+            ],	
+        "nodes": [
+            {
+                "name": "alice",
+                "wsPort": 9844,
+                "rpcPort": 9843,
+                "port": 30444,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "bob",
+                "wsPort": 9855,
+                "rpcPort": 9854,
+                "port": 30555,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "charlie",
+                "wsPort": 9866,
+                "rpcPort": 9865,
+                "port": 30666,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "dave",
+                "wsPort": 9877,
+                "rpcPort": 9876,
+                "port": 30777,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "eve",
+                "wsPort": 9888,
+                "rpcPort": 9887,
+                "port": 30888,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            }
+
+        ],
+        "genesis": {
+            "runtime": {
+                "runtime_genesis_config": {
+                    "parachainsConfiguration": {
+                        "config": {
+                            "validation_upgrade_frequency": 1,
+                            "validation_upgrade_delay": 1
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "parachains": [
+        {
+            "bin": "/unique-chain/target/release/unique-collator",
+            "id": "2037",
+            "balance": "1000000000000000000000000",
+            "nodes": [
+                {
+                    "port": 31200,
+                    "wsPort": 9944,
+                    "rpcPort": 9933,
+                    "name": "alice",
+                    "flags": [
+			"-lruntime=trace",
+			"-lxcm=trace",
+                        "--unsafe-rpc-external",
+                        "--unsafe-ws-external"
+		    ]
+                }
+            ]
+        },
+        {
+            "bin": "/acala/target/release/acala",
+            "id": "2000",
+            "chain":  "acala-dev",
+            "balance": "1000000000000000000000",
+            "chainInitializer": [
+                    "chainql",
+                    "-e",
+                    "(import '${spec}') {id+: '-local'}"
+            ],
+            "nodes": [
+                {
+                    "wsPort": 9946,
+                    "port": 31202,
+                    "name": "alice",
+                    "flags": [
+			"-lruntime=trace",
+			"-lxcm=trace",
+                        "--unsafe-rpc-external",
+                        "--unsafe-ws-external"
+		    ]
+                }
+              ]
+        },
+        {
+            "bin": "/moonbeam/target/release/moonbeam",
+            "id": "2004",
+            "balance": "1000000000000000000000",
+            "chain": "moonbeam-local",
+            "nodes": [
+                {
+                    "wsPort": 9947,
+                    "port": 31203,
+                    "name": "alice",
+                    "flags": [
+			"-lruntime=trace",
+			"-lxcm=trace",
+                        "--unsafe-rpc-external",
+                        "--unsafe-ws-external",
+  			"--",
+                        "--execution=wasm"
+                    ]
+                }
+            ]
+        },
+        {
+            "bin": "/cumulus/target/release/cumulus",
+            "id": "1000",
+            "chain": "statemint-local",
+            "balance": "1000000000000000000000000",
+            "nodes": [
+                {
+                    "wsPort": 9948,
+                    "port": 31204,
+                    "name": "alice",
+                    "flags": [
+			"-lruntime=trace",
+			"-lxcm=trace",
+                        "--unsafe-rpc-external",
+                        "--unsafe-ws-external"
+		    ]
+                }
+            ]
+        }
+    ],
+    "simpleParachains": [],
+    "hrmpChannels": [
+        {
+            "sender": 2037,
+            "recipient": 2000,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 2000,
+            "recipient": 2037,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 2037,
+            "recipient": 2004,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 2004,
+            "recipient": 2037,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 2037,
+            "recipient": 1000,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 1000,
+            "recipient": 2037,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        }
+    ],
+    "finalization": false
+}
+

--- /dev/null
+++ b/.docker/xcm-config/launch-config-xcm-unique.json
@@ -0,0 +1,199 @@
+{
+    "relaychain": {
+        "bin": "/polkadot/target/release/polkadot",
+        "chain": "westend-local",
+        "chainInitializer": [
+                "chainql",
+                "--tla-code=spec=import '${spec}'",
+                "5validators.jsonnet"
+            ],	
+        "nodes": [
+            {
+                "name": "alice",
+                "wsPort": 9844,
+                "rpcPort": 9843,
+                "port": 30444,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "bob",
+                "wsPort": 9855,
+                "rpcPort": 9854,
+                "port": 30555,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "charlie",
+                "wsPort": 9866,
+                "rpcPort": 9865,
+                "port": 30666,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "dave",
+                "wsPort": 9877,
+                "rpcPort": 9876,
+                "port": 30777,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            },
+            {
+                "name": "eve",
+                "wsPort": 9888,
+                "rpcPort": 9887,
+                "port": 30888,
+                "flags": [
+                    "--unsafe-rpc-external",
+                    "--unsafe-ws-external",
+                    "-lparachain::candidate_validation=debug"
+                ]
+            }
+
+        ],
+        "genesis": {
+            "runtime": {
+                "runtime_genesis_config": {
+                    "parachainsConfiguration": {
+                        "config": {
+                            "validation_upgrade_frequency": 1,
+                            "validation_upgrade_delay": 1
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "parachains": [
+        {
+            "bin": "/unique-chain/target/release/unique-collator",
+            "id": "2037",
+            "balance": "1000000000000000000000000",
+            "nodes": [
+                {
+                    "port": 31200,
+                    "wsPort": 9944,
+                    "rpcPort": 9933,
+                    "name": "alice",
+                    "flags": [
+                        "--unsafe-rpc-external",
+                        "--unsafe-ws-external"
+		    ]
+                }
+            ]
+        },
+        {
+            "bin": "/acala/target/release/acala",
+            "id": "2000",
+            "chain":  "acala-dev",
+            "balance": "1000000000000000000000",
+            "chainInitializer": [
+                    "chainql",
+                    "-e",
+                    "(import '${spec}') {id+: '-local'}"
+            ],	    
+            "nodes": [
+                {
+                    "wsPort": 9946,
+                    "port": 31202,
+                    "name": "alice",
+                    "flags": [
+                        "--unsafe-rpc-external",
+                        "--unsafe-ws-external"
+		    ]
+                }
+              ]
+        },
+        {
+            "bin": "/moonbeam/target/release/moonbeam",
+            "id": "2004",
+            "balance": "1000000000000000000000",
+            "chain": "moonbeam-local",
+            "nodes": [
+                {
+                    "wsPort": 9947,
+                    "port": 31203,
+                    "name": "alice",
+                    "flags": [
+                        "--unsafe-rpc-external",
+                        "--unsafe-ws-external",
+  			"--",
+                        "--execution=wasm"
+                    ]
+                }
+            ]
+        },
+        {
+            "bin": "/cumulus/target/release/cumulus",
+            "id": "1000",
+            "chain": "statemint-local",
+            "balance": "1000000000000000000000000",
+            "nodes": [
+                {
+                    "wsPort": 9948,
+                    "port": 31204,
+                    "name": "alice",
+                    "flags": [
+                        "--unsafe-rpc-external",
+                        "--unsafe-ws-external"
+		    ]
+                }
+            ]
+        }
+    ],
+    "simpleParachains": [],
+    "hrmpChannels": [
+        {
+            "sender": 2037,
+            "recipient": 2000,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 2000,
+            "recipient": 2037,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 2037,
+            "recipient": 2004,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 2004,
+            "recipient": 2037,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 2037,
+            "recipient": 1000,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        },
+        {
+            "sender": 1000,
+            "recipient": 2037,
+            "maxCapacity": 8,
+            "maxMessageSize": 512
+        }
+    ],
+    "finalization": false
+}
+

--- /dev/null
+++ b/.docker/xcm-config/minBondFix.jsonnet
@@ -0,0 +1,10 @@
+function(spec)
+spec {
+	genesis+: {
+		runtime+: {
+			parachainStaking+: {
+				candidates: std.map(function(candidate) [candidate[0], candidate[1] * 1000], super.candidates)
+			},
+		},
+	},
+}

--- /dev/null
+++ b/crates/evm-coder/tests/conditional_is.rs
@@ -0,0 +1,44 @@
+use evm_coder::{types::*, solidity_interface, execution::Result, Call};
+
+pub struct Contract(bool);
+
+#[solidity_interface(name = A)]
+impl Contract {
+	fn method_a() -> Result<void> {
+		Ok(())
+	}
+}
+
+#[solidity_interface(name = B)]
+impl Contract {
+	fn method_b() -> Result<void> {
+		Ok(())
+	}
+}
+
+#[solidity_interface(name = Contract, is(
+	A(if(this.0)),
+	B(if(!this.0)),
+))]
+impl Contract {}
+
+#[test]
+fn conditional_erc165() {
+	assert!(ContractCall::supports_interface(
+		&Contract(true),
+		ACall::METHOD_A
+	));
+	assert!(!ContractCall::supports_interface(
+		&Contract(false),
+		ACall::METHOD_A
+	));
+
+	assert!(ContractCall::supports_interface(
+		&Contract(false),
+		BCall::METHOD_B
+	));
+	assert!(!ContractCall::supports_interface(
+		&Contract(true),
+		BCall::METHOD_B
+	));
+}

--- /dev/null
+++ b/pallets/foreign-assets/Cargo.toml
@@ -0,0 +1,53 @@
+[package]
+name = "pallet-foreign-assets"
+version = "0.1.0"
+license = "GPLv3"
+edition = "2021"
+
+[dependencies]
+log = { version = "0.4.16", default-features = false }
+serde = { version = "1.0.136", optional = true }
+scale-info = { version = "2.0.1", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false }
+sp-runtime = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.27", default-features = false }
+sp-std = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.27", default-features = false  }
+frame-support = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.27", default-features = false }
+frame-system = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.27", default-features = false }
+up-data-structs = { default-features = false, path = '../../primitives/data-structs' }
+pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.27", default-features = false }
+pallet-common = { default-features = false, path = '../common' }
+pallet-fungible = { default-features = false, path = '../fungible' }
+xcm = { git = "https://github.com/paritytech/polkadot", branch = "release-v0.9.27", default-features = false }
+xcm-builder = { git = "https://github.com/paritytech/polkadot", branch = "release-v0.9.27", default-features = false }
+xcm-executor = { git = "https://github.com/paritytech/polkadot", branch = "release-v0.9.27", default-features = false }
+#orml-tokens = { git = 'https://github.com/UniqueNetwork/open-runtime-module-library', branch = 'unique-polkadot-v0.9.24', version = "0.4.1-dev", default-features = false }
+orml-tokens = { git = "https://github.com/open-web3-stack/open-runtime-module-library", branch = "polkadot-v0.9.27", version = "0.4.1-dev", default-features = false }
+frame-benchmarking = { default-features = false, optional = true, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.27" }
+
+[dev-dependencies]
+serde_json = "1.0.68"
+hex = { version = "0.4" }
+sp-core = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.27" }
+sp-io = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.27" }
+pallet-timestamp = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.27" }
+pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.27" }
+
+[features]
+default = ["std"]
+std = [
+	"serde",
+	"log/std",
+	"codec/std",
+	"scale-info/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"frame-support/std",
+	"frame-system/std",
+	"up-data-structs/std",
+	"pallet-common/std",
+	"pallet-balances/std",
+	"pallet-fungible/std",
+	"orml-tokens/std"
+]
+try-runtime = ["frame-support/try-runtime"]
+runtime-benchmarks = ['frame-benchmarking', 'pallet-common/runtime-benchmarks']
\ No newline at end of file

--- /dev/null
+++ b/pallets/foreign-assets/src/benchmarking.rs
@@ -0,0 +1,68 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+#![allow(missing_docs)]
+
+use super::{Config, Pallet, Call};
+use frame_benchmarking::{benchmarks, account};
+use frame_system::RawOrigin;
+use crate::AssetMetadata;
+use xcm::opaque::latest::Junction::Parachain;
+use xcm::VersionedMultiLocation;
+use frame_support::{
+	traits::{Currency},
+};
+use sp_std::boxed::Box;
+
+benchmarks! {
+	register_foreign_asset {
+		let owner: T::AccountId = account("user", 0, 1);
+		let location: VersionedMultiLocation = VersionedMultiLocation::from(Parachain(1000).into());
+		let metadata: AssetMetadata<<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance> = AssetMetadata{
+			name: "name".into(),
+			symbol: "symbol".into(),
+			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);
+	}: _(RawOrigin::Root, owner, Box::new(location), Box::new(metadata))
+
+	update_foreign_asset {
+		let owner: T::AccountId = account("user", 0, 1);
+		let location: VersionedMultiLocation = VersionedMultiLocation::from(Parachain(2000).into());
+		let metadata: AssetMetadata<<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance> = AssetMetadata{
+			name: "name".into(),
+			symbol: "symbol".into(),
+			decimals: 18,
+			minimal_balance: 1u32.into()
+		};
+		let metadata2: AssetMetadata<<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance> = AssetMetadata{
+			name: "name2".into(),
+			symbol: "symbol2".into(),
+			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))?;
+	}: _(RawOrigin::Root, 0, Box::new(location), Box::new(metadata2))
+}

--- /dev/null
+++ b/pallets/foreign-assets/src/impl_fungibles.rs
@@ -0,0 +1,454 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+//! Implementations for fungibles trait.
+
+use super::*;
+use frame_system::Config as SystemConfig;
+
+use frame_support::traits::tokens::{DepositConsequence, WithdrawConsequence};
+use pallet_common::CollectionHandle;
+use pallet_fungible::FungibleHandle;
+use pallet_common::CommonCollectionOperations;
+use up_data_structs::budget::Value;
+use sp_runtime::traits::{CheckedAdd, CheckedSub};
+
+impl<T: Config> fungibles::Inspect<<T as SystemConfig>::AccountId> for Pallet<T>
+where
+	T: orml_tokens::Config<CurrencyId = AssetIds>,
+	BalanceOf<T>: From<<T as pallet_balances::Config>::Balance>,
+	BalanceOf<T>: From<<T as orml_tokens::Config>::Balance>,
+	<T as pallet_balances::Config>::Balance: From<BalanceOf<T>>,
+	<T as orml_tokens::Config>::Balance: From<BalanceOf<T>>,
+{
+	type AssetId = AssetIds;
+	type Balance = BalanceOf<T>;
+
+	fn total_issuance(asset: Self::AssetId) -> Self::Balance {
+		log::trace!(target: "fassets::impl_foreign_assets", "impl_fungible total_issuance");
+
+		match asset {
+			AssetIds::NativeAssetId(NativeCurrency::Here) => {
+				<pallet_balances::Pallet<T> as fungible::Inspect<T::AccountId>>::total_issuance()
+					.into()
+			}
+			AssetIds::NativeAssetId(NativeCurrency::Parent) => {
+				<orml_tokens::Pallet<T> as fungibles::Inspect<T::AccountId>>::total_issuance(
+					AssetIds::NativeAssetId(NativeCurrency::Parent),
+				)
+				.into()
+			}
+			AssetIds::ForeignAssetId(fid) => {
+				let target_collection_id = match <AssetBinding<T>>::get(fid) {
+					Some(v) => v,
+					None => return Zero::zero(),
+				};
+				let collection_handle = match <CollectionHandle<T>>::try_get(target_collection_id) {
+					Ok(v) => v,
+					Err(_) => return Zero::zero(),
+				};
+				let collection = FungibleHandle::cast(collection_handle);
+				Self::Balance::try_from(collection.total_supply()).unwrap_or(Zero::zero())
+			}
+		}
+	}
+
+	fn minimum_balance(asset: Self::AssetId) -> Self::Balance {
+		log::trace!(target: "fassets::impl_foreign_assets", "impl_fungible minimum_balance");
+		match asset {
+			AssetIds::NativeAssetId(NativeCurrency::Here) => {
+				<pallet_balances::Pallet<T> as fungible::Inspect<T::AccountId>>::minimum_balance()
+					.into()
+			}
+			AssetIds::NativeAssetId(NativeCurrency::Parent) => {
+				<orml_tokens::Pallet<T> as fungibles::Inspect<T::AccountId>>::minimum_balance(
+					AssetIds::NativeAssetId(NativeCurrency::Parent),
+				)
+				.into()
+			}
+			AssetIds::ForeignAssetId(fid) => {
+				AssetMetadatas::<T>::get(AssetIds::ForeignAssetId(fid))
+					.map(|x| x.minimal_balance)
+					.unwrap_or_else(Zero::zero)
+			}
+		}
+	}
+
+	fn balance(asset: Self::AssetId, who: &<T as SystemConfig>::AccountId) -> Self::Balance {
+		log::trace!(target: "fassets::impl_foreign_assets", "impl_fungible balance");
+		match asset {
+			AssetIds::NativeAssetId(NativeCurrency::Here) => {
+				<pallet_balances::Pallet<T> as fungible::Inspect<T::AccountId>>::balance(who).into()
+			}
+			AssetIds::NativeAssetId(NativeCurrency::Parent) => {
+				<orml_tokens::Pallet<T> as fungibles::Inspect<T::AccountId>>::balance(
+					AssetIds::NativeAssetId(NativeCurrency::Parent),
+					who,
+				)
+				.into()
+			}
+			AssetIds::ForeignAssetId(fid) => {
+				let target_collection_id = match <AssetBinding<T>>::get(fid) {
+					Some(v) => v,
+					None => return Zero::zero(),
+				};
+				let collection_handle = match <CollectionHandle<T>>::try_get(target_collection_id) {
+					Ok(v) => v,
+					Err(_) => return Zero::zero(),
+				};
+				let collection = FungibleHandle::cast(collection_handle);
+				Self::Balance::try_from(
+					collection.balance(T::CrossAccountId::from_sub(who.clone()), TokenId(0)),
+				)
+				.unwrap_or(Zero::zero())
+			}
+		}
+	}
+
+	fn reducible_balance(
+		asset: Self::AssetId,
+		who: &<T as SystemConfig>::AccountId,
+		keep_alive: bool,
+	) -> Self::Balance {
+		log::trace!(target: "fassets::impl_foreign_assets", "impl_fungible reducible_balance");
+
+		match asset {
+			AssetIds::NativeAssetId(NativeCurrency::Here) => {
+				<pallet_balances::Pallet<T> as fungible::Inspect<T::AccountId>>::reducible_balance(
+					who, keep_alive,
+				)
+				.into()
+			}
+			AssetIds::NativeAssetId(NativeCurrency::Parent) => {
+				<orml_tokens::Pallet<T> as fungibles::Inspect<T::AccountId>>::reducible_balance(
+					AssetIds::NativeAssetId(NativeCurrency::Parent),
+					who,
+					keep_alive,
+				)
+				.into()
+			}
+			_ => Self::balance(asset, who),
+		}
+	}
+
+	fn can_deposit(
+		asset: Self::AssetId,
+		who: &<T as SystemConfig>::AccountId,
+		amount: Self::Balance,
+		mint: bool,
+	) -> DepositConsequence {
+		log::trace!(target: "fassets::impl_foreign_assets", "impl_fungible can_deposit");
+
+		match asset {
+			AssetIds::NativeAssetId(NativeCurrency::Here) => {
+				<pallet_balances::Pallet<T> as fungible::Inspect<T::AccountId>>::can_deposit(
+					who,
+					amount.into(),
+					mint,
+				)
+			}
+			AssetIds::NativeAssetId(NativeCurrency::Parent) => {
+				<orml_tokens::Pallet<T> as fungibles::Inspect<T::AccountId>>::can_deposit(
+					AssetIds::NativeAssetId(NativeCurrency::Parent),
+					who,
+					amount.into(),
+					mint,
+				)
+			}
+			_ => {
+				if amount.is_zero() {
+					return DepositConsequence::Success;
+				}
+
+				let extential_deposit_value = T::ExistentialDeposit::get();
+				let ed_value: u128 = match extential_deposit_value.try_into() {
+					Ok(val) => val,
+					Err(_) => return DepositConsequence::CannotCreate,
+				};
+				let extential_deposit: Self::Balance = match ed_value.try_into() {
+					Ok(val) => val,
+					Err(_) => return DepositConsequence::CannotCreate,
+				};
+
+				let new_total_balance = match Self::balance(asset, who).checked_add(&amount) {
+					Some(x) => x,
+					None => return DepositConsequence::Overflow,
+				};
+
+				if new_total_balance < extential_deposit {
+					return DepositConsequence::BelowMinimum;
+				}
+
+				DepositConsequence::Success
+			}
+		}
+	}
+
+	fn can_withdraw(
+		asset: Self::AssetId,
+		who: &<T as SystemConfig>::AccountId,
+		amount: Self::Balance,
+	) -> WithdrawConsequence<Self::Balance> {
+		log::trace!(target: "fassets::impl_foreign_assets", "impl_fungible can_withdraw");
+		let value: u128 = match amount.try_into() {
+			Ok(val) => val,
+			Err(_) => return WithdrawConsequence::UnknownAsset,
+		};
+
+		match asset {
+			AssetIds::NativeAssetId(NativeCurrency::Here) => {
+				let this_amount: <T as pallet_balances::Config>::Balance = match value.try_into() {
+					Ok(val) => val,
+					Err(_) => {
+						return WithdrawConsequence::UnknownAsset;
+					}
+				};
+				match <pallet_balances::Pallet<T> as fungible::Inspect<T::AccountId>>::can_withdraw(
+					who,
+					this_amount,
+				) {
+					WithdrawConsequence::NoFunds => WithdrawConsequence::NoFunds,
+					WithdrawConsequence::WouldDie => WithdrawConsequence::WouldDie,
+					WithdrawConsequence::UnknownAsset => WithdrawConsequence::UnknownAsset,
+					WithdrawConsequence::Underflow => WithdrawConsequence::Underflow,
+					WithdrawConsequence::Overflow => WithdrawConsequence::Overflow,
+					WithdrawConsequence::Frozen => WithdrawConsequence::Frozen,
+					WithdrawConsequence::Success => WithdrawConsequence::Success,
+					_ => WithdrawConsequence::NoFunds,
+				}
+			}
+			AssetIds::NativeAssetId(NativeCurrency::Parent) => {
+				let parent_amount: <T as orml_tokens::Config>::Balance = match value.try_into() {
+					Ok(val) => val,
+					Err(_) => {
+						return WithdrawConsequence::UnknownAsset;
+					}
+				};
+				match <orml_tokens::Pallet<T> as fungibles::Inspect<T::AccountId>>::can_withdraw(
+					AssetIds::NativeAssetId(NativeCurrency::Parent),
+					who,
+					parent_amount,
+				) {
+					WithdrawConsequence::NoFunds => WithdrawConsequence::NoFunds,
+					WithdrawConsequence::WouldDie => WithdrawConsequence::WouldDie,
+					WithdrawConsequence::UnknownAsset => WithdrawConsequence::UnknownAsset,
+					WithdrawConsequence::Underflow => WithdrawConsequence::Underflow,
+					WithdrawConsequence::Overflow => WithdrawConsequence::Overflow,
+					WithdrawConsequence::Frozen => WithdrawConsequence::Frozen,
+					WithdrawConsequence::Success => WithdrawConsequence::Success,
+					_ => WithdrawConsequence::NoFunds,
+				}
+			}
+			_ => match Self::balance(asset, who).checked_sub(&amount) {
+				Some(_) => WithdrawConsequence::Success,
+				None => WithdrawConsequence::NoFunds,
+			},
+		}
+	}
+}
+
+impl<T: Config> fungibles::Mutate<<T as SystemConfig>::AccountId> for Pallet<T>
+where
+	T: orml_tokens::Config<CurrencyId = AssetIds>,
+	BalanceOf<T>: From<<T as pallet_balances::Config>::Balance>,
+	BalanceOf<T>: From<<T as orml_tokens::Config>::Balance>,
+	<T as pallet_balances::Config>::Balance: From<BalanceOf<T>>,
+	<T as orml_tokens::Config>::Balance: From<BalanceOf<T>>,
+	u128: From<BalanceOf<T>>,
+{
+	fn mint_into(
+		asset: Self::AssetId,
+		who: &<T as SystemConfig>::AccountId,
+		amount: Self::Balance,
+	) -> DispatchResult {
+		//Self::do_mint(asset, who, amount, None)
+		log::trace!(target: "fassets::impl_foreign_assets", "impl_fungible mint_into {:?}", asset);
+
+		match asset {
+			AssetIds::NativeAssetId(NativeCurrency::Here) => {
+				<pallet_balances::Pallet<T> as fungible::Mutate<T::AccountId>>::mint_into(
+					who,
+					amount.into(),
+				)
+				.into()
+			}
+			AssetIds::NativeAssetId(NativeCurrency::Parent) => {
+				<orml_tokens::Pallet<T> as fungibles::Mutate<T::AccountId>>::mint_into(
+					AssetIds::NativeAssetId(NativeCurrency::Parent),
+					who,
+					amount.into(),
+				)
+				.into()
+			}
+			AssetIds::ForeignAssetId(fid) => {
+				let target_collection_id = match <AssetBinding<T>>::get(fid) {
+					Some(v) => v,
+					None => {
+						return Err(DispatchError::Other(
+							"Associated collection not found for asset",
+						))
+					}
+				};
+				let collection =
+					FungibleHandle::cast(<CollectionHandle<T>>::try_get(target_collection_id)?);
+				let account = T::CrossAccountId::from_sub(who.clone());
+
+				let amount_data: pallet_fungible::CreateItemData<T> =
+					(account.clone(), amount.into());
+
+				pallet_fungible::Pallet::<T>::create_item_foreign(
+					&collection,
+					&account,
+					amount_data,
+					&Value::new(0),
+				)?;
+
+				Ok(())
+			}
+		}
+	}
+
+	fn burn_from(
+		asset: Self::AssetId,
+		who: &<T as SystemConfig>::AccountId,
+		amount: Self::Balance,
+	) -> Result<Self::Balance, DispatchError> {
+		// let f = DebitFlags { keep_alive: false, best_effort: false };
+		log::trace!(target: "fassets::impl_foreign_assets", "impl_fungible burn_from");
+
+		match asset {
+			AssetIds::NativeAssetId(NativeCurrency::Here) => {
+				match <pallet_balances::Pallet<T> as fungible::Mutate<T::AccountId>>::burn_from(
+					who,
+					amount.into(),
+				) {
+					Ok(v) => Ok(v.into()),
+					Err(e) => Err(e),
+				}
+			}
+			AssetIds::NativeAssetId(NativeCurrency::Parent) => {
+				match <orml_tokens::Pallet<T> as fungibles::Mutate<T::AccountId>>::burn_from(
+					AssetIds::NativeAssetId(NativeCurrency::Parent),
+					who,
+					amount.into(),
+				) {
+					Ok(v) => Ok(v.into()),
+					Err(e) => Err(e),
+				}
+			}
+			AssetIds::ForeignAssetId(fid) => {
+				let target_collection_id = match <AssetBinding<T>>::get(fid) {
+					Some(v) => v,
+					None => {
+						return Err(DispatchError::Other(
+							"Associated collection not found for asset",
+						))
+					}
+				};
+				let collection =
+					FungibleHandle::cast(<CollectionHandle<T>>::try_get(target_collection_id)?);
+				pallet_fungible::Pallet::<T>::burn_foreign(
+					&collection,
+					&T::CrossAccountId::from_sub(who.clone()),
+					amount.into(),
+				)?;
+
+				Ok(amount)
+			}
+		}
+	}
+
+	fn slash(
+		asset: Self::AssetId,
+		who: &<T as SystemConfig>::AccountId,
+		amount: Self::Balance,
+	) -> Result<Self::Balance, DispatchError> {
+		// let f = DebitFlags { keep_alive: false, best_effort: true };
+		log::trace!(target: "fassets::impl_foreign_assets", "impl_fungible slash");
+		Ok(Self::burn_from(asset, who, amount)?)
+	}
+}
+
+impl<T: Config> fungibles::Transfer<T::AccountId> for Pallet<T>
+where
+	T: orml_tokens::Config<CurrencyId = AssetIds>,
+	BalanceOf<T>: From<<T as pallet_balances::Config>::Balance>,
+	BalanceOf<T>: From<<T as orml_tokens::Config>::Balance>,
+	<T as pallet_balances::Config>::Balance: From<BalanceOf<T>>,
+	<T as orml_tokens::Config>::Balance: From<BalanceOf<T>>,
+	u128: From<BalanceOf<T>>,
+{
+	fn transfer(
+		asset: Self::AssetId,
+		source: &<T as SystemConfig>::AccountId,
+		dest: &<T as SystemConfig>::AccountId,
+		amount: Self::Balance,
+		keep_alive: bool,
+	) -> Result<Self::Balance, DispatchError> {
+		// let f = TransferFlags { keep_alive, best_effort: false, burn_dust: false };
+		log::trace!(target: "fassets::impl_foreign_assets", "impl_fungible transfer");
+
+		match asset {
+			AssetIds::NativeAssetId(NativeCurrency::Here) => {
+				match <pallet_balances::Pallet<T> as fungible::Transfer<T::AccountId>>::transfer(
+					source,
+					dest,
+					amount.into(),
+					keep_alive,
+				) {
+					Ok(_) => Ok(amount),
+					Err(_) => Err(DispatchError::Other(
+						"Bad amount to relay chain value conversion",
+					)),
+				}
+			}
+			AssetIds::NativeAssetId(NativeCurrency::Parent) => {
+				match <orml_tokens::Pallet<T> as fungibles::Transfer<T::AccountId>>::transfer(
+					AssetIds::NativeAssetId(NativeCurrency::Parent),
+					source,
+					dest,
+					amount.into(),
+					keep_alive,
+				) {
+					Ok(_) => Ok(amount),
+					Err(e) => Err(e),
+				}
+			}
+			AssetIds::ForeignAssetId(fid) => {
+				let target_collection_id = match <AssetBinding<T>>::get(fid) {
+					Some(v) => v,
+					None => {
+						return Err(DispatchError::Other(
+							"Associated collection not found for asset",
+						))
+					}
+				};
+				let collection =
+					FungibleHandle::cast(<CollectionHandle<T>>::try_get(target_collection_id)?);
+
+				pallet_fungible::Pallet::<T>::transfer(
+					&collection,
+					&T::CrossAccountId::from_sub(source.clone()),
+					&T::CrossAccountId::from_sub(dest.clone()),
+					amount.into(),
+					&Value::new(0),
+				)?;
+
+				Ok(amount)
+			}
+		}
+	}
+}

--- /dev/null
+++ b/pallets/foreign-assets/src/lib.rs
@@ -0,0 +1,498 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+//! # Foreign assets
+//!
+//! - [`Config`]
+//! - [`Call`]
+//! - [`Pallet`]
+//!
+//! ## Overview
+//!
+//! The foreign assests pallet provides functions for:
+//!
+//! - Local and foreign assets management. The foreign assets can be updated without runtime upgrade.
+//! - Bounds between asset and target collection for cross chain transfer and inner transfers.
+//!
+//! ## Overview
+//!
+//! Under construction
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![allow(clippy::unused_unit)]
+
+use frame_support::{
+	dispatch::DispatchResult,
+	ensure,
+	pallet_prelude::*,
+	traits::{fungible, fungibles, Currency, EnsureOrigin},
+	RuntimeDebug,
+};
+use frame_system::pallet_prelude::*;
+use up_data_structs::{CollectionMode};
+use pallet_fungible::{Pallet as PalletFungible};
+use scale_info::{TypeInfo};
+use sp_runtime::{
+	traits::{One, Zero},
+	ArithmeticError,
+};
+use sp_std::{boxed::Box, vec::Vec};
+use up_data_structs::{CollectionId, TokenId, CreateCollectionData};
+
+// NOTE:v1::MultiLocation is used in storages, we would need to do migration if upgrade the
+// MultiLocation in the future.
+use xcm::opaque::latest::prelude::XcmError;
+use xcm::{v1::MultiLocation, VersionedMultiLocation};
+use xcm_executor::{traits::WeightTrader, Assets};
+
+use pallet_common::erc::CrossAccountId;
+
+#[cfg(feature = "std")]
+use serde::{Deserialize, Serialize};
+
+// TODO: Move to primitives
+// Id of native currency.
+// 0 - QTZ\UNQ
+// 1 - KSM\DOT
+#[derive(
+	Clone,
+	Copy,
+	Eq,
+	PartialEq,
+	PartialOrd,
+	Ord,
+	MaxEncodedLen,
+	RuntimeDebug,
+	Encode,
+	Decode,
+	TypeInfo,
+)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub enum NativeCurrency {
+	Here = 0,
+	Parent = 1,
+}
+
+#[derive(
+	Clone,
+	Copy,
+	Eq,
+	PartialEq,
+	PartialOrd,
+	Ord,
+	MaxEncodedLen,
+	RuntimeDebug,
+	Encode,
+	Decode,
+	TypeInfo,
+)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub enum AssetIds {
+	ForeignAssetId(ForeignAssetId),
+	NativeAssetId(NativeCurrency),
+}
+
+pub trait TryAsForeign<T, F> {
+	fn try_as_foreign(asset: T) -> Option<F>;
+}
+
+impl TryAsForeign<AssetIds, ForeignAssetId> for AssetIds {
+	fn try_as_foreign(asset: AssetIds) -> Option<ForeignAssetId> {
+		match asset {
+			AssetIds::ForeignAssetId(id) => Some(id),
+			_ => None,
+		}
+	}
+}
+
+pub type ForeignAssetId = u32;
+pub type CurrencyId = AssetIds;
+
+mod impl_fungibles;
+pub mod weights;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+
+pub use module::*;
+pub use weights::WeightInfo;
+
+/// Type alias for currency balance.
+pub type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+
+/// A mapping between ForeignAssetId and AssetMetadata.
+pub trait AssetIdMapping<ForeignAssetId, MultiLocation, AssetMetadata> {
+	/// Returns the AssetMetadata associated with a given ForeignAssetId.
+	fn get_asset_metadata(foreign_asset_id: ForeignAssetId) -> Option<AssetMetadata>;
+	/// Returns the MultiLocation associated with a given ForeignAssetId.
+	fn get_multi_location(foreign_asset_id: ForeignAssetId) -> Option<MultiLocation>;
+	/// Returns the CurrencyId associated with a given MultiLocation.
+	fn get_currency_id(multi_location: MultiLocation) -> Option<CurrencyId>;
+}
+
+pub struct XcmForeignAssetIdMapping<T>(sp_std::marker::PhantomData<T>);
+
+impl<T: Config> AssetIdMapping<ForeignAssetId, MultiLocation, AssetMetadata<BalanceOf<T>>>
+	for XcmForeignAssetIdMapping<T>
+{
+	fn get_asset_metadata(foreign_asset_id: ForeignAssetId) -> Option<AssetMetadata<BalanceOf<T>>> {
+		log::trace!(target: "fassets::asset_metadatas", "call");
+		Pallet::<T>::asset_metadatas(AssetIds::ForeignAssetId(foreign_asset_id))
+	}
+
+	fn get_multi_location(foreign_asset_id: ForeignAssetId) -> Option<MultiLocation> {
+		log::trace!(target: "fassets::get_multi_location", "call");
+		Pallet::<T>::foreign_asset_locations(foreign_asset_id)
+	}
+
+	fn get_currency_id(multi_location: MultiLocation) -> Option<CurrencyId> {
+		log::trace!(target: "fassets::get_currency_id", "call");
+		Some(AssetIds::ForeignAssetId(
+			Pallet::<T>::location_to_currency_ids(multi_location).unwrap_or(0),
+		))
+	}
+}
+
+#[frame_support::pallet]
+pub mod module {
+	use super::*;
+
+	#[pallet::config]
+	pub trait Config:
+		frame_system::Config
+		+ pallet_common::Config
+		+ pallet_fungible::Config
+		+ orml_tokens::Config
+		+ pallet_balances::Config
+	{
+		/// The overarching event type.
+		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
+
+		/// Currency type for withdraw and balance storage.
+		type Currency: Currency<Self::AccountId>;
+
+		/// Required origin for registering asset.
+		type RegisterOrigin: EnsureOrigin<Self::Origin>;
+
+		/// Weight information for the extrinsics in this module.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[derive(Clone, Eq, PartialEq, RuntimeDebug, Encode, Decode, TypeInfo)]
+	pub struct AssetMetadata<Balance> {
+		pub name: Vec<u8>,
+		pub symbol: Vec<u8>,
+		pub decimals: u8,
+		pub minimal_balance: Balance,
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// The given location could not be used (e.g. because it cannot be expressed in the
+		/// desired version of XCM).
+		BadLocation,
+		/// MultiLocation existed
+		MultiLocationExisted,
+		/// AssetId not exists
+		AssetIdNotExists,
+		/// AssetId exists
+		AssetIdExisted,
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// The foreign asset registered.
+		ForeignAssetRegistered {
+			asset_id: ForeignAssetId,
+			asset_address: MultiLocation,
+			metadata: AssetMetadata<BalanceOf<T>>,
+		},
+		/// The foreign asset updated.
+		ForeignAssetUpdated {
+			asset_id: ForeignAssetId,
+			asset_address: MultiLocation,
+			metadata: AssetMetadata<BalanceOf<T>>,
+		},
+		/// The asset registered.
+		AssetRegistered {
+			asset_id: AssetIds,
+			metadata: AssetMetadata<BalanceOf<T>>,
+		},
+		/// The asset updated.
+		AssetUpdated {
+			asset_id: AssetIds,
+			metadata: AssetMetadata<BalanceOf<T>>,
+		},
+	}
+
+	/// Next available Foreign AssetId ID.
+	///
+	/// NextForeignAssetId: ForeignAssetId
+	#[pallet::storage]
+	#[pallet::getter(fn next_foreign_asset_id)]
+	pub type NextForeignAssetId<T: Config> = StorageValue<_, ForeignAssetId, ValueQuery>;
+	/// The storages for MultiLocations.
+	///
+	/// ForeignAssetLocations: map ForeignAssetId => Option<MultiLocation>
+	#[pallet::storage]
+	#[pallet::getter(fn foreign_asset_locations)]
+	pub type ForeignAssetLocations<T: Config> =
+		StorageMap<_, Twox64Concat, ForeignAssetId, MultiLocation, OptionQuery>;
+
+	/// The storages for CurrencyIds.
+	///
+	/// LocationToCurrencyIds: map MultiLocation => Option<ForeignAssetId>
+	#[pallet::storage]
+	#[pallet::getter(fn location_to_currency_ids)]
+	pub type LocationToCurrencyIds<T: Config> =
+		StorageMap<_, Twox64Concat, MultiLocation, ForeignAssetId, OptionQuery>;
+
+	/// The storages for AssetMetadatas.
+	///
+	/// AssetMetadatas: map AssetIds => Option<AssetMetadata>
+	#[pallet::storage]
+	#[pallet::getter(fn asset_metadatas)]
+	pub type AssetMetadatas<T: Config> =
+		StorageMap<_, Twox64Concat, AssetIds, AssetMetadata<BalanceOf<T>>, OptionQuery>;
+
+	/// The storages for assets to fungible collection binding
+	///
+	#[pallet::storage]
+	#[pallet::getter(fn asset_binding)]
+	pub type AssetBinding<T: Config> =
+		StorageMap<_, Twox64Concat, ForeignAssetId, CollectionId, OptionQuery>;
+
+	#[pallet::pallet]
+	#[pallet::without_storage_info]
+	pub struct Pallet<T>(_);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::weight(<T as Config>::WeightInfo::register_foreign_asset())]
+		pub fn register_foreign_asset(
+			origin: OriginFor<T>,
+			owner: T::AccountId,
+			location: Box<VersionedMultiLocation>,
+			metadata: Box<AssetMetadata<BalanceOf<T>>>,
+		) -> DispatchResult {
+			T::RegisterOrigin::ensure_origin(origin.clone())?;
+
+			let location: MultiLocation = (*location)
+				.try_into()
+				.map_err(|()| Error::<T>::BadLocation)?;
+
+			let md = metadata.clone();
+			let name: Vec<u16> = md.name.into_iter().map(|x| x as u16).collect::<Vec<u16>>();
+			let mut description: Vec<u16> = "Foreign assets collection for "
+				.encode_utf16()
+				.collect::<Vec<u16>>();
+			description.append(&mut name.clone());
+
+			let data: CreateCollectionData<T::AccountId> = CreateCollectionData {
+				name: name.try_into().unwrap(),
+				description: description.try_into().unwrap(),
+				mode: CollectionMode::Fungible(md.decimals),
+				..Default::default()
+			};
+
+			let bounded_collection_id = <PalletFungible<T>>::init_foreign_collection(
+				CrossAccountId::from_sub(owner),
+				data,
+			)?;
+			let foreign_asset_id =
+				Self::do_register_foreign_asset(&location, &metadata, bounded_collection_id)?;
+
+			Self::deposit_event(Event::<T>::ForeignAssetRegistered {
+				asset_id: foreign_asset_id,
+				asset_address: location,
+				metadata: *metadata,
+			});
+			Ok(())
+		}
+
+		#[pallet::weight(<T as Config>::WeightInfo::update_foreign_asset())]
+		pub fn update_foreign_asset(
+			origin: OriginFor<T>,
+			foreign_asset_id: ForeignAssetId,
+			location: Box<VersionedMultiLocation>,
+			metadata: Box<AssetMetadata<BalanceOf<T>>>,
+		) -> DispatchResult {
+			T::RegisterOrigin::ensure_origin(origin)?;
+
+			let location: MultiLocation = (*location)
+				.try_into()
+				.map_err(|()| Error::<T>::BadLocation)?;
+			Self::do_update_foreign_asset(foreign_asset_id, &location, &metadata)?;
+
+			Self::deposit_event(Event::<T>::ForeignAssetUpdated {
+				asset_id: foreign_asset_id,
+				asset_address: location,
+				metadata: *metadata,
+			});
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	fn get_next_foreign_asset_id() -> Result<ForeignAssetId, DispatchError> {
+		NextForeignAssetId::<T>::try_mutate(|current| -> Result<ForeignAssetId, DispatchError> {
+			let id = *current;
+			*current = current
+				.checked_add(One::one())
+				.ok_or(ArithmeticError::Overflow)?;
+			Ok(id)
+		})
+	}
+
+	fn do_register_foreign_asset(
+		location: &MultiLocation,
+		metadata: &AssetMetadata<BalanceOf<T>>,
+		bounded_collection_id: CollectionId,
+	) -> Result<ForeignAssetId, DispatchError> {
+		let foreign_asset_id = Self::get_next_foreign_asset_id()?;
+		LocationToCurrencyIds::<T>::try_mutate(location, |maybe_currency_ids| -> DispatchResult {
+			ensure!(
+				maybe_currency_ids.is_none(),
+				Error::<T>::MultiLocationExisted
+			);
+			*maybe_currency_ids = Some(foreign_asset_id);
+			// *maybe_currency_ids = Some(CurrencyId::ForeignAsset(foreign_asset_id));
+
+			ForeignAssetLocations::<T>::try_mutate(
+				foreign_asset_id,
+				|maybe_location| -> DispatchResult {
+					ensure!(maybe_location.is_none(), Error::<T>::MultiLocationExisted);
+					*maybe_location = Some(location.clone());
+
+					AssetMetadatas::<T>::try_mutate(
+						AssetIds::ForeignAssetId(foreign_asset_id),
+						|maybe_asset_metadatas| -> DispatchResult {
+							ensure!(maybe_asset_metadatas.is_none(), Error::<T>::AssetIdExisted);
+							*maybe_asset_metadatas = Some(metadata.clone());
+							Ok(())
+						},
+					)
+				},
+			)?;
+
+			AssetBinding::<T>::try_mutate(foreign_asset_id, |collection_id| -> DispatchResult {
+				*collection_id = Some(bounded_collection_id);
+				Ok(())
+			})
+		})?;
+
+		Ok(foreign_asset_id)
+	}
+
+	fn do_update_foreign_asset(
+		foreign_asset_id: ForeignAssetId,
+		location: &MultiLocation,
+		metadata: &AssetMetadata<BalanceOf<T>>,
+	) -> DispatchResult {
+		ForeignAssetLocations::<T>::try_mutate(
+			foreign_asset_id,
+			|maybe_multi_locations| -> DispatchResult {
+				let old_multi_locations = maybe_multi_locations
+					.as_mut()
+					.ok_or(Error::<T>::AssetIdNotExists)?;
+
+				AssetMetadatas::<T>::try_mutate(
+					AssetIds::ForeignAssetId(foreign_asset_id),
+					|maybe_asset_metadatas| -> DispatchResult {
+						ensure!(
+							maybe_asset_metadatas.is_some(),
+							Error::<T>::AssetIdNotExists
+						);
+
+						// modify location
+						if location != old_multi_locations {
+							LocationToCurrencyIds::<T>::remove(old_multi_locations.clone());
+							LocationToCurrencyIds::<T>::try_mutate(
+								location,
+								|maybe_currency_ids| -> DispatchResult {
+									ensure!(
+										maybe_currency_ids.is_none(),
+										Error::<T>::MultiLocationExisted
+									);
+									// *maybe_currency_ids = Some(CurrencyId::ForeignAsset(foreign_asset_id));
+									*maybe_currency_ids = Some(foreign_asset_id);
+									Ok(())
+								},
+							)?;
+						}
+						*maybe_asset_metadatas = Some(metadata.clone());
+						*old_multi_locations = location.clone();
+						Ok(())
+					},
+				)
+			},
+		)
+	}
+}
+
+pub use frame_support::{
+	traits::{
+		fungibles::{Balanced, CreditOf},
+		tokens::currency::Currency as CurrencyT,
+		OnUnbalanced as OnUnbalancedT,
+	},
+	weights::{WeightToFeePolynomial, WeightToFee},
+};
+
+pub struct FreeForAll<
+	WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,
+	AssetId: Get<MultiLocation>,
+	AccountId,
+	Currency: CurrencyT<AccountId>,
+	OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,
+>(
+	Weight,
+	Currency::Balance,
+	PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>,
+);
+
+impl<
+		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,
+		AssetId: Get<MultiLocation>,
+		AccountId,
+		Currency: CurrencyT<AccountId>,
+		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,
+	> WeightTrader for FreeForAll<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>
+{
+	fn new() -> Self {
+		Self(0, Zero::zero(), PhantomData)
+	}
+
+	fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> {
+		log::trace!(target: "fassets::weight", "buy_weight weight: {:?}, payment: {:?}", weight, payment);
+		Ok(payment)
+	}
+}
+impl<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced> Drop
+	for FreeForAll<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>
+where
+	WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,
+	AssetId: Get<MultiLocation>,
+	Currency: CurrencyT<AccountId>,
+	OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,
+{
+	fn drop(&mut self) {
+		OnUnbalanced::on_unbalanced(Currency::issue(self.1));
+	}
+}

--- /dev/null
+++ b/pallets/foreign-assets/src/weights.rs
@@ -0,0 +1,94 @@
+// Template adopted from https://github.com/paritytech/substrate/blob/master/.maintain/frame-weight-template.hbs
+
+//! Autogenerated weights for pallet_foreign_assets
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2022-09-16, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
+
+// Executed Command:
+// target/release/unique-collator
+// benchmark
+// pallet
+// --pallet
+// pallet-foreign-assets
+// --wasm-execution
+// compiled
+// --extrinsic
+// *
+// --template
+// .maintain/frame-weight-template.hbs
+// --steps=50
+// --repeat=80
+// --heap-pages=4096
+// --output=./pallets/foreign-assets/src/weights.rs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+#![allow(clippy::unnecessary_cast)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use sp_std::marker::PhantomData;
+
+/// Weight functions needed for pallet_foreign_assets.
+pub trait WeightInfo {
+	fn register_foreign_asset() -> Weight;
+	fn update_foreign_asset() -> Weight;
+}
+
+/// Weights for pallet_foreign_assets using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	// Storage: Common CreatedCollectionCount (r:1 w:1)
+	// Storage: Common DestroyedCollectionCount (r:1 w:0)
+	// Storage: System Account (r:2 w:2)
+	// Storage: ForeignAssets NextForeignAssetId (r:1 w:1)
+	// Storage: ForeignAssets LocationToCurrencyIds (r:1 w:1)
+	// Storage: ForeignAssets ForeignAssetLocations (r:1 w:1)
+	// Storage: ForeignAssets AssetMetadatas (r:1 w:1)
+	// Storage: ForeignAssets AssetBinding (r:1 w:1)
+	// Storage: Common CollectionPropertyPermissions (r:0 w:1)
+	// Storage: Common CollectionProperties (r:0 w:1)
+	// Storage: Common CollectionById (r:0 w:1)
+	fn register_foreign_asset() -> Weight {
+		(52_161_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(9 as Weight))
+			.saturating_add(T::DbWeight::get().writes(11 as Weight))
+	}
+	// Storage: ForeignAssets ForeignAssetLocations (r:1 w:1)
+	// Storage: ForeignAssets AssetMetadatas (r:1 w:1)
+	fn update_foreign_asset() -> Weight {
+		(19_111_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(2 as Weight))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	// Storage: Common CreatedCollectionCount (r:1 w:1)
+	// Storage: Common DestroyedCollectionCount (r:1 w:0)
+	// Storage: System Account (r:2 w:2)
+	// Storage: ForeignAssets NextForeignAssetId (r:1 w:1)
+	// Storage: ForeignAssets LocationToCurrencyIds (r:1 w:1)
+	// Storage: ForeignAssets ForeignAssetLocations (r:1 w:1)
+	// Storage: ForeignAssets AssetMetadatas (r:1 w:1)
+	// Storage: ForeignAssets AssetBinding (r:1 w:1)
+	// Storage: Common CollectionPropertyPermissions (r:0 w:1)
+	// Storage: Common CollectionProperties (r:0 w:1)
+	// Storage: Common CollectionById (r:0 w:1)
+	fn register_foreign_asset() -> Weight {
+		(52_161_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(9 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(11 as Weight))
+	}
+	// Storage: ForeignAssets ForeignAssetLocations (r:1 w:1)
+	// Storage: ForeignAssets AssetMetadatas (r:1 w:1)
+	fn update_foreign_asset() -> Weight {
+		(19_111_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
+	}
+}

--- /dev/null
+++ b/primitives/data-structs/src/bondrewd_codec.rs
@@ -0,0 +1,31 @@
+//! Integration between bondrewd and parity scale codec
+//! Maybe we can move it to scale-codec itself in future?
+
+#[macro_export]
+macro_rules! bondrewd_codec {
+	($T:ty) => {
+		impl Encode for $T {
+			fn encode_to<O: codec::Output + ?Sized>(&self, dest: &mut O) {
+				dest.write(&self.into_bytes())
+			}
+		}
+		impl codec::Decode for $T {
+			fn decode<I: codec::Input + ?Sized>(from: &mut I) -> Result<Self, codec::Error> {
+				let mut bytes = [0; Self::BYTE_SIZE];
+				from.read(&mut bytes)?;
+				Ok(Self::from_bytes(bytes))
+			}
+		}
+		impl MaxEncodedLen for $T {
+			fn max_encoded_len() -> usize {
+				Self::BYTE_SIZE
+			}
+		}
+		impl TypeInfo for $T {
+			type Identity = [u8; Self::BYTE_SIZE];
+			fn type_info() -> scale_info::Type {
+				<[u8; Self::BYTE_SIZE] as TypeInfo>::type_info()
+			}
+		}
+	};
+}

--- /dev/null
+++ b/runtime/common/config/pallets/foreign_asset.rs
@@ -0,0 +1,9 @@
+use crate::{Runtime, Event, Balances};
+use up_common::types::AccountId;
+
+impl pallet_foreign_assets::Config for Runtime {
+	type Event = Event;
+	type Currency = Balances;
+	type RegisterOrigin = frame_system::EnsureRoot<AccountId>;
+	type WeightInfo = pallet_foreign_assets::weights::SubstrateWeight<Self>;
+}

--- /dev/null
+++ b/runtime/common/config/xcm/foreignassets.rs
@@ -0,0 +1,198 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+use frame_support::{
+	traits::{Contains, Get, fungibles},
+	parameter_types,
+};
+use sp_runtime::traits::{Zero, Convert};
+use xcm::v1::{Junction::*, MultiLocation, Junctions::*};
+use xcm::latest::MultiAsset;
+use xcm_builder::{FungiblesAdapter, ConvertedConcreteAssetId};
+use xcm_executor::traits::{Convert as ConvertXcm, JustTry, FilterAssetLocation};
+use pallet_foreign_assets::{
+	AssetIds, AssetIdMapping, XcmForeignAssetIdMapping, NativeCurrency, FreeForAll, TryAsForeign,
+	ForeignAssetId, CurrencyId,
+};
+use sp_std::{borrow::Borrow, marker::PhantomData};
+use crate::{Runtime, Balances, ParachainInfo, PolkadotXcm, ForeignAssets};
+
+use super::{LocationToAccountId, RelayLocation};
+
+use up_common::types::{AccountId, Balance};
+
+parameter_types! {
+	pub CheckingAccount: AccountId = PolkadotXcm::check_account();
+}
+
+/// Allow checking in assets that have issuance > 0.
+pub struct NonZeroIssuance<AccountId, ForeignAssets>(PhantomData<(AccountId, ForeignAssets)>);
+
+impl<AccountId, ForeignAssets> Contains<<ForeignAssets as fungibles::Inspect<AccountId>>::AssetId>
+	for NonZeroIssuance<AccountId, ForeignAssets>
+where
+	ForeignAssets: fungibles::Inspect<AccountId>,
+{
+	fn contains(id: &<ForeignAssets as fungibles::Inspect<AccountId>>::AssetId) -> bool {
+		!ForeignAssets::total_issuance(*id).is_zero()
+	}
+}
+
+pub struct AsInnerId<AssetId, ConvertAssetId>(PhantomData<(AssetId, ConvertAssetId)>);
+impl<AssetId: Clone + PartialEq, ConvertAssetId: ConvertXcm<AssetId, AssetId>>
+	ConvertXcm<MultiLocation, AssetId> for AsInnerId<AssetId, ConvertAssetId>
+where
+	AssetId: Borrow<AssetId>,
+	AssetId: TryAsForeign<AssetId, ForeignAssetId>,
+	AssetIds: Borrow<AssetId>,
+{
+	fn convert_ref(id: impl Borrow<MultiLocation>) -> Result<AssetId, ()> {
+		let id = id.borrow();
+
+		log::trace!(
+			target: "xcm::AsInnerId::Convert",
+			"AsInnerId {:?}",
+			id
+		);
+
+		let parent = MultiLocation::parent();
+		let here = MultiLocation::here();
+		let self_location = MultiLocation::new(1, X1(Parachain(ParachainInfo::get().into())));
+
+		if *id == parent {
+			return ConvertAssetId::convert_ref(AssetIds::NativeAssetId(NativeCurrency::Parent));
+		}
+
+		if *id == here || *id == self_location {
+			return ConvertAssetId::convert_ref(AssetIds::NativeAssetId(NativeCurrency::Here));
+		}
+
+		match XcmForeignAssetIdMapping::<Runtime>::get_currency_id(id.clone()) {
+			Some(AssetIds::ForeignAssetId(foreign_asset_id)) => {
+				ConvertAssetId::convert_ref(AssetIds::ForeignAssetId(foreign_asset_id))
+			}
+			_ => ConvertAssetId::convert_ref(AssetIds::ForeignAssetId(0)),
+		}
+	}
+
+	fn reverse_ref(what: impl Borrow<AssetId>) -> Result<MultiLocation, ()> {
+		log::trace!(
+			target: "xcm::AsInnerId::Reverse",
+			"AsInnerId",
+		);
+
+		let asset_id = what.borrow();
+
+		let parent_id =
+			ConvertAssetId::convert_ref(AssetIds::NativeAssetId(NativeCurrency::Parent)).unwrap();
+		let here_id =
+			ConvertAssetId::convert_ref(AssetIds::NativeAssetId(NativeCurrency::Here)).unwrap();
+
+		if asset_id.clone() == parent_id {
+			return Ok(MultiLocation::parent());
+		}
+
+		if asset_id.clone() == here_id {
+			return Ok(MultiLocation::new(
+				1,
+				X1(Parachain(ParachainInfo::get().into())),
+			));
+		}
+
+		match <AssetId as TryAsForeign<AssetId, ForeignAssetId>>::try_as_foreign(asset_id.clone()) {
+			Some(fid) => match XcmForeignAssetIdMapping::<Runtime>::get_multi_location(fid) {
+				Some(location) => Ok(location),
+				None => Err(()),
+			},
+			None => Err(()),
+		}
+	}
+}
+
+/// Means for transacting assets besides the native currency on this chain.
+pub type FungiblesTransactor = FungiblesAdapter<
+	// Use this fungibles implementation:
+	ForeignAssets,
+	// Use this currency when it is a fungible asset matching the given location or name:
+	ConvertedConcreteAssetId<AssetIds, Balance, AsInnerId<AssetIds, JustTry>, JustTry>,
+	// Convert an XCM MultiLocation into a local account id:
+	LocationToAccountId,
+	// Our chain's account ID type (we can't get away without mentioning it explicitly):
+	AccountId,
+	// We only want to allow teleports of known assets. We use non-zero issuance as an indication
+	// that this asset is known.
+	NonZeroIssuance<AccountId, ForeignAssets>,
+	// The account to use for tracking teleports.
+	CheckingAccount,
+>;
+
+/// Means for transacting assets on this chain.
+pub type AssetTransactors = FungiblesTransactor;
+
+pub struct AllAsset;
+impl FilterAssetLocation for AllAsset {
+	fn filter_asset_location(_asset: &MultiAsset, _origin: &MultiLocation) -> bool {
+		true
+	}
+}
+
+pub type IsReserve = AllAsset;
+
+pub type Trader<T> = FreeForAll<
+	pallet_configuration::WeightToFee<T, Balance>,
+	RelayLocation,
+	AccountId,
+	Balances,
+	(),
+>;
+
+pub struct CurrencyIdConvert;
+impl Convert<AssetIds, Option<MultiLocation>> for CurrencyIdConvert {
+	fn convert(id: AssetIds) -> Option<MultiLocation> {
+		match id {
+			AssetIds::NativeAssetId(NativeCurrency::Here) => Some(MultiLocation::new(
+				1,
+				X1(Parachain(ParachainInfo::get().into())),
+			)),
+			AssetIds::NativeAssetId(NativeCurrency::Parent) => Some(MultiLocation::parent()),
+			AssetIds::ForeignAssetId(foreign_asset_id) => {
+				XcmForeignAssetIdMapping::<Runtime>::get_multi_location(foreign_asset_id)
+			}
+		}
+	}
+}
+
+impl Convert<MultiLocation, Option<CurrencyId>> for CurrencyIdConvert {
+	fn convert(location: MultiLocation) -> Option<CurrencyId> {
+		if location == MultiLocation::here()
+			|| location == MultiLocation::new(1, X1(Parachain(ParachainInfo::get().into())))
+		{
+			return Some(AssetIds::NativeAssetId(NativeCurrency::Here));
+		}
+
+		if location == MultiLocation::parent() {
+			return Some(AssetIds::NativeAssetId(NativeCurrency::Parent));
+		}
+
+		if let Some(currency_id) =
+			XcmForeignAssetIdMapping::<Runtime>::get_currency_id(location.clone())
+		{
+			return Some(currency_id);
+		}
+
+		None
+	}
+}

--- /dev/null
+++ b/runtime/common/config/xcm/mod.rs
@@ -0,0 +1,268 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+use frame_support::{
+	traits::{Everything, Get},
+	weights::Weight,
+	parameter_types,
+};
+use frame_system::EnsureRoot;
+use pallet_xcm::XcmPassthrough;
+use polkadot_parachain::primitives::Sibling;
+use xcm::v1::{Junction::*, MultiLocation, NetworkId};
+use xcm::latest::prelude::*;
+use xcm_builder::{
+	AccountId32Aliases, EnsureXcmOrigin, FixedWeightBounds, LocationInverter, ParentAsSuperuser,
+	RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,
+	SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, ParentIsPreset,
+};
+use xcm_executor::{Config, XcmExecutor, traits::ShouldExecute};
+use sp_std::{marker::PhantomData, vec::Vec};
+use crate::{
+	Runtime, Call, Event, Origin, ParachainInfo, ParachainSystem, PolkadotXcm, XcmpQueue,
+	xcm_barrier::Barrier,
+};
+
+use up_common::types::AccountId;
+
+#[cfg(feature = "foreign-assets")]
+pub mod foreignassets;
+
+#[cfg(not(feature = "foreign-assets"))]
+pub mod nativeassets;
+
+#[cfg(feature = "foreign-assets")]
+pub use foreignassets as xcm_assets;
+
+#[cfg(not(feature = "foreign-assets"))]
+pub use nativeassets as xcm_assets;
+
+use xcm_assets::{AssetTransactors, IsReserve, Trader};
+
+parameter_types! {
+	pub const RelayLocation: MultiLocation = MultiLocation::parent();
+	pub const RelayNetwork: NetworkId = NetworkId::Polkadot;
+	pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();
+	pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();
+	pub SelfLocation: MultiLocation = MultiLocation::new(1, X1(Parachain(ParachainInfo::get().into())));
+
+	// One XCM operation is 1_000_000 weight - almost certainly a conservative estimate.
+	pub UnitWeightCost: Weight = 1_000_000;
+	pub const MaxInstructions: u32 = 100;
+}
+
+/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used
+/// when determining ownership of accounts for asset transacting and when attempting to use XCM
+/// `Transact` in order to determine the dispatch Origin.
+pub type LocationToAccountId = (
+	// The parent (Relay-chain) origin converts to the default `AccountId`.
+	ParentIsPreset<AccountId>,
+	// Sibling parachain origins convert to AccountId via the `ParaId::into`.
+	SiblingParachainConvertsVia<Sibling, AccountId>,
+	// Straight up local `AccountId32` origins just alias directly to `AccountId`.
+	AccountId32Aliases<RelayNetwork, AccountId>,
+);
+
+/// No local origins on this chain are allowed to dispatch XCM sends/executions.
+pub type LocalOriginToLocation = (SignedToAccountId32<Origin, AccountId, RelayNetwork>,);
+
+/// The means for routing XCM messages which are not for local execution into the right message
+/// queues.
+pub type XcmRouter = (
+	// Two routers - use UMP to communicate with the relay chain:
+	cumulus_primitives_utility::ParentAsUmp<ParachainSystem, ()>,
+	// ..and XCMP to communicate with the sibling chains.
+	XcmpQueue,
+);
+
+/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,
+/// ready for dispatching a transaction with Xcm's `Transact`. There is an `OriginKind` which can
+/// biases the kind of local `Origin` it will become.
+pub type XcmOriginToTransactDispatchOrigin = (
+	// Sovereign account converter; this attempts to derive an `AccountId` from the origin location
+	// using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for
+	// foreign chains who want to have a local sovereign account on this chain which they control.
+	SovereignSignedViaLocation<LocationToAccountId, Origin>,
+	// Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when
+	// recognised.
+	RelayChainAsNative<RelayOrigin, Origin>,
+	// Native converter for sibling Parachains; will convert to a `SiblingPara` origin when
+	// recognised.
+	SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,
+	// Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a
+	// transaction from the Root origin.
+	ParentAsSuperuser<Origin>,
+	// Native signed account converter; this just converts an `AccountId32` origin into a normal
+	// `Origin::Signed` origin of the same 32-byte value.
+	SignedAccountId32AsNative<RelayNetwork, Origin>,
+	// Xcm origins can be represented natively under the Xcm pallet's Xcm origin.
+	XcmPassthrough<Origin>,
+);
+
+pub trait TryPass {
+	fn try_pass<Call>(origin: &MultiLocation, message: &mut Xcm<Call>) -> Result<(), ()>;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+impl TryPass for Tuple {
+	fn try_pass<Call>(origin: &MultiLocation, message: &mut Xcm<Call>) -> Result<(), ()> {
+		for_tuples!( #(
+			Tuple::try_pass(origin, message)?;
+		)* );
+
+		Ok(())
+	}
+}
+
+pub struct DenyTransact;
+impl TryPass for DenyTransact {
+	fn try_pass<Call>(_origin: &MultiLocation, message: &mut Xcm<Call>) -> Result<(), ()> {
+		let transact_inst = message
+			.0
+			.iter()
+			.find(|inst| matches![inst, Instruction::Transact { .. }]);
+
+		if transact_inst.is_some() {
+			log::warn!(
+				target: "xcm::barrier",
+				"transact XCM rejected"
+			);
+
+			Err(())
+		} else {
+			Ok(())
+		}
+	}
+}
+
+/// Deny executing the XCM if it matches any of the Deny filter regardless of anything else.
+/// If it passes the Deny, and matches one of the Allow cases then it is let through.
+pub struct DenyThenTry<Deny, Allow>(PhantomData<Deny>, PhantomData<Allow>)
+where
+	Deny: TryPass,
+	Allow: ShouldExecute;
+
+impl<Deny, Allow> ShouldExecute for DenyThenTry<Deny, Allow>
+where
+	Deny: TryPass,
+	Allow: ShouldExecute,
+{
+	fn should_execute<Call>(
+		origin: &MultiLocation,
+		message: &mut Xcm<Call>,
+		max_weight: Weight,
+		weight_credit: &mut Weight,
+	) -> Result<(), ()> {
+		Deny::try_pass(origin, message)?;
+		Allow::should_execute(origin, message, max_weight, weight_credit)
+	}
+}
+
+// Allow xcm exchange only with locations in list
+pub struct DenyExchangeWithUnknownLocation<T>(PhantomData<T>);
+impl<T: Get<Vec<MultiLocation>>> TryPass for DenyExchangeWithUnknownLocation<T> {
+	fn try_pass<Call>(origin: &MultiLocation, message: &mut Xcm<Call>) -> Result<(), ()> {
+		let allowed_locations = T::get();
+
+		// Check if deposit or transfer belongs to allowed parachains
+		let mut allowed = allowed_locations.contains(origin);
+
+		message.0.iter().for_each(|inst| match inst {
+			DepositReserveAsset { dest: dst, .. } => {
+				allowed |= allowed_locations.contains(dst);
+			}
+			TransferReserveAsset { dest: dst, .. } => {
+				allowed |= allowed_locations.contains(dst);
+			}
+			_ => {}
+		});
+
+		if allowed {
+			return Ok(());
+		}
+
+		log::warn!(
+			target: "xcm::barrier",
+			"Unexpected deposit or transfer location"
+		);
+		// Deny
+		Err(())
+	}
+}
+
+pub type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;
+
+pub struct XcmConfig<T>(PhantomData<T>);
+impl<T> Config for XcmConfig<T>
+where
+	T: pallet_configuration::Config,
+{
+	type Call = Call;
+	type XcmSender = XcmRouter;
+	// How to withdraw and deposit an asset.
+	type AssetTransactor = AssetTransactors;
+	type OriginConverter = XcmOriginToTransactDispatchOrigin;
+	type IsReserve = IsReserve;
+	type IsTeleporter = (); // Teleportation is disabled
+	type LocationInverter = LocationInverter<Ancestry>;
+	type Barrier = Barrier;
+	type Weigher = Weigher;
+	type Trader = Trader<T>;
+	type ResponseHandler = (); // Don't handle responses for now.
+	type SubscriptionService = PolkadotXcm;
+
+	type AssetTrap = PolkadotXcm;
+	type AssetClaims = PolkadotXcm;
+}
+
+impl pallet_xcm::Config for Runtime {
+	type Event = Event;
+	type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;
+	type XcmRouter = XcmRouter;
+	type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;
+	type XcmExecuteFilter = Everything;
+	type XcmExecutor = XcmExecutor<XcmConfig<Self>>;
+	type XcmTeleportFilter = Everything;
+	type XcmReserveTransferFilter = Everything;
+	type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;
+	type LocationInverter = LocationInverter<Ancestry>;
+	type Origin = Origin;
+	type Call = Call;
+	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
+	type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;
+}
+
+impl cumulus_pallet_xcm::Config for Runtime {
+	type Event = Event;
+	type XcmExecutor = XcmExecutor<XcmConfig<Self>>;
+}
+
+impl cumulus_pallet_xcmp_queue::Config for Runtime {
+	type WeightInfo = ();
+	type Event = Event;
+	type XcmExecutor = XcmExecutor<XcmConfig<Self>>;
+	type ChannelInfo = ParachainSystem;
+	type VersionWrapper = ();
+	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;
+	type ControllerOrigin = EnsureRoot<AccountId>;
+	type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin;
+}
+
+impl cumulus_pallet_dmp_queue::Config for Runtime {
+	type Event = Event;
+	type XcmExecutor = XcmExecutor<XcmConfig<Self>>;
+	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;
+}

--- /dev/null
+++ b/runtime/common/config/xcm/nativeassets.rs
@@ -0,0 +1,143 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+use frame_support::{
+	traits::{tokens::currency::Currency as CurrencyT, OnUnbalanced as OnUnbalancedT, Get},
+	weights::{Weight, WeightToFeePolynomial},
+};
+use sp_runtime::traits::{CheckedConversion, Zero, Convert};
+use xcm::v1::{Junction::*, MultiLocation, Junctions::*};
+use xcm::latest::{
+	AssetId::{Concrete},
+	Fungibility::Fungible as XcmFungible,
+	MultiAsset, Error as XcmError,
+};
+use xcm_builder::{CurrencyAdapter, NativeAsset};
+use xcm_executor::{
+	Assets,
+	traits::{MatchesFungible, WeightTrader},
+};
+use pallet_foreign_assets::{AssetIds, NativeCurrency};
+use sp_std::marker::PhantomData;
+use crate::{Balances, ParachainInfo};
+use super::{LocationToAccountId, RelayLocation};
+
+use up_common::types::{AccountId, Balance};
+
+pub struct OnlySelfCurrency;
+impl<B: TryFrom<u128>> MatchesFungible<B> for OnlySelfCurrency {
+	fn matches_fungible(a: &MultiAsset) -> Option<B> {
+		let paraid = Parachain(ParachainInfo::parachain_id().into());
+		match (&a.id, &a.fun) {
+			(
+				Concrete(MultiLocation {
+					parents: 1,
+					interior: X1(loc),
+				}),
+				XcmFungible(ref amount),
+			) if paraid == *loc => CheckedConversion::checked_from(*amount),
+			(
+				Concrete(MultiLocation {
+					parents: 0,
+					interior: Here,
+				}),
+				XcmFungible(ref amount),
+			) => CheckedConversion::checked_from(*amount),
+			_ => None,
+		}
+	}
+}
+
+/// Means for transacting assets on this chain.
+pub type LocalAssetTransactor = CurrencyAdapter<
+	// Use this currency:
+	Balances,
+	// Use this currency when it is a fungible asset matching the given location or name:
+	OnlySelfCurrency,
+	// Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:
+	LocationToAccountId,
+	// Our chain's account ID type (we can't get away without mentioning it explicitly):
+	AccountId,
+	// We don't track any teleports.
+	(),
+>;
+
+pub type AssetTransactors = LocalAssetTransactor;
+
+pub type IsReserve = NativeAsset;
+
+pub struct UsingOnlySelfCurrencyComponents<
+	WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,
+	AssetId: Get<MultiLocation>,
+	AccountId,
+	Currency: CurrencyT<AccountId>,
+	OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,
+>(
+	Weight,
+	Currency::Balance,
+	PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>,
+);
+impl<
+		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,
+		AssetId: Get<MultiLocation>,
+		AccountId,
+		Currency: CurrencyT<AccountId>,
+		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,
+	> WeightTrader
+	for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>
+{
+	fn new() -> Self {
+		Self(0, Zero::zero(), PhantomData)
+	}
+
+	fn buy_weight(&mut self, _weight: Weight, payment: Assets) -> Result<Assets, XcmError> {
+		Ok(payment)
+	}
+}
+impl<
+		WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,
+		AssetId: Get<MultiLocation>,
+		AccountId,
+		Currency: CurrencyT<AccountId>,
+		OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,
+	> Drop
+	for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>
+{
+	fn drop(&mut self) {
+		OnUnbalanced::on_unbalanced(Currency::issue(self.1));
+	}
+}
+
+pub type Trader<T> = UsingOnlySelfCurrencyComponents<
+	pallet_configuration::WeightToFee<T, Balance>,
+	RelayLocation,
+	AccountId,
+	Balances,
+	(),
+>;
+
+pub struct CurrencyIdConvert;
+impl Convert<AssetIds, Option<MultiLocation>> for CurrencyIdConvert {
+	fn convert(id: AssetIds) -> Option<MultiLocation> {
+		match id {
+			AssetIds::NativeAssetId(NativeCurrency::Here) => Some(MultiLocation::new(
+				1,
+				X1(Parachain(ParachainInfo::get().into())),
+			)),
+			_ => None,
+		}
+	}
+}

--- /dev/null
+++ b/runtime/common/tests/mod.rs
@@ -0,0 +1,46 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+use sp_runtime::BuildStorage;
+use sp_core::{Public, Pair};
+use sp_std::vec;
+use up_common::types::AuraId;
+use crate::{GenesisConfig, ParachainInfoConfig, AuraConfig};
+
+pub mod xcm;
+
+fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
+	TPublic::Pair::from_string(&format!("//{}", seed), None)
+		.expect("static values are valid; qed")
+		.public()
+}
+
+fn new_test_ext(para_id: u32) -> sp_io::TestExternalities {
+	let cfg = GenesisConfig {
+		aura: AuraConfig {
+			authorities: vec![
+				get_from_seed::<AuraId>("Alice"),
+				get_from_seed::<AuraId>("Bob"),
+			],
+		},
+		parachain_info: ParachainInfoConfig {
+			parachain_id: para_id.into(),
+		},
+		..GenesisConfig::default()
+	};
+
+	cfg.build_storage().unwrap().into()
+}

--- /dev/null
+++ b/runtime/common/tests/xcm.rs
@@ -0,0 +1,162 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+use xcm_executor::traits::ShouldExecute;
+use xcm::latest::prelude::*;
+use logtest::Logger;
+use crate::Call;
+use super::new_test_ext;
+
+fn catch_xcm_barrier_log(logger: &mut Logger, expected_msg: &str) -> Result<(), String> {
+	for record in logger {
+		if record.target() == "xcm::barrier" && record.args() == expected_msg {
+			return Ok(());
+		}
+	}
+
+	Err(format!(
+		"the expected XCM barrier log `{}` is not found",
+		expected_msg
+	))
+}
+
+/// WARNING: Uses log capturing
+/// See https://docs.rs/logtest/latest/logtest/index.html#constraints
+pub fn barrier_denies_transact<B: ShouldExecute>(logger: &mut Logger) {
+	let location = MultiLocation {
+		parents: 0,
+		interior: Junctions::Here,
+	};
+
+	// We will never decode this "call",
+	// so it is irrelevant what we are passing to the `transact` cmd.
+	let fake_encoded_call = vec![0u8];
+
+	let transact_inst = Transact {
+		origin_type: OriginKind::Superuser,
+		require_weight_at_most: 0,
+		call: fake_encoded_call.into(),
+	};
+
+	let mut xcm_program = Xcm::<Call>(vec![transact_inst]);
+
+	let max_weight = 100_000;
+	let mut weight_credit = 100_000_000;
+
+	let result = B::should_execute(&location, &mut xcm_program, max_weight, &mut weight_credit);
+
+	assert!(
+		result.is_err(),
+		"the barrier should disallow the XCM transact cmd"
+	);
+
+	catch_xcm_barrier_log(logger, "transact XCM rejected").unwrap();
+}
+
+fn xcm_execute<B: ShouldExecute>(
+	self_para_id: u32,
+	location: &MultiLocation,
+	xcm: &mut Xcm<Call>,
+) -> Result<(), ()> {
+	new_test_ext(self_para_id).execute_with(|| {
+		let max_weight = 100_000;
+		let mut weight_credit = 100_000_000;
+
+		B::should_execute(&location, xcm, max_weight, &mut weight_credit)
+	})
+}
+
+fn make_multiassets(location: &MultiLocation) -> MultiAssets {
+	let id = AssetId::Concrete(location.clone());
+	let fun = Fungibility::Fungible(42);
+	let multiasset = MultiAsset { id, fun };
+
+	multiasset.into()
+}
+
+fn make_transfer_reserve_asset(location: &MultiLocation) -> Xcm<Call> {
+	let assets = make_multiassets(location);
+	let inst = TransferReserveAsset {
+		assets,
+		dest: location.clone(),
+		xcm: Xcm(vec![]),
+	};
+
+	Xcm::<Call>(vec![inst])
+}
+
+fn make_deposit_reserve_asset(location: &MultiLocation) -> Xcm<Call> {
+	let assets = make_multiassets(location);
+	let inst = DepositReserveAsset {
+		assets: assets.into(),
+		max_assets: 42,
+		dest: location.clone(),
+		xcm: Xcm(vec![]),
+	};
+
+	Xcm::<Call>(vec![inst])
+}
+
+fn expect_transfer_location_denied<B: ShouldExecute>(
+	logger: &mut Logger,
+	self_para_id: u32,
+	location: &MultiLocation,
+	xcm: &mut Xcm<Call>,
+) -> Result<(), String> {
+	let result = xcm_execute::<B>(self_para_id, location, xcm);
+
+	if result.is_ok() {
+		return Err("the barrier should deny the unknown location".into());
+	}
+
+	catch_xcm_barrier_log(logger, "Unexpected deposit or transfer location")
+}
+
+/// WARNING: Uses log capturing
+/// See https://docs.rs/logtest/latest/logtest/index.html#constraints
+pub fn barrier_denies_transfer_from_unknown_location<B>(
+	logger: &mut Logger,
+	self_para_id: u32,
+) -> Result<(), String>
+where
+	B: ShouldExecute,
+{
+	const UNKNOWN_PARACHAIN_ID: u32 = 4057;
+
+	let unknown_location = MultiLocation {
+		parents: 1,
+		interior: X1(Parachain(UNKNOWN_PARACHAIN_ID)),
+	};
+
+	let mut transfer_reserve_asset = make_transfer_reserve_asset(&unknown_location);
+	let mut deposit_reserve_asset = make_deposit_reserve_asset(&unknown_location);
+
+	expect_transfer_location_denied::<B>(
+		logger,
+		self_para_id,
+		&unknown_location,
+		&mut transfer_reserve_asset,
+	)?;
+
+	expect_transfer_location_denied::<B>(
+		logger,
+		self_para_id,
+		&unknown_location,
+		&mut deposit_reserve_asset,
+	)?;
+
+	Ok(())
+}

--- /dev/null
+++ b/runtime/opal/src/tests/logcapture.rs
@@ -0,0 +1,25 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+use logtest::Logger;
+use super::xcm::opal_xcm_tests;
+
+#[test]
+fn opal_log_capture_tests() {
+	let mut logger = Logger::start();
+
+	opal_xcm_tests(&mut logger);
+}

--- /dev/null
+++ b/runtime/opal/src/tests/mod.rs
@@ -0,0 +1,18 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+mod logcapture;
+mod xcm;

--- /dev/null
+++ b/runtime/opal/src/tests/xcm.rs
@@ -0,0 +1,27 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+use logtest::Logger;
+use crate::{runtime_common::tests::xcm::*, xcm_barrier::Barrier};
+
+const OPAL_PARA_ID: u32 = 2095; // Same as Quartz
+
+pub fn opal_xcm_tests(logger: &mut Logger) {
+	barrier_denies_transact::<Barrier>(logger);
+
+	barrier_denies_transfer_from_unknown_location::<Barrier>(logger, OPAL_PARA_ID)
+		.expect_err("opal runtime allows any location");
+}

--- /dev/null
+++ b/runtime/opal/src/xcm_barrier.rs
@@ -0,0 +1,48 @@
+// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.
+// This file is part of Unique Network.
+
+// Unique Network is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Unique Network is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
+
+use frame_support::{weights::Weight, traits::Everything};
+use xcm::{latest::Xcm, v1::MultiLocation};
+use xcm_builder::{AllowTopLevelPaidExecutionFrom, TakeWeightCredit};
+use xcm_executor::traits::ShouldExecute;
+
+use crate::runtime_common::config::xcm::{DenyThenTry, DenyTransact};
+
+/// Execution barrier that just takes `max_weight` from `weight_credit`.
+///
+/// Useful to allow XCM execution by local chain users via extrinsics.
+/// E.g. `pallet_xcm::reserve_asset_transfer` to transfer a reserve asset
+/// out of the local chain to another one.
+pub struct AllowAllDebug;
+impl ShouldExecute for AllowAllDebug {
+	fn should_execute<Call>(
+		_origin: &MultiLocation,
+		_message: &mut Xcm<Call>,
+		_max_weight: Weight,
+		_weight_credit: &mut Weight,
+	) -> Result<(), ()> {
+		Ok(())
+	}
+}
+
+pub type Barrier = DenyThenTry<
+	DenyTransact,
+	(
+		TakeWeightCredit,
+		AllowTopLevelPaidExecutionFrom<Everything>,
+		AllowAllDebug,
+	),
+>;