@subwallet/extension-base 1.3.31-1 → 1.3.33-0

package/services/price-service/coingecko.js

@@ -3,6 +3,7 @@
 
 import { isProductionMode } from '@subwallet/extension-base/constants';
 import { staticData, StaticKey } from '@subwallet/extension-base/utils/staticData';
+import { subwalletApiSdk } from '@subwallet/subwallet-api-sdk';
 import { isArray } from '@polkadot/util';
 const DEFAULT_CURRENCY = 'USD';
 const DERIVATIVE_TOKEN_SLUG_LIST = ['susds', 'savings-dai'];
@@ -101,11 +102,13 @@ export const getPriceMap = async (priceIds, currency = 'USD') => {
     const currencyData = staticData[StaticKey.CURRENCY_SYMBOL][currency || DEFAULT_CURRENCY];
     const priceMap = {};
     const price24hMap = {};
+    const lastUpdatedMap = {};
     responseDataPrice.forEach(val => {
       const currentPrice = val.current_price || 0;
       const price24h = currentPrice - (val.price_change_24h || 0);
       priceMap[val.id] = currentPrice;
       price24hMap[val.id] = price24h;
+      lastUpdatedMap[val.id] = new Date(val.last_updated || val.last_updated_at || Date.now());
     });
     const derivativeTokenSlugs = await fetchDerivativeTokenSlugs();
 
@@ -123,9 +126,24 @@ export const getPriceMap = async (priceIds, currency = 'USD') => {
       currency,
       currencyData,
       priceMap,
-      price24hMap
+      price24hMap,
+      lastUpdatedMap
     };
   } catch (e) {
     return {};
   }
+};
+export const getHistoryPrice = async (priceId, type) => {
+  try {
+    var _subwalletApiSdk$pric;
+    const response = await ((_subwalletApiSdk$pric = subwalletApiSdk.priceHistoryApi) === null || _subwalletApiSdk$pric === void 0 ? void 0 : _subwalletApiSdk$pric.getPriceHistory(priceId, type));
+    if (response) {
+      return response;
+    }
+  } catch (e) {
+    console.error('Error fetching price history:', e);
+  }
+  return {
+    history: []
+  };
 };

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

