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

package/core/logic-validation/request.d.ts

@@ -1,18 +1,21 @@
-import { ConfirmationType, ErrorValidation } from '@subwallet/extension-base/background/KoniTypes';
+import { ConfirmationType, ConfirmationTypeCardano, ErrorValidation } from '@subwallet/extension-base/background/KoniTypes';
+import { AccountAuthType } from '@subwallet/extension-base/background/types';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
 import { AuthUrlInfo } from '@subwallet/extension-base/services/request-service/types';
 import { KeyringPair } from '@subwallet/keyring/types';
 import Joi from 'joi';
 export declare type ValidateStepFunction = (koni: KoniState, url: string, payload: PayloadValidated, topic?: string) => Promise<PayloadValidated>;
+export declare type RequestAccountType = 'substrate' | 'evm' | 'ton' | 'cardano';
 export interface PayloadValidated {
     networkKey: string;
     address: string;
     pair?: KeyringPair;
     authInfo?: AuthUrlInfo;
+    type: AccountAuthType;
     method?: string;
     payloadAfterValidated: any;
     errorPosition?: 'dApp' | 'ui';
-    confirmationType?: ConfirmationType;
+    confirmationType?: ConfirmationType | ConfirmationTypeCardano;
     errors: Error[];
 }
 export declare type SignTypedDataMessageV3V4 = {
@@ -40,5 +43,6 @@ export declare function validationConnectMiddleware(koni: KoniState, url: string
 export declare function validationEvmDataTransactionMiddleware(koni: KoniState, url: string, payload: PayloadValidated): Promise<PayloadValidated>;
 export declare function validationEvmSignMessageMiddleware(koni: KoniState, url: string, payload_: PayloadValidated): Promise<PayloadValidated>;
 export declare function validationAuthWCMiddleware(koni: KoniState, url: string, payload: PayloadValidated, topic?: string): Promise<PayloadValidated>;
+export declare function validationCardanoSignDataMiddleware(koni: KoniState, url: string, payload_: PayloadValidated): Promise<PayloadValidated>;
 export declare function convertErrorMessage(message_: string, name?: string): string[];
 export declare function convertErrorFormat(errors: Error[]): ErrorValidation[];

package/core/logic-validation/request.js

@@ -2,14 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { typedSignatureHash } from '@metamask/eth-sig-util';
+import { CardanoProviderError } from '@subwallet/extension-base/background/errors/CardanoProviderError';
 import { EvmProviderError } from '@subwallet/extension-base/background/errors/EvmProviderError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
-import { EvmProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { CardanoProviderErrorType, EvmProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
 import { BasicTxErrorType } from '@subwallet/extension-base/types';
 import { BN_ZERO, combineEthFee, createPromiseHandler, isSameAddress, stripUrl, wait } from '@subwallet/extension-base/utils';
 import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { getId } from '@subwallet/extension-base/utils/getId';
-import { isSubstrateAddress } from '@subwallet/keyring';
+import { isCardanoAddress, isSubstrateAddress } from '@subwallet/keyring';
 import { keyring } from '@subwallet/ui-keyring';
 import { getSdkError } from '@walletconnect/utils';
 import BigN from 'bignumber.js';
@@ -167,7 +168,8 @@ export async function validationConnectMiddleware(koni, url, payload) {
     address,
     authInfo,
     errors,
-    networkKey
+    networkKey,
+    type
   } = {
     ...payload
   };
@@ -179,8 +181,8 @@ export async function validationConnectMiddleware(koni, url, payload) {
     console.error(error);
     errors.push(error);
   };
-  if (authInfo !== null && authInfo !== void 0 && authInfo.currentEvmNetworkKey) {
-    currentChain = authInfo === null || authInfo === void 0 ? void 0 : authInfo.currentEvmNetworkKey;
+  if (authInfo !== null && authInfo !== void 0 && authInfo.currentNetworkMap[type]) {
+    currentChain = authInfo === null || authInfo === void 0 ? void 0 : authInfo.currentNetworkMap[type];
   }
   if (authInfo !== null && authInfo !== void 0 && authInfo.isAllowed) {
     autoActiveChain = true;
@@ -542,6 +544,50 @@ export function validationAuthWCMiddleware(koni, url, payload, topic) {
   });
   return promise;
 }
+export async function validationCardanoSignDataMiddleware(koni, url, payload_) {
+  const {
+    address,
+    errors,
+    pair: pair_
+  } = payload_;
+  const payload = payload_.payloadAfterValidated;
+  const {
+    promise,
+    resolve
+  } = createPromiseHandler();
+  let canSign = false;
+  const handleError = message_ => {
+    payload_.errorPosition = 'ui';
+    payload_.confirmationType = 'cardanoSignatureRequest';
+    const [message, name] = convertErrorMessage(message_);
+    const error = new CardanoProviderError(CardanoProviderErrorType.INVALID_REQUEST, message, undefined, name);
+    console.error(error);
+    errors.push(error);
+  };
+  if (address === '' || !payload) {
+    handleError('Not found address or payload to sign');
+  }
+  if (!isCardanoAddress(address)) {
+    handleError('Not found cardano address');
+  }
+  const pair = pair_ || keyring.getPair(address);
+  if (!(pair !== null && pair !== void 0 && pair.meta.isExtneral)) {
+    canSign = true;
+  }
+  const payloadAfterValidated = {
+    address,
+    payload: payload,
+    hashPayload: payload,
+    canSign: canSign,
+    id: ''
+  };
+  resolve({
+    ...payload_,
+    errors,
+    payloadAfterValidated
+  });
+  return promise;
+}
 export function convertErrorMessage(message_, name) {
   const message = message_.toLowerCase();
 

package/koni/api/contract-handler/evm/web3.d.ts

@@ -1,8 +1,10 @@
 import { _Address } from '@subwallet/extension-base/background/KoniTypes';
 import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
+import { EvmFeeInfo } from '@subwallet/extension-base/types';
 import { TransactionConfig } from 'web3-core';
 import { Contract } from 'web3-eth-contract';
 export declare const getERC20Contract: (assetAddress: string, evmApi: _EvmApi, options?: {}) => Contract;
 export declare function getWeb3Contract(contractAddress: _Address, evmApi: _EvmApi, contractAbi: Record<string, any>, options?: {}): Contract;
 export declare function getERC20Allowance(spender: _Address, owner: _Address, contractAddress: _Address, evmApi: _EvmApi): Promise<string>;
 export declare function getERC20SpendingApprovalTx(spender: _Address, owner: _Address, contractAddress: _Address, evmApi: _EvmApi, amount?: string): Promise<TransactionConfig>;
+export declare function estimateTxFee(tx: TransactionConfig, evmApi: _EvmApi, feeInfo: EvmFeeInfo): Promise<string>;

package/koni/api/contract-handler/evm/web3.js

@@ -4,6 +4,7 @@
 import { _ERC20_ABI } from '@subwallet/extension-base/koni/api/contract-handler/utils';
 import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
 import { combineEthFee } from '@subwallet/extension-base/utils';
+import BigNumber from 'bignumber.js';
 export const getERC20Contract = (assetAddress, evmApi, options = {}) => {
   // @ts-ignore
   // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
@@ -42,4 +43,22 @@ export async function getERC20SpendingApprovalTx(spender, owner, contractAddress
     gasPrice: priority.gasPrice,
     ...feeCombine
   };
+}
+export async function estimateTxFee(tx, evmApi, feeInfo) {
+  const gasLimit = tx.gas || (await evmApi.api.eth.estimateGas(tx));
+  const feeCombine = combineEthFee(feeInfo);
+  let estimatedFee;
+  if (tx.maxFeePerGas) {
+    estimatedFee = BigNumber(tx.maxFeePerGas.toString()).multipliedBy(gasLimit).toFixed(0);
+  } else if (tx.gasPrice) {
+    estimatedFee = BigNumber(tx.gasPrice.toString()).multipliedBy(gasLimit).toFixed(0);
+  } else {
+    if (feeCombine.maxFeePerGas) {
+      estimatedFee = BigNumber(feeCombine.maxFeePerGas).multipliedBy(gasLimit).toFixed(0);
+    } else if (feeCombine.gasPrice) {
+      estimatedFee = BigNumber(feeCombine.gasPrice).multipliedBy(gasLimit).toFixed(0);
+    }
+    estimatedFee = '0';
+  }
+  return estimatedFee;
 }

package/koni/api/staking/bonding/utils.d.ts

@@ -100,9 +100,10 @@ export declare function calcInflationUniformEraPayout(totalIssuance: BN, yearlyI
 export declare function calcInflationRewardCurve(minInflation: number, stakedFraction: number, idealStake: number, idealInterest: number, falloff: number): number;
 export declare function calculateInflation(totalEraStake: BN, totalIssuance: BN, numAuctions: number, networkKey: string): number;
 export declare function calculateChainStakedReturn(inflation: number, totalEraStake: BN, totalIssuance: BN, networkKey: string): number;
-export declare function calculateChainStakedReturnV2(chainInfo: _ChainInfo, totalIssuance: string, erasPerDay: number, lastTotalStaked: string, validatorEraReward: BigNumber, inflation: BigNumber, isCompound?: boolean): number;
+export declare function calculateChainStakedReturnV2(chainInfo: _ChainInfo, totalIssuance: string, erasPerDay: number, lastTotalStaked: string, validatorEraReward: BigNumber, inflation: BigNumber, isCompound?: boolean): Promise<number | undefined>;
 export declare function calculateAlephZeroValidatorReturn(chainStakedReturn: number, commission: number): number;
 export declare function calculateTernoaValidatorReturn(rewardPerValidator: number, validatorStake: number, commission: number): number;
+export declare function calculateAnalogChainStakedReturn(): Promise<number | undefined>;
 export declare function calculateValidatorStakedReturn(chainStakedReturn: number, totalValidatorStake: BN, avgStake: BN, commission: number): number;
 export declare function getCommission(commissionString: string): number;
 export interface InflationConfig {

package/koni/api/staking/bonding/utils.js

@@ -72,10 +72,9 @@ export function calculateChainStakedReturn(inflation, totalEraStake, totalIssuan
 
   return stakedReturn;
 }
-export function calculateChainStakedReturnV2(chainInfo, totalIssuance, erasPerDay, lastTotalStaked, validatorEraReward, inflation, isCompound) {
+export async function calculateChainStakedReturnV2(chainInfo, totalIssuance, erasPerDay, lastTotalStaked, validatorEraReward, inflation, isCompound) {
   if (chainInfo.slug === 'analog_timechain') {
-    // hotfix for analog
-    return 55;
+    return await calculateAnalogChainStakedReturn();
   }
   const DAYS_PER_YEAR = 365;
   const {
@@ -104,6 +103,27 @@ export function calculateTernoaValidatorReturn(rewardPerValidator, validatorStak
   const stakeRatio = rewardForNominators / validatorStake;
   return stakeRatio * 365 * 100;
 }
+export async function calculateAnalogChainStakedReturn() {
+  const url = 'https://explorer-api.analog.one/api/nominations?projection=apy,rewardsClaimed,eraEndsTime';
+  try {
+    var _apyInfo$data;
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API error: ${response.status} - ${errorText}`);
+    }
+    const apyInfo = await response.json();
+    return apyInfo === null || apyInfo === void 0 ? void 0 : (_apyInfo$data = apyInfo.data) === null || _apyInfo$data === void 0 ? void 0 : _apyInfo$data.apy;
+  } catch (e) {
+    console.error('Fetch error:', e);
+    return undefined;
+  }
+}
 export function calculateValidatorStakedReturn(chainStakedReturn, totalValidatorStake, avgStake, commission) {
   const bnAdjusted = avgStake.mul(BN_HUNDRED).div(totalValidatorStake);
   const adjusted = bnAdjusted.toNumber() * chainStakedReturn;

package/koni/background/handlers/Extension.d.ts

@@ -90,6 +90,8 @@ export default class KoniExtension {
     private subscribeAssetSetting;
     private updateAssetSetting;
     private getPrice;
+    private getHistoryTokenPrice;
+    private subscribeCurrentTokenPrice;
     private setPriceCurrency;
     private subscribePrice;
     private getBalance;

package/koni/background/handlers/Extension.js

@@ -49,7 +49,7 @@ import { _analyzeAddress, calculateMaxTransferable, combineAllAccountProxy, crea
 import { parseContractInput, parseEvmRlp } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import { getKeypairTypeByAddress, isAddress, isCardanoAddress, isSubstrateAddress, isTonAddress } from '@subwallet/keyring';
-import { EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
+import { CardanoKeypairTypes, EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
 import { keyring } from '@subwallet/ui-keyring';
 import { getSdkError } from '@walletconnect/utils';
 import BigN from 'bignumber.js';
@@ -561,7 +561,8 @@ export default class KoniExtension {
     const validTypes = {
       evm: EthereumKeypairTypes,
       substrate: SubstrateKeypairTypes,
-      ton: TonKeypairTypes
+      ton: TonKeypairTypes,
+      cardano: CardanoKeypairTypes
     };
     return !!accountAuthTypes && accountAuthTypes.some(authType => {
       var _validTypes$authType;
@@ -585,6 +586,10 @@ export default class KoniExtension {
         accounts.forEach(({
           address
         }) => isTonAddress(address) && list.push(address));
+      } else if (accountAuthType === 'cardano') {
+        accounts.forEach(({
+          address
+        }) => isCardanoAddress(address) && list.push(address));
       }
       return list;
     }, []);
@@ -869,6 +874,27 @@ export default class KoniExtension {
   async getPrice() {
     return this.#koniState.priceService.getPrice();
   }
+  async getHistoryTokenPrice({
+    priceId,
+    timeframe
+  }) {
+    return this.#koniState.priceService.getHistoryTokenPriceData(priceId, timeframe);
+  }
+  subscribeCurrentTokenPrice(priceId, id, port) {
+    const cb = createSubscription(id, port);
+    const {
+      currentPrice,
+      unsubscribe
+    } = this.#koniState.priceService.subscribeCurrentTokenPrice(priceId, cb);
+    this.createUnsubscriptionHandle(id, unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return {
+      id,
+      price: currentPrice
+    };
+  }
   async setPriceCurrency({
     currency
   }) {
@@ -4243,6 +4269,10 @@ export default class KoniExtension {
         return await this.getPrice();
       case 'pri(price.getSubscription)':
         return await this.subscribePrice(id, port);
+      case 'pri(price.getHistory)':
+        return await this.getHistoryTokenPrice(request);
+      case 'pri(price.subscribeCurrentTokenPrice)':
+        return this.subscribeCurrentTokenPrice(request, id, port);
       case 'pri(settings.savePriceCurrency)':
         return await this.setPriceCurrency(request);
       case 'pri(balance.getBalance)':

package/koni/background/handlers/State.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="chrome" />
+import * as CardanoWasm from '@emurgo/cardano-serialization-lib-nodejs';
 import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
-import { AddTokenRequestExternal, AmountData, ApiMap, AuthRequestV2, ChainStakingMetadata, ConfirmationsQueue, ConfirmationsQueueCardano, ConfirmationsQueueTon, CrowdloanItem, CrowdloanJson, EvmSendTransactionParams, ExternalRequestPromise, MantaPayConfig, MantaPaySyncState, NftCollection, NftItem, NftJson, NominatorMetadata, RequestAccountExportPrivateKey, RequestConfirmationComplete, RequestConfirmationCompleteCardano, RequestConfirmationCompleteTon, RequestCrowdloanContributions, RequestSettingsType, ResponseAccountExportPrivateKey, ServiceInfo, SingleModeJson, StakingItem, StakingJson, StakingRewardItem, StakingRewardJson, StakingType, UiSettings } from '@subwallet/extension-base/background/KoniTypes';
+import { AddTokenRequestExternal, AmountData, ApiMap, AuthRequestV2, ChainStakingMetadata, ConfirmationsQueue, ConfirmationsQueueCardano, ConfirmationsQueueTon, CrowdloanItem, CrowdloanJson, EvmSendTransactionParams, ExternalRequestPromise, MantaPayConfig, MantaPaySyncState, NftCollection, NftItem, NftJson, NominatorMetadata, RequestAccountExportPrivateKey, RequestCardanoSignData, RequestCardanoSignTransaction, RequestConfirmationComplete, RequestConfirmationCompleteCardano, RequestConfirmationCompleteTon, RequestCrowdloanContributions, RequestSettingsType, ResponseAccountExportPrivateKey, ResponseCardanoSignData, ResponseCardanoSignTransaction, ServiceInfo, SingleModeJson, StakingItem, StakingJson, StakingRewardItem, StakingRewardJson, StakingType, UiSettings } from '@subwallet/extension-base/background/KoniTypes';
 import { RequestAuthorizeTab, RequestRpcSend, RequestRpcSubscribe, RequestRpcUnsubscribe, RequestSign, ResponseRpcListProviders, ResponseSigning } from '@subwallet/extension-base/background/types';
 import { EnvConfig } from '@subwallet/extension-base/constants';
 import { BalanceService } from '@subwallet/extension-base/services/balance-service';
@@ -216,6 +217,10 @@ export default class KoniState {
     evmSign(id: string, url: string, method: string, params: any, topic?: string): Promise<string | undefined>;
     calculateAllGasFeeOnChain(activeEvmChains: string[], timeout?: number): Promise<Record<string, EvmFeeInfo | null>>;
     evmSendTransaction(id: string, url: string, transactionParams: EvmSendTransactionParams, networkKeyInit?: string, topic?: string): Promise<string | undefined>;
+    cardanoGetBalance(id: string, url: string, address: string): Promise<CardanoWasm.Value>;
+    cardanoSignData(id: string, url: string, params: RequestCardanoSignData, currentAddress: string): Promise<ResponseCardanoSignData>;
+    cardanoSignTx(id: string, url: string, param: RequestCardanoSignTransaction, currentAddress: string): Promise<ResponseCardanoSignTransaction>;
+    cardanoSubmitTx(id: string, url: string, txHex: string): Promise<string>;
     getConfirmationsQueueSubject(): BehaviorSubject<ConfirmationsQueue>;
     getConfirmationsQueueSubjectTon(): BehaviorSubject<ConfirmationsQueueTon>;
     getConfirmationsQueueSubjectCardano(): BehaviorSubject<ConfirmationsQueueCardano>;

package/koni/background/handlers/State.js

@@ -1,12 +1,14 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import * as CardanoWasm from '@emurgo/cardano-serialization-lib-nodejs';
+import { CardanoProviderError } from '@subwallet/extension-base/background/errors/CardanoProviderError';
 import { EvmProviderError } from '@subwallet/extension-base/background/errors/EvmProviderError';
 import { withErrorLog } from '@subwallet/extension-base/background/handlers/helpers';
 import { isSubscriptionRunning, unsubscribe } from '@subwallet/extension-base/background/handlers/subscriptions';
-import { APIItemState, ChainType, EvmProviderErrorType, ExternalRequestPromiseStatus, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { BACKEND_API_URL, MANTA_PAY_BALANCE_INTERVAL, REMIND_EXPORT_ACCOUNT } from '@subwallet/extension-base/constants';
-import { convertErrorFormat, generateValidationProcess, validationAuthMiddleware, validationAuthWCMiddleware, validationConnectMiddleware, validationEvmDataTransactionMiddleware, validationEvmSignMessageMiddleware } from '@subwallet/extension-base/core/logic-validation';
+import { APIItemState, CardanoProviderErrorType, ChainType, EvmProviderErrorType, ExternalRequestPromiseStatus, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { BACKEND_API_URL, BACKEND_PRICE_HISTORY_URL, MANTA_PAY_BALANCE_INTERVAL, REMIND_EXPORT_ACCOUNT } from '@subwallet/extension-base/constants';
+import { convertErrorFormat, generateValidationProcess, validationAuthMiddleware, validationAuthWCMiddleware, validationCardanoSignDataMiddleware, validationConnectMiddleware, validationEvmDataTransactionMiddleware, validationEvmSignMessageMiddleware } from '@subwallet/extension-base/core/logic-validation';
 import { BalanceService } from '@subwallet/extension-base/services/balance-service';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import BuyService from '@subwallet/extension-base/services/buy-service';
@@ -29,6 +31,7 @@ import NotificationService from '@subwallet/extension-base/services/notification
 import { PriceService } from '@subwallet/extension-base/services/price-service';
 import RequestService from '@subwallet/extension-base/services/request-service';
 import { openPopup } from '@subwallet/extension-base/services/request-service/handler/PopupHandler';
+import { convertAssetToValue, convertValueToAsset, extractKeyHashesFromCollaterals, extractKeyHashesFromRequiredSigners, extractKeyHashesFromScripts, extractKeyHashesFromWithdrawals, extractKeyHashFromCertificate, getBalanceAddressMap } from '@subwallet/extension-base/services/request-service/helper';
 import SettingService from '@subwallet/extension-base/services/setting-service/SettingService';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import { SubscanService } from '@subwallet/extension-base/services/subscan-service';
@@ -37,7 +40,8 @@ import TransactionService from '@subwallet/extension-base/services/transaction-s
 import WalletConnectService from '@subwallet/extension-base/services/wallet-connect-service';
 import { SWStorage } from '@subwallet/extension-base/storage';
 import { BasicTxErrorType } from '@subwallet/extension-base/types';
-import { addLazy, isManifestV3, stripUrl, targetIsWeb } from '@subwallet/extension-base/utils';
+import { addLazy, isManifestV3, isSameAddress, reformatAddress, stripUrl, targetIsWeb } from '@subwallet/extension-base/utils';
+import { convertCardanoHexToBech32 } from '@subwallet/extension-base/utils/cardano';
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import subwalletApiSdk from '@subwallet/subwallet-api-sdk';
 import { keyring } from '@subwallet/ui-keyring';
@@ -85,7 +89,10 @@ export default class KoniState {
   waitStarting = null;
   constructor(providers = {}) {
     // Init subwallet api sdk
-    subwalletApiSdk.init(BACKEND_API_URL);
+    subwalletApiSdk.init({
+      url: BACKEND_API_URL,
+      priceHistoryUrl: BACKEND_PRICE_HISTORY_URL
+    });
     this.providers = providers;
     this.eventService = new EventService();
     this.dbService = new DatabaseService(this.eventService);
@@ -430,7 +437,7 @@ export default class KoniState {
       if (chainInfo && !_isChainEnabled(chainState)) {
         await this.enableChainWithPriorityAssets(networkKey);
       }
-      authUrls[shortenUrl].currentEvmNetworkKey = networkKey;
+      authUrls[shortenUrl].currentNetworkMap.evm = networkKey;
       this.setAuthorize(authUrls);
     } else {
       throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, t('Not found {{shortenUrl}} in auth list', {
@@ -877,6 +884,7 @@ export default class KoniState {
     }
     const payloadValidation = {
       address,
+      type: 'evm',
       payloadAfterValidated: payload,
       method,
       errors: [],
@@ -930,6 +938,7 @@ export default class KoniState {
   async evmSendTransaction(id, url, transactionParams, networkKeyInit, topic) {
     const payloadValidation = {
       errors: [],
+      type: 'evm',
       networkKey: networkKeyInit || '',
       payloadAfterValidated: transactionParams,
       address: transactionParams.from
@@ -1007,6 +1016,219 @@ export default class KoniState {
       });
     });
   }
+  async cardanoGetBalance(id, url, address) {
+    const authInfoMap = await this.getAuthList();
+    const authInfo = authInfoMap[stripUrl(url)];
+    let networkKey = authInfo === null || authInfo === void 0 ? void 0 : authInfo.currentNetworkMap.cardano;
+    const autoActiveChain = (authInfo === null || authInfo === void 0 ? void 0 : authInfo.isAllowed) || false;
+    const chainInfo = this.requestService.getDAppChainInfo({
+      autoActive: autoActiveChain,
+      accessType: 'cardano',
+      defaultChain: networkKey,
+      url
+    });
+    networkKey = (chainInfo === null || chainInfo === void 0 ? void 0 : chainInfo.slug) || 'cardano';
+    const cardanoApi = this.chainService.getCardanoApi(networkKey);
+    const networkAddress = reformatAddress(address, chainInfo !== null && chainInfo !== void 0 && chainInfo.isTestnet ? 0 : 1);
+    const balances = await cardanoApi.getBalanceMap(networkAddress);
+    return convertAssetToValue(balances);
+  }
+  async cardanoSignData(id, url, params, currentAddress) {
+    const {
+      address: addressHex,
+      payload
+    } = params;
+    const address = convertCardanoHexToBech32(addressHex);
+    const payloadValidation = {
+      address,
+      type: 'cardano',
+      payloadAfterValidated: payload,
+      errors: [],
+      networkKey: ''
+    };
+    const validationSteps = [validationAuthMiddleware, validationCardanoSignDataMiddleware];
+    const result = await generateValidationProcess(this, url, payloadValidation, validationSteps);
+    if (!isSameAddress(address, currentAddress)) {
+      throw new CardanoProviderError(CardanoProviderErrorType.ACCOUNT_CHANGED);
+    }
+    const errorsFormated = convertErrorFormat(result.errors);
+    const payloadAfterValidated = {
+      ...result.payloadAfterValidated,
+      errors: errorsFormated,
+      id
+    };
+    return this.requestService.addConfirmationCardano(id, url, 'cardanoSignatureRequest', payloadAfterValidated, {}).then(({
+      isApproved,
+      payload
+    }) => {
+      if (isApproved) {
+        if (payload) {
+          return payload;
+        } else {
+          throw new CardanoProviderError(CardanoProviderErrorType.INVALID_REQUEST, t('Not found signature'));
+        }
+      } else {
+        throw new CardanoProviderError(CardanoProviderErrorType.SIGN_DATA_DECLINED);
+      }
+    });
+  }
+
+  // Todo: Add validate for this method
+  async cardanoSignTx(id, url, param, currentAddress) {
+    const {
+      partialSign,
+      tx: txHex
+    } = param;
+    const tx = CardanoWasm.Transaction.from_hex(txHex);
+    const inputs = tx.body().inputs();
+    const outputs = tx.body().outputs();
+    const estimateCardanoFee = tx.body().fee().to_str();
+    const authInfoMap = await this.getAuthList();
+    const authInfo = authInfoMap[stripUrl(url)];
+    if (!authInfo) {
+      throw new CardanoProviderError(CardanoProviderErrorType.REFUSED_REQUEST, t('Not found auth info'));
+    }
+    let requireKeyHashes = [];
+    let networkKey = authInfo === null || authInfo === void 0 ? void 0 : authInfo.currentNetworkMap.cardano;
+    let autoActiveChain = false;
+    if (authInfo !== null && authInfo !== void 0 && authInfo.isAllowed) {
+      autoActiveChain = true;
+    }
+    const currentEvmNetwork = this.requestService.getDAppChainInfo({
+      autoActive: autoActiveChain,
+      accessType: 'cardano',
+      defaultChain: networkKey,
+      url
+    });
+    networkKey = (currentEvmNetwork === null || currentEvmNetwork === void 0 ? void 0 : currentEvmNetwork.slug) || 'cardano';
+    const allUtxos = await this.chainService.getUtxosByAddress(currentAddress, networkKey);
+    const outputTransactionUnSpend = CardanoWasm.TransactionOutputs.new();
+    inputs.to_js_value().forEach(input => {
+      const availableUtxo = allUtxos.find(utxo => {
+        const txIn = utxo.input();
+        return txIn.transaction_id().to_hex() === input.transaction_id && txIn.index() === input.index;
+      });
+      if (availableUtxo) {
+        var _availableUtxo$output, _availableUtxo$output2;
+        const keyHash = (_availableUtxo$output = availableUtxo.output().address().payment_cred()) === null || _availableUtxo$output === void 0 ? void 0 : (_availableUtxo$output2 = _availableUtxo$output.to_keyhash()) === null || _availableUtxo$output2 === void 0 ? void 0 : _availableUtxo$output2.to_hex();
+        if (keyHash) {
+          requireKeyHashes.push(keyHash);
+        }
+        outputTransactionUnSpend.add(availableUtxo.output());
+      }
+    });
+    const addressInputMap = getBalanceAddressMap(outputTransactionUnSpend);
+    const addressOutputMap = getBalanceAddressMap(outputs);
+    const addressInputAmountMap = {};
+    const addressOutputAmountMap = {};
+    let transactionValue = CardanoWasm.Value.new(CardanoWasm.BigNum.from_str('0'));
+    for (const address in addressInputMap) {
+      var _addressOutputMap$add;
+      const output = (_addressOutputMap$add = addressOutputMap[address]) !== null && _addressOutputMap$add !== void 0 ? _addressOutputMap$add : CardanoWasm.Value.new(CardanoWasm.BigNum.from_str('0'));
+      const input = addressInputMap[address];
+      const amount = input.checked_sub(output);
+      if (amount.is_zero()) {
+        continue;
+      }
+      addressInputAmountMap[address] = {
+        values: convertValueToAsset(input)
+      };
+      addressOutputAmountMap[address] = {
+        values: convertValueToAsset(output)
+      };
+      if (isSameAddress(currentAddress, address)) {
+        transactionValue = transactionValue.checked_add(amount);
+        addressInputAmountMap[address].isOwner = true;
+        addressOutputAmountMap[address].isOwner = true;
+      }
+    }
+    for (const address in addressOutputMap) {
+      if (!addressInputAmountMap[address] && !addressOutputMap[address].is_zero()) {
+        addressOutputAmountMap[address] = {
+          values: convertValueToAsset(addressOutputMap[address]),
+          isRecipient: true
+        };
+      }
+    }
+    transactionValue = transactionValue.checked_sub(CardanoWasm.Value.new(tx.body().fee()));
+    const transactionBody = tx.body();
+    const getSpecificUtxo = this.chainService.getSpecificUtxo.bind(this);
+    requireKeyHashes.push(...extractKeyHashFromCertificate(transactionBody.certs()));
+    requireKeyHashes.push(...extractKeyHashesFromWithdrawals(transactionBody.withdrawals()));
+    requireKeyHashes.push(...extractKeyHashesFromRequiredSigners(transactionBody.required_signers()));
+    requireKeyHashes.push(...(await extractKeyHashesFromCollaterals(transactionBody.collateral(), getSpecificUtxo(networkKey))));
+    requireKeyHashes.push(...extractKeyHashesFromScripts(tx.witness_set().native_scripts()));
+    requireKeyHashes = [...new Set(requireKeyHashes)];
+    const addressRequireKeyTypes = [];
+    const keyHashAddressMap = {};
+    const pair = keyring.getPair(currentAddress);
+    if (pair) {
+      const publicKey = CardanoWasm.Bip32PublicKey.from_bytes(pair.publicKey);
+      const paymentPubKey = publicKey.derive(0).derive(0).to_raw_key().hash().to_hex();
+      const stakePubKey = publicKey.derive(2).derive(0).to_raw_key().hash().to_hex();
+      keyHashAddressMap[paymentPubKey] = 'payment';
+      keyHashAddressMap[stakePubKey] = 'stake';
+    } else {
+      throw new CardanoProviderError(CardanoProviderErrorType.INVALID_REQUEST);
+    }
+    const needForeignKeyHash = requireKeyHashes.some(key => {
+      const ownKeyHash = keyHashAddressMap[key];
+      if (ownKeyHash) {
+        addressRequireKeyTypes.push(ownKeyHash);
+        return false;
+      }
+      return true;
+    });
+    const needOwnerKeyHash = requireKeyHashes.some(key => {
+      const ownKeyHash = keyHashAddressMap[key];
+      if (ownKeyHash) {
+        addressRequireKeyTypes.push(ownKeyHash);
+        return true;
+      }
+      return false;
+    });
+    if (!needOwnerKeyHash) {
+      throw new CardanoProviderError(CardanoProviderErrorType.PROOF_GENERATION_FAILED, t('Not found owner key hash'));
+    }
+    if (needForeignKeyHash && !partialSign) {
+      throw new CardanoProviderError(CardanoProviderErrorType.INVALID_REQUEST, 'Not support foreign key hash yet');
+    }
+    const result = {
+      id,
+      txInputs: addressInputAmountMap,
+      txOutputs: addressOutputAmountMap,
+      addressRequireKeyTypes,
+      value: convertValueToAsset(transactionValue),
+      estimateCardanoFee,
+      from: currentAddress,
+      cardanoPayload: txHex,
+      networkKey
+    };
+    return this.requestService.addConfirmationCardano(id, url, 'cardanoSignTransactionRequest', result, {}).then(({
+      isApproved,
+      payload
+    }) => {
+      if (isApproved) {
+        if (payload) {
+          return payload;
+        } else {
+          throw new CardanoProviderError(CardanoProviderErrorType.INVALID_REQUEST, t('Not found signature'));
+        }
+      } else {
+        throw new CardanoProviderError(CardanoProviderErrorType.SIGN_TRANSACTION_DECLINED);
+      }
+    });
+  }
+  async cardanoSubmitTx(id, url, txHex) {
+    const currentNetwork = this.requestService.getDAppChainInfo({
+      autoActive: true,
+      accessType: 'cardano',
+      url
+    });
+    const networkKey = (currentNetwork === null || currentNetwork === void 0 ? void 0 : currentNetwork.slug) || 'cardano_preproduction';
+    const cardanoApi = this.chainService.getCardanoApi(networkKey);
+    return await cardanoApi.sendCardanoTxReturnHash(txHex);
+  }
   getConfirmationsQueueSubject() {
     return this.requestService.confirmationsQueueSubject;
   }

package/koni/background/handlers/Tabs.d.ts

@@ -30,7 +30,7 @@ export default class KoniTabs {
     private accountsSubstrateSubscribeV2;
     private accountsUnsubscribe;
     private authorizeV2;
-    private getEvmCurrentAccount;
+    private getCurrentAccount;
     private getEvmState;
     private getEvmPermission;
     private revokePermissions;
@@ -49,5 +49,15 @@ export default class KoniTabs {
     private handleEvmSend;
     isEvmPublicRequest(type: string, request: RequestArguments): boolean;
     addPspToken(id: string, url: string, { genesisHash, tokenInfo: input }: RequestAddPspToken): Promise<true>;
+    private getCurrentInformationCardanoDapp;
+    private cardanoGetAccountList;
+    private cardanoGetAccountBalance;
+    private cardanoGetChangeAddress;
+    private cardanoGetCurrentNetworkId;
+    private cardanoGetUtxo;
+    private cardanoGetCollateral;
+    private cardanoSignData;
+    private cardanoSignTransaction;
+    private cardanoSubmitTransaction;
     handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], url: string, port: chrome.runtime.Port): Promise<ResponseTypes[keyof ResponseTypes]>;
 }