diff --git a/package.json b/package.json
index a95368ca8..75b37dca3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@soramitsu/soraneo-wallet-web",
-  "version": "1.43.4",
+  "version": "1.43.4-beta-1",
   "license": "Apache-2.0",
   "private": false,
   "publishConfig": {
diff --git a/src/SoraWallet.vue b/src/SoraWallet.vue
index b56e4e2d3..b05ebe786 100644
--- a/src/SoraWallet.vue
+++ b/src/SoraWallet.vue
@@ -14,7 +14,6 @@
 import { Component, Mixins } from 'vue-property-decorator';
 
 import AddAsset from './components/AddAsset/AddAsset.vue';
-import CreateToken from './components/CreateToken.vue';
 import LoadingMixin from './components/mixins/LoadingMixin';
 import TranslationMixin from './components/mixins/TranslationMixin';
 import ReceiveToken from './components/ReceiveToken.vue';
@@ -34,7 +33,6 @@ import type { AccountAsset } from '@sora-substrate/sdk/build/assets/types';
   components: {
     AddAsset,
     SelectAsset,
-    CreateToken,
     ReceiveToken,
     Wallet,
     WalletAssetDetails,
diff --git a/src/components/AssetDetails/AssetDetailsSBT.vue b/src/components/AssetDetails/AssetDetailsSBT.vue
new file mode 100644
index 000000000..7b6d60105
--- /dev/null
+++ b/src/components/AssetDetails/AssetDetailsSBT.vue
@@ -0,0 +1,241 @@
+<template>
+  <wallet-base :title="sbtSymbol || TranslationConsts.SBT" show-back @back="handleBack" class="sbt-permissions-info">
+    <s-card class="asset-details" primary>
+      <div class="asset-details-container s-flex">
+        <token-logo :token="asset" size="large" />
+        <div class="asset-details-title">{{ t('sbtDetails.kycVerification', { KYC: TranslationConsts.KYC }) }}</div>
+        <div class="asset-details-desc">
+          {{ t('sbtDetails.description') }}
+        </div>
+        <div class="asset-details-subtitle">{{ t('sbtDetails.issuedBy', { SBT: TranslationConsts.SBT }) }}</div>
+        <account-card class="asset-details-issuer">
+          <template #avatar>
+            <wallet-avatar slot="avatar" class="account-gravatar" :address="asset.address" :size="28" />
+          </template>
+          <template #name>
+            {{ t('sbtDetails.kycProvider', { KYC: TranslationConsts.KYC }) }}
+            <s-icon name="el-icon-success" size="16" />
+          </template>
+          <template #description>
+            <div class="asset-details-instition-mark">{{ t('sbtDetails.regulatedInsitution') }}</div>
+            <formatted-address :value="asset.address" :symbols="24" :tooltip-text="t('account.walletAddress')" />
+          </template>
+        </account-card>
+        <template v-if="showExpiryDate">
+          <info-line
+            :label="t('sbtDetails.expiryDate')"
+            :label-tooltip="t('sbtDetails.expiryDateTooltip')"
+            :value="expiryDate"
+          />
+          <info-line
+            :label="t('sbtDetails.expiresIn')"
+            :label-tooltip="t('sbtDetails.expiresInTooltip')"
+            :value="expiresIn"
+          />
+        </template>
+        <div v-if="regulatedAssets.length" class="asset-details-regulated-section">
+          <div class="asset-details-subtitle">{{ regulatedAssetsTitle }}</div>
+          <div class="asset-details-regulated-assets">
+            <div v-for="(asset, index) in regulatedAssets" :key="index">
+              <asset-list-item
+                :asset="asset"
+                :pinnable="false"
+                with-clickable-logo
+                @show-details="handleOpenAssetDetails"
+              >
+                <template #default="asset">
+                  <s-button
+                    class="wallet-assets__button el-button--details"
+                    type="action"
+                    size="small"
+                    alternative
+                    :tooltip="t('assets.details')"
+                    @click="handleOpenAssetDetails(asset)"
+                  >
+                    <s-icon name="arrows-chevron-right-rounded-24" size="24" />
+                  </s-button>
+                </template>
+              </asset-list-item>
+              <s-divider v-if="index < regulatedAssets.length - 1" />
+            </div>
+          </div>
+        </div>
+        <div v-else class="asset-details-subtitle asset-details-subtitle--no-permission">
+          {{ t('sbtDetails.noPermissions') }}
+        </div>
+      </div>
+    </s-card>
+  </wallet-base>
+</template>
+
+<script lang="ts">
+import { AccountAsset, Asset } from '@sora-substrate/sdk/build/assets/types';
+import { Component, Mixins, Prop } from 'vue-property-decorator';
+
+import { api } from '../../api';
+import { RouteNames } from '../../consts';
+import { mutation, state } from '../../store/decorators';
+import { Route } from '../../store/router/types';
+import AccountCard from '../Account/AccountCard.vue';
+import WalletAvatar from '../Account/WalletAvatar.vue';
+import AssetListItem from '../AssetListItem.vue';
+import TokenLogo from '../AssetLogos/TokenLogo.vue';
+import InfoLine from '../InfoLine.vue';
+import NumberFormatterMixin from '../mixins/NumberFormatterMixin';
+import TranslationMixin from '../mixins/TranslationMixin';
+import FormattedAddress from '../shared/FormattedAddress.vue';
+import WalletBase from '../WalletBase.vue';
+
+@Component({
+  components: {
+    AccountCard,
+    AssetListItem,
+    FormattedAddress,
+    TokenLogo,
+    InfoLine,
+    WalletAvatar,
+    WalletBase,
+  },
+})
+export default class WalletAssetDetails extends Mixins(TranslationMixin, NumberFormatterMixin) {
+  @state.router.currentRouteParams private currentRouteParams!: Record<string, AccountAsset>;
+  @state.account.address private connected!: string;
+  @mutation.router.navigate navigate!: (options: Route) => Promise<void>;
+
+  @Prop({ required: true, type: Object }) readonly asset!: Asset;
+
+  regulatedAssets: Array<Asset | undefined> = [];
+  showExpiryDate = false;
+  sbtSymbol = '';
+  expiryDate = '';
+  expiresIn = '';
+  isOwnerOpenedPage = false;
+
+  get regulatedAssetsTitle(): string {
+    return this.isOwnerOpenedPage ? this.t('sbtDetails.listOperable') : this.t('sbtDetails.accessPermitted');
+  }
+
+  handleOpenAssetDetails(asset: AccountAsset): void {
+    this.navigate({
+      name: RouteNames.WalletAssetDetails,
+      params: { asset, fromSbtDetails: true, prevAsset: this.currentRouteParams.asset },
+    });
+  }
+
+  handleBack(): void {
+    this.navigate({ name: RouteNames.Wallet });
+  }
+
+  isZeroBalance(asset: AccountAsset): boolean {
+    return this.isCodecZero(asset.balance.transferable, asset.decimals);
+  }
+
+  async checkExpirationDate(): Promise<void> {
+    const ownedAssets = await api.assets.getOwnedAssetIds(this.connected);
+
+    if (ownedAssets.includes(this.asset.address)) {
+      this.showExpiryDate = false;
+      this.isOwnerOpenedPage = true;
+      return;
+    }
+
+    if (this.isZeroBalance(this.asset as AccountAsset)) {
+      this.showExpiryDate = false;
+      return;
+    }
+
+    this.showExpiryDate = true;
+
+    const expiryDate = await api.extendedAssets.getSbtExpiration(this.connected, this.asset.address);
+
+    this.expiryDate = this.formatDate(Number(expiryDate), 'lll');
+    this.expiresIn = this.getRelativeTime(Number(expiryDate));
+  }
+
+  async mounted(): Promise<void> {
+    const { regulatedAssets, symbol } = await api.extendedAssets.getSbtMetaInfo(this.asset.address);
+    const infos = regulatedAssets.map((address) => api.assets.getAssetInfo(address));
+
+    this.sbtSymbol = symbol;
+
+    const regulatedAssetsInfos = (await Promise.allSettled(infos))
+      .map((result) => (result.status === 'fulfilled' ? result.value : undefined))
+      .filter(Boolean);
+
+    this.regulatedAssets = regulatedAssetsInfos;
+
+    this.checkExpirationDate();
+  }
+}
+</script>
+
+<style lang="scss">
+.sbt-permissions-info {
+  .asset-details {
+    &-container {
+      flex-direction: column;
+      justify-content: center;
+      align-items: center;
+      width: 100%;
+    }
+
+    &-title {
+      margin-top: $basic-spacing;
+      font-size: var(--s-icon-font-size-big);
+      font-weight: 500;
+    }
+
+    &-desc {
+      margin-top: $inner-spacing-mini;
+      color: var(--s-color-base-content-secondary);
+      text-align: center;
+      font-weight: 300;
+      width: 80%;
+    }
+
+    &-regulated-section {
+      width: 100%;
+    }
+
+    &-issuer {
+      margin-bottom: $basic-spacing;
+      margin-top: $inner-spacing-mini;
+    }
+
+    &-subtitle {
+      color: var(--s-color-base-content-secondary);
+      margin-top: $inner-spacing-big;
+      text-transform: uppercase;
+      align-self: flex-start;
+      font-weight: 600;
+
+      &--no-permission {
+        align-self: center;
+      }
+    }
+
+    &-instition-mark {
+      font-size: var(--s-font-size-mini);
+      color: var(--s-color-status-info);
+    }
+  }
+
+  .account-card {
+    width: 100%;
+  }
+
+  // overwrite card
+  .el-card.asset-details {
+    padding: 0 !important;
+  }
+
+  .el-divider {
+    margin: 0;
+  }
+
+  .el-icon-success {
+    color: var(--s-color-fiat-value);
+    margin-left: 4px;
+  }
+}
+</style>
diff --git a/src/components/AssetDetails/AssetDetailsTransferable.vue b/src/components/AssetDetails/AssetDetailsTransferable.vue
new file mode 100644
index 000000000..64bfbddc3
--- /dev/null
+++ b/src/components/AssetDetails/AssetDetailsTransferable.vue
@@ -0,0 +1,495 @@
+<template>
+  <wallet-base :title="headerTitle" show-back :reset-focus="hasResetFocus" @back="handleBack">
+    <template v-if="!selectedTransaction" #actions>
+      <s-button v-if="!isXor" type="action" :tooltip="t('asset.remove')" @click="handleRemoveAsset">
+        <s-icon name="basic-eye-24" size="28" />
+      </s-button>
+    </template>
+    <template v-if="!selectedTransaction">
+      <s-card class="asset-details" primary>
+        <div class="asset-details-container s-flex">
+          <nft-details
+            v-if="isNft"
+            is-asset-details
+            :content-link="nftContentLink"
+            :token-name="asset.name"
+            :token-symbol="asset.symbol"
+            :token-description="asset.description"
+            @click-details="handleClickNftDetails"
+          />
+          <template v-else>
+            <token-logo :token="asset" size="bigger" />
+            <div
+              v-button="isXor"
+              :style="balanceStyles"
+              :class="balanceDetailsClasses"
+              :tabindex="isXor ? 0 : -1"
+              @click="isXor && handleClickDetailedBalance()"
+            >
+              <formatted-amount
+                value-can-be-hidden
+                symbol-as-decimal
+                :value="balance"
+                :font-size-rate="FontSizeRate.SMALL"
+                :asset-symbol="asset.symbol"
+              >
+                <s-icon v-if="isXor" name="chevron-down-rounded-16" size="18" />
+              </formatted-amount>
+            </div>
+          </template>
+          <formatted-amount
+            v-if="price && !isNft"
+            value-can-be-hidden
+            is-fiat-value
+            :value="getFiatBalance(asset)"
+            :font-size-rate="FontSizeRate.MEDIUM"
+          />
+          <div class="asset-details-actions">
+            <s-button
+              v-for="operation in operations"
+              :key="operation.type"
+              :class="['asset-details-action', operation.type]"
+              :tooltip="getOperationTooltip(operation)"
+              :disabled="isOperationDisabled(operation.type)"
+              type="action"
+              size="medium"
+              rounded
+              primary
+              @click="handleOperation(operation.type)"
+            >
+              <s-icon :name="operation.icon" size="24" />
+            </s-button>
+
+            <qr-code-scan-button primary size="medium" @change="parseQrCodeValue" />
+
+            <s-button type="action" primary rounded :tooltip="t('code.receive')" @click="receiveByQrCode(asset)">
+              <s-icon name="finance-receive-show-QR-24" size="24" />
+            </s-button>
+          </div>
+          <transition name="fadeHeight">
+            <div v-if="isXor && wasBalanceDetailsClicked" class="asset-details-balance-info">
+              <template v-for="(balanceGroup, index) in balanceTypes">
+                <div
+                  v-for="balanceType in Array.isArray(balanceGroup) ? balanceGroup : [balanceGroup]"
+                  :key="balanceType"
+                  class="balance s-flex p4"
+                >
+                  <div :class="['balance-label', { 'balance-label--total': index === balanceTypes.length - 1 }]">
+                    <template v-if="Array.isArray(balanceGroup)"> - </template>
+                    {{ t(`assets.balance.${balanceType}`) }}
+                  </div>
+                  <formatted-amount-with-fiat-value
+                    value-can-be-hidden
+                    value-class="balance-value"
+                    :value="formatBalance(asset.balance[balanceType])"
+                    :font-size-rate="FontSizeRate.MEDIUM"
+                    :font-weight-rate="FontWeightRate.SMALL"
+                    :asset-symbol="asset.symbol"
+                    :fiat-value="getFiatBalance(asset, balanceType)"
+                    fiat-format-as-value
+                    with-left-shift
+                  />
+                </div>
+              </template>
+            </div>
+          </transition>
+        </div>
+      </s-card>
+      <div v-if="isNft" class="asset-details-nft-container">
+        <transition name="fadeHeight">
+          <div v-if="wasNftDetailsClicked" class="info-line-container">
+            <info-line :label="t('createToken.nft.supply.quantity')" :value="balance" />
+            <info-line
+              class="external-link"
+              :label="t('createToken.nft.source.label')"
+              :value="displayedNftContentLink"
+              :value-tooltip="nftLinkTooltipText"
+              @click.native.stop="handleCopyNftLink"
+            />
+          </div>
+        </transition>
+      </div>
+    </template>
+    <wallet-transaction-details v-else />
+    <wallet-history v-show="!selectedTransaction" :asset="asset" />
+  </wallet-base>
+</template>
+
+<script lang="ts">
+import { XOR, BalanceType } from '@sora-substrate/sdk/build/assets/consts';
+import { AssetTypes } from '@sora-substrate/sdk/build/assets/types';
+import { Component, Mixins } from 'vue-property-decorator';
+
+import { api } from '../../api';
+import { RouteNames } from '../../consts';
+import { state, getter, mutation } from '../../store/decorators';
+import { Operations } from '../../types/common';
+import { copyToClipboard, delay, shortenValue } from '../../util';
+import { IpfsStorage } from '../../util/ipfsStorage';
+import TokenLogo from '../AssetLogos/TokenLogo.vue';
+import FormattedAmount from '../FormattedAmount.vue';
+import FormattedAmountWithFiatValue from '../FormattedAmountWithFiatValue.vue';
+import InfoLine from '../InfoLine.vue';
+import CopyAddressMixin from '../mixins/CopyAddressMixin';
+import FormattedAmountMixin from '../mixins/FormattedAmountMixin';
+import OperationsMixin from '../mixins/OperationsMixin';
+import QrCodeParserMixin from '../mixins/QrCodeParserMixin';
+import NftDetails from '../NftDetails.vue';
+import QrCodeScanButton from '../QrCode/QrCodeScanButton.vue';
+import WalletBase from '../WalletBase.vue';
+import WalletHistory from '../WalletHistory.vue';
+import WalletTransactionDetails from '../WalletTransactionDetails.vue';
+
+import type { WalletPermissions } from '../../consts';
+import type { CodecString, AccountHistory, HistoryItem } from '@sora-substrate/sdk';
+import type { AccountAsset } from '@sora-substrate/sdk/build/assets/types';
+
+interface Operation {
+  type: Operations;
+  icon: string;
+}
+
+@Component({
+  components: {
+    WalletBase,
+    FormattedAmount,
+    FormattedAmountWithFiatValue,
+    WalletHistory,
+    WalletTransactionDetails,
+    QrCodeScanButton,
+    NftDetails,
+    InfoLine,
+    TokenLogo,
+  },
+})
+export default class AssetDetailsTransferable extends Mixins(
+  OperationsMixin,
+  FormattedAmountMixin,
+  CopyAddressMixin,
+  QrCodeParserMixin
+) {
+  readonly balanceTypes = [
+    BalanceType.Transferable,
+    BalanceType.Locked,
+    [BalanceType.Frozen, BalanceType.Reserved, BalanceType.Bonded],
+    BalanceType.Total,
+  ];
+
+  @state.router.currentRouteParams private currentRouteParams!: Record<string, AccountAsset>;
+  @state.router.previousRouteParams private previousRouteParams!: Record<string, unknown>;
+  @state.settings.permissions private permissions!: WalletPermissions;
+  @state.account.accountAssets private accountAssets!: Array<AccountAsset>;
+  @state.transactions.history private history!: AccountHistory<HistoryItem>;
+  @getter.transactions.selectedTx selectedTransaction!: Nullable<HistoryItem>;
+  @mutation.transactions.resetTxDetailsId private resetTxDetailsId!: FnWithoutArgs;
+
+  wasBalanceDetailsClicked = false;
+  asset = {} as AccountAsset;
+
+  // ____________________NFT Token Details_____________________________
+  private wasNftLinkCopied = false;
+  wasNftDetailsClicked = false;
+  nftContentLink = '';
+
+  get hasResetFocus(): string {
+    return this.selectedTransaction && this.selectedTransaction.id
+      ? this.selectedTransaction.id.toString()
+      : this.wasBalanceDetailsClicked.toString();
+  }
+
+  get isNft(): boolean {
+    return api.assets.isNft(this.asset);
+  }
+
+  get headerTitle(): string {
+    if (!this.selectedTransaction) return this.asset.name;
+
+    return this.getTitle(this.selectedTransaction);
+  }
+
+  get nftLinkTooltipText(): string {
+    // TODO: Remove assets.copy, assets.copied
+    return this.wasNftLinkCopied ? this.t('copiedText') : this.t('createToken.nft.link.copyLink');
+  }
+
+  get displayedNftContentLink(): string {
+    const hostname = IpfsStorage.getStorageHostname(this.nftContentLink);
+    const path = IpfsStorage.getIpfsPath(this.nftContentLink);
+    return shortenValue(hostname + '/ipfs/' + path, 25);
+  }
+
+  private async setNftMeta(): Promise<void> {
+    const ipfsPath = this.asset.content as string;
+    this.nftContentLink = IpfsStorage.constructFullIpfsUrl(ipfsPath);
+  }
+
+  handleClickNftDetails(): void {
+    this.wasNftDetailsClicked = !this.wasNftDetailsClicked;
+  }
+
+  async handleCopyNftLink(): Promise<void> {
+    await copyToClipboard(this.nftContentLink);
+    this.wasNftLinkCopied = true;
+    await delay(1000);
+    this.wasNftLinkCopied = false;
+  }
+
+  async created(): Promise<void> {
+    const asset =
+      this.accountAssets.find(({ address }) => address === this.currentRouteParams.asset.address) ||
+      this.currentRouteParams.asset;
+
+    // asset wasn't added to accountAssets (SBT regulated asset case)
+    if (!asset.balance) {
+      const nonAddedAsset = await api.assets.getAccountAsset(this.currentRouteParams.asset.address);
+      this.asset = nonAddedAsset;
+    } else {
+      this.asset = asset;
+    }
+
+    if (this.isNft) {
+      this.setNftMeta();
+    }
+  }
+  // __________________________________________________________
+
+  formatBalance(value: CodecString): string {
+    return this.formatCodecNumber(value, this.asset.decimals);
+  }
+
+  get operations(): Array<Operation> {
+    const list: Array<Operation> = [];
+    const divisible = !!this.asset.decimals;
+
+    if (this.permissions.sendAssets) {
+      list.push({ type: Operations.Send, icon: 'finance-send-24' });
+    }
+    if (this.permissions.swapAssets && divisible) {
+      list.push({ type: Operations.Swap, icon: 'arrows-swap-24' });
+    }
+    if (this.permissions.addLiquidity && divisible) {
+      list.push({ type: Operations.Liquidity, icon: 'basic-drop-24' });
+    }
+    if (this.permissions.bridgeAssets && divisible) {
+      list.push({ type: Operations.Bridge, icon: 'grid-block-distribute-vertically-24' });
+    }
+
+    return list;
+  }
+
+  get price(): Nullable<CodecString> {
+    return this.getAssetFiatPrice(this.asset);
+  }
+
+  get balance(): string {
+    return this.formatCodecNumber(this.asset.balance?.transferable, this.asset.decimals);
+  }
+
+  get totalBalance(): string {
+    return this.formatBalance(this.asset.balance.total);
+  }
+
+  get isEmptyBalance(): boolean {
+    return this.isCodecZero(this.asset.balance?.transferable, this.asset.decimals);
+  }
+
+  get balanceStyles(): object {
+    const balanceLength = this.balance.length;
+    // We've decided to calcutate font size values manually
+    let fontSize = 30;
+    if (balanceLength > 35) {
+      fontSize = 14;
+    } else if (balanceLength > 24 && balanceLength <= 35) {
+      fontSize = 16;
+    } else if (balanceLength > 17 && balanceLength <= 24) {
+      fontSize = 20;
+    }
+    return { fontSize: `${fontSize}px` };
+  }
+
+  get balanceDetailsClasses(): Array<string> {
+    const cssClasses: Array<string> = ['asset-details-balance', 'd2'];
+    if (this.isXor) {
+      cssClasses.push('asset-details-balance--clickable');
+    }
+    if (this.wasBalanceDetailsClicked) {
+      cssClasses.push('asset-details-balance--clicked');
+    }
+    return cssClasses;
+  }
+
+  get isXor(): boolean {
+    return this.asset.address === XOR.address;
+  }
+
+  get isCleanHistoryDisabled(): boolean {
+    if (!this.asset) return true;
+
+    return Object.values(this.history).every(
+      (item) => ![item.assetAddress, item.asset2Address].includes(this.asset.address)
+    );
+  }
+
+  handleBack(): void {
+    if (this.selectedTransaction) {
+      this.resetTxDetailsId();
+    } else {
+      if (this.currentRouteParams.fromWalletAssets) {
+        this.navigate({ name: RouteNames.Wallet });
+        return;
+      }
+
+      if (this.currentRouteParams.fromSbtDetails && this.currentRouteParams.prevAsset) {
+        this.navigate({ name: RouteNames.WalletAssetDetails, params: { asset: this.currentRouteParams.prevAsset } });
+        return;
+      }
+
+      this.navigate({ name: RouteNames.Wallet });
+    }
+  }
+
+  getOperationTooltip(operation: Operation): string {
+    return this.t(`assets.${operation.type}`);
+  }
+
+  isOperationDisabled(operation: Operations): boolean {
+    // TODO: [DEFI-R] [Rustem] remove check when all SBT operations become available
+    if (
+      [Operations.Bridge, Operations.Liquidity, Operations.Swap].includes(operation) &&
+      this.asset?.type === AssetTypes.Regulated
+    ) {
+      return true;
+    }
+
+    return operation === Operations.Send && this.isEmptyBalance;
+  }
+
+  handleOperation(operation: Operations): void {
+    switch (operation) {
+      case Operations.Send:
+        this.navigate({
+          name: RouteNames.WalletSend,
+          params: {
+            asset: this.asset,
+            fromWalletAssets: this.currentRouteParams.fromWalletAssets,
+            fromSbtDetails: this.currentRouteParams.fromSbtDetails,
+            prevAsset: this.previousRouteParams.asset,
+          },
+        });
+        break;
+      default:
+        this.$emit(operation, this.asset);
+        break;
+    }
+  }
+
+  handleClickDetailedBalance(): void {
+    this.wasBalanceDetailsClicked = !this.wasBalanceDetailsClicked;
+  }
+
+  getBalance(asset: AccountAsset, type: BalanceType): string {
+    return `${this.formatCodecNumber(asset.balance[type], asset.decimals)}`;
+  }
+
+  handleRemoveAsset(): void {
+    api.assets.removeAccountAsset(this.asset.address);
+    this.handleBack();
+  }
+}
+</script>
+
+<style scoped lang="scss">
+.asset-details {
+  padding: 0 !important;
+  margin-bottom: 0;
+  border-radius: 0;
+  &.s-card.neumorphic {
+    padding-top: 0;
+    padding-bottom: 0;
+  }
+  &-container {
+    flex-direction: column;
+    align-items: center;
+    @include fadeHeight;
+    .formatted-amount--fiat-value {
+      + .asset-details-actions {
+        margin-top: #{$basic-spacing-small};
+        margin-bottom: #{$basic-spacing-medium};
+      }
+    }
+  }
+  &-nft-container {
+    @include fadeHeight(50px, 0.1s);
+  }
+  &-balance {
+    width: 100%;
+    margin-top: var(--s-basic-spacing);
+    position: relative;
+    text-align: center;
+    &--clickable {
+      cursor: pointer;
+      @include focus-outline($withOffset: true);
+    }
+    & + .formatted-amount--fiat-value {
+      width: 100%;
+      text-align: center;
+      font-size: var(--s-font-size-medium);
+      font-weight: 600;
+    }
+    .s-icon-chevron-down-rounded-16 {
+      display: inline-block;
+      margin-left: var(--s-basic-spacing);
+      height: var(--s-icon-font-size-small);
+      width: var(--s-icon-font-size-small);
+      transition: transform 0.3s;
+      background-color: var(--s-color-base-content-secondary);
+      color: var(--s-color-base-on-accent);
+      border-radius: 50%;
+      text-align: left;
+    }
+    &--clicked .s-icon-chevron-down-rounded-16 {
+      padding-right: #{$basic-spacing-small};
+      transform: rotate(180deg);
+    }
+    &-info {
+      width: 100%;
+      margin-top: #{$basic-spacing-medium};
+      .balance {
+        justify-content: space-between;
+        align-items: baseline;
+        margin-bottom: $basic-spacing-mini;
+        border-bottom: 1px solid var(--s-color-base-border-secondary);
+        font-size: var(--s-font-size-extra-small);
+        &-label {
+          text-transform: uppercase;
+          margin-right: var(--s-basic-spacing);
+          font-weight: 300;
+          white-space: nowrap;
+          &--total {
+            font-weight: 600;
+          }
+        }
+      }
+    }
+  }
+  &-actions {
+    margin-top: #{$basic-spacing-medium};
+
+    & > *:not(:first-child) {
+      margin-left: $basic-spacing;
+    }
+  }
+}
+
+.info-line-container {
+  @include fadeHeight;
+}
+</style>
+
+<style lang="scss">
+.external-link {
+  .info-line-value {
+    cursor: pointer;
+  }
+}
+</style>
diff --git a/src/components/AssetListItem.vue b/src/components/AssetListItem.vue
index 618e056da..b30ef9155 100644
--- a/src/components/AssetListItem.vue
+++ b/src/components/AssetListItem.vue
@@ -39,11 +39,13 @@
 <script lang="ts">
 import { Component, Mixins, Prop } from 'vue-property-decorator';
 
+import { state } from '../store/decorators';
+
+import NftTokenLogo from './AssetLogos/NftTokenLogo.vue';
+import TokenLogo from './AssetLogos/TokenLogo.vue';
 import TranslationMixin from './mixins/TranslationMixin';
-import NftTokenLogo from './NftTokenLogo.vue';
 import PinIcon from './PinIcon.vue';
 import TokenAddress from './TokenAddress.vue';
-import TokenLogo from './TokenLogo.vue';
 
 import type { Asset } from '@sora-substrate/sdk/build/assets/types';
 
@@ -87,6 +89,10 @@ export default class AssetListItem extends Mixins(TranslationMixin) {
   .formatted-amount__container {
     width: 100%;
   }
+
+  .asset-sbt-expiration {
+    margin-bottom: calc($inner-spacing-mini * -1);
+  }
 }
 </style>
 
@@ -112,9 +118,15 @@ export default class AssetListItem extends Mixins(TranslationMixin) {
 
   &-symbol {
     font-size: var(--s-font-size-big);
-    font-weight: 600;
     letter-spacing: var(--s-letter-spacing-small);
     line-height: var(--s-line-height-extra-small);
+    font-weight: 600;
+  }
+
+  &-sbt-expiration {
+    font-size: var(--s-font-size-extra-mini);
+    display: block;
+    font-weight: 300;
   }
   .check {
     display: flex;
diff --git a/src/components/NftTokenLogo.vue b/src/components/AssetLogos/NftTokenLogo.vue
similarity index 94%
rename from src/components/NftTokenLogo.vue
rename to src/components/AssetLogos/NftTokenLogo.vue
index 35314d079..4d4666f8a 100644
--- a/src/components/NftTokenLogo.vue
+++ b/src/components/AssetLogos/NftTokenLogo.vue
@@ -2,8 +2,9 @@
   <img
     v-show="asset.content && showNftImage"
     class="asset-logo nft-image"
-    :src="nftImageUrl"
     ref="nftImage"
+    alt="NFT"
+    :src="nftImageUrl"
     @load="handleNftImageLoad"
     @error="hideNftImage"
   />
@@ -12,7 +13,7 @@
 <script lang="ts">
 import { Component, Prop, Vue, Ref } from 'vue-property-decorator';
 
-import { IpfsStorage } from '../util/ipfsStorage';
+import { IpfsStorage } from '../../util/ipfsStorage';
 
 import type { Asset } from '@sora-substrate/sdk/build/assets/types';
 
diff --git a/src/components/AssetLogos/SbtTokenLogo.vue b/src/components/AssetLogos/SbtTokenLogo.vue
new file mode 100644
index 000000000..63bb168a9
--- /dev/null
+++ b/src/components/AssetLogos/SbtTokenLogo.vue
@@ -0,0 +1,165 @@
+<template>
+  <img
+    v-show="asset.content && showSbtImage"
+    class="asset-logo sbt-image"
+    ref="nftImage"
+    alt="SBT"
+    :src="sbtImageUrl"
+    @load="handleSbtImageLoad"
+    @error="hideSbtImage"
+  />
+</template>
+
+<script lang="ts">
+import { Component, Prop, Vue, Ref } from 'vue-property-decorator';
+
+import { IpfsStorage } from '../../util/ipfsStorage';
+
+import type { Asset } from '@sora-substrate/sdk/build/assets/types';
+
+@Component
+export default class SbtTokenLogo extends Vue {
+  @Prop({ default: () => {}, type: Object, required: true }) readonly asset!: Asset;
+  @Ref('sbtImage') readonly nftImage!: HTMLImageElement;
+
+  showSbtImage = false;
+
+  get sbtImageUrl(): string {
+    if (this.asset.content) {
+      return IpfsStorage.constructFullIpfsUrl(this.asset.content);
+    }
+    return '';
+  }
+
+  handleSbtImageLoad(): void {
+    const imgElement = this.nftImage as HTMLImageElement;
+    if (imgElement) {
+      this.showSbtImage = imgElement.complete && imgElement.naturalHeight !== 0;
+    } else {
+      this.showSbtImage = false;
+    }
+  }
+
+  hideSbtImage(): void {
+    this.showSbtImage = false;
+  }
+}
+</script>
+
+<style lang="scss">
+$token-background-color: var(--s-color-base-on-accent);
+$token-color: var(--s-color-base-content-tertiary);
+
+.logo {
+  position: relative;
+}
+.asset-logo {
+  &__sbt-image {
+    border-radius: 50%;
+    object-fit: cover;
+    position: absolute !important;
+    top: 0;
+    left: 0;
+  }
+
+  &--clickable {
+    cursor: pointer;
+  }
+}
+
+@mixin token-logo-size($size: '') {
+  $className: 'asset-logo';
+  @if ($size == 'mini') {
+    $size-px: 16px;
+    $classNameMini: '#{$className}--mini';
+    @include element-size($classNameMini, $size-px);
+    .#{$classNameMini} {
+      @include asset-logo-styles;
+      line-height: $size-px;
+      font-size: 12px;
+      color: var(--s-color-base-content-tertiary);
+      &.#{$className}-nft::before {
+        content: 'SBT';
+        font-size: 6px;
+      }
+    }
+  } @else if ($size == 'small') {
+    $size-px: 24px;
+    $classNameSmall: '#{$className}--small';
+    @include element-size($classNameSmall, $size-px);
+    .#{$classNameSmall} {
+      @include asset-logo-styles;
+      line-height: $size-px;
+      font-size: 18px;
+      &.#{$className}-nft::before {
+        content: 'SBT';
+        font-size: 8px;
+        font-weight: 800;
+      }
+    }
+  } @else if ($size == 'medium') {
+    $size-px: 32px;
+    $classNameMedium: '#{$className}--medium';
+    @include element-size($classNameMedium, $size-px);
+    .#{$classNameMedium} {
+      @include asset-logo-styles;
+      line-height: $size-px;
+      font-size: 24px;
+      &.#{$className}-nft::before {
+        content: 'SBT';
+        font-size: 12px;
+        font-weight: 800;
+      }
+    }
+  } @else if ($size == 'big') {
+    $size-px: var(--s-size-medium);
+    $classNameBig: '#{$className}--big';
+    @include element-size($classNameBig, $size-px);
+    .#{$classNameBig} {
+      @include asset-logo-styles;
+      line-height: $size-px;
+      font-size: 32px;
+      &.#{$className}-nft::before {
+        content: 'SBT';
+        font-size: 14px;
+        font-weight: 800;
+      }
+    }
+  } @else if ($size == 'bigger') {
+    $size-px: 48px;
+    $classNameBig: '#{$className}--bigger';
+    @include element-size($classNameBig, $size-px);
+    .#{$classNameBig} {
+      @include asset-logo-styles;
+      line-height: $size-px;
+      font-size: 32px;
+      &.#{$className}-nft::before {
+        content: 'SBT';
+        font-size: 14px;
+        font-weight: 800;
+      }
+    }
+  } @else if ($size == 'large') {
+    $size-px: 80px;
+    $classNameLarge: '#{$className}--large';
+    @include element-size($classNameLarge, $size-px);
+    .#{$classNameLarge} {
+      @include asset-logo-styles;
+      line-height: $size-px;
+      font-size: 64px;
+      &.#{$className}-nft::before {
+        content: 'SBT';
+        font-size: 28px;
+        font-weight: 800;
+      }
+    }
+  }
+}
+
+@include token-logo-size('mini');
+@include token-logo-size('small');
+@include token-logo-size('medium');
+@include token-logo-size('big');
+@include token-logo-size('bigger');
+@include token-logo-size('large');
+</style>
diff --git a/src/components/TokenLogo.vue b/src/components/AssetLogos/TokenLogo.vue
similarity index 76%
rename from src/components/TokenLogo.vue
rename to src/components/AssetLogos/TokenLogo.vue
index 6ccbf22e0..24a1af626 100644
--- a/src/components/TokenLogo.vue
+++ b/src/components/AssetLogos/TokenLogo.vue
@@ -1,26 +1,30 @@
 <template>
   <div class="logo">
     <span :class="iconClasses" :style="iconStyles" />
