@subwallet/extension-base 1.3.78-0 → 1.3.80-0

package/services/balance-service/index.js

@@ -613,10 +613,10 @@ export class BalanceService {
       return getDefaultTransferProcess();
     }
     const destChainInfo = this.state.chainService.getChainInfoByKey(params.destChain);
+    const evmApi = this.state.chainService.getEvmApi(originChainInfo.slug);
 
     // xcm
     if (!_isXcmWithinSameConsensus(originChainInfo, destChainInfo) && _isPureEvmChain(originChainInfo)) {
-      const evmApi = this.state.chainService.getEvmApi(originChainInfo.slug);
       const tokenInfo = this.state.chainService.getAssetBySlug(params.tokenSlug);
       return getSnowbridgeTransferProcessFromEvm(params.address, evmApi, tokenInfo, params.amount);
     }
@@ -644,7 +644,7 @@ export class BalanceService {
         if (!data) {
           throw new Error('Failed to fetch Across Bridge Data. Please try again later');
         }
-        return getAcrossbridgeTransferProcessFromEvm(data.to);
+        return getAcrossbridgeTransferProcessFromEvm(data.to, params.address, originTokenInfo, evmApi, params.amount);
       }
     }
     return getDefaultTransferProcess();

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

@@ -13,7 +13,7 @@ import { fetchFromProxyService } from '@subwallet/extension-base/utils';
 import BigNumber from 'bignumber.js';
 import { assert, compactToU8a, isHex, u8aConcat, u8aEq } from '@polkadot/util';
 import { _isBittensorToSubtensorBridge, _isSubtensorToBittensorBridge } from "./bittensorBridge/index.js";
