@subwallet/extension-base 1.3.3-0 → 1.3.4-0

package/services/balance-service/transfer/xcm/availBridge.js

@@ -0,0 +1,186 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
+import { getWeb3Contract } from '@subwallet/extension-base/koni/api/contract-handler/evm/web3';
+import { _AVAIL_BRIDGE_GATEWAY_ABI, _AVAIL_TEST_BRIDGE_GATEWAY_ABI, getAvailBridgeGatewayContract } from '@subwallet/extension-base/koni/api/contract-handler/utils';
+import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
+import { AVAIL_BRIDGE_API } from '@subwallet/extension-base/services/inapp-notification-service/utils';
+import { decodeAddress } from '@subwallet/keyring';
+import { u8aToHex } from '@polkadot/util';
+export const AvailBridgeConfig = {
+  ASSET_ID: '0x0000000000000000000000000000000000000000000000000000000000000000',
+  ETHEREUM_DOMAIN: 2,
+  // todo: check if these config can change later
+  AVAIL_DOMAIN: 1
+};
+export async function getAvailBridgeTxFromEth(originChainInfo, sender, recipient, value, evmApi) {
+  var _priority$maxFeePerGa, _priority$maxPriority;
+  const availBridgeContractAddress = getAvailBridgeGatewayContract(originChainInfo.slug);
+  const ABI = getAvailBridgeAbi(originChainInfo.slug);
+  const availBridgeContract = getWeb3Contract(availBridgeContractAddress, evmApi, ABI);
+  const _address = u8aToHex(decodeAddress(recipient));
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+  const sendAvail = availBridgeContract.methods.sendAVAIL(_address, value);
+  const transferData = sendAvail.encodeABI();
+  const priority = await calculateGasFeeParams(evmApi, evmApi.chainSlug);
+  const gasLimit = await sendAvail.estimateGas({
+    from: sender
+  });
+  return {
+    from: sender,
+    to: availBridgeContractAddress,
+    value: '0',
+    data: transferData,
+    gasPrice: priority.gasPrice,
+    maxFeePerGas: (_priority$maxFeePerGa = priority.maxFeePerGas) === null || _priority$maxFeePerGa === void 0 ? void 0 : _priority$maxFeePerGa.toString(),
+    maxPriorityFeePerGas: (_priority$maxPriority = priority.maxPriorityFeePerGas) === null || _priority$maxPriority === void 0 ? void 0 : _priority$maxPriority.toString(),
+    gas: gasLimit
+  };
+}
+export async function getAvailBridgeExtrinsicFromAvail(recipient, sendingValue, substrateApi) {
+  const data = {
+    message: {
+      FungibleToken: {
+        assetId: AvailBridgeConfig.ASSET_ID,
+        amount: BigInt(sendingValue)
+      }
+    },
+    to: `${recipient.padEnd(66, '0')}`,
+    domain: AvailBridgeConfig.ETHEREUM_DOMAIN
+  };
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.vector.sendMessage(data.message, data.to, data.domain);
+}
+export async function getClaimTxOnAvail(notification, substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  const chainSlug = chainApi.chainSlug;
+  const metadata = notification.metadata;
+  const lastestEthHeadSlot = await getLastestEthHeadSlot(chainSlug);
+  const lastestBlockHash = await getLastestBlockHash(chainSlug, lastestEthHeadSlot);
+  const proof = await getClaimProofOnAvail(chainSlug, lastestBlockHash, metadata.messageId);
+  return chainApi.api.tx.vector.execute(lastestEthHeadSlot, getAddressMessage(notification), proof.accountProof, proof.storageProof);
+}
+async function getLastestEthHeadSlot(chainSlug) {
+  try {
+    const api = getAvailBridgeApi(chainSlug);
+    const rawResponse = await fetch(`${api}/eth/head`);
+    const response = await rawResponse.json();
+    return response.slot;
+  } catch (e) {
+    console.error(e);
+    throw e;
+  }
+}
+async function getLastestBlockHash(chainSlug, slot) {
+  try {
+    const api = getAvailBridgeApi(chainSlug);
+    const rawResponse = await fetch(`${api}/beacon/slot/${slot}`);
+    const response = await rawResponse.json();
+    return response.blockHash;
+  } catch (e) {
+    console.error(e);
+    throw e;
+  }
+}
+async function getClaimProofOnAvail(chainSlug, blockHash, messageId) {
+  try {
+    const api = getAvailBridgeApi(chainSlug);
+    const rawResponse = await fetch(`${api}/avl/proof/${blockHash}/${messageId}`);
+    return await rawResponse.json();
+  } catch (e) {
+    console.error(e);
+    throw e;
+  }
+}
+async function getClaimProofOnEthereum(chainSlug, blockHash, transactionIndex) {
+  try {
+    const api = getAvailBridgeApi(chainSlug);
+    const rawResponse = await fetch(`${api}/eth/proof/${blockHash}?index=${transactionIndex}`);
+    return await rawResponse.json();
+  } catch (e) {
+    console.error(e);
+    throw e;
+  }
+}
+function getAvailBridgeApi(chainSlug) {
+  if (chainSlug === 'avail_mainnet' || chainSlug === COMMON_CHAIN_SLUGS.ETHEREUM) {
+    // todo: add COMMON_CHAIN_SLUGS for AVAIL, AVAIL TURING
+    return AVAIL_BRIDGE_API.AVAIL_MAINNET;
+  }
+  return AVAIL_BRIDGE_API.AVAIL_TESTNET;
+}
+export async function getClaimTxOnEthereum(chainSlug, notification, evmApi) {
+  var _priority$maxFeePerGa2, _priority$maxPriority2;
+  const availBridgeContractAddress = getAvailBridgeGatewayContract(chainSlug);
+  const ABI = getAvailBridgeAbi(chainSlug);
+  const availBridgeContract = getWeb3Contract(availBridgeContractAddress, evmApi, ABI);
+  const metadata = notification.metadata;
+  const merkleProof = await getClaimProofOnEthereum(chainSlug, metadata.sourceBlockHash, metadata.sourceTransactionIndex);
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+  const transfer = availBridgeContract.methods.receiveAVAIL({
+    messageType: '0x02',
+    from: merkleProof.message.from,
+    to: merkleProof.message.to,
+    originDomain: merkleProof.message.originDomain,
+    destinationDomain: merkleProof.message.destinationDomain,
+    data: evmApi.api.eth.abi.encodeParameters([{
+      name: 'assetId',
+      type: 'bytes32'
+    }, {
+      name: 'amount',
+      type: 'uint256'
+    }], [merkleProof.message.message.fungibleToken.asset_id, BigInt(merkleProof.message.message.fungibleToken.amount)]),
+    messageId: merkleProof.message.id
+  }, {
+    dataRootProof: merkleProof.dataRootProof,
+    leafProof: merkleProof.leafProof,
+    rangeHash: merkleProof.rangeHash,
+    dataRootIndex: merkleProof.dataRootIndex,
+    blobRoot: merkleProof.blobRoot,
+    bridgeRoot: merkleProof.bridgeRoot,
+    leaf: merkleProof.leaf,
+    leafIndex: merkleProof.leafIndex
+  });
+  const transferData = transfer.encodeABI();
+  const gasLimit = await transfer.estimateGas({
+    from: metadata.receiverAddress
+  });
+  const priority = await calculateGasFeeParams(evmApi, evmApi.chainSlug);
+  return {
+    from: metadata.receiverAddress,
+    to: availBridgeContractAddress,
+    value: '0',
+    data: transferData,
+    gasPrice: priority.gasPrice,
+    maxFeePerGas: (_priority$maxFeePerGa2 = priority.maxFeePerGas) === null || _priority$maxFeePerGa2 === void 0 ? void 0 : _priority$maxFeePerGa2.toString(),
+    maxPriorityFeePerGas: (_priority$maxPriority2 = priority.maxPriorityFeePerGas) === null || _priority$maxPriority2 === void 0 ? void 0 : _priority$maxPriority2.toString(),
+    gas: gasLimit
+  };
+}
+function getAddressMessage(notification) {
+  const metadata = notification.metadata;
+  return {
+    message: {
+      FungibleToken: {
+        assetId: AvailBridgeConfig.ASSET_ID,
+        amount: metadata.amount
+      }
+    },
+    from: `${metadata.depositorAddress.padEnd(66, '0')}`,
+    to: u8aToHex(decodeAddress(metadata.receiverAddress)),
+    originDomain: AvailBridgeConfig.ETHEREUM_DOMAIN,
+    destinationDomain: AvailBridgeConfig.AVAIL_DOMAIN,
+    id: metadata.messageId
+  };
+}
+function getAvailBridgeAbi(chainSlug) {
+  if (chainSlug === COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA) {
+    return _AVAIL_TEST_BRIDGE_GATEWAY_ABI;
+  }
+  return _AVAIL_BRIDGE_GATEWAY_ABI;
+}
+export function isAvailChainBridge(chainSlug) {
+  return ['avail_mainnet', 'availTuringTest'].includes(chainSlug);
+}