+    <sbt-token-logo v-if="isSbt" class="asset-logo__nft-image" :class="iconClasses" :asset="token" />
     <nft-token-logo v-if="isNft" class="asset-logo__nft-image" :class="iconClasses" :asset="token" />
   </div>
 </template>
 
 <script lang="ts">
+import { AssetTypes } from '@sora-substrate/sdk/build/assets/types';
 import { Component, Mixins, Prop } from 'vue-property-decorator';
 
-import { api } from '../api';
-import { LogoSize, ObjectInit } from '../consts';
-import { getter } from '../store/decorators';
+import { api } from '../../api';
+import { LogoSize, ObjectInit } from '../../consts';
+import { getter } from '../../store/decorators';
+import TranslationMixin from '../mixins/TranslationMixin';
 
-import TranslationMixin from './mixins/TranslationMixin';
 import NftTokenLogo from './NftTokenLogo.vue';
+import SbtTokenLogo from './SbtTokenLogo.vue';
 
-import type { WhitelistIdsBySymbol } from '../types/common';
+import type { WhitelistIdsBySymbol } from '../../types/common';
 import type { Asset, AccountAsset, Whitelist, WhitelistItem } from '@sora-substrate/sdk/build/assets/types';
 
 @Component({
   components: {
     NftTokenLogo,
+    SbtTokenLogo,
   },
 })
 export default class TokenLogo extends Mixins(TranslationMixin) {
@@ -33,9 +37,14 @@ export default class TokenLogo extends Mixins(TranslationMixin) {
   @Prop({ default: false, type: Boolean }) readonly withClickableLogo!: boolean;
 
   get isNft(): boolean {
+    if (this.token?.type === AssetTypes.Soulbound) return false;
     return !!this.token && api.assets.isNft(this.token);
   }
 
+  get isSbt(): boolean {
+    return this.token?.type === AssetTypes.Soulbound;
+  }
+
   get assetAddress(): Nullable<string> {
     return this.tokenSymbol ? this.whitelistIdsBySymbol[this.tokenSymbol] : (this.token || {}).address;
   }
@@ -70,7 +79,11 @@ export default class TokenLogo extends Mixins(TranslationMixin) {
     if (!this.assetAddress) {
       classes.push(questionMark);
     } else if (!this.whitelistedItem) {
-      classes.push(this.isNft ? 'asset-logo-nft' : questionMark);
+      if (this.isSbt) {
+        classes.push('asset-logo-sbt');
+      } else {
+        classes.push(this.isNft ? 'asset-logo-nft' : questionMark);
+      }
     }
 
     classes.push(`${tokenLogoClass}--${this.size.toLowerCase()}`);
@@ -92,8 +105,13 @@ $token-color: var(--s-color-base-content-tertiary);
   position: relative;
 }
 .asset-logo {
+  &-nft,
+  &-sbt {
+    border-radius: 20% !important;
+  }
+
   &__nft-image {
-    border-radius: 50%;
+    border-radius: 20%;
     object-fit: cover;
     position: absolute !important;
     top: 0;
@@ -120,6 +138,10 @@ $token-color: var(--s-color-base-content-tertiary);
         content: 'NFT';
         font-size: 6px;
       }
+      &.#{$className}-sbt::before {
+        content: 'SBT';
+        font-size: 6px;
+      }
     }
   } @else if ($size == 'small') {
     $size-px: 24px;
@@ -134,6 +156,11 @@ $token-color: var(--s-color-base-content-tertiary);
         font-size: 8px;
         font-weight: 800;
       }