@@ -1,4 +1,4 @@
-import { CurrencyType, PriceJson } from '@subwallet/extension-base/background/KoniTypes';
+import { CurrencyType, CurrentTokenPrice, HistoryTokenPriceJSON, PriceChartTimeframe, PriceJson } from '@subwallet/extension-base/background/KoniTypes';
 import { CronServiceInterface, PersistDataServiceInterface, ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { EventService } from '@subwallet/extension-base/services/event-service';
@@ -12,6 +12,7 @@ export declare class PriceService implements StoppableServiceInterface, PersistD
     private priceSubject;
     private rawPriceSubject;
     private rawExchangeRateMap;
+    private historyTokenPriceSubject;
     private refreshTimeout;
     private priceIds;
     private readonly currency;
@@ -28,6 +29,15 @@ export declare class PriceService implements StoppableServiceInterface, PersistD
     getPriceIds(): Set<string>;
     setPriceCurrency(newCurrencyCode: CurrencyType): Promise<boolean>;
     refreshPriceData(priceIds?: Set<string>): void;
+    getHistoryTokenPriceData(priceId: string, timeframe: PriceChartTimeframe): Promise<HistoryTokenPriceJSON>;
+    subscribeCurrentTokenPrice(priceId: string, callback: (price: CurrentTokenPrice) => void): {
+        unsubscribe: () => void;
+        currentPrice: {
+            value: number;
+            value24h: number;
+            time: number;
+        };
+    };
     init(): Promise<void>;
     loadData(): Promise<void>;
     persistData(): Promise<void>;

package/services/price-service/index.js

@@ -3,13 +3,13 @@
 
 import { CRON_REFRESH_PRICE_INTERVAL, CURRENCY } from '@subwallet/extension-base/constants';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
-import { getExchangeRateMap, getPriceMap } from '@subwallet/extension-base/services/price-service/coingecko';
+import { getExchangeRateMap, getHistoryPrice, getPriceMap } from '@subwallet/extension-base/services/price-service/coingecko';
 import { SWStorage } from '@subwallet/extension-base/storage';
 import { CurrentCurrencyStore } from '@subwallet/extension-base/stores';
-import { wait } from '@subwallet/extension-base/utils';
+import { getTokenPriceHistoryId, TIME_INTERVAL, wait } from '@subwallet/extension-base/utils';
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import { staticData, StaticKey } from '@subwallet/extension-base/utils/staticData';
-import { BehaviorSubject, combineLatest } from 'rxjs';
+import { BehaviorSubject, combineLatest, distinctUntilChanged, map } from 'rxjs';
 const DEFAULT_CURRENCY = 'USD';
 const DEFAULT_PRICE_SUBJECT = {
   currency: DEFAULT_CURRENCY,
@@ -21,7 +21,8 @@ const DEFAULT_PRICE_SUBJECT = {
   },
   priceMap: {},
   price24hMap: {},
-  exchangeRateMap: {}
+  exchangeRateMap: {},
+  lastUpdatedMap: {}
 };
 const checkFetchSuccess = (obj1, obj2) => {
   return Object.keys(obj1).length > 0 && Object.keys(obj2).length > 0;
@@ -35,6 +36,7 @@ export class PriceService {
     });
     this.rawPriceSubject = new BehaviorSubject({});
     this.rawExchangeRateMap = new BehaviorSubject({});
+    this.historyTokenPriceSubject = new BehaviorSubject({});
     this.status = ServiceStatus.NOT_INITIALIZED;
     this.dbService = dbService;
     this.eventService = eventService;
@@ -92,6 +94,7 @@ export class PriceService {
   }
   async calculatePriceMap(currency) {
     let {
+      lastUpdatedMap,
       price24hMap,
       priceMap
     } = this.rawPriceSubject.value;
@@ -122,7 +125,10 @@ export class PriceService {
       },
       currency: currencyKey,
       exchangeRateMap: exchangeRateData,
-      currencyData: staticData[StaticKey.CURRENCY_SYMBOL][currencyKey || DEFAULT_CURRENCY]
+      currencyData: staticData[StaticKey.CURRENCY_SYMBOL][currencyKey || DEFAULT_CURRENCY],
+      lastUpdatedMap: {
+        ...lastUpdatedMap
+      }
     };
     if (currencyKey === DEFAULT_CURRENCY) {
       return finalPriceMap;
@@ -164,6 +170,73 @@ export class PriceService {
     });
     this.refreshTimeout = setTimeout(this.refreshPriceData.bind(this), CRON_REFRESH_PRICE_INTERVAL);
   }