package/services/balance-service/transfer/xcm/index.d.ts

@@ -3,19 +3,19 @@ import { _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain
 import BigN from 'bignumber.js';
 import { TransactionConfig } from 'web3-core';
 import { SubmittableExtrinsic } from '@polkadot/api/types';
-declare type CreateXcmExtrinsicProps = {
+export declare type CreateXcmExtrinsicProps = {
     originTokenInfo: _ChainAsset;
     destinationTokenInfo: _ChainAsset;
     recipient: string;
     sendingValue: string;
-    substrateApi: _SubstrateApi;
+    evmApi?: _EvmApi;
+    substrateApi?: _SubstrateApi;
     chainInfoMap: Record<string, _ChainInfo>;
+    sender?: string;
 };
-declare type CreateSnowBridgeExtrinsicProps = Omit<CreateXcmExtrinsicProps, 'substrateApi'> & {
-    evmApi: _EvmApi;
-    sender: string;
-};
-export declare const createSnowBridgeExtrinsic: ({ chainInfoMap, destinationTokenInfo, evmApi, originTokenInfo, recipient, sender, sendingValue }: CreateSnowBridgeExtrinsicProps) => Promise<TransactionConfig>;
+export declare type FunctionCreateXcmExtrinsic = (props: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'> | TransactionConfig>;
+export declare const createSnowBridgeExtrinsic: ({ chainInfoMap, destinationTokenInfo, evmApi, originTokenInfo, recipient, sender, sendingValue }: CreateXcmExtrinsicProps) => Promise<TransactionConfig>;
 export declare const createXcmExtrinsic: ({ chainInfoMap, destinationTokenInfo, originTokenInfo, recipient, sendingValue, substrateApi }: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'>>;
+export declare const createAvailBridgeTxFromEth: ({ chainInfoMap, evmApi, originTokenInfo, recipient, sender, sendingValue }: CreateXcmExtrinsicProps) => Promise<TransactionConfig>;
+export declare const createAvailBridgeExtrinsicFromAvail: ({ recipient, sendingValue, substrateApi }: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'>>;
 export declare const getXcmMockTxFee: (substrateApi: _SubstrateApi, chainInfoMap: Record<string, _ChainInfo>, originTokenInfo: _ChainAsset, destinationTokenInfo: _ChainAsset) => Promise<BigN>;
-export {};

package/services/balance-service/transfer/xcm/index.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { _isSnowBridgeXcm } from '@subwallet/extension-base/core/substrate/xcm-parser';
+import { getAvailBridgeExtrinsicFromAvail, getAvailBridgeTxFromEth } from '@subwallet/extension-base/services/balance-service/transfer/xcm/availBridge';
 import { getExtrinsicByPolkadotXcmPallet } from '@subwallet/extension-base/services/balance-service/transfer/xcm/polkadotXcm';
 import { getSnowBridgeEvmTransfer } from '@subwallet/extension-base/services/balance-service/transfer/xcm/snowBridge';
 import { getExtrinsicByXcmPalletPallet } from '@subwallet/extension-base/services/balance-service/transfer/xcm/xcmPallet';
@@ -10,7 +11,7 @@ import { _XCM_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-servi
 import { _isChainEvmCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import BigN from 'bignumber.js';
 import { u8aToHex } from '@polkadot/util';
-import { addressToEvm, isEthereumAddress } from '@polkadot/util-crypto';
+import { addressToEvm } from '@polkadot/util-crypto';
 export const createSnowBridgeExtrinsic = async ({
   chainInfoMap,
   destinationTokenInfo,
@@ -25,6 +26,12 @@ export const createSnowBridgeExtrinsic = async ({
   if (!_isSnowBridgeXcm(originChainInfo, destinationChainInfo)) {
     throw new Error('This is not a valid SnowBridge transfer');
   }
+  if (!evmApi) {
+    throw Error('Evm API is not available');
+  }
+  if (!sender) {
+    throw Error('Sender is required');
+  }
   return getSnowBridgeEvmTransfer(originTokenInfo, originChainInfo, destinationChainInfo, sender, recipient, sendingValue, evmApi);
 };
 export const createXcmExtrinsic = async ({
@@ -37,6 +44,9 @@ export const createXcmExtrinsic = async ({
 }) => {
   const originChainInfo = chainInfoMap[originTokenInfo.originChain];
   const destinationChainInfo = chainInfoMap[destinationTokenInfo.originChain];
+  if (!substrateApi) {
+    throw Error('Substrate API is not available');
+  }
   const chainApi = await substrateApi.isReady;
   const api = chainApi.api;
   const polkadotXcmSpecialCases = _XCM_CHAIN_GROUP.polkadotXcmSpecialCases.includes(originChainInfo.slug) && _isNativeToken(originTokenInfo);
@@ -48,24 +58,55 @@ export const createXcmExtrinsic = async ({
   }
   return getExtrinsicByXtokensPallet(originTokenInfo, originChainInfo, destinationChainInfo, recipient, sendingValue, api);
 };
+export const createAvailBridgeTxFromEth = ({
+  chainInfoMap,
+  evmApi,
+  originTokenInfo,
+  recipient,
+  sender,
+  sendingValue
+}) => {
+  const originChainInfo = chainInfoMap[originTokenInfo.originChain];
+  if (!evmApi) {
+    throw Error('Evm API is not available');
+  }
+  if (!sender) {
+    throw Error('Sender is required');
+  }
+  return getAvailBridgeTxFromEth(originChainInfo, sender, recipient, sendingValue, evmApi);
+};
+export const createAvailBridgeExtrinsicFromAvail = async ({
+  recipient,
+  sendingValue,
+  substrateApi
+}) => {
+  if (!substrateApi) {
+    throw Error('Substrate API is not available');
+  }
+  return await getAvailBridgeExtrinsicFromAvail(recipient, sendingValue, substrateApi);
+};
 export const getXcmMockTxFee = async (substrateApi, chainInfoMap, originTokenInfo, destinationTokenInfo) => {
   try {
     var _paymentInfo$partialF;
     const destChainInfo = chainInfoMap[destinationTokenInfo.originChain];
     const originChainInfo = chainInfoMap[originTokenInfo.originChain];
-    const address = '5DRewsYzhJqZXU3SRaWy1FSt5iDr875ao91aw5fjrJmDG4Ap'; // todo: move this
+    const fakeAddress = '5DRewsYzhJqZXU3SRaWy1FSt5iDr875ao91aw5fjrJmDG4Ap'; // todo: move this
+    const substrateAddress = fakeAddress; // todo: move this
+    const evmAddress = u8aToHex(addressToEvm(fakeAddress)); // todo: move this
 
     // mock receiving account from sender
-    const recipient = !isEthereumAddress(address) && _isChainEvmCompatible(destChainInfo) && !_isChainEvmCompatible(originChainInfo) ? u8aToHex(addressToEvm(address)) : address;
+    const sender = _isChainEvmCompatible(originChainInfo) ? evmAddress : substrateAddress;
+    const recipient = _isChainEvmCompatible(destChainInfo) ? evmAddress : substrateAddress;
     const mockTx = await createXcmExtrinsic({
       chainInfoMap,
       destinationTokenInfo,
       originTokenInfo,
-      recipient: recipient,
+      sender,
+      recipient,
       sendingValue: '1000000000000000000',
       substrateApi
     });
-    const paymentInfo = await mockTx.paymentInfo(address);
+    const paymentInfo = await mockTx.paymentInfo(fakeAddress);
     return new BigN((paymentInfo === null || paymentInfo === void 0 ? void 0 : (_paymentInfo$partialF = paymentInfo.partialFee) === null || _paymentInfo$partialF === void 0 ? void 0 : _paymentInfo$partialF.toString()) || '0');
   } catch (e) {
     console.error('error mocking xcm tx fee', e);

package/services/chain-service/handler/EvmApi.js

@@ -72,15 +72,11 @@ export class EvmApi {
   createIntervalCheckApi() {
     this.clearIntervalCheckApi();
     return setInterval(() => {
-      if (!this.ignoreNetListen) {
-        this.api.eth.net.isListening().then(() => {
-          this.onConnect();
-        }).catch(() => {
-          this.onDisconnect();
-        });
-      } else {
+      this.api.eth.getChainId().then(() => {
         this.onConnect();
-      }
+      }).catch(() => {
+        this.onDisconnect();
+      });
     }, 10000);
   }
   clearIntervalCheckApi() {
@@ -93,21 +89,16 @@ export class EvmApi {
     this.updateConnectionStatus(_ChainConnectionStatus.CONNECTING);
 
     // Check if api is ready
-    if (!this.ignoreNetListen) {
-      this.api.eth.net.isListening().then(() => {
-        this.isApiReadyOnce = true;
-        this.onConnect();
-      }).catch(error => {
-        this.isApiReadyOnce = false;
-        this.isApiReady = false;
-        this.isReadyHandler.reject(error);
-        this.updateConnectionStatus(_ChainConnectionStatus.DISCONNECTED);
-        console.warn(`Can not connect to ${this.chainSlug} (EVM) at ${this.apiUrl}`);
-      });
-    } else {
+    this.api.eth.getChainId().then(() => {
       this.isApiReadyOnce = true;
       this.onConnect();
-    }
+    }).catch(error => {
+      this.isApiReadyOnce = false;
+      this.isApiReady = false;
+      this.isReadyHandler.reject(error);
+      this.updateConnectionStatus(_ChainConnectionStatus.DISCONNECTED);
+      console.warn(`Can not connect to ${this.chainSlug} (EVM) at ${this.apiUrl}`);
+    });
 
     // Interval to check connecting status
     this.intervalCheckApi = this.createIntervalCheckApi();

package/services/chain-service/handler/SubstrateChainHandler.d.ts

@@ -19,7 +19,9 @@ export declare class SubstrateChainHandler extends AbstractChainHandler {
     private getPsp34TokenInfo;
     private getGrc20TokenInfo;
     private getVftTokenInfo;
+    private getLocalTokenInfo;
     getSubstrateContractTokenInfo(contractAddress: string, tokenType: _AssetType, originChain: string, contractCaller?: string): Promise<_SmartContractTokenInfo>;
+    getSubstrateAssetIdTokenInfo(assetId: string, originChain: string): Promise<_SmartContractTokenInfo>;
     setSubstrateApi(chainSlug: string, substrateApi: _SubstrateApi): void;
     destroySubstrateApi(chainSlug: string): void;
     initApi(chainSlug: string, apiUrl: string, { externalApiPromise, onUpdateStatus, providerName }?: Omit<_ApiOptions, 'metadata'>): Promise<_SubstrateApi>;

package/services/chain-service/handler/SubstrateChainHandler.js

@@ -179,6 +179,15 @@ export class SubstrateChainHandler extends AbstractChainHandler {
     }
     return [nameRes, decimals, symbolRes, contractError];
   }
+  async getLocalTokenInfo(apiPromise, assetId) {
+    const _metadata = await apiPromise.query.assets.metadata(assetId);
+    const metadata = _metadata.toPrimitive();
+    let idError = false;
+    if (!metadata.name || !metadata.symbol) {
+      idError = true;
+    }
+    return [metadata.name, metadata.decimals, metadata.symbol, idError];
+  }
   async getSubstrateContractTokenInfo(contractAddress, tokenType, originChain, contractCaller) {
     // todo: improve this funtion later
 
@@ -218,6 +227,26 @@ export class SubstrateChainHandler extends AbstractChainHandler {
       };
     }
   }
+  async getSubstrateAssetIdTokenInfo(assetId, originChain) {
+    const apiPromise = this.getSubstrateApiByChain(originChain).api;
+    try {
+      const [name, decimals, symbol, contractError] = await this.getLocalTokenInfo(apiPromise, assetId);
+      return {
+        name,
+        decimals,
+        symbol,
+        contractError
+      };
+    } catch (e) {
+      this.logger.error(e);
+      return {
+        name: '',
+        decimals: -1,
+        symbol: '',
+        contractError: true
+      };
+    }
+  }
   setSubstrateApi(chainSlug, substrateApi) {
     this.substrateApiMap[chainSlug] = substrateApi;
   }

package/services/chain-service/index.d.ts

@@ -63,6 +63,7 @@ export declare class ChainService {
     getAssetRegistry(): Record<string, _ChainAsset>;
     getMultiChainAssetMap(): Record<string, _MultiChainAsset>;
     getSmartContractTokens(): Record<string, _ChainAsset>;
+    getAssetHubToken(): Record<string, _ChainAsset>;
     getChainInfoMap(): Record<string, _ChainInfo>;
     getEvmChainInfoMap(): Record<string, _ChainInfo>;
     getSubstrateChainInfoMap(): Record<string, _ChainInfo>;
@@ -131,6 +132,7 @@ export declare class ChainService {
     private getChainSpecByProvider;
     private validateProvider;
     private getSmartContractTokenInfo;
+    private getAssetIdTokenInfo;
     validateCustomToken(data: _ValidateCustomAssetRequest): Promise<_ValidateCustomAssetResponse>;
     private generateSlugForSmartContractAsset;
     private generateSlugForNativeToken;

package/services/chain-service/index.js

@@ -10,7 +10,7 @@ import { SubstrateChainHandler } from '@subwallet/extension-base/services/chain-
 import { TonChainHandler } from '@subwallet/extension-base/services/chain-service/handler/TonChainHandler';
 import { _CHAIN_VALIDATION_ERROR } from '@subwallet/extension-base/services/chain-service/handler/types';
 import { _ChainConnectionStatus, _CUSTOM_PREFIX, _NFT_CONTRACT_STANDARDS, _SMART_CONTRACT_STANDARDS } from '@subwallet/extension-base/services/chain-service/types';
-import { _isAssetAutoEnable, _isAssetCanPayTxFee, _isAssetFungibleToken, _isChainEnabled, _isCustomAsset, _isCustomChain, _isCustomProvider, _isEqualContractAddress, _isEqualSmartContractAsset, _isMantaZkAsset, _isPureEvmChain, _isPureSubstrateChain, _parseAssetRefKey, fetchPatchData, randomizeProvider, updateLatestChainInfo } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isAssetAutoEnable, _isAssetCanPayTxFee, _isAssetFungibleToken, _isChainEnabled, _isCustomAsset, _isCustomChain, _isCustomProvider, _isEqualContractAddress, _isEqualSmartContractAsset, _isLocalToken, _isMantaZkAsset, _isPureEvmChain, _isPureSubstrateChain, _parseAssetRefKey, fetchPatchData, randomizeProvider, updateLatestChainInfo } from '@subwallet/extension-base/services/chain-service/utils';
 import AssetSettingStore from '@subwallet/extension-base/stores/AssetSetting';
 import { addLazy, calculateMetadataHash, fetchStaticData, filterAssetsByChainAndType, getShortMetadata, MODULE_SUPPORT } from '@subwallet/extension-base/utils';
 import { BehaviorSubject, Subject } from 'rxjs';
@@ -186,6 +186,15 @@ export class ChainService {
     });
     return filteredAssetRegistry;
   }
+  getAssetHubToken() {
+    const assetHubToken = {};
+    Object.values(this.getAssetRegistry()).forEach(asset => {
+      if (['statemint', 'statemine'].includes(asset.originChain)) {
+        assetHubToken[asset.slug] = asset;
+      }
+    });
+    return assetHubToken;
+  }
   getChainInfoMap() {
     return this.dataMap.chainInfoMap;
   }
@@ -435,7 +444,7 @@ export class ChainService {
   upsertCustomToken(token) {
     if (token.slug.length === 0) {
       // new token
-      if (token.assetType === _AssetType.NATIVE) {
+      if (token.assetType === _AssetType.NATIVE || token.assetType === _AssetType.LOCAL) {
         const defaultSlug = this.generateSlugForNativeToken(token.originChain, token.assetType, token.symbol);
         token.slug = `${_CUSTOM_PREFIX}${defaultSlug}`;
       } else {
@@ -444,7 +453,7 @@ export class ChainService {
         token.slug = `${_CUSTOM_PREFIX}${defaultSlug}`;
       }
     }
-    if (token.originChain && _isAssetFungibleToken(token)) {
+    if (token.originChain && (_isAssetFungibleToken(token) || _isLocalToken(token))) {
       var _this$getChainInfoByK;
       token.hasValue = !((_this$getChainInfoByK = this.getChainInfoByKey(token.originChain)) !== null && _this$getChainInfoByK !== void 0 && _this$getChainInfoByK.isTestnet);
     }
@@ -1510,13 +1519,35 @@ export class ChainService {
       contractError: false
     };
   }
+  async getAssetIdTokenInfo(assetId, tokenType, chain) {
+    if ([_AssetType.LOCAL].includes(tokenType) && assetId) {
+      return await this.substrateChainHandler.getSubstrateAssetIdTokenInfo(assetId, chain);
+    }
+    return {
+      decimals: -1,
+      name: '',
+      symbol: '',
+      contractError: false
+    };
+  }
   async validateCustomToken(data) {
     const assetRegistry = this.getSmartContractTokens();
+    const asset = this.getAssetHubToken();
     let existedToken;
     for (const token of Object.values(assetRegistry)) {
       var _token$metadata2;
       const contractAddress = token === null || token === void 0 ? void 0 : (_token$metadata2 = token.metadata) === null || _token$metadata2 === void 0 ? void 0 : _token$metadata2.contractAddress;
-      if (_isEqualContractAddress(contractAddress, data.contractAddress) && token.assetType === data.type && token.originChain === data.originChain) {
+      if (data.contractAddress) {
+        if (_isEqualContractAddress(contractAddress, data.contractAddress) && token.assetType === data.type && token.originChain === data.originChain) {
+          existedToken = token;
+          break;
+        }
+      }
+    }
+    for (const token of Object.values(asset)) {
+      var _token$metadata3;
+      const assetId = token === null || token === void 0 ? void 0 : (_token$metadata3 = token.metadata) === null || _token$metadata3 === void 0 ? void 0 : _token$metadata3.assetId;
+      if (assetId === data.assetId && token.assetType === data.type && token.originChain === data.originChain) {
         existedToken = token;
         break;
       }
@@ -1532,18 +1563,18 @@ export class ChainService {
         contractError: false
       };
     }
-    const {
-      contractError,
-      decimals,
-      name,
-      symbol
-    } = await this.getSmartContractTokenInfo(data.contractAddress, data.type, data.originChain, data.contractCaller);
+    let info;
+    if (data.contractAddress) {
+      info = await this.getSmartContractTokenInfo(data.contractAddress, data.type, data.originChain, data.contractCaller);
+    } else {
+      info = await this.getAssetIdTokenInfo(data.assetId, data.type, data.originChain);
+    }
     return {
-      name,
-      decimals,
-      symbol,
+      name: info.name,
+      decimals: info.decimals,
+      symbol: info.symbol,
       isExist: !!existedToken,
-      contractError
+      contractError: info.contractError
     };
   }
   generateSlugForSmartContractAsset(originChain, assetType, symbol, contractAddress) {

package/services/chain-service/types.d.ts

@@ -160,10 +160,11 @@ export interface EnableMultiChainParams {
     enableTokens?: boolean;
 }
 export interface _ValidateCustomAssetRequest {
-    contractAddress: string;
+    contractAddress?: string;
     originChain: string;
     type: _AssetType;
     contractCaller?: string;
+    assetId?: string;
 }
 export interface _SmartContractTokenInfo {
     name: string;

package/services/chain-service/utils/index.d.ts

@@ -53,6 +53,8 @@ export declare function _isChainSupportEvmNft(chainInfo: _ChainInfo): boolean;
 export declare function _isChainSupportWasmNft(chainInfo: _ChainInfo): boolean;
 export declare function _isChainSupportEvmERC20(chainInfo: _ChainInfo): boolean;
 export declare function _isChainSupportWasmPSP22(chainInfo: _ChainInfo): boolean;
+export declare function _isAssetHubChain(chainInfo: _ChainInfo): boolean;
+export declare function _isAssetHubToken(token: _ChainAsset): boolean;
 export declare function _isChainSupportGRC20(chainInfo: _ChainInfo): boolean;
 export declare function _isChainSupportVFT(chainInfo: _ChainInfo): boolean;
 export declare const _isSupportOrdinal: (chain: string) => boolean;
@@ -88,6 +90,7 @@ export declare function _getChainName(chainInfo?: _ChainInfo): string;
 export declare function _getAssetDecimals(assetInfo?: _ChainAsset): number;
 export declare function _getBlockExplorerFromChain(chainInfo: _ChainInfo): string | undefined;
 export declare function _parseMetadataForSmartContractAsset(contractAddress: string): Record<string, string>;
+export declare function _parseMetadataForAssetId(assetId: string): Record<string, string>;
 export declare function _isChainTestNet(chainInfo: _ChainInfo): boolean;
 export declare function _isAssetFungibleToken(chainAsset: _ChainAsset): boolean;
 export declare const _isAssetAutoEnable: (chainAsset: _ChainAsset) => boolean;

package/services/chain-service/utils/index.js

@@ -194,6 +194,12 @@ export function _isChainSupportWasmPSP22(chainInfo) {
   var _chainInfo$substrateI10, _chainInfo$substrateI11;
   return ((_chainInfo$substrateI10 = chainInfo.substrateInfo) === null || _chainInfo$substrateI10 === void 0 ? void 0 : (_chainInfo$substrateI11 = _chainInfo$substrateI10.supportSmartContract) === null || _chainInfo$substrateI11 === void 0 ? void 0 : _chainInfo$substrateI11.includes(_AssetType.PSP22)) || false;
 }
+export function _isAssetHubChain(chainInfo) {
+  return ['statemint', 'statemine'].includes(chainInfo.slug);
+}
+export function _isAssetHubToken(token) {
+  return ['statemint', 'statemine'].includes(token.originChain);
+}
 export function _isChainSupportGRC20(chainInfo) {
   var _chainInfo$substrateI12, _chainInfo$substrateI13;
   return ((_chainInfo$substrateI12 = chainInfo.substrateInfo) === null || _chainInfo$substrateI12 === void 0 ? void 0 : (_chainInfo$substrateI13 = _chainInfo$substrateI12.supportSmartContract) === null || _chainInfo$substrateI13 === void 0 ? void 0 : _chainInfo$substrateI13.includes(_AssetType.GRC20)) || false;
@@ -240,6 +246,9 @@ export function _getTokenTypesSupportedByChain(chainInfo) {
       }
     });
   }
+  if (['statemint', 'statemine'].includes(chainInfo.slug)) {
+    result.push(_AssetType.LOCAL);
+  }
   return result;
 }
 export function _getChainNativeTokenBasicInfo(chainInfo) {
@@ -393,6 +402,11 @@ export function _parseMetadataForSmartContractAsset(contractAddress) {
     contractAddress
   };
 }
+export function _parseMetadataForAssetId(assetId) {
+  return {
+    assetId
+  };
+}
 export function _isChainTestNet(chainInfo) {
   return chainInfo.isTestnet || false;
 }

package/services/earning-service/handlers/base.d.ts

@@ -45,6 +45,8 @@ export default abstract class BasePoolHandler {
     protected abstract getDescription(amount?: string): string;
     protected get maintainBalance(): string;
     get metadataInfo(): Omit<BaseYieldPoolMetadata, 'description'>;
+    createWithdrawNotifications(unstakingInfos: UnstakingInfo[], tokenInfo: _ChainAsset, address: string): Promise<void>;
+    createClaimNotification(claimItemInfo: EarningRewardItem, tokenInfo: _ChainAsset): Promise<void>;
     /** Can mint when haven't enough native token (use input token for fee) */
     get isPoolSupportAlternativeFee(): boolean;
     getPoolInfo(): Promise<YieldPoolInfo | undefined>;

package/services/earning-service/handlers/base.js

@@ -4,6 +4,7 @@
 import { ChainType } from '@subwallet/extension-base/background/KoniTypes';
 import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
 import { DEFAULT_YIELD_FIRST_STEP } from '@subwallet/extension-base/services/earning-service/constants';
+import { createClaimNotification, createWithdrawNotifications } from '@subwallet/extension-base/services/inapp-notification-service/utils';
 import { formatNumber, reformatAddress } from '@subwallet/extension-base/utils';
 import { BN, BN_TEN } from '@polkadot/util';
 
@@ -93,6 +94,14 @@ export default class BasePoolHandler {
       availableMethod: this.availableMethod
     };
   }
+  async createWithdrawNotifications(unstakingInfos, tokenInfo, address) {
+    const notifications = createWithdrawNotifications(unstakingInfos, tokenInfo, address, this.baseInfo.slug, this.type);
+    await this.state.inappNotificationService.validateAndWriteNotificationsToDB(notifications, address);
+  }
+  async createClaimNotification(claimItemInfo, tokenInfo) {
+    const notification = createClaimNotification(claimItemInfo, tokenInfo);
+    await this.state.inappNotificationService.validateAndWriteNotificationsToDB([notification], claimItemInfo.address);
+  }
 
   /** Can mint when haven't enough native token (use input token for fee) */
   get isPoolSupportAlternativeFee() {