@subwallet/extension-base 1.3.31-0 → 1.3.32-0

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

@@ -11,7 +11,7 @@ import { BasicTxErrorType, EarningStatus } from '@subwallet/extension-base/types
 import { formatNumber, reformatAddress } from '@subwallet/extension-base/utils';
 import BigN from 'bignumber.js';
 import { t } from 'i18next';
-import { BN, BN_TEN, BN_ZERO } from '@polkadot/util';
+import { BN, BN_ZERO } from '@polkadot/util';
 import { calculateReward } from "../../utils/index.js";
 import { DEFAULT_DTAO_MINBOND } from "./dtao.js";
 export const BITTENSOR_API_KEY_1 = process.env.BITTENSOR_API_KEY_1 || '';
@@ -154,8 +154,8 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
   /* Unimplemented function  */
 
   get maintainBalance() {
-    const ed = new BN(this.nativeToken.minAmount || '0');
-    const calculateMaintainBalance = new BN(15).mul(ed).div(BN_TEN);
+    const ed = new BigN(this.nativeToken.minAmount || '0');
+    const calculateMaintainBalance = new BigN(15).multipliedBy(ed).dividedBy(10);
     const maintainBalance = calculateMaintainBalance;
     return maintainBalance.toString();
   }
@@ -181,7 +181,7 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
             highestApr = validators[i];
           }
         }
-        const bnTaoIn = new BN(taoIn);
+        const bnTaoIn = new BigN(taoIn);
         const BNminDelegatorStake = new BigN(minDelegatorStake.toString());
         const apr = this.chain === 'bittensor' ? Number(highestApr.apr) * 100 : 0;
         const data = {
@@ -409,7 +409,7 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
     const testnetDelegate = (await this.substrateApi.api.call.delegateInfoRuntimeApi.getDelegates()).toJSON();
     const getNominatorMinRequiredStake = this.substrateApi.api.query.subtensorModule.nominatorMinRequiredStake();
     const nominatorMinRequiredStake = (await getNominatorMinRequiredStake).toString();
-    const bnMinBond = new BN(nominatorMinRequiredStake);
+    const bnMinBond = new BigN(nominatorMinRequiredStake);
     return testnetDelegate.map(delegate => ({
       address: delegate.delegateSs58,
       totalStake: '0',
@@ -429,14 +429,14 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
     const topValidator = _topValidator;
     const getNominatorMinRequiredStake = this.substrateApi.api.query.subtensorModule.nominatorMinRequiredStake();
     const nominatorMinRequiredStake = (await getNominatorMinRequiredStake).toString();
-    const bnMinBond = new BN(nominatorMinRequiredStake);
+    const bnMinBond = new BigN(nominatorMinRequiredStake);
     const validatorList = topValidator.data;
     const validatorAddresses = Object.keys(validatorList);
     const results = await Promise.all(validatorAddresses.map(i => {
       const address = validatorList[i].hotkey.ss58;
-      const bnTotalStake = new BN(validatorList[i].stake);
-      const bnOwnStake = new BN(validatorList[i].validator_stake);
-      const otherStake = bnTotalStake.sub(bnOwnStake);
+      const bnTotalStake = new BigN(validatorList[i].stake);
+      const bnOwnStake = new BigN(validatorList[i].validator_stake);
+      const otherStake = bnTotalStake.minus(bnOwnStake);
       const nominatorCount = validatorList[i].nominators;
       const commission = validatorList[i].take;
       const roundedCommission = (parseFloat(commission) * 100).toFixed(0);
@@ -479,10 +479,10 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
       selectedValidators: targetValidators
     } = data;
     const chainApi = await this.substrateApi.isReady;
-    const binaryAmount = new BN(amount);
+    const binaryAmount = new BigN(amount);
     const selectedValidatorInfo = targetValidators[0];
     const hotkey = selectedValidatorInfo.address;
-    const extrinsic = chainApi.api.tx.subtensorModule.addStake(hotkey, 0, binaryAmount);
+    const extrinsic = chainApi.api.tx.subtensorModule.addStake(hotkey, 0, binaryAmount.toFixed());
     return [extrinsic, {
       slug: this.nativeToken.slug,
       amount: '0'
@@ -496,7 +496,7 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
     const {
       amount
     } = data;
-    if (new BN(amount).lt(new BN(DEFAULT_DTAO_MINBOND))) {
+    if (new BigN(amount).lt(new BigN(DEFAULT_DTAO_MINBOND))) {
       return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, t(`Insufficient stake. You need to stake at least ${formatNumber(DEFAULT_DTAO_MINBOND, _getAssetDecimals(this.nativeToken))} ${_getAssetSymbol(this.nativeToken)} to earn rewards`))];
     }
     return baseErrors;
@@ -508,12 +508,12 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
 
   async handleYieldUnstake(amount, address, selectedTarget) {
     const apiPromise = await this.substrateApi.isReady;
-    const binaryAmount = new BN(amount);
+    const binaryAmount = new BigN(amount);
     const poolPosition = await this.getPoolPosition(address);
     if (!selectedTarget || !poolPosition) {
       return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
     }
-    const extrinsic = apiPromise.api.tx.subtensorModule.removeStake(selectedTarget, 0, binaryAmount);
+    const extrinsic = apiPromise.api.tx.subtensorModule.removeStake(selectedTarget, 0, binaryAmount.toFixed());
     return [ExtrinsicType.STAKING_UNBOND, extrinsic];
   }
   async validateYieldLeave(amount, address, fastLeave, selectedTarget, slug, poolInfo) {

package/services/earning-service/handlers/nomination-pool/index.js

@@ -95,7 +95,7 @@ export default class NominationPoolHandler extends BasePoolHandler {
       const bnTotalIssuance = new BN(rawTotalIssuance);
       const inflation = calculateInflation(bnTotalEraStake, bnTotalIssuance, numAuctions, chainInfo.slug);
       const minPoolJoin = (_minPoolJoin === null || _minPoolJoin === void 0 ? void 0 : _minPoolJoin.toString()) || undefined;
-      const expectedReturn = calculateChainStakedReturnV2(chainInfo, rawTotalIssuance, erasPerDay, lastTotalStaked, validatorEraReward, new BigN(inflation), true);
+      const expectedReturn = await calculateChainStakedReturnV2(chainInfo, rawTotalIssuance, erasPerDay, lastTotalStaked, validatorEraReward, new BigN(inflation), true);
       const eraTime = _STAKING_ERA_LENGTH_MAP[this.chain] || _STAKING_ERA_LENGTH_MAP.default; // in hours
       const unlockingPeriod = parseInt(unlockingEras) * eraTime; // in hours
 

package/services/migration-service/scripts/MigrateAuthUrls.js

@@ -11,7 +11,7 @@ export default class MigrateSettings extends BaseMigrationJob {
             const key = 'app.stellaswap.com';
             const stellaSwap = value[key];
             if (stellaSwap) {
-              stellaSwap.currentEvmNetworkKey = 'moonbeam';
+              stellaSwap.currentNetworkMap.evm = 'moonbeam';
               value[key] = stellaSwap;
               this.state.setAuthorize(value, () => {
                 resolve();

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;