-const version = '/v5';
+const version = '/v1';
 const paraSpellApi = {
   buildXcm: `${version}/x-transfer`,
   feeXcm: `${version}/xcm-fee`,
@@ -93,8 +93,8 @@ export async function buildXcm(request) {
   }
   const paraSpellChainMap = await fetchParaSpellChainMap();
   const bodyData = {
-    senderAddress: sender,
-    address: recipient,
+    sender,
+    recipient,
     from: paraSpellChainMap[originChain.slug],
     to: paraSpellChainMap[destinationChain.slug],
     currency: createParaSpellCurrency(paraSpellIdentifyV4, sendingValue),
@@ -134,8 +134,8 @@ export async function dryRunXcm(request) {
     throw new Error('Token is not support XCM at this time');
   }
   const bodyData = {
-    senderAddress: sender,
-    address: recipient,
+    sender,
+    recipient,
     from: paraSpellChainMap[originChain.slug],
     to: paraSpellChainMap[destinationChain.slug],
     currency: createParaSpellCurrency(paraSpellIdentifyV4, sendingValue),
@@ -178,8 +178,8 @@ export async function dryRunPreviewXcm(request) {
     throw new Error('Token is not support XCM at this time');
   }
   const bodyData = {
-    senderAddress: sender,
-    address: recipient,
+    sender,
+    recipient,
     from: paraSpellChainMap[originChain.slug],
     to: paraSpellChainMap[destinationChain.slug],
     currency: createParaSpellCurrency(paraSpellIdentifyV4, sendingValue),
@@ -226,8 +226,8 @@ export async function estimateXcmFee(request) {
     return undefined;
   }
   const bodyData = {
-    senderAddress: sender,
-    address: recipient,
+    sender,
+    recipient,
     from: paraSpellChainMap[fromChainInfo.slug],
     to: paraSpellChainMap[toChainInfo.slug],
     currency: createParaSpellCurrency(paraSpellIdentifyV4, requestValue),

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

@@ -52,6 +52,9 @@ export declare const _NFT_CHAIN_GROUP: {
     rari: string[];
     story_odyssey: string[];
 };
+export declare const NFT_CHAIN_GROUPS_MIGRATED: {
+    unique_network: string[];
+};
 export declare const _STAKING_ERA_LENGTH_MAP: Record<string, number>;
 export declare const _EXPECTED_BLOCK_TIME: Record<string, number>;
 export declare const _PARACHAIN_INFLATION_DISTRIBUTION: Record<string, Record<string, number>>;

package/services/chain-service/constants.js

@@ -67,6 +67,9 @@ export const _NFT_CHAIN_GROUP = {
   rari: ['rari'],
   story_odyssey: ['storyOdyssey', 'storyOdyssey_testnet']
 };
+export const NFT_CHAIN_GROUPS_MIGRATED = {
+  unique_network: ['unique_network']
+};
 
 // Staking--------------------------------------------------------------------------------------------------------------
 

package/services/earning-service/handlers/native-staking/dtao.js

@@ -9,20 +9,19 @@ import { reformatAddress } from '@subwallet/extension-base/utils';
 import BigN from 'bignumber.js';
 import { BN_ZERO } from '@polkadot/util';
 import TaoNativeStakingPoolHandler, { DEFAULT_DTAO_MINBOND } from "./tao.js";
-const getAlphaToTaoRateMap = async substrateApi => {
-  const allSubnets = (await substrateApi.api.call.subnetInfoRuntimeApi.getAllDynamicInfo()).toJSON();
-  if (!allSubnets || allSubnets.length === 0) {
-    return {};
-  }
+const getAlphaToTaoRateMap = async (substrateApi, priceScaleDecimals = 9) => {
   const result = Object.create(null);
-  for (const subnet of allSubnets) {
-    const netuid = subnet === null || subnet === void 0 ? void 0 : subnet.netuid;
-    if (netuid === undefined) {
-      continue;
+  const PRICE_SCALE = new BigN(10).pow(priceScaleDecimals);
+  const allSubnetPrices = (await substrateApi.api.call.swapRuntimeApi.currentAlphaPriceAll()).toJSON();
+  if (allSubnetPrices && allSubnetPrices.length > 0) {
+    for (const subnetPrice of allSubnetPrices) {
+      const netuid = subnetPrice === null || subnetPrice === void 0 ? void 0 : subnetPrice.netuid;
+      if (netuid === undefined) {
+        continue;
+      }
+      const rawPrice = subnetPrice !== null && subnetPrice !== void 0 && subnetPrice.price ? new BigN(subnetPrice.price) : new BigN(0);
+      result[netuid] = netuid === 0 ? '1' : rawPrice.dividedBy(PRICE_SCALE).toFixed();
     }
-    const taoIn = subnet !== null && subnet !== void 0 && subnet.taoIn ? new BigN(subnet.taoIn) : new BigN(0);
-    const alphaIn = subnet !== null && subnet !== void 0 && subnet.alphaIn ? new BigN(subnet.alphaIn) : new BigN(0);
-    result[netuid] = netuid === 0 || alphaIn.lte(0) ? '1' : taoIn.dividedBy(alphaIn).toString();
   }
   return result;
 };
@@ -204,7 +203,7 @@ export default class SubnetTaoStakingPoolHandler extends TaoNativeStakingPoolHan
     const getPoolPosition = async () => {
       const rawDelegateStateInfos = await substrateApi.api.call.stakeInfoRuntimeApi.getStakeInfoForColdkeys(useAddresses);
       const delegateStateInfos = rawDelegateStateInfos.toPrimitive();
-      const alphaToTaoRateMap = await getAlphaToTaoRateMap(this.substrateApi);
+      const alphaToTaoRateMap = await getAlphaToTaoRateMap(this.substrateApi, this.getAlphaPriceScaleDecimals());
       if (!delegateStateInfos || delegateStateInfos.length === 0) {
         return;
       }

package/services/earning-service/handlers/native-staking/tao.d.ts

@@ -82,10 +82,11 @@ export declare class BittensorCache {
     fetchApr(netuid: number): Promise<ValidatorAprResponse>;
     fetchSubnetFeeRate(netuid: number): Promise<string>;
 }
-export declare const getAlphaToTaoRate: (substrateApi: _SubstrateApi, netuid: number) => Promise<string>;
+export declare const getAlphaToTaoRate: (substrateApi: _SubstrateApi, netuid: number, priceScaleDecimals?: number) => Promise<string>;
 export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHandler {
     readonly availableMethod: YieldPoolMethodInfo;
     protected bittensorCache: BittensorCache;
+    protected getAlphaPriceScaleDecimals(): number;
     protected getMinBond(netuid?: number): Promise<BigN>;
     constructor(state: KoniState, chain: string);
     get maintainBalance(): string;

package/services/earning-service/handlers/native-staking/tao.js

@@ -113,14 +113,16 @@ export class BittensorCache {
     }
   }
 }
-export const getAlphaToTaoRate = async (substrateApi, netuid) => {
-  const subnetInfo = (await substrateApi.api.call.subnetInfoRuntimeApi.getDynamicInfo(netuid)).toJSON();
-  if (!subnetInfo) {
+export const getAlphaToTaoRate = async (substrateApi, netuid, priceScaleDecimals = 9) => {
+  if (netuid === 0) {
     return '1';
   }
-  const taoIn = subnetInfo.taoIn ? new BigN(subnetInfo.taoIn) : new BigN(0);
-  const alphaIn = subnetInfo.alphaIn ? new BigN(subnetInfo.alphaIn) : new BigN(0);
-  return netuid === 0 || alphaIn.lte(0) ? '1' : taoIn.dividedBy(alphaIn).toString();
+  const [rawSubnetPrice, rawRootPrice] = await Promise.all([substrateApi.api.call.swapRuntimeApi.currentAlphaPrice(netuid), substrateApi.api.call.swapRuntimeApi.currentAlphaPrice(0)]);
+  const subnetPrice = new BigN(rawSubnetPrice.toString());
+  const defaultScale = new BigN(10).pow(priceScaleDecimals);
+  const rootPrice = new BigN(rawRootPrice.toString());
+  const priceScale = rootPrice.lte(0) ? defaultScale : rootPrice;
+  return subnetPrice.lte(0) ? '0' : subnetPrice.dividedBy(priceScale).toFixed();
 };
 export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHandler {
   availableMethod = {
@@ -132,6 +134,9 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
     claimReward: false,
     changeValidator: true
   };
+  getAlphaPriceScaleDecimals() {
+    return _getAssetDecimals(this.nativeToken);
+  }
   async getMinBond(netuid) {
     var _cachedPool$metadata2, _cachedPool$statistic, _cachedPool$statistic2, _onlinePool$metadata2, _onlinePool$statistic, _onlinePool$statistic2;
     // @ts-ignore
@@ -469,7 +474,7 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
     const hotkey = selectedValidatorInfo.address;
     const netuid = (_subnetData$netuid = subnetData === null || subnetData === void 0 ? void 0 : subnetData.netuid) !== null && _subnetData$netuid !== void 0 ? _subnetData$netuid : 0;
     const slippage = (_subnetData$slippage = subnetData === null || subnetData === void 0 ? void 0 : subnetData.slippage) !== null && _subnetData$slippage !== void 0 ? _subnetData$slippage : DEFAULT_BITTENSOR_SLIPPAGE;
-    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid));
+    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid, this.getAlphaPriceScaleDecimals()));
     const limitPrice = alphaToTaoPrice.multipliedBy(10 ** _getAssetDecimals(this.nativeToken)).multipliedBy(1 + slippage);
     const BNlimitPrice = new BigN(limitPrice.integerValue(BigN.ROUND_CEIL).toFixed());
     const extrinsic = chainApi.api.tx.subtensorModule.addStakeLimit(hotkey, netuid, binaryAmount.toFixed(), BNlimitPrice.toFixed(), false);
@@ -511,7 +516,7 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
       return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
     }
     const binaryAmount = new BigN(amount);
-    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid));
+    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid, this.getAlphaPriceScaleDecimals()));
     const limitPrice = alphaToTaoPrice.multipliedBy(10 ** _getAssetDecimals(this.nativeToken)).multipliedBy(1 - slippage);
     const BNlimitPrice = new BigN(limitPrice.integerValue(BigN.ROUND_CEIL).toFixed());
     const extrinsic = apiPromise.api.tx.subtensorModule.removeStakeLimit(selectedTarget, netuid, binaryAmount.toFixed(), BNlimitPrice.toFixed(), false);
@@ -527,7 +532,7 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
       return [new TransactionError(BasicTxErrorType.INVALID_PARAMS)];
     }
     const netuid = (_poolInfo$metadata$su = poolInfo.metadata.subnetData) === null || _poolInfo$metadata$su === void 0 ? void 0 : _poolInfo$metadata$su.netuid;
-    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid || 0));
+    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid || 0, this.getAlphaPriceScaleDecimals()));
     const minDelegatorStake = await this.getMinBond(netuid);
     const minUnstake = minDelegatorStake.dividedBy(alphaToTaoPrice);
     if (new BigN(amount).lt(minUnstake)) {
@@ -567,7 +572,7 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
     if (originValidator === destValidator) {
       return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('bg.EARNING.services.service.earning.nativeStaking.tao.fromValidatorSameAsTo')));
     }