+      &.#{$className}-sbt::before {
+        content: 'SBT';
+        font-size: 8px;
+        font-weight: 800;
+      }
     }
   } @else if ($size == 'medium') {
     $size-px: 32px;
@@ -148,6 +175,11 @@ $token-color: var(--s-color-base-content-tertiary);
         font-size: 12px;
         font-weight: 800;
       }
+      &.#{$className}-sbt::before {
+        content: 'SBT';
+        font-size: 12px;
+        font-weight: 800;
+      }
     }
   } @else if ($size == 'big') {
     $size-px: var(--s-size-medium);
@@ -157,11 +189,17 @@ $token-color: var(--s-color-base-content-tertiary);
       @include asset-logo-styles;
       line-height: $size-px;
       font-size: 32px;
-      &.#{$className}-nft::before {
-        content: 'NFT';
+      &.#{$className}-nft::before,
+      &.#{$className}-sbt::before {
         font-size: 14px;
         font-weight: 800;
       }
+      &.#{$className}-nft::before {
+        content: 'NFT';
+      }
+      &.#{$className}-sbt::before {
+        content: 'SBT';
+      }
     }
   } @else if ($size == 'bigger') {
     $size-px: 48px;
@@ -176,6 +214,11 @@ $token-color: var(--s-color-base-content-tertiary);
         font-size: 14px;
         font-weight: 800;
       }
+      &.#{$className}-sbt::before {
+        content: 'SBT';
+        font-size: 14px;
+        font-weight: 800;
+      }
     }
   } @else if ($size == 'large') {
     $size-px: 80px;
@@ -190,6 +233,11 @@ $token-color: var(--s-color-base-content-tertiary);
         font-size: 28px;
         font-weight: 800;
       }
+      &.#{$className}-sbt::before {
+        content: 'SBT';
+        font-size: 28px;
+        font-weight: 800;
+      }
     }
   }
 }