+  async getHistoryTokenPriceData(priceId, timeframe) {
+    var _this$rawExchangeRate;
+    const id = getTokenPriceHistoryId(priceId, timeframe);
+    const currentData = this.historyTokenPriceSubject.value[id];
+    const now = Date.now();
+    const timeInterval = TIME_INTERVAL[timeframe];
+    let history = currentData ? structuredClone(currentData) : undefined;
+    const needsRefresh = !history || history.length === 0 || now - history[history.length - 1].time > timeInterval;
+    if (needsRefresh) {
+      const {
+        history: newHistory
+      } = await getHistoryPrice(priceId, timeframe);
+      if (newHistory.length > 0) {
+        history = newHistory;
+
+        // Update internal cache
+        this.historyTokenPriceSubject.next({
+          ...this.historyTokenPriceSubject.value,
+          [id]: structuredClone(history)
+        });
+      }
+    }
+    if (!history) {
+      return {
+        history: []
+      };
+    }
+
+    // Resolve current currency
+    const {
+      promise,
+      resolve
+    } = createPromiseHandler();
+    this.getCurrentCurrency(resolve);
+    const currencyKey = await promise;
+    const exchangeRate = (_this$rawExchangeRate = this.rawExchangeRateMap.value[currencyKey || DEFAULT_CURRENCY]) === null || _this$rawExchangeRate === void 0 ? void 0 : _this$rawExchangeRate.exchange;
+
+    // Convert value if needed
+    if (exchangeRate && currencyKey !== DEFAULT_CURRENCY) {
+      history = history.map(point => ({
+        ...point,
+        value: point.value * exchangeRate
+      }));
+    }
+    return {
+      history
+    };
+  }
+  subscribeCurrentTokenPrice(priceId, callback) {
+    const priceData = this.priceSubject.value;
+    const currentPrice = {
+      value: priceData.priceMap[priceId],
+      value24h: priceData.price24hMap[priceId],
+      time: priceData.lastUpdatedMap[priceId].getTime()
+    };
+    const unsubscribe = this.priceSubject.pipe(map(valueSubject => ({
+      value: valueSubject.priceMap[priceId],
+      value24h: valueSubject.price24hMap[priceId],
+      time: valueSubject.lastUpdatedMap[priceId].getTime()
+    })), distinctUntilChanged()).subscribe(callback);
+    return {
+      unsubscribe: () => {
+        unsubscribe.unsubscribe();
+      },
+      currentPrice
+    };
+  }
   async init() {
     this.status = ServiceStatus.INITIALIZING;
     // Fetch data from storage

package/services/request-service/constants.js

@@ -5,7 +5,9 @@ export const EXTENSION_REQUEST_URL = 'extension';
 export const PREDEFINED_CHAIN_DAPP_CHAIN_MAP = {
   'portal.astar.network': ['astar', 'astarEvm'],
   'apps.moonbeam.network': ['moonbeam', 'moonriver'],
-  'app.stellaswap.com': ['moonbeam']
+  'app.stellaswap.com': ['moonbeam'],
+  'testnet-preprod.minswap.org': ['cardano_preproduction'],
+  'localhost:7777': ['cardano_preproduction']
 };
 export const WEB_APP_URL = [
 /// Web app

package/services/request-service/handler/AuthRequestHandler.js

@@ -2,12 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ALL_ACCOUNT_AUTH_TYPES } from '@subwallet/extension-base/constants';
-import { _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isChainCardanoCompatible, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
 import { DAPP_CONNECT_BOTH_TYPE_ACCOUNT_URL, PREDEFINED_CHAIN_DAPP_CHAIN_MAP, WEB_APP_URL } from '@subwallet/extension-base/services/request-service/constants';
 import AuthorizeStore from '@subwallet/extension-base/stores/Authorize';
 import { createPromiseHandler, getDomainFromUrl, stripUrl } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
-import { isSubstrateAddress, isTonAddress } from '@subwallet/keyring';
+import { isCardanoAddress, isSubstrateAddress, isTonAddress } from '@subwallet/keyring';
 import { BehaviorSubject } from 'rxjs';
 import { isEthereumAddress } from '@polkadot/util-crypto';
 const AUTH_URLS_KEY = 'authUrls';
@@ -37,6 +37,13 @@ export default class AuthRequestHandler {
         value.accountAuthTypes = ['evm', 'substrate'];
         needUpdateAuthList = true;
       }
+      const existKeyEvmNetworkConnect = value.currentEvmNetworkKey;
+      if (existKeyEvmNetworkConnect) {
+        value.currentNetworkMap = {
+          evm: existKeyEvmNetworkConnect
+        };
+        needUpdateAuthList = true;
+      }
       acc[key] = {
         ...value
       };
@@ -145,6 +152,18 @@ export default class AuthRequestHandler {
         }
       }
     }