-    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid));
+    const alphaToTaoPrice = new BigN(await getAlphaToTaoRate(this.substrateApi, netuid, this.getAlphaPriceScaleDecimals()));
     const bnMinStake = await this.getMinBond(netuid);
     const minUnstake = bnMinStake.dividedBy(alphaToTaoPrice);
     const formattedMinUnstake = minUnstake.dividedBy(1000000).integerValue(BigN.ROUND_CEIL).dividedBy(1000);

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

@@ -10,7 +10,7 @@ import { estimateXcmFee } from '@subwallet/extension-base/services/balance-servi
 import { _getAssetDecimals, _getAssetExistentialDeposit, _getAssetSymbol, _getChainName, _getChainNativeTokenSlug } from '@subwallet/extension-base/services/chain-service/utils';
 import { MIN_XCM_LIQUID_STAKING_DOT } from '@subwallet/extension-base/services/earning-service/constants';
 import { BasicTxErrorType, YieldStepType, YieldValidationStatus } from '@subwallet/extension-base/types';
-import { createPromiseHandler, formatNumber } from '@subwallet/extension-base/utils';
+import { _reformatAddressWithChain, createPromiseHandler, formatNumber } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import BigN from 'bignumber.js';
 import { t } from 'i18next';
@@ -248,6 +248,7 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
           }
           const metadata = {
             sendingValue,
+            xcmDestinationFee,
             originTokenInfo: altInputTokenInfo,
             destinationTokenInfo: inputTokenInfo
           };