diff --git a/src/components/CreateNftToken.vue b/src/components/CreateNftToken.vue
deleted file mode 100644
index b7469a98e..000000000
--- a/src/components/CreateNftToken.vue
+++ /dev/null
@@ -1,524 +0,0 @@
-<template>
-  <div class="wallet-settings-create-token">
-    <template v-if="step === Step.CreateNftToken">
-      <s-input
-        :placeholder="t('createToken.nft.link.placeholder')"
-        :minlength="1"
-        :maxlength="200"
-        :disabled="loading"
-        v-model="tokenContentLink"
-        @input="handleInputLinkChange"
-      >
-        <s-tooltip
-          slot="suffix"
-          popper-class="ipfs-tooltip"
-          :content="t('createToken.nft.link.tooltip')"
-          placement="bottom"
-          tabindex="-1"
-        >
-          <s-icon class="ipfs-tooltip__icon" name="info-16" size="18px" />
-        </s-tooltip>
-      </s-input>
-      <file-uploader
-        ref="uploader"
-        class="preview-image-create-nft"
-        :is-link-provided="!!contentSrcLink"
-        @upload="upload"
-        @clear="clear"
-        @show-limit="showLimit"
-        @hide-limit="hideLimit"
-      >
-        <div v-if="imageLoading" v-loading="imageLoading" />
-        <div v-else-if="fileExceedsLimit" class="placeholder">
-          <s-icon class="preview-image-create-nft__icon icon--error" name="basic-clear-X-24" size="32px" />
-          <span>{{ t('createToken.nft.image.placeholderFileLimit', { value: FILE_SIZE_LIMIT }) }}</span>
-          <s-button class="preview-image-create-nft__btn">{{ t('createToken.nft.source.limit') }}</s-button>
-        </div>
-        <div v-else-if="!tokenContentLink && !file" class="placeholder">
-          <s-icon class="preview-image-create-nft__icon" name="camera-16" size="32px" />
-          <span class="preview-image-create-nft__placeholder">{{ t('createToken.nft.image.placeholderNoImage') }}</span>
-        </div>
-        <div v-else-if="badSource && !file" class="placeholder">
-          <s-icon class="preview-image-create-nft__icon icon--error" name="basic-clear-X-24" size="32px" />
-          <span class="preview-image-create-nft__placeholder">{{
-            t('createToken.nft.image.placeholderBadSource')
-          }}</span>
-        </div>
-        <div v-else class="image">
-          <img class="preview-image-create-nft__content" :src="contentSrcLink" />
-        </div>
-      </file-uploader>
-      <s-input
-        :placeholder="t('createToken.tokenSymbol.placeholder')"
-        :minlength="1"
-        :maxlength="7"
-        :disabled="loading"
-        v-maska="tokenSymbolMask"
-        v-model="tokenSymbol"
-      />
-      <p class="wallet-settings-create-token_desc">{{ t('createToken.tokenSymbol.desc') }}</p>
-      <s-input
-        :placeholder="t('createToken.tokenName.placeholder')"
-        :minlength="1"
-        :maxlength="33"
-        :disabled="loading"
-        v-maska="tokenNameMask"
-        v-model="tokenName"
-      />
-      <p class="wallet-settings-create-token_desc">{{ t('createToken.tokenName.desc') }}</p>
-      <s-input
-        class="input-textarea"
-        type="textarea"
-        :placeholder="t('createToken.nft.description.placeholder')"
-        :disabled="loading"
-        :maxlength="200"
-        v-model="tokenDescription"
-        @keypress.native="handleTextAreaInput($event)"
-      />
-      <s-float-input
-        has-locale-string
-        :placeholder="t('createToken.nft.supply.placeholder')"
-        :decimals="decimals"
-        :delimiters="delimiters"
-        :max="maxTotalSupply"
-        :disabled="loading"
-        v-model="tokenSupply"
-      />
-      <p class="wallet-settings-create-token_desc">{{ t('createToken.nft.supply.desc') }}</p>
-      <div class="wallet-settings-create-token_supply-block">
-        <s-switch v-model="extensibleSupply" :disabled="loading" />
-        <span>{{ t('createToken.extensibleSupply.placeholder') }}</span>
-      </div>
-      <p class="wallet-settings-create-token_desc">{{ t('createToken.extensibleSupply.desc') }}</p>
-      <div class="delimiter"></div>
-      <div class="wallet-settings-create-token_divisible-block">
-        <s-switch v-model="divisible" :disabled="loading" @change="handleChangeDivisible" />
-        <span>{{ t('createToken.divisible.placeholder') }}</span>
-      </div>
-      <p class="wallet-settings-create-token_desc">{{ t('createToken.divisible.desc') }}</p>
-      <s-button
-        class="wallet-settings-create-token_action s-typography-button--large"
-        type="primary"
-        :loading="loading"
-        :disabled="isCreateDisabled"
-        @click="onCreate"
-      >
-        <template v-if="!tokenContentLink.trim() && !file">{{ t('createToken.provideContent') }}</template>
-        <template v-else-if="!tokenSymbol">{{ t('createToken.enterSymbol') }}</template>
-        <template v-else-if="!tokenName.trim()">{{ t('createToken.enterName') }}</template>
-        <template v-else-if="!+tokenSupply">{{ t('createToken.enterSupply') }}</template>
-        <template v-else-if="!tokenDescription">{{ t('createToken.enterTokenDescription') }}</template>
-        <template v-else-if="badSource">{{ t('createToken.provideContent') }}</template>
-        <template v-else>{{ t('createTokenTextNFT') }}</template>
-      </s-button>
-    </template>
-    <template v-else-if="step === Step.Warn">
-      <network-fee-warning-dialog :fee="formattedFee" @confirm="confirmNextTxFailure" />
-    </template>
-    <template v-else-if="step === Step.ConfirmNftToken">
-      <nft-details
-        :content-link="contentSrcLink"
-        :token-name="tokenName"
-        :token-symbol="tokenSymbol"
-        :token-description="tokenDescription"
-      />
-      <div class="info-line-container">
-        <info-line :label="t('createToken.nft.source.label')" :value="contentSource"></info-line>
-        <info-line :label="t('createToken.nft.supply.quantity')" :value="tokenSupply"></info-line>
-      </div>
-      <account-confirmation-option with-hint class="wallet-settings-create-token_action" />
-      <s-button
-        class="wallet-settings-create-token_action s-typography-button--large"
-        type="primary"
-        :disabled="!hasEnoughXor"
-        :loading="loading"
-        @click="onConfirm"
-      >
-        <template v-if="!hasEnoughXor">{{ t('insufficientBalanceText', { symbol: XOR_SYMBOL }) }}</template>
-        <template v-else>{{ t('confirmText') }}</template>
-      </s-button>
-    </template>
-
-    <wallet-fee v-if="!isCreateDisabled && showFee" :value="fee" />
-  </div>
-</template>
-
-<script lang="ts">
-import { FPNumber, Operation } from '@sora-substrate/sdk';
-import { MaxTotalSupply, XOR } from '@sora-substrate/sdk/build/assets/consts';
-import { File as ImageNFT } from 'nft.storage';
-import { Component, Mixins, Prop, Ref } from 'vue-property-decorator';
-
-import { api } from '../api';
-import LoadingMixin from '../components/mixins/LoadingMixin';
-import TransactionMixin from '../components/mixins/TransactionMixin';
-import TranslationMixin from '../components/mixins/TranslationMixin';
-import { RouteNames, Step } from '../consts';
-import { state, mutation, action } from '../store/decorators';
-import { IMAGE_MIME_TYPES } from '../util/image';
-import { IpfsStorage } from '../util/ipfsStorage';
-
-import AccountConfirmationOption from './Account/Settings/ConfirmationOption.vue';
-import FileUploader from './FileUploader.vue';
-import InfoLine from './InfoLine.vue';
-import NetworkFeeWarningMixin from './mixins/NetworkFeeWarningMixin';
-import NumberFormatterMixin from './mixins/NumberFormatterMixin';
-import NetworkFeeWarningDialog from './NetworkFeeWarning.vue';
-import NftDetails from './NftDetails.vue';
-import WalletFee from './WalletFee.vue';
-
-import type { Route } from '../store/router/types';
-import type { NFTStorage } from 'nft.storage';
-
-@Component({
-  components: {
-    InfoLine,
-    WalletFee,
-    NftDetails,
-    NetworkFeeWarningDialog,
-    FileUploader,
-    AccountConfirmationOption,
-  },
-})
-export default class CreateNftToken extends Mixins(
-  TranslationMixin,
-  TransactionMixin,
-  LoadingMixin,
-  NumberFormatterMixin,
-  NetworkFeeWarningMixin
-) {
-  readonly tokenSymbolMask = 'AAAAAAA';
-  readonly tokenNameMask = { mask: 'Z*', tokens: { Z: { pattern: /[0-9a-zA-Z ]/ } } };
-  readonly maxTotalSupply = MaxTotalSupply;
-  readonly delimiters = FPNumber.DELIMITERS_CONFIG;
-  readonly Step = Step;
-  readonly XOR_SYMBOL = XOR.symbol;
-  readonly FILE_SIZE_LIMIT = 100; // in megabytes
-
-  @Prop({ default: Step.CreateSimpleToken, type: String }) readonly step!: Step;
-
-  @state.settings.nftStorage private nftStorage!: NFTStorage;
-  @state.transactions.isConfirmTxDialogDisabled private isConfirmTxDisabled!: boolean;
-  @mutation.router.navigate private navigate!: (options: Route) => void;
-  @action.settings.createNftStorageInstance private createNftStorageInstance!: AsyncFnWithoutArgs;
-
-  @Ref('fileInput') readonly fileInput!: HTMLInputElement;
-  @Ref('uploader') readonly uploader!: HTMLFormElement;
-
-  imageLoading = false;
-  fileExceedsLimit = false;
-  badSource = false;
-  contentSrcLink = '';
-  tokenContentIpfsParsed = '';
-  tokenContentLink = '';
-  tokenSymbol = '';
-  tokenName = '';
-  tokenDescription = '';
-  tokenSupply = '';
-  showFee = true;
-  file: Nullable<File> = null;
-  extensibleSupply = false;
-  divisible = false;
-
-  private calcDecimals(divisible: boolean): number {
-    return divisible ? FPNumber.DEFAULT_PRECISION : 0;
-  }
-
-  get decimals(): number {
-    return this.calcDecimals(this.divisible);
-  }
-
-  get isCreateDisabled(): boolean {
-    return (
-      !(this.tokenSymbol && this.tokenName.trim() && +this.tokenSupply && this.tokenDescription.trim()) ||
-      this.badSource ||
-      !(this.file || this.tokenContentLink)
-    );
-  }
-
-  get fee(): FPNumber {
-    return this.getFPNumberFromCodec(this.networkFees.RegisterAsset);
-  }
-
-  get formattedFee(): string {
-    return this.fee.toLocaleString();
-  }
-
-  get contentSource(): string {
-    if (this.file) return this.t('createToken.nft.source.value');
-    return IpfsStorage.getStorageHostname(this.tokenContentLink);
-  }
-
-  get hasEnoughXor(): boolean {
-    return FPNumber.gte(this.xorBalance, this.fee); // xorBalance -> NetworkFeeWarningMixin
-  }
-
-  async upload(file: File): Promise<void> {
-    this.imageLoading = true;
-    this.file = file;
-    this.contentSrcLink = await IpfsStorage.fileToBase64(file);
-    this.badSource = false;
-    this.imageLoading = false;
-    this.tokenContentLink = '';
-  }
-
-  showLimit(): void {
-    this.contentSrcLink = '';
-    this.fileExceedsLimit = true;
-  }
-
-  hideLimit(): void {
-    this.contentSrcLink = '';
-    this.fileExceedsLimit = false;
-  }
-
-  handleChangeDivisible(value: boolean): void {
-    if (!value && this.tokenSupply) {
-      const decimals = this.calcDecimals(value);
-      this.tokenSupply = this.getCorrectSupply(this.tokenSupply, decimals);
-    }
-  }
-
-  handleInputLinkChange(link: string): void {
-    this.uploader.resetFileInput();
-    this.resetFileInput();
-    this.fileExceedsLimit = false;
-    this.contentSrcLink = '';
-
-    try {
-      const url = new URL(link);
-    } catch {
-      this.badSource = true;
-      return;
-    }
-
-    this.checkImageFromSource(link);
-  }
-
-  handleTextAreaInput(e: KeyboardEvent): boolean | void {
-    if (/^[A-Za-z0-9 _',.#]+$/.test(e.key)) return true;
-    e.preventDefault();
-  }
-
-  async checkImageFromSource(url: string): Promise<void> {
-    this.imageLoading = true;
-    this.badSource = false;
-
-    try {
-      const response = await fetch(url);
-      const buffer = await response.blob();
-      this.imageLoading = false;
-
-      if (this.isValidType(buffer.type)) {
-        this.badSource = false;
-        this.contentSrcLink = url;
-        this.tokenContentIpfsParsed = IpfsStorage.getIpfsPath(url);
-      } else {
-        this.badSource = true;
-        this.contentSrcLink = '';
-      }
-    } catch (error) {
-      this.badSource = true;
-      this.contentSrcLink = '';
-    }
-
-    this.resetFileInput();
-  }
-
-  isValidType(type: string): boolean {
-    return Object.values(IMAGE_MIME_TYPES).includes(type);
-  }
-
-  clear(): void {
-    this.tokenContentLink = '';
-    this.contentSrcLink = '';
-    this.resetFileInput();
-  }
-
-  resetFileInput(): void {
-    this.file = null;
-    this.imageLoading = false;
-  }
-
-  async storeNftImage(file: File): Promise<void> {
-    const content = (await IpfsStorage.fileToBuffer(file)) as ArrayBuffer;
-
-    if (!this.nftStorage) {
-      await this.createNftStorageInstance();
-    }
-
-    try {
-      const metadata = await this.nftStorage.store({
-        name: file.name,
-        description: this.tokenDescription,
-        image: new ImageNFT([content], file.name, { type: file.type }),
-      });
-
-      this.tokenContentIpfsParsed = IpfsStorage.getIpfsPath(metadata.embed().image.href);
-    } catch (error) {
-      console.error('Error while storing NFT content:', error);
-    }
-  }
-
-  async registerNftAsset(): Promise<void> {
-    if (!this.tokenContentIpfsParsed.trim()) {
-      throw new Error('IPFS Token issue');
-    }
-    return api.assets.register(
-      this.tokenSymbol,
-      this.tokenName.trim(),
-      this.tokenSupply,
-      this.extensibleSupply,
-      !this.divisible,
-      { content: this.tokenContentIpfsParsed, description: this.tokenDescription.trim() }
-    );
-  }
-
-  async onCreate(): Promise<void> {
-    if (
-      !this.tokenSymbol.length ||
-      !this.tokenSupply.length ||
-      !this.tokenDescription.length ||
-      !this.tokenName.length ||
-      this.badSource
-    ) {
-      return;
-    }
-
-    this.tokenSupply = this.getCorrectSupply(this.tokenSupply, this.decimals);
-
-    this.$emit('showTabs');
-
-    if (this.allowFeePopup && this.hasEnoughXor && !this.isXorSufficientForNextTx({ type: Operation.RegisterAsset })) {
-      this.$emit('showHeader');
-      this.showFee = false;
-      this.$emit('stepChange', Step.Warn);
-      return;
-    }
-
-    if (this.isConfirmTxDisabled) {
-      await this.onConfirm();
-    } else {
-      this.showFee = true;
-      this.$emit('stepChange', Step.ConfirmNftToken);
-    }
-  }
-
-  async onConfirm(): Promise<void> {
-    await this.withNotifications(async () => {
-      if (!this.hasEnoughXor) {
-        throw new Error('insufficientBalanceText');
-      }
-      if (this.file) {
-        await this.storeNftImage(this.file);
-      }
-      await this.registerNftAsset();
-      this.navigate({ name: RouteNames.Wallet });
-    });
-  }
-
-  confirmNextTxFailure(): void {
-    this.$emit('showHeader');
-    this.showFee = true;
-    this.$emit('stepChange', Step.ConfirmNftToken);
-  }
-}
-</script>
-
-<style lang="scss" scoped>
-.info-line-container {
-  text-transform: uppercase;
-  margin-bottom: calc(var(--s-size-small) / 2);
-}
-</style>
-
-<style lang="scss">
-.wallet-settings-create-token {
-  .ipfs-tooltip {
-    font-size: 10px !important;
-    padding: 10px 15px !important;
-    &__icon {
-      color: var(--s-color-base-content-tertiary);
-      &:hover {
-        cursor: pointer;
-        color: var(--s-color-base-content-secondary);
-      }
-    }
-  }
-  &_desc {
-    color: var(--s-color-base-content-primary);
-    font-size: var(--s-font-size-extra-small);
-    font-weight: 300;
-    line-height: var(--s-line-height-base);
-    padding: var(--s-basic-spacing) #{$basic-spacing-small} #{$basic-spacing-medium};
-  }
-
-  &_action {
-    margin-top: #{$basic-spacing-medium};
-    width: 100%;
-  }
-
-  &_supply-block,
-  &_divisible-block {
-    @include switch-block;
-    & {
-      padding: 0 #{$basic-spacing-small};
-    }
-  }
-}
-
-.s-textarea {
-  margin-bottom: #{$basic-spacing-medium};
-}
-
-.el-textarea {
-  height: 54px;
-
-  &__inner {
-    resize: none;
-    scrollbar-width: none; /* Firefox - not customizable */
-
-    &:hover::-webkit-scrollbar {
-      width: 4px;
-
-      &-thumb {
-        background-color: var(--s-color-base-content-tertiary);
-        border-radius: 6px;
-      }
-    }
-
-    &::-webkit-scrollbar {
-      width: 4px;
-
-      &-track {
-        margin-bottom: calc(var(--s-size-small) * 0.25);
-      }
-    }
-  }
-}
-
-.preview-image-create-nft {
-  margin: #{$basic-spacing-medium} 0;
-  height: 200px;
-
-  @include drag-drop-content;
-
-  .image {
-    margin: 0 auto;
-    height: 176px;
-  }
-
-  &__content {
-    height: 176px;
-    width: 176px;
-    object-fit: cover;
-    border-radius: calc(var(--s-border-radius-mini) * 0.75);
-  }
-}
-
-.delimiter {
-  background-color: var(--s-color-base-border-secondary);
-  margin-bottom: calc(var(--s-size-small) / 2);
-  height: 1px;
-}
-</style>
diff --git a/src/components/CreateSimpleToken.vue b/src/components/CreateSimpleToken.vue
deleted file mode 100644
index d9f826862..000000000
--- a/src/components/CreateSimpleToken.vue
+++ /dev/null
@@ -1,217 +0,0 @@
-<template>
-  <div class="wallet-settings-create-token">
-    <template v-if="step === Step.CreateSimpleToken">
-      <s-input
-        :placeholder="t('createToken.tokenSymbol.placeholder')"
-        :minlength="1"
-        :maxlength="7"
-        :disabled="loading"
-        v-maska="tokenSymbolMask"
-        v-model="tokenSymbol"
-      />
-      <p class="wallet-settings-create-token_desc">{{ t('createToken.tokenSymbol.desc') }}</p>
-      <s-input
-        :placeholder="t('createToken.tokenName.placeholder')"
-        :minlength="1"
-        :maxlength="33"
-        :disabled="loading"
-        v-maska="tokenNameMask"
-        v-model="tokenName"
-      />
-      <p class="wallet-settings-create-token_desc">{{ t('createToken.tokenName.desc') }}</p>
-      <s-float-input
-        v-model="tokenSupply"
-        :placeholder="t('createToken.tokenSupply.placeholder')"
-        :decimals="decimals"
-        has-locale-string
-        :delimiters="delimiters"
-        :max="maxTotalSupply"
-        :disabled="loading"
-      />
-      <p class="wallet-settings-create-token_desc">{{ t('createToken.tokenSupply.desc') }}</p>
-      <div class="wallet-settings-create-token_supply-block">
-        <s-switch v-model="extensibleSupply" :disabled="loading" />
-        <span>{{ t('createToken.extensibleSupply.placeholder') }}</span>
-      </div>
-      <p class="wallet-settings-create-token_desc">{{ t('createToken.extensibleSupply.desc') }}</p>
-      <s-button
-        class="wallet-settings-create-token_action s-typography-button--large"
-        type="primary"
-        :loading="loading"
-        :disabled="isCreateDisabled"
-        @click="onCreate"
-      >
-        <template v-if="!tokenSymbol">{{ t('createToken.enterSymbol') }}</template>
-        <template v-else-if="!tokenName.trim()">{{ t('createToken.enterName') }}</template>
-        <template v-else-if="!+tokenSupply">{{ t('createToken.enterSupply') }}</template>
-        <template v-else>{{ t('createTokenText') }}</template>
-      </s-button>
-    </template>
-    <template v-else-if="step === Step.Warn">
-      <network-fee-warning-dialog :fee="formattedFee" @confirm="confirmNextTxFailure" />
-    </template>
-    <template v-else-if="step === Step.ConfirmSimpleToken">
-      <info-line :label="t('createToken.tokenSymbol.placeholder')" :value="tokenSymbol" />
-      <info-line :label="t('createToken.tokenName.placeholder')" :value="tokenName.trim()" />
-      <info-line :label="t('createToken.tokenSupply.placeholder')" :value="formattedTokenSupply" />
-      <info-line :label="t('createToken.extensibleSupply.placeholder')" :value="extensibleSupply ? 'Yes' : 'No'" />
-      <account-confirmation-option with-hint class="wallet-settings-create-token_action" />
-      <s-button
-        class="wallet-settings-create-token_action s-typography-button--large"
-        type="primary"
-        :disabled="!hasEnoughXor"
-        :loading="loading"
-        @click="onConfirm"
-      >
-        <template v-if="!hasEnoughXor">{{ t('insufficientBalanceText', { symbol: XOR }) }}</template>
-        <template v-else>{{ t('confirmText') }}</template>
-      </s-button>
-    </template>
-    <wallet-fee v-if="!isCreateDisabled && showFee" :value="fee" />
-  </div>
-</template>
-
-<script lang="ts">
-import { FPNumber, Operation } from '@sora-substrate/sdk';
-import { MaxTotalSupply, XOR } from '@sora-substrate/sdk/build/assets/consts';
-import { Component, Mixins, Prop } from 'vue-property-decorator';
-
-import { api } from '../api';
-import { RouteNames, Step } from '../consts';
-import { mutation, state } from '../store/decorators';
-
-import AccountConfirmationOption from './Account/Settings/ConfirmationOption.vue';
-import InfoLine from './InfoLine.vue';
-import NetworkFeeWarningMixin from './mixins/NetworkFeeWarningMixin';
-import NumberFormatterMixin from './mixins/NumberFormatterMixin';
-import TransactionMixin from './mixins/TransactionMixin';
-import NetworkFeeWarningDialog from './NetworkFeeWarning.vue';
-import WalletBase from './WalletBase.vue';
-import WalletFee from './WalletFee.vue';
-
-import type { Route } from '../store/router/types';
-
-@Component({
-  components: {
-    WalletBase,
-    InfoLine,
-    WalletFee,
-    NetworkFeeWarningDialog,
-    AccountConfirmationOption,
-  },
-})
-export default class CreateSimpleToken extends Mixins(TransactionMixin, NumberFormatterMixin, NetworkFeeWarningMixin) {
-  readonly XOR = XOR.symbol;
-  readonly Step = Step;
-  readonly decimals = FPNumber.DEFAULT_PRECISION;
-  readonly delimiters = FPNumber.DELIMITERS_CONFIG;
-  readonly maxTotalSupply = MaxTotalSupply;
-  readonly tokenSymbolMask = 'AAAAAAA';
-  readonly tokenNameMask = { mask: 'Z*', tokens: { Z: { pattern: /[0-9a-zA-Z ]/ } } };
-
-  @Prop({ default: Step.CreateSimpleToken, type: String }) readonly step!: Step;
-
-  @mutation.router.navigate private navigate!: (options: Route) => void;
-  @state.transactions.isConfirmTxDialogDisabled private isConfirmTxDisabled!: boolean;
-
-  tokenSymbol = '';
-  tokenName = '';
-  tokenSupply = '';
-  extensibleSupply = false;
-  showFee = true;
-
-  get fee(): FPNumber {
-    return this.getFPNumberFromCodec(this.networkFees.RegisterAsset);
-  }
-
-  get formattedFee(): string {
-    return this.fee.toLocaleString();
-  }
-
-  get isCreateDisabled(): boolean {
-    return !(this.tokenSymbol && this.tokenName.trim() && +this.tokenSupply);
-  }
-
-  get formattedTokenSupply(): string {
-    return this.formatStringValue(this.tokenSupply, this.decimals);
-  }
-
-  get hasEnoughXor(): boolean {
-    const accountXor = api.assets.accountAssets.find((asset) => asset.address === XOR.address);
-    if (!accountXor || !accountXor.balance || !+accountXor.balance.transferable) {
-      return false;
-    }
-    const fpAccountXor = this.getFPNumberFromCodec(accountXor.balance.transferable, accountXor.decimals);
-    return FPNumber.gte(fpAccountXor, this.fee);
-  }
-
-  async registerAsset(): Promise<void> {
-    return api.assets.register(this.tokenSymbol, this.tokenName.trim(), this.tokenSupply, this.extensibleSupply);
-  }
-
-  async onCreate(): Promise<void> {
-    if (!this.tokenSymbol.length || !this.tokenSupply.length || !this.tokenName.length) {
-      return;
-    }
-
-    this.tokenSupply = this.getCorrectSupply(this.tokenSupply, this.decimals);
-
-    this.$emit('showTabs');
-
-    if (this.allowFeePopup && this.hasEnoughXor && !this.isXorSufficientForNextTx({ type: Operation.RegisterAsset })) {
-      this.$emit('showHeader');
-      this.showFee = false;
-      this.$emit('stepChange', Step.Warn);
-      return;
-    }
-
-    if (this.isConfirmTxDisabled) {
-      await this.onConfirm();
-    } else {
-      this.showFee = true;
-      this.$emit('stepChange', Step.ConfirmSimpleToken);
-    }
-  }
-
-  async onConfirm(): Promise<void> {
-    await this.withNotifications(async () => {
-      if (!this.hasEnoughXor) {
-        throw new Error('insufficientBalanceText');
-      }
-      await this.registerAsset();
-      this.navigate({ name: RouteNames.Wallet });
-    });
-  }
-
-  confirmNextTxFailure(): void {
-    this.$emit('showHeader');
-    this.showFee = true;
-    this.$emit('stepChange', Step.ConfirmSimpleToken);
-  }
-}
-</script>
-
-<style scoped lang="scss">
-.wallet-settings-create-token {
-  &_desc {
-    color: var(--s-color-base-content-primary);
-    font-size: var(--s-font-size-extra-small);
-    font-weight: 300;
-    line-height: var(--s-line-height-base);
-    padding: var(--s-basic-spacing) #{$basic-spacing-small} #{$basic-spacing-medium};
-  }
-  &_supply-block {
-    @include switch-block;
-    & {
-      padding: 0 #{$basic-spacing-small};
-    }
-  }
-  &_action {
-    margin-top: #{$basic-spacing-medium};
-    width: 100%;
-  }
-  &_divider {
-    margin: unset;
-  }
-}
-</style>
diff --git a/src/components/CreateToken.vue b/src/components/CreateToken.vue
deleted file mode 100644
index f70bc41e0..000000000
--- a/src/components/CreateToken.vue
+++ /dev/null
@@ -1,110 +0,0 @@
-<template>
-  <wallet-base show-back :reset-focus="step" :title="createTokenTitle" :show-header="showHeader" @back="handleBack">
-    <div class="token">
-      <s-tabs v-if="showTabs" class="token__tab" type="rounded" :value="currentTab" @input="handleChangeTab">
-        <s-tab v-for="tab in TokenTabs" :key="tab" :label="getTabName(tab)" :name="tab" />
-      </s-tabs>
-      <component
-        :is="currentTab"
-        :step="currentStep"
-        @showTabs="setTabVisibility"
-        @showHeader="setHeaderVisibility"
-        @stepChange="setStep"
-      />
-    </div>
-  </wallet-base>
-</template>
-
-<script lang="ts">
-import { Component, Mixins } from 'vue-property-decorator';
-
-import { TokenTabs, Step, RouteNames } from '../consts';
-import { mutation } from '../store/decorators';
-
-import CreateNftToken from './CreateNftToken.vue';
-import CreateSimpleToken from './CreateSimpleToken.vue';
-import TranslationMixin from './mixins/TranslationMixin';
-import WalletBase from './WalletBase.vue';
-
-import type { Route } from '../store/router/types';
-
-@Component({
-  components: {
-    WalletBase,
-    CreateSimpleToken,
-    CreateNftToken,
-  },
-})
-export default class CreateToken extends Mixins(TranslationMixin) {
-  readonly TokenTabs = TokenTabs;
-
-  @mutation.router.navigate private navigate!: (options: Route) => void;
-
-  step = Step.CreateSimpleToken;
-  currentTab: Step = Step.CreateSimpleToken;
-  showTabs = true;
-  showHeader = true;
-  createTokenTitle = this.t('createToken.titleCommon');
-
-  get currentStep(): Step {
-    return this.step;
-  }
-
-  getTabName(tab: TokenTabs): string {
-    if (tab === TokenTabs.NonFungibleToken) {
-      return this.TranslationConsts.NFT;
-    }
-    return this.t(`createToken.${tab}`);
-  }
-
-  handleChangeTab(value: Step): void {
-    this.step = value;
-    this.currentTab = value;
-  }
-
-  setTabVisibility(): void {
-    this.showTabs = !this.showTabs;
-  }
-
-  setHeaderVisibility(): void {
-    this.showHeader = !this.showHeader;
-  }
-
-  setStep(step: Step): void {
-    if ([Step.CreateSimpleToken, Step.CreateNftToken].includes(step)) this.setTabVisibility();
-    if (step === Step.ConfirmSimpleToken) this.createTokenTitle = this.t('createToken.confirmTokenTitleCommon');
-    if (step === Step.ConfirmNftToken) this.createTokenTitle = this.t('createToken.confirmTokenTitleNFT');
-    this.step = step;
-  }
-
-  handleBack(): void {
-    if ([Step.CreateSimpleToken, Step.CreateNftToken].includes(this.step)) {
-      this.navigate({ name: RouteNames.Wallet });
-      return;
-    }
-
-    if ([Step.ConfirmSimpleToken, Step.ConfirmNftToken].includes(this.step)) {
-      if (this.step === Step.ConfirmSimpleToken) this.step = Step.CreateSimpleToken;
-      if (this.step === Step.ConfirmNftToken) this.step = Step.CreateNftToken;
-      this.createTokenTitle = this.t('createToken.titleCommon');
-    } else if (this.step === Step.Warn) {
-      if (this.currentTab === Step.CreateSimpleToken) this.step = Step.CreateSimpleToken;
-      if (this.currentTab === Step.CreateNftToken) this.step = Step.CreateNftToken;
-    }
-
-    this.showTabs = true;
-    this.showHeader = true;
-    this.navigate({ name: RouteNames.CreateToken });
-  }
-}
-</script>
-
-<style lang="scss">
-.token {
-  @include custom-tabs;
-
-  &__tab {
-    margin-bottom: #{$basic-spacing-medium};
-  }
-}
-</style>
diff --git a/src/components/ReceiveToken.vue b/src/components/ReceiveToken.vue
index e2cc6c6df..6f80ce930 100644
--- a/src/components/ReceiveToken.vue
+++ b/src/components/ReceiveToken.vue
@@ -34,9 +34,9 @@ import { state, getter, mutation } from '../store/decorators';
 import { svgSaveAs, IMAGE_EXTENSIONS } from '../util/image';
 
 import WalletAccount from './Account/WalletAccount.vue';
+import TokenLogo from './AssetLogos/TokenLogo.vue';
 import NotificationMixin from './mixins/NotificationMixin';
 import QrCode from './QrCode/QrCode.vue';
-import TokenLogo from './TokenLogo.vue';
 import WalletBase from './WalletBase.vue';
 
 import type { RouteNames } from '../consts';
diff --git a/src/components/Wallet.vue b/src/components/Wallet.vue
index a5f856004..0afb60709 100644
--- a/src/components/Wallet.vue
+++ b/src/components/Wallet.vue
@@ -4,14 +4,6 @@
       <s-button type="action" :tooltip="t('accountSettings.title')" @click="handleAccountSettings">
         <s-icon name="basic-settings-24" size="28" />
       </s-button>
-      <s-button
-        v-if="permissions.createAssets"
-        type="action"
-        :tooltip="t('createTokenText')"
-        @click="handleCreateToken"
-      >
-        <s-icon name="various-atom-24" size="28" />
-      </s-button>
     </template>
 
     <wallet-account v-if="!selectedTransaction">
@@ -149,10 +141,6 @@ export default class Wallet extends Mixins(AccountActionsMixin, OperationsMixin,
     this.$emit('swap', asset);
   }
 
-  handleCreateToken(): void {
-    this.navigate({ name: RouteNames.CreateToken });
-  }
-
   handleSwitchAccount(): void {
     this.navigate({ name: RouteNames.WalletConnection });
   }
diff --git a/src/components/WalletAssetDetails.vue b/src/components/WalletAssetDetails.vue
index 435826557..68dab6a20 100644
--- a/src/components/WalletAssetDetails.vue
+++ b/src/components/WalletAssetDetails.vue
@@ -1,271 +1,29 @@
 <template>
-  <wallet-base :title="headerTitle" show-back :reset-focus="hasResetFocus" @back="handleBack">
-    <template v-if="!selectedTransaction" #actions>
-      <s-button v-if="!isXor" type="action" :tooltip="t('asset.remove')" @click="handleRemoveAsset">
-        <s-icon name="basic-eye-24" size="28" />
-      </s-button>
-    </template>
-    <template v-if="!selectedTransaction">
-      <s-card class="asset-details" primary>
-        <div class="asset-details-container s-flex">
-          <nft-details
-            v-if="isNft"
-            is-asset-details
-            :content-link="nftContentLink"
-            :token-name="asset.name"
-            :token-symbol="asset.symbol"
-            :token-description="asset.description"
-            @click-details="handleClickNftDetails"
-          />
-          <template v-else>
-            <token-logo :token="asset" size="bigger" />
-            <div
-              v-button
-              :style="balanceStyles"
-              :class="balanceDetailsClasses"
-              :tabindex="0"
-              @click="handleClickDetailedBalance()"
-            >
-              <formatted-amount
-                value-can-be-hidden
-                symbol-as-decimal
-                :value="balance"
-                :font-size-rate="FontSizeRate.SMALL"
-                :asset-symbol="asset.symbol"
-              >
-                <s-icon name="chevron-down-rounded-16" size="18" />
-              </formatted-amount>
-            </div>
-          </template>
-          <formatted-amount
-            v-if="price && !isNft"
-            value-can-be-hidden
-            is-fiat-value
-            :value="getFiatBalance(asset)"
-            :font-size-rate="FontSizeRate.MEDIUM"
-          />
-          <div class="asset-details-actions">
-            <s-button
-              v-for="operation in operations"
-              :key="operation.type"
-              :class="['asset-details-action', operation.type]"
-              :tooltip="getOperationTooltip(operation)"
-              :disabled="isOperationDisabled(operation.type)"
-              type="action"
-              size="medium"
-              rounded
-              primary
-              @click="handleOperation(operation.type)"
-            >
-              <s-icon :name="operation.icon" size="24" />
-            </s-button>
-
-            <qr-code-scan-button primary size="medium" @change="parseQrCodeValue" />
-
-            <s-button type="action" primary rounded :tooltip="t('code.receive')" @click="receiveByQrCode(asset)">
-              <s-icon name="finance-receive-show-QR-24" size="24" />
-            </s-button>
-          </div>
-          <transition name="fadeHeight">
-            <div v-if="wasBalanceDetailsClicked" class="asset-details-balance-info">
-              <template v-for="(balanceGroup, index) in balanceTypes">
-                <div
-                  v-for="balanceType in Array.isArray(balanceGroup) ? balanceGroup : [balanceGroup]"
-                  :key="balanceType"
-                  class="balance s-flex p4"
-                >
-                  <div :class="['balance-label', { 'balance-label--total': index === balanceTypes.length - 1 }]">
-                    <template v-if="Array.isArray(balanceGroup)"> - </template>
-                    {{ t(`assets.balance.${balanceType}`) }}
-                  </div>
-                  <formatted-amount-with-fiat-value
-                    value-can-be-hidden
-                    value-class="balance-value"
-                    :value="formatBalance(asset.balance[balanceType])"
-                    :font-size-rate="FontSizeRate.MEDIUM"
-                    :font-weight-rate="FontWeightRate.SMALL"
-                    :asset-symbol="asset.symbol"
-                    :fiat-value="getFiatBalance(asset, balanceType)"
-                    fiat-format-as-value
-                    with-left-shift
-                  />
-                </div>
-              </template>
-            </div>
-          </transition>
-        </div>
-      </s-card>
-      <div v-if="isNft" class="asset-details-nft-container">
-        <transition name="fadeHeight">
-          <div v-if="wasNftDetailsClicked" class="info-line-container">
-            <info-line :label="t('createToken.nft.supply.quantity')" :value="balance" />
-            <info-line
-              v-button
-              class="external-link"
-              :label="t('createToken.nft.source.label')"
-              :value="displayedNftContentLink"
-              :value-tooltip="nftLinkTooltipText"
-              @click.native.stop="handleCopyNftLink"
-            />
-          </div>
-        </transition>
-      </div>
-    </template>
-    <wallet-transaction-details v-else />
-    <wallet-history v-show="!selectedTransaction" :asset="asset" />
-  </wallet-base>
+  <asset-details-sbt v-if="isSoulboundAsset" :asset="asset" />
+  <asset-details-transferable v-else :asset="asset" />
 </template>
 
 <script lang="ts">
-import { XOR, BalanceType } from '@sora-substrate/sdk/build/assets/consts';
+import { AccountAsset, AssetTypes } from '@sora-substrate/sdk/build/assets/types';
 import { Component, Mixins } from 'vue-property-decorator';
 
-import { api } from '../api';
-import { RouteNames } from '../consts';
-import { state, getter, mutation } from '../store/decorators';
-import { Operations } from '../types/common';
-import { copyToClipboard, delay, shortenValue } from '../util';
-import { IpfsStorage } from '../util/ipfsStorage';
-
-import FormattedAmount from './FormattedAmount.vue';
-import FormattedAmountWithFiatValue from './FormattedAmountWithFiatValue.vue';
-import InfoLine from './InfoLine.vue';
-import CopyAddressMixin from './mixins/CopyAddressMixin';
-import FormattedAmountMixin from './mixins/FormattedAmountMixin';
-import OperationsMixin from './mixins/OperationsMixin';
-import QrCodeParserMixin from './mixins/QrCodeParserMixin';
-import NftDetails from './NftDetails.vue';
-import QrCodeScanButton from './QrCode/QrCodeScanButton.vue';
-import TokenLogo from './TokenLogo.vue';
-import WalletBase from './WalletBase.vue';
-import WalletHistory from './WalletHistory.vue';
-import WalletTransactionDetails from './WalletTransactionDetails.vue';
+import { state } from '@/store/decorators';
 
-import type { WalletPermissions } from '../consts';
-import type { CodecString, AccountHistory, HistoryItem } from '@sora-substrate/sdk';
-import type { AccountAsset } from '@sora-substrate/sdk/build/assets/types';
-
-interface Operation {
-  type: Operations;
-  icon: string;
-}
+import AssetDetailsSbt from './AssetDetails/AssetDetailsSBT.vue';
+import AssetDetailsTransferable from './AssetDetails/AssetDetailsTransferable.vue';
 
 @Component({
   components: {
-    WalletBase,
-    FormattedAmount,
-    FormattedAmountWithFiatValue,
-    WalletHistory,
-    WalletTransactionDetails,
-    QrCodeScanButton,
-    NftDetails,
-    InfoLine,
-    TokenLogo,
+    AssetDetailsTransferable,
+    AssetDetailsSbt,
   },
 })
-export default class WalletAssetDetails extends Mixins(
-  OperationsMixin,
-  FormattedAmountMixin,
-  CopyAddressMixin,
-  QrCodeParserMixin
-) {
-  readonly balanceTypes = [
-    BalanceType.Transferable,
-    BalanceType.Locked,
-    [BalanceType.Frozen, BalanceType.Reserved, BalanceType.Bonded],
-    BalanceType.Total,
-  ];
-
+export default class WalletAssetDetails extends Mixins() {
   @state.router.currentRouteParams private currentRouteParams!: Record<string, AccountAsset>;
-  @state.settings.permissions private permissions!: WalletPermissions;
   @state.account.accountAssets private accountAssets!: Array<AccountAsset>;
-  @state.transactions.history private history!: AccountHistory<HistoryItem>;
-  @getter.transactions.selectedTx selectedTransaction!: Nullable<HistoryItem>;
-  @mutation.transactions.resetTxDetailsId private resetTxDetailsId!: FnWithoutArgs;
-
-  wasBalanceDetailsClicked = false;
-
-  // ____________________NFT Token Details_____________________________
-  private wasNftLinkCopied = false;
-  wasNftDetailsClicked = false;
-  nftContentLink = '';
-
-  get hasResetFocus(): string {
-    return this.selectedTransaction && this.selectedTransaction.id
-      ? this.selectedTransaction.id.toString()
-      : this.wasBalanceDetailsClicked.toString();
-  }
-
-  get isNft(): boolean {
-    return api.assets.isNft(this.asset);
-  }
-
-  get headerTitle(): string {
-    if (!this.selectedTransaction) return this.asset.name;
-
-    return this.getTitle(this.selectedTransaction);
-  }
-
-  get nftLinkTooltipText(): string {
-    // TODO: Remove assets.copy, assets.copied
-    return this.wasNftLinkCopied ? this.t('copiedText') : this.t('createToken.nft.link.copyLink');
-  }
-
-  get displayedNftContentLink(): string {
-    const hostname = IpfsStorage.getStorageHostname(this.nftContentLink);
-    const path = IpfsStorage.getIpfsPath(this.nftContentLink);
-    return shortenValue(hostname + '/ipfs/' + path, 25);
-  }
 
-  private async setNftMeta(): Promise<void> {
-    const ipfsPath = this.asset.content as string;
-    this.nftContentLink = IpfsStorage.constructFullIpfsUrl(ipfsPath);
-  }
-
-  handleClickNftDetails(): void {
-    this.wasNftDetailsClicked = !this.wasNftDetailsClicked;
-  }
-
-  async handleCopyNftLink(): Promise<void> {
-    await copyToClipboard(this.nftContentLink);
-    this.wasNftLinkCopied = true;
-    await delay(1000);
-    this.wasNftLinkCopied = false;
-  }
-
-  mounted(): void {
-    if (this.isNft) {
-      this.setNftMeta();
-    }
-  }
-  // __________________________________________________________
-
-  formatBalance(value: CodecString): string {
-    return this.formatCodecNumber(value, this.asset.decimals);
-  }
-
-  get operations(): Array<Operation> {
-    const list: Array<Operation> = [];
-    const divisible = !!this.asset.decimals;
-
-    if (this.permissions.sendAssets) {
-      list.push({ type: Operations.Send, icon: 'finance-send-24' });
-    }
-    if (this.permissions.swapAssets && divisible) {
-      list.push({ type: Operations.Swap, icon: 'arrows-swap-24' });
-    }
-    if (this.permissions.addLiquidity && divisible) {
-      list.push({ type: Operations.Liquidity, icon: 'basic-drop-24' });
-    }
-    if (this.permissions.bridgeAssets && divisible) {
-      list.push({ type: Operations.Bridge, icon: 'grid-block-distribute-vertically-24' });
-    }
-
-    return list;
-  }
-
-  get price(): Nullable<CodecString> {
-    return this.getAssetFiatPrice(this.asset);
+  get isSoulboundAsset(): boolean {
+    return this.asset.type === AssetTypes.Soulbound;
   }
 
   get asset(): AccountAsset {
@@ -275,190 +33,5 @@ export default class WalletAssetDetails extends Mixins(
       this.currentRouteParams.asset
     );
   }
-
-  get balance(): string {
-    return this.formatCodecNumber(this.asset.balance.transferable, this.asset.decimals);
-  }
-
-  get totalBalance(): string {
-    return this.formatBalance(this.asset.balance.total);
-  }
-
-  get isEmptyBalance(): boolean {
-    return this.isCodecZero(this.asset.balance.transferable, this.asset.decimals);
-  }
-
-  get balanceStyles() {
-    const balanceLength = this.balance.length;
-    // We've decided to calcutate font size values manually
-    let fontSize = 30;
-    if (balanceLength > 35) {
-      fontSize = 14;
-    } else if (balanceLength > 24 && balanceLength <= 35) {
-      fontSize = 16;
-    } else if (balanceLength > 17 && balanceLength <= 24) {
-      fontSize = 20;
-    }
-    return { fontSize: `${fontSize}px` };
-  }
-
-  get balanceDetailsClasses(): Array<string> {
-    const cssClasses: Array<string> = ['asset-details-balance', 'd2'];
-    if (this.isXor) {
-      cssClasses.push('asset-details-balance--clickable');
-    }
-    if (this.wasBalanceDetailsClicked) {
-      cssClasses.push('asset-details-balance--clicked');
-    }
-    return cssClasses;
-  }
-
-  get isXor(): boolean {
-    return this.asset.address === XOR.address;
-  }
-
-  get isCleanHistoryDisabled(): boolean {
-    if (!this.asset) return true;
-
-    return Object.values(this.history).every(
-      (item) => ![item.assetAddress, item.asset2Address].includes(this.asset.address)
-    );
-  }
-
-  handleBack(): void {
-    if (this.selectedTransaction) {
-      this.resetTxDetailsId();
-    } else {
-      this.navigate({ name: RouteNames.Wallet });
-    }
-  }
-
-  getOperationTooltip(operation: Operation): string {
-    return this.t(`assets.${operation.type}`);
-  }
-
-  isOperationDisabled(operation: Operations): boolean {
-    return operation === Operations.Send && this.isEmptyBalance;
-  }
-
-  handleOperation(operation: Operations): void {
-    switch (operation) {
-      case Operations.Send:
-        this.navigate({ name: RouteNames.WalletSend, params: { asset: this.asset } });
-        break;
-      default:
-        this.$emit(operation, this.asset);
-        break;
-    }
-  }
-
-  handleClickDetailedBalance(): void {
-    this.wasBalanceDetailsClicked = !this.wasBalanceDetailsClicked;
-  }
-
-  getBalance(asset: AccountAsset, type: BalanceType): string {
-    return `${this.formatCodecNumber(asset.balance[type], asset.decimals)}`;
-  }
-
-  handleRemoveAsset(): void {
-    api.assets.removeAccountAsset(this.asset.address);
-    this.handleBack();
-  }
 }
 </script>
-
-<style scoped lang="scss">
-.asset-details {
-  padding: 0 !important;
-  margin-bottom: 0;
-  border-radius: 0;
-  &.s-card.neumorphic {
-    padding-top: 0;
-    padding-bottom: 0;
-  }
-  &-container {
-    flex-direction: column;
-    align-items: center;
-    @include fadeHeight;
-    .formatted-amount--fiat-value {
-      + .asset-details-actions {
-        margin-top: #{$basic-spacing-small};
-        margin-bottom: #{$basic-spacing-medium};
-      }
-    }
-  }
-  &-nft-container {
-    @include fadeHeight(50px, 0.1s);
-  }
-  &-balance {
-    width: 100%;
-    margin-top: var(--s-basic-spacing);
-    position: relative;
-    text-align: center;
-    &--clickable {
-      cursor: pointer;
-      @include focus-outline($withOffset: true);
-    }
-    & + .formatted-amount--fiat-value {
-      width: 100%;
-      text-align: center;
-      font-size: var(--s-font-size-medium);
-      font-weight: 600;
-    }
-    .s-icon-chevron-down-rounded-16 {
-      display: inline-block;
-      margin-left: var(--s-basic-spacing);
-      height: var(--s-icon-font-size-small);
-      width: var(--s-icon-font-size-small);
-      transition: transform 0.3s;
-      background-color: var(--s-color-base-content-secondary);
-      color: var(--s-color-base-on-accent);
-      border-radius: 50%;
-      text-align: left;
-    }
-    &--clicked .s-icon-chevron-down-rounded-16 {
-      padding-right: #{$basic-spacing-small};
-      transform: rotate(180deg);
-    }
-    &-info {
-      width: 100%;
-      margin-top: #{$basic-spacing-medium};
-      .balance {
-        justify-content: space-between;
-        align-items: baseline;
-        margin-bottom: $basic-spacing-mini;
-        border-bottom: 1px solid var(--s-color-base-border-secondary);
-        font-size: var(--s-font-size-extra-small);
-        &-label {
-          text-transform: uppercase;
-          margin-right: var(--s-basic-spacing);
-          font-weight: 300;
-          white-space: nowrap;
-          &--total {
-            font-weight: 600;
-          }
-        }
-      }
-    }
-  }
-  &-actions {
-    margin-top: #{$basic-spacing-medium};
-
-    & > *:not(:first-child) {
-      margin-left: $basic-spacing;
-    }
-  }
-}
-
-.info-line-container {
-  @include fadeHeight;
-}
-</style>
-
-<style lang="scss">
-.external-link {
-  .info-line-value {
-    cursor: pointer;
-  }
-}
-</style>
diff --git a/src/components/WalletAssets.vue b/src/components/WalletAssets.vue
index 2febd75e2..c71285a11 100644
--- a/src/components/WalletAssets.vue
+++ b/src/components/WalletAssets.vue
@@ -15,6 +15,7 @@
           >
             <template #value="asset">
               <formatted-amount-with-fiat-value
+                v-if="!isSoulbound(asset)"
                 value-can-be-hidden
                 value-class="asset-value"
                 :value="getBalance(asset)"
@@ -30,10 +31,21 @@
                   <span>{{ formatFrozenBalance(asset) }}</span>
                 </div>
               </formatted-amount-with-fiat-value>
+              <div v-else class="asset-sbt-meta">
+                <div class="title">
+                  {{ TranslationConsts.KYC }} <span class="counter">{{ `#${index}` }}</span>
+                  <s-icon name="el-icon-success" size="16" />
+                </div>
+                <div class="permissions">
+                  <span class="counter">{{ sbtPermissions[asset.address] }}</span>
+                  {{ getTranslation(sbtPermissions[asset.address]) }}
+                </div>
+                <span v-if="isSoulbound(asset)" class="asset-sbt-expiration">{{ sbtExpDates[asset.address] }}</span>
+              </div>
             </template>
             <template #default="asset">
               <s-button
-                v-if="permissions.sendAssets && !isZeroBalance(asset)"
+                v-if="permissions.sendAssets && !isZeroBalance(asset) && !isSoulbound(asset)"
                 class="wallet-assets__button send"
                 type="action"
                 size="small"
@@ -44,7 +56,7 @@
                 <s-icon name="finance-send-24" size="24" />
               </s-button>
               <s-button
-                v-if="permissions.swapAssets && asset.decimals"
+                v-if="permissions.swapAssets && asset.decimals && !isSoulbound(asset)"
                 class="wallet-assets__button swap"
                 type="action"
                 size="small"
@@ -85,8 +97,9 @@
 
 <script lang="ts">
 import { api, FPNumber } from '@sora-substrate/sdk';
+import { AssetTypes } from '@sora-substrate/sdk/build/assets/types';
 import isEmpty from 'lodash/fp/isEmpty';
-import { Component, Mixins } from 'vue-property-decorator';
+import { Component, Mixins, Watch } from 'vue-property-decorator';
 import draggable from 'vuedraggable';
 
 import { RouteNames, HiddenValue, WalletFilteringOptions } from '../consts';
@@ -116,6 +129,7 @@ import type { MoveEvent } from 'vuedraggable';
 })
 export default class WalletAssets extends Mixins(LoadingMixin, FormattedAmountMixin, TranslationMixin) {
   @state.account.accountAssets private accountAssets!: Array<AccountAsset>;
+  @state.account.address private connected!: string;
   @state.settings.shouldBalanceBeHidden private shouldBalanceBeHidden!: boolean;
   @state.settings.permissions permissions!: WalletPermissions;
   @state.settings.filters private filters!: WalletAssetFilters;
@@ -129,6 +143,15 @@ export default class WalletAssets extends Mixins(LoadingMixin, FormattedAmountMi
   @mutation.account.removePinnedAsset private removePinnedAsset!: (pinnedAccountAssets: AccountAsset) => void;
   @mutation.account.setMultiplePinnedAssets private setMultiplePinnedAssets!: (pinnedAssetsAddresses: string[]) => void;
 
+  @Watch('assetList')
+  private async recalcInfo(): Promise<void> {
+    await this.checkSbtPermissions();
+    await this.checkSbtExpirationDates();
+  }
+
+  sbtPermissions = {};
+  sbtExpDates = {};
+
   get assetList(): Array<AccountAsset> {
     return this.accountAssets.sort((a, b) => {
       const aPinned = Number(this.isAssetPinned(a));
@@ -194,6 +217,14 @@ export default class WalletAssets extends Mixins(LoadingMixin, FormattedAmountMi
     return fiatAmount ? fiatAmount.toLocaleString() : null;
   }
 
+  isSoulbound(asset: AccountAsset): boolean {
+    return asset.type === AssetTypes.Soulbound;
+  }
+
+  getTranslation(number: number): string {
+    return number === 1 ? this.t('sbtDetails.permission') : this.t('sbtDetails.permissions');
+  }
+
   onMove(event: MoveEvent<AccountAsset>): boolean {
     const draggedItem = event.draggedContext.element;
     const targetItem = event.relatedContext.element;
@@ -214,6 +245,41 @@ export default class WalletAssets extends Mixins(LoadingMixin, FormattedAmountMi
     return `${this.formatCodecNumber(asset.balance.transferable, asset.decimals)}`;
   }
 
+  async checkSbtPermissions(): Promise<void> {
+    if (!this.accountAssets.length) return;
+
+    const sbts = this.accountAssets.filter((asset) => asset.type === AssetTypes.Soulbound);
+
+    const sbtsInfo = sbts.map(async (asset) => {
+      const { regulatedAssets } = await api.extendedAssets.getSbtMetaInfo(asset.address);
+
+      return {
+        [asset.address]: regulatedAssets.length,
+      };
+    });
+
+    for await (const sbt of sbtsInfo) {
+      this.sbtPermissions = { ...this.sbtPermissions, ...sbt };
+    }
+  }
+
+  async checkSbtExpirationDates(): Promise<void> {
+    const sbts = this.accountAssets.filter((asset) => asset.type === AssetTypes.Soulbound);
+
+    sbts.map(async (asset) => {
+      const sbtExpiryDate = await api.extendedAssets.getSbtExpiration(this.connected, asset.address);
+      let expDate = '';
+
+      if (Number(sbtExpiryDate) === Infinity) {
+        expDate = this.t('sbtDetails.indefiniteExp');
+      } else {
+        expDate = this.formatDate(Number(sbtExpiryDate), 'll');
+      }
+
+      this.sbtExpDates = { ...this.sbtExpDates, [asset.address]: expDate };
+    });
+  }
+
   isZeroBalance(asset: AccountAsset): boolean {
     return this.isCodecZero(asset.balance.transferable, asset.decimals);
   }
@@ -238,7 +304,7 @@ export default class WalletAssets extends Mixins(LoadingMixin, FormattedAmountMi
   }
 
   handleOpenAssetDetails(asset: AccountAsset): void {
-    this.navigate({ name: RouteNames.WalletAssetDetails, params: { asset } });
+    this.navigate({ name: RouteNames.WalletAssetDetails, params: { asset, fromWalletAssets: true } });
   }
 
   handleOpenAddAsset(): void {
@@ -262,13 +328,22 @@ export default class WalletAssets extends Mixins(LoadingMixin, FormattedAmountMi
     const hideZeroBalance = this.filters.zeroBalance;
 
     // asset
-    const isNft = api.assets.isNft(asset);
+    const isNft = asset.type === AssetTypes.NFT;
+    const isSbt = asset.type === AssetTypes.Soulbound;
     const isWhitelisted = api.assets.isWhitelist(asset, this.whitelist);
     const hasZeroBalance = !asset.decimals
       ? asset.balance.total === '0' // for non-divisible tokens
       : asset.balance.total[8] === undefined; // for 0.00000009 and less
 
-    if (tokenType === WalletFilteringOptions.Currencies && isNft) {
+    if (tokenType === WalletFilteringOptions.SBT && !isSbt) {
+      return false;
+    }
+
+    if (tokenType === WalletFilteringOptions.Currencies && isNft && isSbt) {
+      return false;
+    }
+
+    if (tokenType === WalletFilteringOptions.NFT && isSbt) {
       return false;
     }
 
@@ -286,6 +361,11 @@ export default class WalletAssets extends Mixins(LoadingMixin, FormattedAmountMi
 
     return true;
   }
+
+  async mounted(): Promise<void> {
+    await this.checkSbtPermissions();
+    await this.checkSbtExpirationDates();
+  }
 }
 </script>
 
@@ -395,6 +475,34 @@ $padding: 5px;
       color: var(--s-color-base-content-primary);
       line-height: var(--s-line-height-reset);
     }
+
+    &-sbt-meta {
+      .title {
+        font-weight: 600;
+
+        .counter {
+          font-size: var(--s-font-size-mini);
+          font-weight: 450;
+        }
+      }
+
+      .permissions {
+        color: var(--s-color-fiat-value);
+        font-size: 11.5px;
+        margin-top: -7px;
+        margin-bottom: -4px;
+
+        .counter {
+          font-size: var(--s-font-size-extra-small);
+          font-weight: 600;
+        }
+      }
+
+      .el-icon-success {
+        color: var(--s-color-fiat-value);
+        margin-left: 4px;
+      }
+    }
   }
 
   &__button.el-button.neumorphic.s-action:not(.s-primary).s-alternative {
diff --git a/src/components/WalletAssetsHeadline.vue b/src/components/WalletAssetsHeadline.vue
index e35dddd76..fbcab7fd0 100644
--- a/src/components/WalletAssetsHeadline.vue
+++ b/src/components/WalletAssetsHeadline.vue
@@ -36,7 +36,7 @@
 import { Component, Mixins, Prop } from 'vue-property-decorator';
 
 import { WalletFilteringOptions } from '../consts';
-import { mutation, state } from '../store/decorators';
+import { state, getter, mutation } from '../store/decorators';
 
 import FormattedAmount from './FormattedAmount.vue';
 import LoadingMixin from './mixins/LoadingMixin';
@@ -59,7 +59,9 @@ export default class WalletAssetsHeadline extends Mixins(TranslationMixin, Loadi
   @Prop({ default: '0', type: String }) readonly assetsFiatAmount!: string;
 
   @state.settings.filters filters!: WalletAssetFilters;
-  @mutation.settings.setFilterOptions private setFilterOptions!: (filter: WalletAssetFilters) => void;
+  @getter.account.hasSomeSbt hasSomeSbt!: boolean;
+  @mutation.settings.setFilterOptions
+  private setFilterOptions!: (filter: WalletAssetFilters) => void;
 
   zeroBalanceSwitch = false;
 
@@ -114,12 +116,16 @@ export default class WalletAssetsHeadline extends Mixins(TranslationMixin, Loadi
   }
 
   get filterOptionsText(): Array<string> {
-    return [this.t('filter.all'), this.t('filter.token'), this.TranslationConsts.NFT];
+    const basicOptions = [this.t('filter.all'), this.t('filter.token'), this.TranslationConsts.NFT];
+
+    if (this.hasSomeSbt) basicOptions.push(this.TranslationConsts.SBT);
+
+    return basicOptions;
   }
 
   get verifiedOnlySwitchDisabled(): boolean {
-    // disable verified only switch as there are no whitelisted NFTs.
-    return this.filters.option === WalletFilteringOptions.NFT;
+    // disable verified only switch as there are no whitelisted NFTs or SBTs.
+    return [WalletFilteringOptions.NFT, WalletFilteringOptions.SBT].includes(this.filters.option);
   }
 
   get chosenOptionText(): string {
@@ -131,6 +137,9 @@ export default class WalletAssetsHeadline extends Mixins(TranslationMixin, Loadi
       case WalletFilteringOptions.NFT:
         text = this.TranslationConsts.NFT;
         break;
+      case WalletFilteringOptions.SBT:
+        text = this.TranslationConsts.SBT;
+        break;
     }
     return text.toUpperCase();
   }
diff --git a/src/components/WalletSend.vue b/src/components/WalletSend.vue
index 3e9dff4b7..7004ef36f 100644
--- a/src/components/WalletSend.vue
+++ b/src/components/WalletSend.vue
@@ -20,6 +20,9 @@
           </s-tooltip>
         </template>
         <p v-if="isAccountAddress" class="wallet-send-address-error">{{ t('walletSend.addressError') }}</p>
+        <p v-if="showIsNotSbtOwnerReceiver" class="wallet-send-address-error">
+          {{ t('sbtDetails.noReceiverAccess') }}
+        </p>
 
         <s-float-input
           v-model="amount"
@@ -154,9 +157,17 @@
 
 <script lang="ts">
 import { FPNumber, Operation } from '@sora-substrate/sdk';
+import { getAssetBalance } from '@sora-substrate/sdk/build/assets';
 import { XOR } from '@sora-substrate/sdk/build/assets/consts';
+import {
+  AssetTypes,
+  type Asset,
+  type AccountAsset,
+  type AccountBalance,
+  type UnlockPeriodDays,
+} from '@sora-substrate/sdk/build/assets/types';
 import debounce from 'lodash/fp/debounce';
-import { Component, Mixins } from 'vue-property-decorator';
+import { Component, Mixins, Watch } from 'vue-property-decorator';
 
 import { api } from '../api';
 import { RouteNames } from '../consts';
@@ -165,6 +176,7 @@ import { validateAddress, formatAddress, formatAccountAddress } from '../util';
 
 import AccountConfirmationOption from './Account/Settings/ConfirmationOption.vue';
 import AddressBookInput from './AddressBook/Input.vue';
+import TokenLogo from './AssetLogos/TokenLogo.vue';
 import FormattedAmount from './FormattedAmount.vue';
 import FormattedAmountWithFiatValue from './FormattedAmountWithFiatValue.vue';
 import InfoLine from './InfoLine.vue';
@@ -173,14 +185,12 @@ import FormattedAmountMixin from './mixins/FormattedAmountMixin';
 import NetworkFeeWarningMixin from './mixins/NetworkFeeWarningMixin';
 import TransactionMixin from './mixins/TransactionMixin';
 import NetworkFeeWarning from './NetworkFeeWarning.vue';
-import TokenLogo from './TokenLogo.vue';
 import WalletBase from './WalletBase.vue';
 import WalletFee from './WalletFee.vue';
 
 import type { VestedTransferFeeParams, VestedTransferParams } from '../store/account/types';
 import type { Route } from '../store/router/types';
 import type { CodecString } from '@sora-substrate/sdk';
-import type { AccountAsset, AccountBalance, UnlockPeriodDays } from '@sora-substrate/sdk/build/assets/types';
 import type { Subscription } from 'rxjs';
 
 @Component({
@@ -218,8 +228,9 @@ export default class WalletSend extends Mixins(
 
   @state.router.previousRoute private previousRoute!: RouteNames;
   @state.router.previousRouteParams private previousRouteParams!: Record<string, unknown>;
-  @state.router.currentRouteParams private currentRouteParams!: Record<string, AccountAsset | string>;
+  @state.router.currentRouteParams private currentRouteParams!: Record<string, Nullable<AccountAsset> | string>;
   @state.account.accountAssets private accountAssets!: Array<AccountAsset>;
+  @state.account.assets assets!: Array<Asset>;
   @state.transactions.isConfirmTxDialogDisabled private isConfirmTxDisabled!: boolean;
 
   @mutation.router.navigate private navigate!: (options: Route) => void;
@@ -234,6 +245,8 @@ export default class WalletSend extends Mixins(
   address = '';
   amount = '';
   showAdditionalInfo = true;
+  showIsNotSbtOwnerReceiver = false;
+  prevAsset: Nullable<AccountAsset> = null; /* remember previous asset for routing */
   withVesting = false;
   selectedVestingPeriod: UnlockPeriodDays = 1;
   vestingPercentage = '10';
@@ -241,6 +254,29 @@ export default class WalletSend extends Mixins(
   private assetBalance: Nullable<AccountBalance> = null;
   private assetBalanceSubscription: Nullable<Subscription> = null;
 
+  @Watch('address')
+  async getIsNotSbtOwnerReceiver(): Promise<void> {
+    if (this.validAddress && this.asset.address) {
+      const regulatedAsset = this.assets.find(
+        (asset) => asset.address === this.asset.address && asset.type === AssetTypes.Regulated
+      );
+
+      if (regulatedAsset) {
+        const sbtAddress = await api.extendedAssets.getSbtAddress(regulatedAsset.address);
+
+        const balance = await getAssetBalance(api.api, this.address, sbtAddress);
+
+        if (this.getFPNumberFromCodec(balance.total).lte(FPNumber.ZERO)) {
+          this.showIsNotSbtOwnerReceiver = true;
+        } else {
+          this.showIsNotSbtOwnerReceiver = false;
+        }
+      }
+    } else {
+      this.showIsNotSbtOwnerReceiver = false;
+    }
+  }
+
   created(): void {
     if (!this.currentRouteParams.asset) {
       this.handleBack();
@@ -372,6 +408,8 @@ export default class WalletSend extends Mixins(
       !this.validAddress ||
       !this.validAmount ||
       !this.hasEnoughXor ||
+      this.isAccountAddress ||
+      this.showIsNotSbtOwnerReceiver ||
       (this.withVesting && !+this.vestingPercentage)
     );
   }
@@ -436,7 +474,11 @@ export default class WalletSend extends Mixins(
     }
     this.navigate({
       name: this.previousRoute,
-      params: this.previousRouteParams,
+      params: {
+        ...this.previousRouteParams,
+        fromWalletAssets: this.currentRouteParams.fromWalletAssets,
+        fromSbtDetails: this.currentRouteParams.fromSbtDetails,
+      },
     });
   }
 
diff --git a/src/components/mixins/OperationsMixin.ts b/src/components/mixins/OperationsMixin.ts
index 0d7c33983..4e93641ef 100644
--- a/src/components/mixins/OperationsMixin.ts
+++ b/src/components/mixins/OperationsMixin.ts
@@ -26,6 +26,7 @@ const amountBasedOperations = [
   Operation.Burn,
   Operation.Mint,
   Operation.Transfer,
+  Operation.XorlessTransfer,
   Operation.VestedTransfer,
   Operation.SwapTransferBatch,
   Operation.DemeterFarmingGetRewards,
@@ -106,6 +107,9 @@ export default class OperationsMixin extends Mixins(NotificationMixin, NumberFor
     } else if (status !== TransactionStatus.Error) {
       status = TransactionStatus.Finalized;
     }
+    if (value.type === Operation.SetAccessExpiration) {
+      params.endTime = new Date(params?.endTime).toLocaleDateString();
+    }
     if (hideAmountValues) {
       params.amount = HiddenValue;
       params.amount2 = HiddenValue;
diff --git a/src/components/mixins/TransactionMixin.ts b/src/components/mixins/TransactionMixin.ts
index f6e5b911a..e62dbc3bb 100644
--- a/src/components/mixins/TransactionMixin.ts
+++ b/src/components/mixins/TransactionMixin.ts
@@ -55,7 +55,12 @@ export default class TransactionMixin extends Mixins(LoadingMixin, OperationsMix
         this.showAppNotification(message, 'success');
       }
       if (value.status === TransactionStatus.InBlock) return;
-    } else if (value.type === Operation.RegisterAsset && value.assetAddress) {
+    } else if (
+      [Operation.RegisterAsset, Operation.RegisterAndRegulateAsset, Operation.IssueSoulBoundToken].includes(
+        value.type
+      ) &&
+      value.assetAddress
+    ) {
       // If user was really fast and already added tx
       const alreadyExists = this.accountAssetsAddressTable[value.assetAddress];
       if (!alreadyExists) {
diff --git a/src/components/mixins/TranslationMixin.ts b/src/components/mixins/TranslationMixin.ts
index 7a6576268..c2228540b 100644
--- a/src/components/mixins/TranslationMixin.ts
+++ b/src/components/mixins/TranslationMixin.ts
@@ -1,11 +1,13 @@
 import dayjs from 'dayjs';
 import localizedFormat from 'dayjs/plugin/localizedFormat';
+import relativeTime from 'dayjs/plugin/relativeTime';
 import { Vue, Component } from 'vue-property-decorator';
 
 import { TranslationConsts } from '../../consts';
 
 // enable dayjs plugin
 dayjs.extend(localizedFormat);
+dayjs.extend(relativeTime);
 
 @Component
 export default class TranslationMixin extends Vue {
@@ -39,6 +41,23 @@ export default class TranslationMixin extends Vue {
     }
   }
 
+  getRelativeTime(date: number): string {
+    let startTime, endTime;
+    const currentTime = Date.now();
+
+    if (date < currentTime) {
+      startTime = date;
+      endTime = currentTime;
+    } else {
+      startTime = currentTime;
+      endTime = date;
+    }
+
+    return startTime < endTime
+      ? dayjs().to(dayjs(date).locale(this.dayjsLocale))
+      : dayjs().from(dayjs(date).locale(this.dayjsLocale));
+  }
+
   formatDate(date: Nullable<number>, format = 'll LTS'): string {
     return dayjs(date).locale(this.dayjsLocale).format(format);
   }
diff --git a/src/consts/index.ts b/src/consts/index.ts
index 966ffd0c2..6a7733816 100644
--- a/src/consts/index.ts
+++ b/src/consts/index.ts
@@ -6,6 +6,7 @@ import type { FPNumber } from '@sora-substrate/sdk';
 export const accountIdBasedOperations = [
   Operation.SwapAndSend,
   Operation.Transfer,
+  Operation.XorlessTransfer,
   Operation.VestedTransfer,
   Operation.SwapTransferBatch,
   Operation.Mint,
@@ -59,7 +60,6 @@ export enum RouteNames {
   WalletSend = 'WalletSend',
   Wallet = 'Wallet',
   WalletAssetDetails = 'WalletAssetDetails',
-  CreateToken = 'CreateToken',
   ReceiveToken = 'ReceiveToken',
   AddAsset = 'AddAsset',
   SelectAsset = 'SelectAsset',
@@ -84,6 +84,7 @@ export enum WalletFilteringOptions {
   All = 'All',
   Currencies = 'Currencies',
   NFT = 'NFT',
+  SBT = 'SBT',
 }
 
 export enum SoraNetwork {
@@ -238,7 +239,9 @@ export const TranslationConsts = {
   TBC: 'TBC',
   XYK: 'XYK',
   NFT: 'NFT',
+  SBT: 'SBT',
   CEX: 'CEX',
+  KYC: 'KYC',
   Polkadot: 'Polkadot',
   SORAScan: 'SORAScan',
   Subscan: 'Subscan',
diff --git a/src/index.ts b/src/index.ts
index 76f9d8c2d..85922ea45 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -8,6 +8,7 @@ import AddAssetDetailsCard from './components/AddAsset/AddAssetDetailsCard.vue';
 import AddressBookInput from './components/AddressBook/Input.vue';
 import AssetList from './components/AssetList.vue';
 import AssetListItem from './components/AssetListItem.vue';
+import TokenLogo from './components/AssetLogos/TokenLogo.vue';
 import ConfirmDialog from './components/ConfirmDialog.vue';
 import ConnectionView from './components/Connection/ConnectionView.vue';
 import AccountConnectionList from './components/Connection/List/Account.vue';
@@ -41,7 +42,6 @@ import FormattedAddress from './components/shared/FormattedAddress.vue';
 import SyntheticSwitcher from './components/shared/SyntheticSwitcher.vue';
 import SimpleNotification from './components/SimpleNotification.vue';
 import TokenAddress from './components/TokenAddress.vue';
-import TokenLogo from './components/TokenLogo.vue';
 import TransactionHashView from './components/TransactionHashView.vue';
 import WalletBase from './components/WalletBase.vue';
 import WalletFee from './components/WalletFee.vue';
@@ -77,6 +77,7 @@ import {
   getAssetsSubset,
 } from './util';
 import * as accountUtils from './util/account';
+import { IpfsStorage } from './util/ipfsStorage';
 import { ScriptLoader } from './util/scriptLoader';
 import { storage, runtimeStorage, settingsStorage } from './util/storage';
 
@@ -262,6 +263,7 @@ export {
   storage,
   runtimeStorage,
   settingsStorage,
+  IpfsStorage,
   getExplorerLinks,
   groupRewardsByAssetsList,
   formatAccountAddress,
diff --git a/src/lang/en/index.ts b/src/lang/en/index.ts
index b95f83621..2d07af177 100644
--- a/src/lang/en/index.ts
+++ b/src/lang/en/index.ts
@@ -54,6 +54,7 @@ export default {
     [Operation.SwapAndSend]: 'Swap and Send',
     [Operation.SwapTransferBatch]: '{ADAR} transfer',
     [Operation.Transfer]: 'Transfer',
+    [Operation.XorlessTransfer]: 'Transfer',
     [Operation.VestedTransfer]: 'Transfer',
     [Operation.AddLiquidity]: 'Add Liquidity',
     [Operation.RemoveLiquidity]: 'Remove Liquidity',
@@ -91,9 +92,15 @@ export default {
     [Operation.DepositCollateral]: 'Deposit Position',
     [Operation.RepayVaultDebt]: 'Repay Debt',
     [Operation.BorrowVaultDebt]: 'Borrow Debt',
+    [Operation.SetAccessExpiration]: 'Set SBT Expiration',
+    [Operation.RegulateAsset]: 'Regulate Asset',
+    [Operation.RegisterAndRegulateAsset]: 'Register Asset',
+    [Operation.BindRegulatedAsset]: 'Bind Regulated Asset',
+    [Operation.IssueSoulBoundToken]: 'Issue SBT',
     andText: 'and',
     [TransactionStatus.Finalized]: {
       [Operation.Transfer]: '{action} {amount} {symbol} {direction} {address}',
+      [Operation.XorlessTransfer]: '{action} {amount} {symbol} {direction} {address}',
       [Operation.VestedTransfer]: '{action} {amount} {symbol} {direction} {address}',
       [Operation.Swap]: 'Swapped {amount} {symbol} for {amount2} {symbol2}',
       [Operation.SwapAndSend]: 'Swapped {amount} {symbol} for {amount2} {symbol2} and {action} {direction} {address}',
@@ -134,9 +141,15 @@ export default {
       [Operation.DepositCollateral]: 'Deposited {amount} {symbol}',
       [Operation.RepayVaultDebt]: 'Repaid {amount} {symbol}',
       [Operation.BorrowVaultDebt]: 'Borrowed {amount} {symbol}',
+      [Operation.SetAccessExpiration]: 'SB token {symbol} Updated expiration to {endTime}',
+      [Operation.RegulateAsset]: 'Regulate Asset {symbol}',
+      [Operation.RegisterAndRegulateAsset]: 'Register And Regulate {symbol} asset',
+      [Operation.BindRegulatedAsset]: 'Bind Asset {symbol2} to SBT',
+      [Operation.IssueSoulBoundToken]: 'Issue Soulbound Token {symbol}',
     },
     [TransactionStatus.Error]: {
       [Operation.Transfer]: 'Failed to {action} {amount} {symbol} {direction} {address}',
+      [Operation.XorlessTransfer]: 'Failed to send {amount} {symbol} to {address}',
       [Operation.VestedTransfer]: 'Failed to {action} {amount} {symbol} {direction} {address}',
       [Operation.Swap]: 'Failed to swap {amount} {symbol} for {amount2} {symbol2}',
       [Operation.SwapAndSend]:
@@ -178,6 +191,11 @@ export default {
       [Operation.DepositCollateral]: 'Failed to deposit {amount} {symbol}',
       [Operation.RepayVaultDebt]: 'Failed to repaid {amount} {symbol}',
       [Operation.BorrowVaultDebt]: 'Failed to borrow {amount} {symbol}',
+      [Operation.SetAccessExpiration]: 'Failed to update expiration to {to} for {symbol}',
+      [Operation.RegulateAsset]: 'Failed To Regulate Asset {symbol}',
+      [Operation.RegisterAndRegulateAsset]: 'Failed To Register And Regulate {symbol}',
+      [Operation.BindRegulatedAsset]: 'Failed To Bind Asset {symbol} to SBT {symbol2}',
+      [Operation.IssueSoulBoundToken]: 'Failed to issue Soulbound token {symbol}',
     },
   },
   polkadotjs: {
@@ -588,4 +606,22 @@ export default {
     enterPassword: 'Enter password',
     googleOnly: '{Google} accounts only',
   },
+  sbtDetails: {
+    description: 'This SBT provides access to multiple tokens & pools and is attached to your account',
+    issuedBy: '{SBT} issued by',
+    kycVerification: '{KYC} Verification',
+    kycProvider: '{KYC} Provider',
+    accessPermitted: 'Access permitted',
+    listOperable: 'Regulated assets operable',
+    noPermissions: 'No additional permissions',
+    regulatedInsitution: 'Regulated Institution',
+    expiryDate: 'Expiry date',
+    expiryDateTooltip: "The 'Expiry Date' is the deadline for your access to regulated assets of SBT",
+    expiresIn: 'Expires in',
+    expiresInTooltip: "The 'Expires in' shows period or point of time the access is acquired",
+    indefiniteExp: 'open-ended',
+    permission: 'permission',
+    permissions: 'permissions',
+    noReceiverAccess: "You're trying to send regulated token to the user with no SBT access",
+  },
 };
diff --git a/src/services/indexer/parser.ts b/src/services/indexer/parser.ts
index 498a1ba50..03cbdfd4e 100644
--- a/src/services/indexer/parser.ts
+++ b/src/services/indexer/parser.ts
@@ -39,6 +39,11 @@ import type {
   HistoryElementVaultClose,
   HistoryElementVaultDepositCollateral,
   HistoryElementVaultDebt,
+  HistoryElementDefiRIssueSBT,
+  HistoryElementDefiRSetSBTExpiration,
+  HistoryElementDefiRRegulateAsset,
+  HistoryElementDefiRBindRegulatedAssetToSbt,
+  HistoryElementDefiRRegisterRegulatedAsset,
   HistoryElementEthBridgeIncoming,
   HistoryElementEthBridgeOutgoing,
   ClaimedRewardItem,
@@ -78,7 +83,6 @@ const OperationsMap = {
   [insensitive(ModuleNames.Utility)]: {
     [insensitive(ModuleMethods.UtilityBatchAll)]: (data: HistoryElementBatchCall[]) => {
       if (!(Array.isArray(data) && !!data.length)) return null;
-
       if (
         !!getBatchCall(data, { module: ModuleNames.PoolXYK, method: ModuleMethods.PoolXYKInitializePool }) &&
         !!getBatchCall(data, { module: ModuleNames.PoolXYK, method: ModuleMethods.PoolXYKDepositLiquidity })
@@ -118,6 +122,16 @@ const OperationsMap = {
         return Operation.StakingBondAndNominate;
       }
 
+      if (
+        data.every(
+          (call) =>
+            isModuleMethod(call, ModuleNames.DefiR, ModuleMethods.DefiRBindRegulatedAsset) ||
+            isModuleMethod(call, ModuleNames.DefiR, ModuleMethods.DefiRIssueSoulBoundToken)
+        )
+      ) {
+        return Operation.IssueSoulBoundToken;
+      }
+
       return null;
     },
   },
@@ -169,6 +183,13 @@ const OperationsMap = {
     [insensitive(ModuleMethods.VaultDebtPayment)]: () => Operation.RepayVaultDebt,
     [insensitive(ModuleMethods.VaultDebtBorrow)]: () => Operation.BorrowVaultDebt,
   },
+  [insensitive(ModuleNames.DefiR)]: {
+    [insensitive(ModuleMethods.DefiRSetAccessExpiration)]: () => Operation.SetAccessExpiration,
+    [insensitive(ModuleMethods.DefiRRegulateAsset)]: () => Operation.RegulateAsset,
+    [insensitive(ModuleMethods.DefiRRegisterAndRegulateAsset)]: () => Operation.RegisterAndRegulateAsset,
+    [insensitive(ModuleMethods.DefiRBindRegulatedAsset)]: () => Operation.BindRegulatedAsset,
+    [insensitive(ModuleMethods.DefiRIssueSoulBoundToken)]: () => Operation.IssueSoulBoundToken,
+  },
   [insensitive(ModuleNames.BridgeMultisig)]: {
     [insensitive(ModuleMethods.BridgeMultisigAsMulti)]: () => Operation.EthBridgeIncoming,
   },
@@ -715,6 +736,43 @@ const parseVaultDebtPaymentOrBorrow = async (transaction: HistoryElement, payloa
   return payload;
 };
 
+const parseDefiRIssueSBT = async (transaction: HistoryElement, payload: HistoryItem) => {
+  const data = transaction.calls[0].data as HistoryElementDefiRIssueSBT;
+  payload.symbol = Buffer.from(data.symbol.slice(2), 'hex').toString();
+  return payload;
+};
+
+const parseDefiRRegisterAndRegulatedAsset = async (transaction: HistoryElement, payload: HistoryItem) => {
+  const data = transaction.data as HistoryElementDefiRRegisterRegulatedAsset;
+  payload.symbol = Buffer.from(data.symbol.slice(2), 'hex').toString();
+  return payload;
+};
+
+const parseDefiRSetSBTExpiration = async (transaction: HistoryElement, payload: HistoryItem) => {
+  const data = transaction.data as HistoryElementDefiRSetSBTExpiration;
+  const sbtAsset = await getAssetByAddress(data.sbtAssetId);
+  payload.symbol = getAssetSymbol(sbtAsset);
+  const date = new Date(parseInt(data.newExpiresAtTime, 10));
+  payload.to = date.toLocaleString('en-US');
+  return payload;
+};
+
+const parseDefiRRegulateAsset = async (transaction: HistoryElement, payload: HistoryItem) => {
+  const data = transaction.data as HistoryElementDefiRRegulateAsset;
+  const regulateAsset = await getAssetByAddress(data.assetId);
+  payload.symbol = getAssetSymbol(regulateAsset);
+  return payload;
+};
+
+const parseBindRegulatedAssetToSbt = async (transaction: HistoryElement, payload: HistoryItem) => {
+  const data = transaction.data as HistoryElementDefiRBindRegulatedAssetToSbt;
+  const regulateAsset = await getAssetByAddress(data.assetId);
+  payload.symbol = getAssetSymbol(regulateAsset);
+  const sbtAsset = await getAssetByAddress(data.sbtAssetId);
+  payload.symbol2 = getAssetSymbol(sbtAsset);
+  return payload;
+};
+
 const parseEthBridgeIncoming = async (transaction: HistoryElement, payload: HistoryItem) => {
   const data = transaction.data as HistoryElementEthBridgeIncoming;
 
@@ -790,6 +848,11 @@ export default class IndexerDataParser {
     Operation.DepositCollateral,
     Operation.RepayVaultDebt,
     Operation.BorrowVaultDebt,
+    Operation.SetAccessExpiration,
+    Operation.RegulateAsset,
+    Operation.RegisterAndRegulateAsset,
+    Operation.BindRegulatedAsset,
+    Operation.IssueSoulBoundToken,
     /** Don't show bridge tx in wallet */
     // Operation.EthBridgeIncoming,
     // Operation.EthBridgeOutgoing,
@@ -859,6 +922,9 @@ export default class IndexerDataParser {
       case Operation.Transfer: {
         return await parseTransfer(transaction, payload);
       }
+      case Operation.XorlessTransfer: {
+        return await parseTransfer(transaction, payload);
+      }
       case Operation.RegisterAsset: {
         return await parseRegisterAsset(transaction, payload);
       }
@@ -930,6 +996,21 @@ export default class IndexerDataParser {
       case Operation.BorrowVaultDebt: {
         return await parseVaultDebtPaymentOrBorrow(transaction, payload);
       }
+      case Operation.RegisterAndRegulateAsset: {
+        return await parseDefiRRegisterAndRegulatedAsset(transaction, payload);
+      }
+      case Operation.IssueSoulBoundToken: {
+        return await parseDefiRIssueSBT(transaction, payload);
+      }
+      case Operation.SetAccessExpiration: {
+        return await parseDefiRSetSBTExpiration(transaction, payload);
+      }
+      case Operation.RegulateAsset: {
+        return await parseDefiRRegulateAsset(transaction, payload);
+      }
+      case Operation.BindRegulatedAsset: {
+        return await parseBindRegulatedAssetToSbt(transaction, payload);
+      }
       case Operation.EthBridgeIncoming: {
         return await parseEthBridgeIncoming(transaction, payload);
       }
diff --git a/src/services/indexer/subquery/queries/historyElements.ts b/src/services/indexer/subquery/queries/historyElements.ts
index 2bd831bf6..7f881000f 100644
--- a/src/services/indexer/subquery/queries/historyElements.ts
+++ b/src/services/indexer/subquery/queries/historyElements.ts
@@ -447,6 +447,53 @@ const OperationFilterMap = {
       equalTo: ModuleMethods.VaultDebtBorrow,
     },
   },
+  // DEFI-R
+  [Operation.SetAccessExpiration]: {
+    module: {
+      equalTo: ModuleNames.DefiR,
+    },
+    method: {
+      equalTo: ModuleMethods.DefiRSetAccessExpiration,
+    },
+  },
+  [Operation.RegulateAsset]: {
+    module: {
+      equalTo: ModuleNames.DefiR,
+    },
+    method: {
+      equalTo: ModuleMethods.DefiRRegulateAsset,
+    },
+  },
+  [Operation.BindRegulatedAsset]: {
+    module: {
+      equalTo: ModuleNames.DefiR,
+    },
+    method: {
+      equalTo: ModuleMethods.DefiRBindRegulatedAsset,
+    },
+  },
+  [Operation.RegisterAndRegulateAsset]: {
+    module: {
+      equalTo: ModuleNames.DefiR,
+    },
+    method: {
+      equalTo: ModuleMethods.DefiRRegisterAndRegulateAsset,
+    },
+  },
+  [Operation.IssueSoulBoundToken]: {
+    module: {
+      equalTo: ModuleNames.Utility,
+    },
+    method: {
+      equalTo: ModuleMethods.UtilityBatchAll,
+    },
+    callNames: {
+      contains: [
+        ModuleNames.DefiR + '.' + ModuleMethods.DefiRBindRegulatedAsset,
+        ModuleNames.DefiR + '.' + ModuleMethods.DefiRIssueSoulBoundToken,
+      ],
+    },
+  },
 };
 
 const createOperationsCriteria = (operations: Array<Operation>) => {
diff --git a/src/services/indexer/subsquid/queries/historyElements.ts b/src/services/indexer/subsquid/queries/historyElements.ts
index a2cfb80bb..3b3590302 100644
--- a/src/services/indexer/subsquid/queries/historyElements.ts
+++ b/src/services/indexer/subsquid/queries/historyElements.ts
@@ -306,6 +306,31 @@ const OperationFilterMap = {
     module_eq: ModuleNames.Vault,
     method_eq: ModuleMethods.VaultDebtBorrow,
   },
+  // DEFI-R
+  [Operation.SetAccessExpiration]: {
+    module_eq: ModuleNames.DefiR,
+    method_eq: ModuleMethods.DefiRSetAccessExpiration,
+  },
+  [Operation.RegulateAsset]: {
+    module_eq: ModuleNames.DefiR,
+    method_eq: ModuleMethods.DefiRRegulateAsset,
+  },
+  [Operation.BindRegulatedAsset]: {
+    module_eq: ModuleNames.DefiR,
+    method_eq: ModuleMethods.DefiRBindRegulatedAsset,
+  },
+  [Operation.RegisterAndRegulateAsset]: {
+    module_eq: ModuleNames.DefiR,
+    method_eq: ModuleMethods.DefiRRegisterAndRegulateAsset,
+  },
+  [Operation.IssueSoulBoundToken]: {
+    module_eq: ModuleNames.Utility,
+    method_eq: ModuleMethods.UtilityBatchAll,
+    callNames_containsAny: [
+      ModuleNames.DefiR + '.' + ModuleMethods.DefiRBindRegulatedAsset,
+      ModuleNames.DefiR + '.' + ModuleMethods.DefiRIssueSoulBoundToken,
+    ],
+  },
 };
 
 const createOperationsCriteria = (operations: Array<Operation>) => {
diff --git a/src/services/indexer/types/calls.ts b/src/services/indexer/types/calls.ts
index 805122419..b7242a706 100644
--- a/src/services/indexer/types/calls.ts
+++ b/src/services/indexer/types/calls.ts
@@ -14,6 +14,7 @@ export enum ModuleNames {
   OrderBook = 'orderBook',
   Staking = 'staking',
   Vault = 'kensetsu',
+  DefiR = 'extendedAssets',
 }
 
 export enum ModuleMethods {
@@ -59,4 +60,9 @@ export enum ModuleMethods {
   VaultCollateralDeposit = 'depositCollateral',
   VaultDebtPayment = 'repayDebt',
   VaultDebtBorrow = 'borrow',
+  DefiRSetAccessExpiration = 'setSbtExpiration',
+  DefiRRegulateAsset = 'regulateAsset',
+  DefiRRegisterAndRegulateAsset = 'registerRegulatedAsset',
+  DefiRBindRegulatedAsset = 'bindRegulatedAssetToSbt',
+  DefiRIssueSoulBoundToken = 'issueSbt',
 }
diff --git a/src/services/indexer/types/models.ts b/src/services/indexer/types/models.ts
index 448797e8f..e77f3688a 100644
--- a/src/services/indexer/types/models.ts
+++ b/src/services/indexer/types/models.ts
@@ -497,6 +497,36 @@ export type HistoryElementVaultDebt = {
 
 export type HistoryElementVaultClose = Required<HistoryElementVaultCreate>;
 
+export type HistoryElementDefiRIssueSBT = {
+  description: string;
+  externalurl: string;
+  image: string;
+  name: string;
+  symbol: string;
+};
+
+export type HistoryElementDefiRSetSBTExpiration = {
+  accountId: string;
+  newExpiresAtTime: string;
+  sbtAssetId: string;
+};
+
+export type HistoryElementDefiRRegulateAsset = {
+  assetId: string;
+};
+
+export type HistoryElementDefiRBindRegulatedAssetToSbt = {
+  assetId: string;
+  sbtAssetId: string;
+};
+
+export type HistoryElementDefiRRegisterRegulatedAsset = {
+  name: string;
+  supply: string;
+  symbol: string;
+  mintable: boolean;
+};
+
 export type HistoryElementDataBase = Nullable<
   | HistoryElementReferralSetReferrer
   | HistoryElementReferrerReserve
@@ -526,6 +556,11 @@ export type HistoryElementDataBase = Nullable<
   | HistoryElementVaultDepositCollateral
   | HistoryElementVaultDebt
   | HistoryElementVaultClose
+  | HistoryElementDefiRIssueSBT
+  | HistoryElementDefiRSetSBTExpiration
+  | HistoryElementDefiRRegulateAsset
+  | HistoryElementDefiRBindRegulatedAssetToSbt
+  | HistoryElementDefiRRegisterRegulatedAsset
 >;
 
 export type HistoryElementBase = {
diff --git a/src/store/account/actions.ts b/src/store/account/actions.ts
index 2e8086174..1c96b0f89 100644
--- a/src/store/account/actions.ts
+++ b/src/store/account/actions.ts
@@ -268,6 +268,8 @@ const actions = defineActions({
     commit.resetAccountAssetsSubscription();
 
     if (getters.isLoggedIn) {
+      const sbtAssetsList = await api.extendedAssets.getAllSbtIds();
+
       try {
         const subscription = api.assets.balanceUpdated.subscribe(() => {
           const filtered = api.assets.accountAssets.filter(
diff --git a/src/store/account/getters.ts b/src/store/account/getters.ts
index 6ed05bbbe..ed122eccb 100644
--- a/src/store/account/getters.ts
+++ b/src/store/account/getters.ts
@@ -1,3 +1,11 @@
+import { FPNumber } from '@sora-substrate/sdk';
+import {
+  type Asset,
+  type Whitelist,
+  type AccountAsset,
+  type WhitelistArrayItem,
+  AssetTypes,
+} from '@sora-substrate/sdk/build/assets/types';
 import { AES, enc } from 'crypto-js';
 import { defineGetters } from 'direct-vuex';
 import isEqual from 'lodash/fp/isEqual';
@@ -10,7 +18,6 @@ import { accountGetterContext } from './../account';
 
 import type { AccountState } from './types';
 import type { AssetsTable, AccountAssetsTable, PolkadotJsAccount } from '../../types/common';
-import type { Asset, Whitelist, AccountAsset, WhitelistArrayItem } from '@sora-substrate/sdk/build/assets/types';
 
 const toHashTable = <T extends Asset>(list: Readonly<Array<T>>, key: string) => {
   return list.reduce((result, item) => {
@@ -98,6 +105,17 @@ const getters = defineGetters<AccountState>()({
       return isEqual(formatted)(accountData);
     };
   },
+  hasSomeSbt(...args): boolean {
+    const { state } = accountGetterContext(args);
+
+    return state.accountAssets.some((asset) => {
+      if (asset.type === AssetTypes.Soulbound) {
+        return !FPNumber.fromCodecValue(asset.balance.total, asset.decimals).isZero();
+      }
+
+      return false;
+    });
+  },
 });
 
 export default getters;
diff --git a/src/store/transactions/actions.ts b/src/store/transactions/actions.ts
index a889c199b..9d67ae4a5 100644
--- a/src/store/transactions/actions.ts
+++ b/src/store/transactions/actions.ts
@@ -88,8 +88,8 @@ const actions = defineActions({
     }: ExternalHistoryParams = {}
   ): Promise<void> {
     const { state, commit } = transactionsActionContext(context);
-    const { externalHistory, externalHistoryUpdates } = state;
 
+    const { externalHistory, externalHistoryUpdates } = state;
     const indexer = getCurrentIndexer();
     const operations = indexer.services.dataParser.supportedOperations;
     const filter = indexer.historyElementsFilter({
@@ -107,7 +107,6 @@ const actions = defineActions({
 
     try {
       const response = await indexer.services.explorer.account.getHistory(variables);
-
       if (!response) return;
 
       const { nodes, totalCount } = response;
diff --git a/tests/unit/components/WalletAssetDetails.spec.ts b/tests/unit/components/AssetDetailsTransferable.spec.ts
similarity index 78%
rename from tests/unit/components/WalletAssetDetails.spec.ts
rename to tests/unit/components/AssetDetailsTransferable.spec.ts
index d21860300..f4946938c 100644
--- a/tests/unit/components/WalletAssetDetails.spec.ts
+++ b/tests/unit/components/AssetDetailsTransferable.spec.ts
@@ -1,4 +1,4 @@
-import WalletAssetDetails from '@/components/WalletAssetDetails.vue';
+import AssetDetailsTransferable from '@/components/AssetDetails/AssetDetailsTransferable.vue';
 
 import { useDescribe, useShallowMount, useVuex } from '../../utils';
 import { MOCK_ACCOUNT_ASSETS, MOCK_FIAT_PRICE_OBJECT, MOCK_HISTORY, MOCK_WALLET_PERMISSIONS } from '../../utils/mock';
@@ -35,15 +35,15 @@ const createStore = ({ permissions = MOCK_WALLET_PERMISSIONS, isNotXor = false }
     },
   });
 
-useDescribe('WalletAssetDetails.vue', WalletAssetDetails, () => {
+useDescribe('WalletAssetDetails.vue', AssetDetailsTransferable, () => {
   it('should be rendered correctly', () => {
-    const wrapper = useShallowMount(WalletAssetDetails, { store: createStore() });
+    const wrapper = useShallowMount(AssetDetailsTransferable, { store: createStore() });
 
     expect(wrapper.element).toMatchSnapshot();
   });
 
   it('should show detailed balance info when button clicked', async () => {
-    const wrapper = useShallowMount(WalletAssetDetails, { store: createStore() });
+    const wrapper = useShallowMount(AssetDetailsTransferable, { store: createStore() });
     const el = wrapper.find('.asset-details-balance');
 
     await el.trigger('click');
@@ -54,7 +54,7 @@ useDescribe('WalletAssetDetails.vue', WalletAssetDetails, () => {
   it('should not show balance details button', () => {
     const isNotXor = true;
     const store = createStore({ isNotXor });
-    const wrapper = useShallowMount(WalletAssetDetails, { store });
+    const wrapper = useShallowMount(AssetDetailsTransferable, { store });
     const btnBalanceDetails = wrapper.find('.asset-details-balance--clickable');
 
     expect(btnBalanceDetails.exists()).toBeFalse();
@@ -62,7 +62,7 @@ useDescribe('WalletAssetDetails.vue', WalletAssetDetails, () => {
 
   it('should not show send action button', () => {
     const store = createStore({ permissions: { ...MOCK_WALLET_PERMISSIONS, sendAssets: false } });
-    const wrapper = useShallowMount(WalletAssetDetails, { store });
+    const wrapper = useShallowMount(AssetDetailsTransferable, { store });
     const btn = wrapper.find('.asset-details-action.send');
 
     expect(btn.exists()).toBeFalse();
@@ -70,7 +70,7 @@ useDescribe('WalletAssetDetails.vue', WalletAssetDetails, () => {
 
   it('should not show bridge action button', () => {
     const store = createStore({ permissions: { ...MOCK_WALLET_PERMISSIONS, bridgeAssets: false } });
-    const wrapper = useShallowMount(WalletAssetDetails, { store });
+    const wrapper = useShallowMount(AssetDetailsTransferable, { store });
     const btn = wrapper.find('.asset-details-action.bridge');
 
     expect(btn.exists()).toBeFalse();
@@ -78,7 +78,7 @@ useDescribe('WalletAssetDetails.vue', WalletAssetDetails, () => {
 
   it('should not show swap action button', () => {
     const store = createStore({ permissions: { ...MOCK_WALLET_PERMISSIONS, swapAssets: false } });
-    const wrapper = useShallowMount(WalletAssetDetails, { store });
+    const wrapper = useShallowMount(AssetDetailsTransferable, { store });
     const btn = wrapper.find('.asset-details-action.swap');
 
     expect(btn.exists()).toBeFalse();
@@ -86,7 +86,7 @@ useDescribe('WalletAssetDetails.vue', WalletAssetDetails, () => {
 
   it('should not show liquidity action button', () => {
     const store = createStore({ permissions: { ...MOCK_WALLET_PERMISSIONS, addLiquidity: false } });
-    const wrapper = useShallowMount(WalletAssetDetails, { store });
+    const wrapper = useShallowMount(AssetDetailsTransferable, { store });
     const btn = wrapper.find('.asset-details-action.liquidity');
 
     expect(btn.exists()).toBeFalse();
@@ -94,7 +94,7 @@ useDescribe('WalletAssetDetails.vue', WalletAssetDetails, () => {
 
   it('should not show bridge action button', () => {
     const store = createStore({ permissions: { ...MOCK_WALLET_PERMISSIONS, bridgeAssets: false } });
-    const wrapper = useShallowMount(WalletAssetDetails, { store });
+    const wrapper = useShallowMount(AssetDetailsTransferable, { store });
     const btn = wrapper.find('.asset-details-action.bridge');
 
     expect(btn.exists()).toBeFalse();
diff --git a/tests/unit/components/CreateToken.spec.ts b/tests/unit/components/CreateToken.spec.ts
deleted file mode 100644
index 054b9c071..000000000
--- a/tests/unit/components/CreateToken.spec.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import omit from 'lodash/fp/omit';
-
-import CreateToken from '@/components/CreateToken.vue';
-
-import { useDescribe, useShallowMount, useVuex } from '../../utils';
-import { MOCK_CREATE_TOKEN } from '../../utils/CreateTokenMock';
-
-const createStore = () =>
-  useVuex({
-    router: {
-      mutations: {
-        navigate: jest.fn(),
-      },
-    },
-  });
-
-useDescribe('CreateToken.vue', CreateToken, () => {
-  MOCK_CREATE_TOKEN.map((item) =>
-    it(`[${item.title}]: should be rendered correctly`, () => {
-      const data = omit(['title'], item);
-      const wrapper = useShallowMount(CreateToken, {
-        store: createStore(),
-        data: () => data,
-      });
-      expect(wrapper.element).toMatchSnapshot();
-    })
-  );
-});
diff --git a/tests/unit/components/TokenLogo.spec.ts b/tests/unit/components/TokenLogo.spec.ts
index 77156f7ed..8c310cb1a 100644
--- a/tests/unit/components/TokenLogo.spec.ts
+++ b/tests/unit/components/TokenLogo.spec.ts
@@ -1,4 +1,4 @@
-import TokenLogo from '@/components/TokenLogo.vue';
+import TokenLogo from '@/components/AssetLogos/TokenLogo.vue';
 
 import { useDescribe, useShallowMount, useVuex } from '../../utils';
 import { MOCK_ACCOUNT_ASSETS_NFT, MOCK_WHITE_LIST, MOCK_WHITELIST_IDS_BY_SYMBOL } from '../../utils/mock';
diff --git a/tests/unit/components/__snapshots__/WalletAssetDetails.spec.ts.snap b/tests/unit/components/__snapshots__/AssetDetailsTransferable.spec.ts.snap
similarity index 100%
rename from tests/unit/components/__snapshots__/WalletAssetDetails.spec.ts.snap
rename to tests/unit/components/__snapshots__/AssetDetailsTransferable.spec.ts.snap
diff --git a/tests/unit/components/__snapshots__/CreateToken.spec.ts.snap b/tests/unit/components/__snapshots__/CreateToken.spec.ts.snap
deleted file mode 100644
index b1a97423a..000000000
--- a/tests/unit/components/__snapshots__/CreateToken.spec.ts.snap
+++ /dev/null
@@ -1,181 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`CreateToken.vue [Confirm NFT Token Step]: should be rendered correctly 1`] = `
-<wallet-base-stub
-  resetfocus="ConfirmNftToken"
-  showback="true"
-  showheader="true"
-  title="Create"
-  tooltip=""
->
-  <div
-    class="token"
-  >
-    <s-tabs-stub
-      borderradius="small"
-      class="token__tab"
-      position="top"
-      type="rounded"
-      usedesignsystem="true"
-      value="CreateSimpleToken"
-    >
-      <s-tab-stub
-        label="Token"
-        name="CreateSimpleToken"
-      />
-      <s-tab-stub
-        label="NFT"
-        name="CreateNftToken"
-      />
-    </s-tabs-stub>
-     
-    <createsimpletoken-stub
-      step="ConfirmNftToken"
-    />
-  </div>
-</wallet-base-stub>
-`;
-
-exports[`CreateToken.vue [Confirm Simple Token Step]: should be rendered correctly 1`] = `
-<wallet-base-stub
-  resetfocus="ConfirmSimpleToken"
-  showback="true"
-  showheader="true"
-  title="Create"
-  tooltip=""
->
-  <div
-    class="token"
-  >
-    <s-tabs-stub
-      borderradius="small"
-      class="token__tab"
-      position="top"
-      type="rounded"
-      usedesignsystem="true"
-      value="CreateSimpleToken"
-    >
-      <s-tab-stub
-        label="Token"
-        name="CreateSimpleToken"
-      />
-      <s-tab-stub
-        label="NFT"
-        name="CreateNftToken"
-      />
-    </s-tabs-stub>
-     
-    <createsimpletoken-stub
-      step="ConfirmSimpleToken"
-    />
-  </div>
-</wallet-base-stub>
-`;
-
-exports[`CreateToken.vue [Create NFT Token Step]: should be rendered correctly 1`] = `
-<wallet-base-stub
-  resetfocus="CreateNftToken"
-  showback="true"
-  showheader="true"
-  title="Create"
-  tooltip=""
->
-  <div
-    class="token"
-  >
-    <s-tabs-stub
-      borderradius="small"
-      class="token__tab"
-      position="top"
-      type="rounded"
-      usedesignsystem="true"
-      value="CreateSimpleToken"
-    >
-      <s-tab-stub
-        label="Token"
-        name="CreateSimpleToken"
-      />
-      <s-tab-stub
-        label="NFT"
-        name="CreateNftToken"
-      />
-    </s-tabs-stub>
-     
-    <createsimpletoken-stub
-      step="CreateNftToken"
-    />
-  </div>
-</wallet-base-stub>
-`;
-
-exports[`CreateToken.vue [Create Step]: should be rendered correctly 1`] = `
-<wallet-base-stub
-  resetfocus="CreateSimpleToken"
-  showback="true"
-  showheader="true"
-  title="Create"
-  tooltip=""
->
-  <div
-    class="token"
-  >
-    <s-tabs-stub
-      borderradius="small"
-      class="token__tab"
-      position="top"
-      type="rounded"
-      usedesignsystem="true"
-      value="CreateSimpleToken"
-    >
-      <s-tab-stub
-        label="Token"
-        name="CreateSimpleToken"
-      />
-      <s-tab-stub
-        label="NFT"
-        name="CreateNftToken"
-      />
-    </s-tabs-stub>
-     
-    <createsimpletoken-stub
-      step="CreateSimpleToken"
-    />
-  </div>
-</wallet-base-stub>
-`;
-
-exports[`CreateToken.vue [Warn Step]: should be rendered correctly 1`] = `
-<wallet-base-stub
-  resetfocus="Warn"
-  showback="true"
-  showheader="true"
-  title="Create"
-  tooltip=""
->
-  <div
-    class="token"
-  >
-    <s-tabs-stub
-      borderradius="small"
-      class="token__tab"
-      position="top"
-      type="rounded"
-      usedesignsystem="true"
-      value="CreateSimpleToken"
-    >
-      <s-tab-stub
-        label="Token"
-        name="CreateSimpleToken"
-      />
-      <s-tab-stub
-        label="NFT"
-        name="CreateNftToken"
-      />
-    </s-tabs-stub>
-     
-    <createsimpletoken-stub
-      step="Warn"
-    />
-  </div>
-</wallet-base-stub>
-`;
diff --git a/tests/unit/components/__snapshots__/WalletSend.spec.ts.snap b/tests/unit/components/__snapshots__/WalletSend.spec.ts.snap
index 3ffe532d6..6faa24276 100644
--- a/tests/unit/components/__snapshots__/WalletSend.spec.ts.snap
+++ b/tests/unit/components/__snapshots__/WalletSend.spec.ts.snap
@@ -45,6 +45,8 @@ exports[`WalletSend.vue [Create Step: Empty Fields]: should be rendered correctl
      
     <!---->
      
+    <!---->
+     
     <s-float-input-stub
       class="wallet-send-input"
       decimals="18"
@@ -197,6 +199,8 @@ exports[`WalletSend.vue [Create Step: Incorrect Address]: should be rendered cor
      
     <!---->
      
+    <!---->
+     
     <s-float-input-stub
       class="wallet-send-input"
       decimals="18"
@@ -349,6 +353,8 @@ exports[`WalletSend.vue [Create Step: Not SORA Address]: should be rendered corr
      
     <!---->
      
+    <!---->
+     
     <s-float-input-stub
       class="wallet-send-input"
       decimals="18"
@@ -534,6 +540,8 @@ exports[`WalletSend.vue [Create Step: The Same Account]: should be rendered corr
       You cannot send tokens to the same account that you are currently connected to.
     </p>
      
+    <!---->
+     
     <s-float-input-stub
       class="wallet-send-input"
       decimals="18"