+    if (options.accessType === 'cardano') {
+      const cardanoChains = Object.values(chainInfoMaps).filter(_isChainCardanoCompatible);
+      chainInfo = (defaultChain ? chainInfoMaps[defaultChain] : chainInfoMaps.cardano) || cardanoChains[0]; // auto active cardano mainnet chain, because dont support switch network yet
+
+      if (options.autoActive) {
+        var _chainInfo3;
+        if (!needEnableChains.includes((_chainInfo3 = chainInfo) === null || _chainInfo3 === void 0 ? void 0 : _chainInfo3.slug)) {
+          var _chainInfo4;
+          needEnableChains.push((_chainInfo4 = chainInfo) === null || _chainInfo4 === void 0 ? void 0 : _chainInfo4.slug);
+        }
+      }
+    }
     needEnableChains = needEnableChains.filter(slug => {
       var _chainStateMap$slug;
       return !((_chainStateMap$slug = chainStateMap[slug]) !== null && _chainStateMap$slug !== void 0 && _chainStateMap$slug.active);
@@ -193,20 +212,31 @@ export default class AuthRequestHandler {
           if (isTonAddress(a) && !accountAuthTypes.includes('ton')) {
             return true;
           }
+          if (isCardanoAddress(a) && !accountAuthTypes.includes('cardano')) {
+            return true;
+          }
           return false;
         });
         backupAllowed.forEach(acc => {
           isAllowedMap[acc] = true;
         });
       }