@@ -459,11 +460,13 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     const {
       destinationTokenInfo,
       originTokenInfo,
-      sendingValue
+      sendingValue,
+      xcmDestinationFee
     } = metadata;
     const originChainInfo = this.state.getChainInfo(originTokenInfo.originChain);
     const originTokenSlug = _getChainNativeTokenSlug(originChainInfo);
     const substrateApi = this.state.getSubstrateApi(originChainInfo.slug);
+    const fromAddress = _reformatAddressWithChain(address, originChainInfo);
     const id = getId();
     const feeInfo = await this.state.feeService.subscribeChainFee(id, originChainInfo.slug, 'substrate');
     const xcmRequest = {
@@ -472,7 +475,7 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
       recipient: address,
       sendingValue,
       substrateApi,
-      sender: address,
+      sender: fromAddress,
       originChain: originChainInfo,
       destinationChain: this.chainInfo,
       feeInfo
@@ -484,7 +487,7 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     const xcmData = {
       originNetworkKey: originChainInfo.slug,
       destinationNetworkKey: destinationTokenInfo.originChain,
-      from: address,
+      from: fromAddress,
       to: address,
       value: sendingValue,
       tokenSlug: originTokenSlug,
@@ -497,7 +500,12 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
       txData: xcmData,
       transferNativeAmount: sendingValue,
       chainType: ChainType.SUBSTRATE,
-      xcmStepFee
+      xcmStepFee,
+      xcmDestinationFee: xcmDestinationFee ? {
+        decimals: _getAssetDecimals(destinationTokenInfo),
+        symbol: _getAssetSymbol(destinationTokenInfo),
+        value: xcmDestinationFee
+      } : undefined
     };
   }
   handleYieldJoin(data, path, currentStep) {

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

@@ -1,9 +1,45 @@
-import { NftFullListRequest } from '@subwallet/extension-base/background/KoniTypes';
+import { NftCollection, NftDetailRequest, NftFullListRequest, NftItem, NftJson } from '@subwallet/extension-base/background/KoniTypes';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
-export default class NftService {
-    private inProgress;
-    private state;
+import { ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
+import { PromiseHandler } from '@subwallet/extension-base/utils';
+export interface NftState {
+    nftData: NftJson;
+    nftCollections: NftCollection[];
+}
+export declare class NftService implements StoppableServiceInterface {
+    private readonly state;
+    private readonly multiChainFetcher;
+    private _intervalFetchNft;
+    private readonly NFT_INTERVAL_TIME;
+    private readonly nftStateSubject;
+    readonly nftState$: import("rxjs").Observable<NftState>;
+    private isReloading;
+    startPromiseHandler: PromiseHandler<void>;
+    stopPromiseHandler: PromiseHandler<void>;
+    status: ServiceStatus;
+    get isStarted(): boolean;
     constructor(state: KoniState);
-    fetchEvmCollectionsWithPreview(addresses: string[]): Promise<void>;
-    getFullNftInstancesByCollection(request: NftFullListRequest): Promise<boolean>;
+    init(): Promise<void>;
+    private loadCachedData;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    waitForStarted(): Promise<void>;
+    waitForStopped(): Promise<void>;
+    private checkIfNftUpdateNeeded;
+    private extractUpdatedChains;
+    private hasNftSupportedChainUpdate;
+    private isChainNftSupported;
+    private handleImmediateRefresh;
+    private scheduleLazyRefresh;
+    private handleEvents;
+    fetchFullListNftOfACollection(request: NftFullListRequest): Promise<boolean>;
+    fetchNftDetail(request: NftDetailRequest): Promise<NftItem | null>;
+    private startScanNft;
+    private stopScanNft;
+    private persistNftData;
+    private refreshNftData;
+    /** Subscribe NFT state */
+    subscribeNftItem(): import("rxjs").Observable<NftState>;
+    subscribeNftCollection(): import("dexie").Observable<NftCollection[]>;
+    forceReload(): Promise<void>;
 }