@subwallet/extension-base 1.3.67-0 → 1.3.68-1

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

@@ -5,6 +5,7 @@ import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/K
 import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
 import { DEFAULT_YIELD_FIRST_STEP, STAKING_IDENTITY_API_SLUG } from '@subwallet/extension-base/services/earning-service/constants';
 import { createClaimNotification, createWithdrawNotifications } from '@subwallet/extension-base/services/inapp-notification-service/utils';
+import { BalanceType, YieldPoolType } from '@subwallet/extension-base/types';
 import { formatNumber, reformatAddress } from '@subwallet/extension-base/utils';
 import { BN, BN_TEN } from '@polkadot/util';
 /**
@@ -154,7 +155,12 @@ export default class BasePoolHandler {
     }
     const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(this.chain);
     // Use TRANSFER_BALANCE extrinsic in order to get transferable balanace without minus ED
-    const nativeTokenBalance = await this.state.balanceService.getTransferableBalance(request.address, this.chain, undefined, ExtrinsicType.TRANSFER_BALANCE);
+    let nativeTokenBalance;
+    if ([YieldPoolType.NATIVE_STAKING, YieldPoolType.NOMINATION_POOL].includes(poolInfo.type)) {
+      nativeTokenBalance = await this.state.balanceService.getBalanceByType(request.address, this.chain, undefined, BalanceType.TOTAL_MINUS_RESERVED, ExtrinsicType.TRANSFER_BALANCE);
+    } else {
+      nativeTokenBalance = await this.state.balanceService.getTransferableBalance(request.address, this.chain, undefined, ExtrinsicType.TRANSFER_BALANCE);
+    }
     const bnNativeTokenBalance = new BN(nativeTokenBalance.value);
     const bnMinBalanceToJoin = new BN(((_poolInfo$statistic2 = poolInfo.statistic) === null || _poolInfo$statistic2 === void 0 ? void 0 : (_poolInfo$statistic2$ = _poolInfo$statistic2.earningThreshold) === null || _poolInfo$statistic2$ === void 0 ? void 0 : _poolInfo$statistic2$.join) || '0').add(new BN(poolInfo.metadata.maintainBalance));
     if (bnNativeTokenBalance.lte(bnMinBalanceToJoin)) {

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

@@ -0,0 +1,9 @@
+import { NftFullListRequest } from '@subwallet/extension-base/background/KoniTypes';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+export default class NftService {
+    private inProgress;
+    private state;
+    constructor(state: KoniState);
+    fetchEvmCollectionsWithPreview(addresses: string[]): Promise<void>;
+    getFullNftInstancesByCollection(request: NftFullListRequest): Promise<boolean>;
+}

package/services/nft-service/index.js

@@ -0,0 +1,165 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { _AssetType } from '@subwallet/chain-list/types';
+import { _getEvmChainId } from '@subwallet/extension-base/services/chain-service/utils';
+import { baseParseIPFSUrl } from '@subwallet/extension-base/utils';
+import { getKeypairTypeByAddress } from '@subwallet/keyring';
+import { EthereumKeypairTypes } from '@subwallet/keyring/types';
+import subwalletApiSdk from '@subwallet-monorepos/subwallet-services-sdk';
+function mapSdkToNftItem(rawInstance, chain, collectionId, owner) {
+  var _rawInstance$token_ty, _rawInstance$token_ty2, _rawInstance$id;
+  const metadata = rawInstance.metadata || {};
+  const image = metadata.image || rawInstance.image_url || rawInstance.media_url || '';
+  const attributes = Array.isArray(metadata.attributes) ? metadata.attributes : [];
+  let rarity;
+  const properties = {};
+  for (const attr of attributes) {
+    try {
+      var _attr$trait_type;
+      const key = (_attr$trait_type = attr.trait_type) === null || _attr$trait_type === void 0 ? void 0 : _attr$trait_type.trim();
+      if (!key) {
+        continue;
+      }
+      let value = attr.value;
+      if (typeof value === 'string') {
+        const lower = value.toLowerCase();
+        if (lower === 'true') {
+          value = true;
+        } else if (lower === 'false') {
+          value = false;
+        }
+      }
+      properties[key] = value;
+      if (key.toLowerCase() === 'rarity') {
+        rarity = String(value);
+      }
+    } catch {}
+  }
+  const hasProperties = Object.keys(properties).length > 0;
+  const normalizedType = (_rawInstance$token_ty = rawInstance.token_type) === null || _rawInstance$token_ty === void 0 ? void 0 : (_rawInstance$token_ty2 = _rawInstance$token_ty.replace('-', '')) === null || _rawInstance$token_ty2 === void 0 ? void 0 : _rawInstance$token_ty2.toUpperCase();
+
+  // Only support ERC721
+  if (normalizedType !== 'ERC721') {
+    return null;
+  }
+  return {
+    id: (_rawInstance$id = rawInstance.id) === null || _rawInstance$id === void 0 ? void 0 : _rawInstance$id.toString(),
+    chain,
+    collectionId,
+    owner: rawInstance.owner || owner,
+    originAsset: undefined,
+    name: metadata.name || `#${rawInstance.id}`,
+    image: baseParseIPFSUrl(image),
+    externalUrl: rawInstance.external_app_url || undefined,
+    rarity,
+    description: metadata.description || undefined,
+    properties: hasProperties ? properties : null,
+    type: normalizedType === 'ERC721' ? _AssetType.ERC721 : _AssetType.ERC721,
+    // currently only support ERC721
+    rmrk_ver: undefined,
+    onChainOption: undefined,
+    assetHubType: undefined
+  };
+}
+function mapSdkToCollection(raw, chain) {
+  var _raw$token_instances;
+  const token = raw.token || {};
+  return {
+    // must-have
+    collectionId: token.address_hash,
+    chain,
+    originAsset: undefined,
+    // optional
+    collectionName: token.name || token.symbol || 'Unknown Collection',
+    image: token.icon_url || undefined,
+    itemCount: Number(raw.amount) || ((_raw$token_instances = raw.token_instances) === null || _raw$token_instances === void 0 ? void 0 : _raw$token_instances.length) || 0,
+    externalUrl: undefined
+  };
+}
+export default class NftService {
+  inProgress = new Set();
+  constructor(state) {
+    this.state = state;
+  }
+  async fetchEvmCollectionsWithPreview(addresses) {
+    for (const address of addresses) {
+      const type = getKeypairTypeByAddress(address);
+      const typeValid = [...EthereumKeypairTypes].includes(type);
+      if (typeValid) {
+        if (this.inProgress.has(address)) {
+          console.log(`[NftService] ${address} already running`);
+          continue;
+        }
+        this.inProgress.add(address);
+        try {
+          const nftDetectionApi = subwalletApiSdk.nftDetectionApi;
+          if (!(nftDetectionApi !== null && nftDetectionApi !== void 0 && nftDetectionApi.getEvmNftCollectionsByAddress)) {
+            console.warn('[NftService] NftDetectionApi not available');
+            continue;
+          }
+          const rawData = await nftDetectionApi.getEvmNftCollectionsByAddress(address);
+          const allItems = [];
+          const allCollections = [];
+          for (const [chain, collections] of Object.entries(rawData)) {
+            if (!Array.isArray(collections)) {
+              continue;
+            }
+            for (const col of collections) {
+              const mappedCollection = mapSdkToCollection(col, chain);
+              allCollections.push(mappedCollection);
+              if (Array.isArray(col.token_instances)) {
+                const items = col.token_instances.map(inst => mapSdkToNftItem(inst, chain, mappedCollection.collectionId, address)).filter(i => Boolean(i));
+                allItems.push(...items);
+              }
+            }
+          }
+          await this.state.handleDetectedNftCollections(allCollections);
+          await this.state.handleDetectedNfts(address, allItems);
+        } catch (err) {
+          console.warn(`[NftService] detect error for ${address}`, err);
+        } finally {
+          this.inProgress.delete(address);
+        }
+      }
+    }
+  }
+  async getFullNftInstancesByCollection(request) {
+    const {
+      chainInfo,
+      contractAddress,
+      owners
+    } = request;
+    const chainId = _getEvmChainId(chainInfo);
+    if (!contractAddress || !owners || !chainId) {
+      console.warn('[NftService] missing params for getFullNftInstancesByCollection');
+      return false;
+    }
+    try {
+      const nftDetectionApi = subwalletApiSdk.nftDetectionApi;
+      if (!(nftDetectionApi !== null && nftDetectionApi !== void 0 && nftDetectionApi.getAllNftInstances)) {
+        console.warn('[NftService] getAllNftInstances not available');
+        return false;
+      }
+      const ownerList = Array.isArray(owners) ? owners : [owners];
+      for (const eachOwner of ownerList) {
+        try {
+          const instances = await nftDetectionApi.getAllNftInstances(contractAddress, eachOwner, chainId.toString());
+          if (!Array.isArray(instances)) {
+            continue;
+          }
+          console.log('FOR TESTER (before)', instances);
+          const nftList = instances.map(inst => mapSdkToNftItem(inst, chainInfo.slug, contractAddress, eachOwner)).filter(i => Boolean(i));
+          console.log('FOR TESTER (after)', nftList);
+          await this.state.handleDetectedNfts(eachOwner, nftList);
+        } catch (innerErr) {
+          console.warn(`[NftService] getAllNftInstances failed for ${eachOwner}`, innerErr);
+        }
+      }
+      return true;
+    } catch (err) {
+      console.error(`[NftDetectionService] getFullNftInstancesByCollection error for ${contractAddress}`, err);
+      return false;
+    }
+  }
+}

package/services/transaction-service/index.js

@@ -127,7 +127,7 @@ export default class TransactionService {
     // Check account signing transaction
 
     checkSigningAccountForTransaction(validationResponse, chainInfoMap);
-    const nativeTokenAvailable = await this.state.balanceService.getTransferableBalance(address, chain, nativeTokenInfo.slug, extrinsicType);
+    const nativeTokenAvailable = await this.state.balanceService.getBalanceByType(address, chain, nativeTokenInfo.slug, transactionInput.balanceType, extrinsicType);
 
     // Check available balance against transaction fee
     checkBalanceWithTransactionFee(validationResponse, transactionInput, nativeTokenInfo, nativeTokenAvailable);

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

@@ -2,7 +2,7 @@ import { ChainType, ExtrinsicDataTypeMap, ExtrinsicStatus, ExtrinsicType, FeeDat
 import { SignTypedDataMessageV3V4 } from '@subwallet/extension-base/core/logic-validation';
 import { TonTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
 import { UniswapOrderInfo } from '@subwallet/extension-base/services/swap-service/handler/uniswap-handler';
-import { BaseRequestSign, BriefProcessStep, ProcessTransactionData, TransactionFee } from '@subwallet/extension-base/types';
+import { BalanceType, BaseRequestSign, BriefProcessStep, ProcessTransactionData, TransactionFee } from '@subwallet/extension-base/types';
 import { Psbt } from 'bitcoinjs-lib';
 import EventEmitter from 'eventemitter3';
 import { TransactionConfig } from 'web3-core';
@@ -61,6 +61,7 @@ export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransact
     resolveOnDone?: boolean;
     skipFeeValidation?: boolean;
     skipFeeRecalculation?: boolean;
+    balanceType?: BalanceType;
 }
 export interface SWPermitTransactionInput extends Omit<SWTransactionInput, 'transaction'> {
     transaction?: SWPermitTransaction['transaction'] | null;

package/types/balance/index.d.ts

@@ -8,6 +8,12 @@ export interface TokenBalanceRaw {
     frozen: BN;
     free: BN;
 }
+export declare enum BalanceType {
+    TRANSFERABLE = "transferable",
+    TOTAL = "total",
+    TOTAL_MINUS_RESERVED = "totalMinusReserved",
+    KEEP_ALIVE = "keepAlive"
+}
 /**
  * Balance info of a token on an address
  * @property {string} address - Address
@@ -18,6 +24,13 @@ export interface TokenBalanceRaw {
  * @property {string} locked - Locked balance, cannot be transferred, locked here is only meaningful in the context of token transfer
  * @property {metadata} [metadata] - Could be anything, supposed to be generic to handle various contexts
  */