-      let defaultEvmNetworkKey;
+      const defaultNetworkMap = {};
       if (accountAuthTypes.includes('evm')) {
         const chainInfo = this.getDAppChainInfo({
           accessType: 'evm',
           autoActive: true,
           url
         });
-        defaultEvmNetworkKey = chainInfo === null || chainInfo === void 0 ? void 0 : chainInfo.slug;
+        defaultNetworkMap.evm = chainInfo === null || chainInfo === void 0 ? void 0 : chainInfo.slug;
+      }
+      if (accountAuthTypes.includes('cardano')) {
+        const chainInfo = this.getDAppChainInfo({
+          accessType: 'cardano',
+          autoActive: true,
+          url
+        });
+        defaultNetworkMap.cardano = chainInfo === null || chainInfo === void 0 ? void 0 : chainInfo.slug;
       }
       this.getAuthorize(value => {
         let authorizeList = {};
@@ -230,7 +260,7 @@ export default class AuthRequestHandler {
           origin,
           url,
           accountAuthTypes: [...new Set([...accountAuthTypes, ...((existed === null || existed === void 0 ? void 0 : existed.accountAuthTypes) || [])])],
-          currentEvmNetworkKey: existed ? existed.currentEvmNetworkKey : defaultEvmNetworkKey
+          currentNetworkMap: existed ? existed.currentNetworkMap : defaultNetworkMap
         };
         this.setAuthorize(authorizeList, () => {
           cb();
@@ -328,12 +358,14 @@ export default class AuthRequestHandler {
           list.push(...allowedListByRequestType.filter(a => isSubstrateAddress(a)));
         } else if (accountAuthType === 'ton') {
           list.push(...allowedListByRequestType.filter(a => isTonAddress(a)));
+        } else if (accountAuthType === 'cardano') {
+          list.push(...allowedListByRequestType.filter(a => isCardanoAddress(a)));
         }
         return list;
       }, []);
       if (!confirmAnotherType && !request.reConfirm && allowedListByRequestType.length !== 0) {
         // Prevent appear confirmation popup
-        return false;
+        return true;
       }
     } else {
       // Auto auth for web app
@@ -349,7 +381,8 @@ export default class AuthRequestHandler {
           isAllowedMap,
           origin,
           url,
-          accountAuthTypes: ALL_ACCOUNT_AUTH_TYPES
+          accountAuthTypes: ALL_ACCOUNT_AUTH_TYPES,
+          currentNetworkMap: {}
         };
         this.setAuthorize(authList);
         return true;

package/services/request-service/handler/CardanoRequestHandler.d.ts

@@ -11,6 +11,8 @@ export default class CardanoRequestHandler {
     addConfirmationCardano<CT extends ConfirmationTypeCardano>(id: string, url: string, type: CT, payload: ConfirmationDefinitionsCardano[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsCardano[CT][1]) => Error | undefined): Promise<ConfirmationDefinitionsCardano[CT][1]>;
     completeConfirmationCardano(request: RequestConfirmationCompleteCardano): Promise<boolean>;
     private decorateResult;
+    private signMessage;
     private signTransactionCardano;
+    private signDappTransactionCardano;
     resetWallet(): void;
 }

package/services/request-service/handler/CardanoRequestHandler.js

@@ -1,6 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { FixedTransaction, TransactionWitnessSet, Vkeywitnesses } from '@emurgo/cardano-serialization-lib-nodejs';
 import { isInternalRequest } from '@subwallet/extension-base/utils/request';
 import { keyring } from '@subwallet/ui-keyring';
 import { t } from 'i18next';
@@ -12,7 +13,8 @@ export default class CardanoRequestHandler {
   confirmationsQueueSubjectCardano = new BehaviorSubject({
     cardanoSignatureRequest: {},
     cardanoSendTransactionRequest: {},
-    cardanoWatchTransactionRequest: {}
+    cardanoWatchTransactionRequest: {},
+    cardanoSignTransactionRequest: {}
   });
   confirmationsPromiseMap = {};
   constructor(requestService) {
@@ -114,9 +116,11 @@ export default class CardanoRequestHandler {
   async decorateResult(t, request, result) {
     if (result.payload === '') {
       if (t === 'cardanoSignatureRequest') {
-        // result.payload = await this.signMessage(request as ConfirmationDefinitions['evmSignatureRequest'][0]);
+        result.payload = this.signMessage(request);
       } else if (t === 'cardanoSendTransactionRequest') {
         result.payload = this.signTransactionCardano(request);
+      } else if (t === 'cardanoSignTransactionRequest') {
+        result.payload = this.signDappTransactionCardano(request);
       }
       if (t === 'cardanoSignatureRequest' || t === 'cardanoSendTransactionRequest') {
         const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
@@ -126,6 +130,17 @@ export default class CardanoRequestHandler {
       }
     }
   }
+  signMessage(confirmation) {
+    const {
+      address,
+      payload
+    } = confirmation.payload;
+    const pair = keyring.getPair(address);
+    if (pair.isLocked) {
+      keyring.unlockPair(pair.address);
+    }
+    return pair.cardano.signMessage(payload, true);
+  }
   signTransactionCardano(confirmation) {
     // alibaba
     const transaction = confirmation.payload;
@@ -137,7 +152,34 @@ export default class CardanoRequestHandler {
     if (pair.isLocked) {
       keyring.unlockPair(pair.address);
     }
-    return pair.cardano.sign(cardanoPayload);
+    return pair.cardano.signTransaction(cardanoPayload);
+  }
+  signDappTransactionCardano(confirmation) {
+    var _FixedTransaction$fro;
+    // alibaba
+    const transaction = confirmation.payload;
+    const {
+      addressRequireKeyTypes,
+      cardanoPayload,
+      from
+    } = transaction;
+    const vkeyWitnessesFinal = Vkeywitnesses.new();
+    const txWitnessSet = (_FixedTransaction$fro = FixedTransaction.from_hex(cardanoPayload).witness_set()) !== null && _FixedTransaction$fro !== void 0 ? _FixedTransaction$fro : TransactionWitnessSet.new();
+    const pair = keyring.getPair(from);
+    if (pair.isLocked) {
+      keyring.unlockPair(pair.address);
+    }
+    const keyTypes = [...new Set(addressRequireKeyTypes)];
+    const vKeyWitnessesHex = pair.cardano.signTransaction(cardanoPayload, {
+      needVkeywitness: true,
+      keyTypes
+    });
+    const vKeyWitnesses = Vkeywitnesses.from_hex(vKeyWitnessesHex);
+    for (let i = 0; i < vKeyWitnesses.len(); i++) {
+      vkeyWitnessesFinal.add(vKeyWitnesses.get(i));
+    }
+    txWitnessSet.set_vkeys(vkeyWitnessesFinal);
+    return txWitnessSet.to_hex();
   }
   resetWallet() {
     const confirmations = this.confirmationsQueueSubjectCardano.getValue();

package/services/request-service/helper/index.d.ts

@@ -1,2 +1,56 @@
+import * as CardanoWasm from '@emurgo/cardano-serialization-lib-nodejs';
+import { CardanoBalanceItem, CardanoUtxosItem } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/cardano/types';
 import { MetadataStore } from '@subwallet/extension-base/stores';
 export declare const extractMetadata: (store: MetadataStore) => void;
+export declare const convertAssetToValue: (amount: CardanoBalanceItem[]) => CardanoWasm.Value;
+export declare const convertValueToAsset: (value: CardanoWasm.Value) => CardanoBalanceItem[];
+export declare const convertUtxoRawToUtxo: (utxos: CardanoUtxosItem[]) => CardanoWasm.TransactionUnspentOutput[];
+export declare function getBalanceAddressMap(outputs: CardanoWasm.TransactionOutputs): Record<string, CardanoWasm.Value>;
+/**
+ * Extracts all required key hashes from a list of certificates.
+ * Handles different certificate kinds: stake deregistration, delegation,
+ * pool registration, pool retirement, and MIR (move instantaneous rewards).
+ *
+ * Only processes key hash credentials (ignores script credentials).
+ *
+ * @param {Certificates} certificates - List of certificate objects from a transaction body.
+ * @returns {string[]} - An array of required key hashes in hex format.
+ */
+export declare function extractKeyHashFromCertificate(certificates?: CardanoWasm.Certificates): string[];
+/**
+ * Extracts required key hashes from withdrawal entries.
+ * It processes only credentials of kind 0 (key hash based).
+ *
+ * @param {Withdrawals} withdrawals - The withdrawal map from a transaction body.
+ * @returns {string[]} - An array of required key hashes in hex format.
+ */
+export declare function extractKeyHashesFromWithdrawals(withdrawals?: CardanoWasm.Withdrawals): string[];
+/**
+ * Recursively extract all Ed25519 key hashes from a NativeScripts collection.
+ * Only processes `ScriptPubkey` entries (kind = 0), and traverses through nested scripts.
+ *
+ * @param {NativeScripts} scripts - A collection of native scripts.
+ * @returns {string[]} - An array of key hashes (hex-encoded) from all script_pubkey entries.
+ */
+export declare function extractKeyHashesFromScripts(scripts?: CardanoWasm.NativeScripts): string[];
+/**
+ * Extract required key hashes from the RequiredSigners field in the transaction body.
+ * Each entry is an Ed25519 key hash that must sign the transaction.
+ *
+ * @param {Ed25519KeyHashes} requiredSigners - A list of required signer key hashes.
+ * @returns {string[]} - Array of hex-encoded Ed25519 key hashes.
+ */
+export declare function extractKeyHashesFromRequiredSigners(requiredSigners?: CardanoWasm.Ed25519KeyHashes): string[];
+/**
+ * Extract required key hashes from collateral inputs in a linear and readable flow.
+ *
+ * This function resolves UTXOs of each collateral input,
+ * attempts to extract the payment key hash from various supported address types,
+ * and returns an array of required signer key hashes in hex format.
+ *
+ * @param {TransactionInputs} collaterals - Collateral inputs used for script validation
+ * @param getSpecificUtxo
+ * @returns {Promise<string[]>} - Hex-encoded key hashes required to sign the transaction
+ */
+export declare function extractKeyHashesFromCollaterals(collaterals?: CardanoWasm.TransactionInputs, getSpecificUtxo?: (txHash: string, txId: number) => Promise<CardanoUtxosItem | undefined>): Promise<string[]>;
+export declare function hasSufficientCardanoValue(valueA: CardanoWasm.Value, valueB: CardanoWasm.Value): boolean;