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

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;