+export interface LockedBalanceDetails {
+    staking: string;
+    governance: string;
+    democracy: string;
+    reserved: string;
+    others: string;
+}
 export interface BalanceItem {
     address: string;
     tokenSlug: string;
@@ -25,6 +38,7 @@ export interface BalanceItem {
     timestamp?: number;
     free: string;
     locked: string;
+    lockedDetails?: LockedBalanceDetails;
     metadata?: _BalanceMetadata;
 }
 /** Balance info of all tokens on an address */

package/types/balance/index.js

@@ -1 +1,21 @@
-export {};
+// Copyright 2019-2022 @subwallet/extension-koni-ui authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export let BalanceType;
+
+/**
+ * Balance info of a token on an address
+ * @property {string} address - Address
+ * @property {string} tokenSlug - Slug of token
+ * @property {APIItemState} state - State of information
+ * @property {number} [timestamp] - Time to get information
+ * @property {string} free - Transferable balance
+ * @property {string} locked - Locked balance, cannot be transferred, locked here is only meaningful in the context of token transfer
+ * @property {metadata} [metadata] - Could be anything, supposed to be generic to handle various contexts
+ */
+(function (BalanceType) {
+  BalanceType["TRANSFERABLE"] = "transferable";
+  BalanceType["TOTAL"] = "total";
+  BalanceType["TOTAL_MINUS_RESERVED"] = "totalMinusReserved";
+  BalanceType["KEEP_ALIVE"] = "keepAlive";
+})(BalanceType || (BalanceType = {}));

package/utils/index.js

@@ -273,13 +273,36 @@ export const stripUrl = url => {
   return parts[2];
 };
 export const baseParseIPFSUrl = (input, customDomain) => {
-  const selectedDomain = customDomain || getRandomIpfsGateway();
   if (!input || input.length === 0) {
     return undefined;
   }
-  if (isUrl(input)) {
+
+  // Case 1: Return as-is for inline data URLs (e.g. base64-encoded images)
+  if (input.startsWith('data:')) {
     return input;
   }
+  const selectedDomain = customDomain || getRandomIpfsGateway();
+
+  // Case 2: Replace Pinata private gateways with a public IPFS gateway
+  // ==== EX: https://ikzttp.mypinata.cloud/ipfs/QmYDvPAXtiJg7s8JdRBSLWdgSphQdac8j1YuQNNxcGE1hg/9586.png
+  // Case 2b: Blockscout IPFS debug gateway -> rewrite to public gateway
+  // ==== EX: http://ipfs-debug.node.blockscout.com/ipfs/QmX2qHy1o27KgmHJSG2wKj2qLiv1gMCJCTn4nxzEVtTdgF
+  // Case 2c: http://ipfs.node.blockscout.com/ipfs/QmeTETrnJcG3iowfT3tXtz2jKmyeYbeag3AeYfDk5pBjGg
+
+  const privateGatewayPattern = /https?:\/\/([^/]*pinata\.cloud|[^/]*\.node\.blockscout\.com)\/ipfs\//;
+  if (privateGatewayPattern.test(input)) {
+    return input.replace(privateGatewayPattern, selectedDomain);
+  }
+
+  // Case 3: Handle NFT.storage subdomain links (e.g. https://<cid>.ipfs.nftstorage.link/...)
+  // Always redirect to selectedDomain to avoid SSL version/cipher mismatch errors
+  // ==== EX: https://bafybeias6as7k66hkghst3w4jwk6x5dkfk56oglqh44x6jmok6n7kcvg7m.ipfs.nftstorage.link/0.gif?ext=gif
+  const nftStorageMatch = input.match(/^https?:\/\/([a-zA-Z0-9]+)\.ipfs\.nftstorage\.link\/(.*)$/);
+  if (nftStorageMatch) {
+    const cid = nftStorageMatch[1];
+    const pathAndQuery = nftStorageMatch[2] || '';
+    return `${selectedDomain}${cid}/${pathAndQuery}`;
+  }
   if (isUrl(input) || input.includes('https://') || input.includes('http')) {
     return input;
   }

package/utils/setup-api-sdk.js

@@ -1,7 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { APP_VERSION, BACKEND_API_URL, BACKEND_PRICE_HISTORY_URL } from '@subwallet/extension-base/constants';
+import { APP_VERSION, BACKEND_API_URL } from '@subwallet/extension-base/constants';
 import subwalletApiSdk from '@subwallet-monorepos/subwallet-services-sdk';
 import { TARGET_ENV } from "./environment.js";
 const CHAIN_LIST_VERSION = process.env.CHAIN_LIST_VERSION;
@@ -12,9 +12,4 @@ export function setupApiSDK() {
     platform: TARGET_ENV,
     chainListVersion: CHAIN_LIST_VERSION
   });
-
-  // Custom the price history API with other different base URL
-  subwalletApiSdk.priceHistoryApi.updateConfig({
-    baseUrl: BACKEND_PRICE_HISTORY_URL
-  });
 }