@subwallet/extension-base 0.8.3-2 → 1.0.1

package/background/KoniTypes.d.ts

@@ -1,34 +1,32 @@
 /// <reference types="bn.js" />
+import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { AuthUrls, Resolver } from '@subwallet/extension-base/background/handlers/State';
-import { AccountAuthType, AccountJson, AuthorizeRequest, RequestAccountList, RequestAccountSubscribe, RequestAuthorizeCancel, RequestAuthorizeReject, RequestAuthorizeSubscribe, RequestAuthorizeTab, RequestCurrentAccountAddress, ResponseAuthorizeList, ResponseJsonGetAccountInfo, SeedLengths } from '@subwallet/extension-base/background/types';
-import { ExternalState, LedgerState, QrState } from '@subwallet/extension-base/signers/types';
+import { AccountAuthType, AccountJson, AuthorizeRequest, ConfirmationRequestBase, RequestAccountList, RequestAccountSubscribe, RequestAuthorizeCancel, RequestAuthorizeReject, RequestAuthorizeSubscribe, RequestAuthorizeTab, RequestCurrentAccountAddress, ResponseAuthorizeList, ResponseJsonGetAccountInfo, SeedLengths } from '@subwallet/extension-base/background/types';
+import { _CHAIN_VALIDATION_ERROR } from '@subwallet/extension-base/services/chain-service/handler/types';
+import { _ChainState, _EvmApi, _NetworkUpsertParams, _SubstrateApi, _ValidateCustomAssetRequest, _ValidateCustomAssetResponse } from '@subwallet/extension-base/services/chain-service/types';
+import { SWTransactionResponse, SWTransactionResult } from '@subwallet/extension-base/services/transaction-service/types';
 import { InjectedAccount, MetadataDefBase } from '@subwallet/extension-inject/types';
+import { KeyringPair$Json, KeyringPair$Meta } from '@subwallet/keyring/types';
+import { SingleAddress } from '@subwallet/ui-keyring/observable/types';
+import { KeyringOptions } from '@subwallet/ui-keyring/options/types';
+import { KeyringPairs$Json } from '@subwallet/ui-keyring/types';
 import Web3 from 'web3';
 import { RequestArguments, TransactionConfig } from 'web3-core';
 import { JsonRpcPayload, JsonRpcResponse } from 'web3-core-helpers';
-import { ApiPromise } from '@polkadot/api';
-import { SubmittableExtrinsicFunction } from '@polkadot/api/promise/types';
-import { KeyringPair$Json, KeyringPair$Meta } from '@polkadot/keyring/types';
-import { Registry } from '@polkadot/types/types';
 import { SignerResult } from '@polkadot/types/types/extrinsic';
-import { SingleAddress } from '@polkadot/ui-keyring/observable/types';
-import { KeyringOptions } from '@polkadot/ui-keyring/options/types';
-import { KeyringPairs$Json } from '@polkadot/ui-keyring/types';
 import { BN } from '@polkadot/util';
 import { KeypairType } from '@polkadot/util-crypto/types';
+import { TransactionWarning } from './warnings/TransactionWarning';
 export interface ServiceInfo {
-    networkMap: Record<string, NetworkJson>;
-    apiMap: ApiMap;
-    isLock?: boolean;
+    chainInfoMap: Record<string, _ChainInfo>;
+    chainStateMap: Record<string, _ChainState>;
+    chainApiMap: ApiMap;
     currentAccountInfo: CurrentAccountInfo;
-    chainRegistry: Record<string, ChainRegistry>;
-    customNftRegistry: CustomToken[];
+    assetRegistry: Record<string, _ChainAsset>;
 }
-export declare enum ApiInitStatus {
-    SUCCESS = 0,
-    ALREADY_EXIST = 1,
-    NOT_SUPPORT = 2,
-    NOT_EXIST = 3
+export interface AssetSetting {
+    visible: boolean;
 }
 export interface AuthRequestV2 extends Resolver<ResultResolver> {
     id: string;
@@ -98,14 +96,13 @@ export interface StakingItem {
     name: string;
     chain: string;
     address: string;
+    type: StakingType;
     balance?: string;
     activeBalance?: string;
     unlockingBalance?: string;
     nativeToken: string;
     unit?: string;
-    type: StakingType;
     state: APIItemState;
-    unlockingInfo?: UnlockingStakeInfo;
     rewardInfo?: StakingRewardItem;
 }
 export interface StakingJson {
@@ -118,15 +115,11 @@ export interface StakingRewardJson {
     slowInterval: Array<StakingRewardItem>;
     fastInterval: Array<StakingRewardItem>;
 }
-export interface StakeUnlockingJson {
-    timestamp: number;
-    details: UnlockingStakeInfo[];
-}
 export interface PriceJson {
     ready?: boolean;
     currency: string;
     priceMap: Record<string, number>;
-    tokenPriceMap: Record<string, number>;
+    price24hMap: Record<string, number>;
 }
 export declare enum APIItemState {
     PENDING = "pending",
@@ -144,33 +137,30 @@ export declare enum CrowdloanParaState {
     COMPLETED = "completed",
     FAILED = "failed"
 }
-export interface NftTransferExtra {
-    cronUpdate: boolean;
-    forceUpdate: boolean;
-    selectedNftCollection?: NftCollection;
-    nftItems?: NftItem[];
-}
 export interface NftItem {
-    id?: string;
+    id: string;
+    chain: string;
+    collectionId: string;
+    owner: string;
+    originAsset?: string;
     name?: string;
     image?: string;
-    external_url?: string;
+    externalUrl?: string;
     rarity?: string;
-    collectionId?: string;
     description?: string;
     properties?: Record<any, any> | null;
-    chain?: string;
-    type?: CustomTokenType.erc721 | CustomTokenType.psp34 | RMRK_VER;
+    type?: _AssetType.ERC721 | _AssetType.PSP34 | RMRK_VER;
     rmrk_ver?: RMRK_VER;
-    owner?: string;
     onChainOption?: any;
 }
 export interface NftCollection {
     collectionId: string;
+    chain: string;
+    originAsset?: string;
     collectionName?: string;
     image?: string;
-    chain?: string;
     itemCount?: number;
+    externalUrl?: string;
 }
 export interface NftJson {
     total: number;
@@ -180,29 +170,23 @@ export interface NftCollectionJson {
     ready: boolean;
     nftCollectionList: Array<NftCollection>;
 }
-export interface NftStoreJson {
-    nftList: Array<NftItem>;
-    nftCollectionList: Array<NftCollection>;
-}
 export interface TokenBalanceRaw {
     reserved: BN;
     frozen: BN;
     free: BN;
 }
-export interface BalanceChildItem {
-    reserved: string;
-    frozen: string;
-    free: string;
-    decimals: number;
-}
-export interface BalanceItem {
-    state: APIItemState;
-    free?: string;
+export interface SubstrateBalance {
     reserved?: string;
     miscFrozen?: string;
     feeFrozen?: string;
-    children?: Record<string, BalanceChildItem>;
+}
+export interface BalanceItem {
+    tokenSlug: string;
+    state: APIItemState;
     timestamp?: number;
+    free: string;
+    locked: string;
+    substrateInfo?: SubstrateBalance;
 }
 export interface BalanceJson {
     reset?: boolean;
@@ -217,59 +201,7 @@ export interface CrowdloanJson {
     reset?: boolean;
     details: Record<string, CrowdloanItem>;
 }
-export interface ChainRegistry {
-    chainDecimals: number[];
-    chainTokens: string[];
-    tokenMap: Record<string, TokenInfo>;
-}
-export interface DefaultFormatBalance {
-    decimals?: number[] | number;
-    unit?: string[] | string;
-}
-export interface ApiState {
-    apiDefaultTx: SubmittableExtrinsicFunction;
-    apiDefaultTxSudo: SubmittableExtrinsicFunction;
-    isApiInitialized: boolean;
-    isApiReady: boolean;
-    isDevelopment?: boolean;
-    isEthereum?: boolean;
-    specName: string;
-    specVersion: string;
-    systemChain: string;
-    systemName: string;
-    systemVersion: string;
-    registry: Registry;
-    defaultFormatBalance: DefaultFormatBalance;
-}
-export interface ApiProps extends ApiState {
-    api: ApiPromise;
-    apiError?: string;
-    apiUrl: string;
-    isNotSupport?: boolean;
-    isApiConnected: boolean;
-    isEthereum: boolean;
-    isEthereumOnly: boolean;
-    isApiInitialized: boolean;
-    isReady: Promise<ApiProps>;
-    apiRetry?: number;
-    recoverConnect?: () => void;
-    useEvmAddress?: boolean;
-}
 export declare type NetWorkGroup = 'RELAY_CHAIN' | 'POLKADOT_PARACHAIN' | 'KUSAMA_PARACHAIN' | 'MAIN_NET' | 'TEST_NET' | 'UNKNOWN';
-export interface NetWorkInfo {
-    chain: string;
-    genesisHash: string;
-    icon?: string;
-    ss58Format: number;
-    chainType?: 'substrate' | 'ethereum';
-    provider: string;
-    groups: NetWorkGroup[];
-    paraId?: number;
-    isEthereum?: boolean;
-    nativeToken?: string;
-    crowdloanUrl?: string;
-    decimals?: number;
-}
 export declare enum ContractType {
     wasm = "wasm",
     evm = "evm"
@@ -312,18 +244,10 @@ export interface DonateInfo {
     icon: string;
     link: string;
 }
-export interface DropdownOptionType {
-    text: string;
-    value: string;
-}
 export interface DropdownTransformOptionType {
     label: string;
     value: string;
 }
-export interface DropdownTransformGroupOptionType {
-    label: string;
-    options: DropdownTransformOptionType[];
-}
 export interface NetWorkMetadataDef extends MetadataDefBase {
     networkKey: string;
     groups: NetWorkGroup[];
@@ -341,19 +265,6 @@ export declare type CurrentNetworkInfo = {
     isEthereum: boolean;
     isReady?: boolean;
 };
-export declare type TokenInfo = {
-    isMainToken: boolean;
-    symbol: string;
-    symbolAlt?: string;
-    contractAddress?: string;
-    type?: CustomTokenType;
-    decimals: number;
-    name: string;
-    coinGeckoKey?: string;
-    specialOption?: object;
-    assetId?: string;
-    assetIndex?: number | string;
-};
 export interface AccountsWithCurrentAddress {
     accounts: AccountJson[];
     currentAddress?: string;
@@ -369,52 +280,215 @@ export interface CurrentAccountInfo {
     currentGenesisHash: string | null;
     allGenesisHash?: string;
 }
-export interface RequestSettingsType {
-    isShowBalance: boolean;
-    accountAllLogo: string;
-    theme: ThemeTypes;
-}
-export interface ResponseSettingsType {
+export declare type LanguageType = 'en' | 'zh' | 'fr' | 'tr' | 'pl' | 'th' | 'ur';
+export declare type LanguageOptionType = {
+    text: string;
+    value: LanguageType;
+};
+export declare type BrowserConfirmationType = 'extension' | 'popup' | 'window';
+export interface UiSettings {
+    browserConfirmationType: BrowserConfirmationType;
     isShowBalance: boolean;
     accountAllLogo: string;
-    theme: ThemeTypes;
+    theme: ThemeNames;
+    camera: boolean;
 }
+export declare type RequestSettingsType = UiSettings;
+export declare type RequestCameraSettings = {
+    camera: boolean;
+};
 export interface RandomTestRequest {
     start: number;
     end: number;
 }
-export interface TransactionHistoryItemType {
+export declare enum TransactionDirection {
+    SEND = "send",
+    RECEIVED = "received"
+}
+export declare enum ChainType {
+    EVM = "evm",
+    SUBSTRATE = "substrate"
+}
+export declare enum ExtrinsicType {
+    TRANSFER_BALANCE = "transfer.balance",
+    TRANSFER_TOKEN = "transfer.token",
+    TRANSFER_XCM = "transfer.xcm",
+    SEND_NFT = "send_nft",
+    CROWDLOAN = "crowdloan",
+    STAKING_JOIN_POOL = "staking.join_pool",
+    STAKING_LEAVE_POOL = "staking.leave_pool",
+    STAKING_POOL_WITHDRAW = "staking.pool_withdraw",
+    STAKING_BOND = "staking.bond",
+    STAKING_UNBOND = "staking.unbond",
+    STAKING_CLAIM_REWARD = "staking.claim_reward",
+    STAKING_WITHDRAW = "staking.withdraw",
+    STAKING_COMPOUNDING = "staking.compounding",
+    STAKING_CANCEL_COMPOUNDING = "staking.cancel_compounding",
+    STAKING_CANCEL_UNSTAKE = "staking.cancel_unstake",
+    EVM_EXECUTE = "evm.execute",
+    UNKNOWN = "unknown"
+}
+export interface ExtrinsicDataTypeMap {
+    [ExtrinsicType.TRANSFER_BALANCE]: RequestTransfer;
+    [ExtrinsicType.TRANSFER_TOKEN]: RequestTransfer;
+    [ExtrinsicType.TRANSFER_XCM]: RequestCrossChainTransfer;
+    [ExtrinsicType.SEND_NFT]: NftTransactionRequest;
+    [ExtrinsicType.CROWDLOAN]: any;
+    [ExtrinsicType.STAKING_JOIN_POOL]: RequestStakePoolingBonding;
+    [ExtrinsicType.STAKING_LEAVE_POOL]: RequestStakePoolingUnbonding;
+    [ExtrinsicType.STAKING_BOND]: RequestStakePoolingBonding;
+    [ExtrinsicType.STAKING_UNBOND]: RequestUnbondingSubmit;
+    [ExtrinsicType.STAKING_CLAIM_REWARD]: RequestStakeClaimReward;
+    [ExtrinsicType.STAKING_WITHDRAW]: RequestStakeWithdrawal;
+    [ExtrinsicType.STAKING_COMPOUNDING]: RequestTuringStakeCompound;
+    [ExtrinsicType.STAKING_CANCEL_COMPOUNDING]: RequestTuringCancelStakeCompound;
+    [ExtrinsicType.STAKING_CANCEL_UNSTAKE]: RequestStakeCancelWithdrawal;
+    [ExtrinsicType.STAKING_POOL_WITHDRAW]: any;
+    [ExtrinsicType.EVM_EXECUTE]: any;
+    [ExtrinsicType.UNKNOWN]: any;
+}
+export declare enum ExtrinsicStatus {
+    PENDING = "pending",
+    PROCESSING = "processing",
+    SUCCESS = "success",
+    FAIL = "fail",
+    UNKNOWN = "unknown"
+}
+export interface TxHistoryItem {
     time: number | string;
     networkKey: string;
-    change: string;
+    isSuccess: boolean;
+    action: TransactionDirection;
+    extrinsicHash: string;
+    change?: string;
     changeSymbol?: string;
     fee?: string;
     feeSymbol?: string;
-    isSuccess: boolean;
-    action: 'send' | 'received';
-    extrinsicHash: string;
     origin?: 'app' | 'network';
-    eventIdx?: number | null;
 }
 export interface TransactionHistoryItemJson {
-    items: TransactionHistoryItemType[];
+    items: TxHistoryItem[];
     total: number;
 }
-export interface RequestTransactionHistoryGet {
-    address: string;
-    networkKey: string;
+export interface BasicTokenInfo {
+    decimals: number;
+    symbol: string;
 }
-export interface RequestTransactionHistoryGetByMultiNetworks {
-    address: string;
-    networkKeys: string[];
+export interface AmountData extends BasicTokenInfo {
+    value: string;
+}
+export interface XCMTransactionAdditionalInfo {
+    destinationChain: string;
+    fee: AmountData;
 }
-export interface RequestTransactionHistoryAdd {
+export interface NFTTransactionAdditionalInfo {
+    collectionName: string;
+}
+export declare type TransactionAdditionalInfo<T extends ExtrinsicType> = T extends ExtrinsicType.TRANSFER_XCM ? XCMTransactionAdditionalInfo : T extends ExtrinsicType.SEND_NFT ? NFTTransactionAdditionalInfo : undefined;
+export interface TransactionHistoryItem<ET extends ExtrinsicType = ExtrinsicType.TRANSFER_BALANCE> {
+    origin?: string;
+    callhash?: string;
+    signature?: string;
+    chain: string;
+    chainType?: ChainType;
+    chainName?: string;
+    direction: TransactionDirection;
+    type: ExtrinsicType;
+    from: string;
+    fromName?: string;
+    to: string;
+    toName?: string;
     address: string;
-    networkKey: string;
-    item: TransactionHistoryItemType;
+    status: ExtrinsicStatus;
+    extrinsicHash: string;
+    time: number;
+    data?: string;
+    blockNumber: number;
+    blockHash: string;
+    amount?: AmountData;
+    tip?: AmountData;
+    fee?: AmountData;
+    explorerUrl?: string;
+    additionalInfo?: TransactionAdditionalInfo<ET>;
+}
+export interface SWError extends Error {
+    code?: number;
+    errorType: string;
+    data?: unknown;
 }
-export interface RequestApi {
-    networkKey: string;
+export interface SWWarning {
+    errorType: string;
+    code?: number;
+    message: string;
+    data?: unknown;
+}
+export declare enum BasicTxErrorType {
+    NOT_ENOUGH_FEE = "NOT_ENOUGH_FEE",
+    NOT_ENOUGH_BALANCE = "NOT_ENOUGH_BALANCE",
+    CHAIN_DISCONNECTED = "CHAIN_DISCONNECTED",
+    INVALID_PARAMS = "INVALID_PARAMS",
+    DUPLICATE_TRANSACTION = "DUPLICATE_TRANSACTION",
+    UNABLE_TO_SIGN = "UNABLE_TO_SIGN",
+    USER_REJECT_REQUEST = "USER_REJECT_REQUEST",
+    UNABLE_TO_SEND = "UNABLE_TO_SEND",
+    SEND_TRANSACTION_FAILED = "SEND_TRANSACTION_FAILED",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    UNSUPPORTED = "UNSUPPORTED",
+    NOT_ENOUGH_EXISTENTIAL_DEPOSIT = "NOT_ENOUGH_EXISTENTIAL_DEPOSIT"
+}
+export declare enum StakingTxErrorType {
+    STAKING_ERROR = "stakingError",
+    UN_STAKING_ERROR = "unStakingError",
+    WITHDRAW_STAKING_ERROR = "withdrawStakingError",
+    CLAIM_REWARD_ERROR = "claimRewardError",
+    CREATE_COMPOUND_ERROR = "createCompoundError",
+    CANCEL_COMPOUND_ERROR = "cancelCompoundError"
+}
+export declare enum TransferTxErrorType {
+    NOT_ENOUGH_VALUE = "NOT_ENOUGH_VALUE",
+    NOT_ENOUGH_FEE = "NOT_ENOUGH_FEE",
+    INVALID_TOKEN = "INVALID_TOKEN",
+    TRANSFER_ERROR = "TRANSFER_ERROR"
+}
+export declare type TransactionErrorType = BasicTxErrorType | TransferTxErrorType | StakingTxErrorType;
+export declare enum BasicTxWarningCode {
+    NOT_ENOUGH_EXISTENTIAL_DEPOSIT = "notEnoughExistentialDeposit"
+}
+export declare type BasicTxError = {
+    errorType: TxErrorCode;
+    data?: object;
+    message: string;
+};
+export declare type BasicTxWarning = {
+    warningType: TransactionWarningType;
+    data?: object;
+    message: string;
+};
+export interface TransactionResponse {
+    extrinsicHash?: string;
+    txError?: boolean;
+    errors?: TransactionError[];
+    status?: boolean;
+    txResult?: TxResultType;
+    passwordError?: string | null;
+}
+export interface NftTransactionResponse extends SWTransactionResponse {
+    isSendingSelf: boolean;
+}
+export declare type HandleBasicTx = (data: TransactionResponse) => void;
+export declare type TxErrorCode = TransferTxErrorType | TransactionErrorType;
+export declare enum BalanceErrorType {
+    NETWORK_ERROR = "NETWORK_ERROR",
+    TOKEN_ERROR = "TOKEN_ERROR",
+    TIMEOUT = "TIMEOUT",
+    GET_BALANCE_ERROR = "GET_BALANCE_ERROR"
+}
+export declare type TransactionWarningType = BasicTxWarningCode;
+export declare enum ProviderErrorType {
+    CHAIN_DISCONNECTED = "CHAIN_DISCONNECTED",
+    INVALID_PARAMS = "INVALID_PARAMS",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    USER_REJECT = "USER_REJECT"
 }
 export interface RequestAccountExportPrivateKey {
     address: string;
@@ -450,7 +524,7 @@ export declare type ResponseSeedValidateV2 = ResponseSeedCreateV2;
 export interface RequestAccountCreateSuriV2 {
     name: string;
     genesisHash?: string | null;
-    password: string;
+    password?: string;
     suri: string;
     types?: Array<KeypairType>;
     isAllowed: boolean;
@@ -461,15 +535,43 @@ export interface RequestDeriveCreateV2 {
     genesisHash?: string | null;
     suri: string;
     parentAddress: string;
-    parentPassword: string;
-    password: string;
     isAllowed: boolean;
 }
+export interface CreateDeriveAccountInfo {
+    name: string;
+    suri: string;
+}
+export interface RequestDeriveCreateV3 {
+    address: string;
+}
+export interface RequestDeriveCreateMultiple {
+    parentAddress: string;
+    isAllowed: boolean;
+    items: CreateDeriveAccountInfo[];
+}
+export interface DeriveAccountInfo {
+    address: string;
+    suri: string;
+}
+export interface RequestDeriveValidateV2 {
+    suri: string;
+    parentAddress: string;
+}
+export declare type ResponseDeriveValidateV2 = DeriveAccountInfo;
+export interface RequestGetDeriveAccounts {
+    page: number;
+    limit: number;
+    parentAddress: string;
+}
+export interface ResponseGetDeriveAccounts {
+    result: DeriveAccountInfo[];
+}
 export interface RequestJsonRestoreV2 {
     file: KeyringPair$Json;
     password: string;
     address: string;
     isAllowed: boolean;
+    withMasterPassword: boolean;
 }
 export interface RequestBatchRestoreV2 {
     file: KeyringPairs$Json;
@@ -507,10 +609,20 @@ export interface RequestAccountCreateHardwareV2 {
     name: string;
     isAllowed?: boolean;
 }
+export interface CreateHardwareAccountItem {
+    accountIndex: number;
+    address: string;
+    addressOffset: number;
+    genesisHash: string;
+    hardwareType: string;
+    name: string;
+}
+export interface RequestAccountCreateHardwareMultiple {
+    accounts: CreateHardwareAccountItem[];
+}
 export interface RequestAccountCreateWithSecretKey {
     publicKey: string;
     secretKey: string;
-    password: string;
     name: string;
     isAllow: boolean;
     isEthereum: boolean;
@@ -560,15 +672,11 @@ export declare type RequestSubscribeCrowdloan = null;
 export declare type RequestSubscribeNft = null;
 export declare type RequestSubscribeStaking = null;
 export declare type RequestSubscribeStakingReward = null;
-export declare type ThemeTypes = 'light' | 'dark' | 'subspace';
-export declare type RequestNftForceUpdate = {
-    collectionId: string;
-    nft: NftItem;
-    isSendingSelf: boolean;
-    chain: string;
-    senderAddress: string;
-    recipientAddress: string;
-};
+export declare enum ThemeNames {
+    LIGHT = "light",
+    DARK = "dark",
+    SUBSPACE = "subspace"
+}
 export declare enum NETWORK_ERROR {
     INVALID_INFO_TYPE = "invalidInfoType",
     INJECT_SCRIPT_DETECTED = "injectScriptDetected",
@@ -585,74 +693,10 @@ export declare enum NETWORK_STATUS {
     DISCONNECTED = "disconnected",
     PENDING = "pending"
 }
-export declare enum TransferErrorCode {
-    NOT_ENOUGH_VALUE = "notEnoughValue",
-    NOT_ENOUGH_FEE = "notEnoughValue",
-    INVALID_VALUE = "invalidValue",
-    INVALID_TOKEN = "invalidToken",
-    TRANSFER_ERROR = "transferError",
-    UNSUPPORTED = "unsupported"
-}
-export declare enum BasicTxErrorCode {
-    INVALID_PARAM = "invalidParam",
-    KEYRING_ERROR = "keyringError",
-    STAKING_ERROR = "stakingError",
-    UN_STAKING_ERROR = "unStakingError",
-    WITHDRAW_STAKING_ERROR = "withdrawStakingError",
-    CLAIM_REWARD_ERROR = "claimRewardError",
-    CREATE_COMPOUND_ERROR = "createCompoundError",
-    CANCEL_COMPOUND_ERROR = "cancelCompoundError",
-    TIMEOUT = "timeout",
-    BALANCE_TO_LOW = "balanceTooLow1",
-    UNKNOWN_ERROR = "unknownError"
-}
-export declare enum BasicTxWarningCode {
-    NOT_ENOUGH_EXISTENTIAL_DEPOSIT = "notEnoughExistentialDeposit"
-}
-export declare type TxErrorCode = TransferErrorCode | BasicTxErrorCode;
-export declare type TxWarningCode = BasicTxWarningCode;
-export declare type BasicTxError = {
-    code: TxErrorCode;
-    data?: object;
-    message: string;
-};
-export declare type BasicTxWarning = {
-    code: TxWarningCode;
-    data?: object;
-    message: string;
-};
-export interface BasicTxResponse {
-    passwordError?: string | null;
-    callHash?: string;
-    status?: boolean;
-    extrinsicHash?: string;
-    txError?: boolean;
-    errors?: BasicTxError[];
-    externalState?: ExternalState;
-    qrState?: QrState;
-    ledgerState?: LedgerState;
-    isBusy?: boolean;
-    txResult?: TxResultType;
-    isFinalized?: boolean;
-}
-export interface NftTransactionResponse extends BasicTxResponse {
-    isSendingSelf: boolean;
-}
-export declare type HandleBasicTx = (data: BasicTxResponse) => void;
-export declare type HandleTxResponse<T extends BasicTxResponse> = (data: T) => void;
-export declare type BaseRequestSign = {};
-export declare type PasswordRequestSign<T extends BaseRequestSign> = T & {
-    password: string;
+export declare type BaseRequestSign = {
+    ignoreWarnings?: boolean;
 };
-export declare type ExternalRequestSign<T extends BaseRequestSign> = Omit<T, 'password'>;
-export declare enum TransferStep {
-    READY = "ready",
-    SIGNING = "signing",
-    START = "start",
-    PROCESSING = "processing",
-    SUCCESS = "success",
-    ERROR = "error"
-}
+export declare type InternalRequestSign<T extends BaseRequestSign> = Omit<T, 'password'>;
 export declare type TxResultType = {
     change: string;
     changeSymbol?: string;
@@ -663,86 +707,41 @@ export interface NftTransactionRequest {
     networkKey: string;
     senderAddress: string;
     recipientAddress: string;
+    nftItemName?: string;
     params: Record<string, any>;
+    nftItem: NftItem;
 }
-export interface EvmNftTransaction {
+export interface EvmNftTransaction extends ValidateTransactionResponse {
     tx: Record<string, any> | null;
-    estimatedFee: string | null;
-    balanceError: boolean;
 }
 export interface EvmNftSubmitTransaction extends BaseRequestSign {
     senderAddress: string;
     recipientAddress: string;
     networkKey: string;
+    estimateGas: string;
     rawTransaction: Record<string, any>;
 }
 export interface ValidateNetworkResponse {
     success: boolean;
-    key: string;
-    genesisHash: string;
-    ss58Prefix: string;
-    networkGroup: NetWorkGroup[];
-    chain: string;
-    evmChainId: number;
-    nativeToken?: string;
-    decimal?: number;
-    error?: NETWORK_ERROR;
+    error?: _CHAIN_VALIDATION_ERROR;
     conflictChain?: string;
     conflictKey?: string;
+    genesisHash: string;
+    addressPrefix: string;
+    name: string;
+    paraId: number | null;
+    evmChainId: number | null;
+    symbol: string;
+    decimals: number;
+    existentialDeposit: string;
 }
 export interface ValidateNetworkRequest {
     provider: string;
-    isEthereum: boolean;
-    existedNetwork?: NetworkJson;
+    existedChainSlug?: string;
 }
 export interface ApiMap {
-    dotSama: Record<string, ApiProps>;
-    web3: Record<string, Web3>;
-}
-export interface DisableNetworkResponse {
-    success: boolean;
-    activeNetworkCount?: number;
-}
-export declare enum CustomTokenType {
-    erc20 = "erc20",
-    erc721 = "erc721",
-    psp22 = "psp22",
-    psp34 = "psp34"
-}
-export interface CustomToken {
-    smartContract: string;
-    chain: string;
-    type: CustomTokenType;
-    name?: string;
-    symbol?: string;
-    decimals?: number;
-    isCustom?: boolean;
-    isDeleted?: boolean;
-    image?: string;
-}
-export interface CustomTokenJson {
-    [CustomTokenType.erc20]: CustomToken[];
-    [CustomTokenType.erc721]: CustomToken[];
-    [CustomTokenType.psp22]: CustomToken[];
-    [CustomTokenType.psp34]: CustomToken[];
-}
-export interface DeleteCustomTokenParams {
-    smartContract: string;
-    chain: string;
-    type: CustomTokenType;
-}
-export interface ValidateCustomTokenRequest {
-    smartContract: string;
-    chain: string;
-    type: CustomTokenType;
-    contractCaller?: string;
-}
-export interface ValidateCustomTokenResponse {
-    name: string;
-    symbol: string;
-    decimals?: number;
-    isExist: boolean;
-    contractError: boolean;
+    substrate: Record<string, _SubstrateApi>;
+    evm: Record<string, _EvmApi>;
 }
 export interface SupportTransferResponse {
     supportTransfer: boolean;
@@ -759,11 +758,10 @@ export interface RequestTransferCheckReferenceCount {
 }
 export interface RequestTransferCheckSupporting {
     networkKey: string;
-    token: string;
+    tokenSlug: string;
 }
 export interface RequestTransferExistentialDeposit {
-    networkKey: string;
-    token: string;
+    tokenSlug: string;
 }
 export interface RequestSaveRecentAccount {
     accountId: string;
@@ -776,21 +774,11 @@ export interface SubstrateNftTransaction {
 export interface SubstrateNftSubmitTransaction extends BaseRequestSign {
     params: Record<string, any> | null;
     senderAddress: string;
+    nftItemName?: string;
     recipientAddress: string;
 }
-export declare type RequestSubstrateNftSubmitTransaction = PasswordRequestSign<SubstrateNftSubmitTransaction>;
-export declare type RequestEvmNftSubmitTransaction = PasswordRequestSign<EvmNftSubmitTransaction>;
-export declare type ChainRelationType = 'p' | 'r';
-export interface ChainRelationInfo {
-    type: ChainRelationType;
-    isEthereum: boolean;
-    supportedToken: string[];
-}
-export interface CrossChainRelation {
-    type: ChainRelationType;
-    isEthereum: boolean;
-    relationMap: Record<string, ChainRelationInfo>;
-}
+export declare type RequestSubstrateNftSubmitTransaction = InternalRequestSign<SubstrateNftSubmitTransaction>;
+export declare type RequestEvmNftSubmitTransaction = InternalRequestSign<EvmNftSubmitTransaction>;
 export interface RequestAccountMeta {
     address: string | Uint8Array;
 }
@@ -821,14 +809,15 @@ export interface ResponseEvmProviderSend {
     error: (Error | null);
     result?: JsonRpcResponse;
 }
-export interface SubWalletProviderErrorInterface extends Error {
-    code?: number;
-    data?: unknown;
-}
-export interface EvmProviderRpcErrorInterface extends SubWalletProviderErrorInterface {
-    code: number;
+export declare enum EvmProviderErrorType {
+    USER_REJECTED_REQUEST = "USER_REJECTED_REQUEST",
+    UNAUTHORIZED = "UNAUTHORIZED",
+    UNSUPPORTED_METHOD = "UNSUPPORTED_METHOD",
+    DISCONNECTED = "DISCONNECTED",
+    CHAIN_DISCONNECTED = "CHAIN_DISCONNECTED",
+    INVALID_PARAMS = "INVALID_PARAMS",
+    INTERNAL_ERROR = "INTERNAL_ERROR"
 }
-export declare type EvmRpcErrorHelperMap = Record<'USER_REJECTED_REQUEST' | 'UNAUTHORIZED' | 'UNSUPPORTED_METHOD' | 'DISCONNECTED' | 'CHAIN_DISCONNECTED' | 'INVALID_PARAMS' | 'INTERNAL_ERROR', [number, string]>;
 export interface EvmSendTransactionParams {
     from: string;
     to?: string;
@@ -843,34 +832,33 @@ export interface SwitchNetworkRequest {
     networkKey: string;
     address?: string;
 }
-export interface EvmSignatureRequest {
-    address: string;
+export interface EvmSignRequest {
+    account: AccountJson;
+    hashPayload: string;
+    canSign: boolean;
+}
+export interface EvmSignatureRequest extends EvmSignRequest {
+    id: string;
     type: string;
     payload: unknown;
 }
+export interface EvmSendTransactionRequest extends TransactionConfig, EvmSignRequest {
+    estimateGas: string;
+    parseData: EvmTransactionData;
+    isToContract: boolean;
+}
 export interface ConfirmationsQueueItemOptions {
     requiredPassword?: boolean;
     address?: string;
     networkKey?: string;
 }
-export interface ConfirmationsQueueItem<T> extends ConfirmationsQueueItemOptions {
-    id: string;
-    url: string;
+export interface ConfirmationsQueueItem<T> extends ConfirmationsQueueItemOptions, ConfirmationRequestBase {
     payload: T;
     payloadJson: string;
 }
-export interface ConfirmationResult<T> {
-    id: string;
+export interface ConfirmationResult<T> extends ConfirmationRequestBase {
     isApproved: boolean;
-    url?: string;
     payload?: T;
-    password?: string;
-}
-export interface ConfirmationResultExternal<T> extends ConfirmationResult<T> {
-    signature: `0x${string}`;
-}
-export interface EvmSendTransactionRequest extends TransactionConfig {
-    estimateGas: string;
 }
 export interface EvmRequestExternal {
     hashPayload: string;
@@ -880,82 +868,83 @@ export interface EvmSendTransactionRequestExternal extends EvmSendTransactionReq
 }
 export interface EvmSignatureRequestExternal extends EvmSignatureRequest, EvmRequestExternal {
 }
+export interface AddNetworkRequestExternal {
+    chainId: string;
+    rpcUrls: string[];
+    chainName: string;
+    blockExplorerUrls?: string[];
+    requestId?: string;
+}
+export interface AddNetworkExternalRequest {
+    chainId: string;
+    rpcUrl: string;
+    chainName: string;
+    blockExplorerUrl: string;
+    requestId: string;
+}
+export interface AddTokenRequestExternal {
+    contractAddress: string;
+    originChain: string;
+    type: _AssetType;
+    name: string;
+    symbol: string;
+    decimals: number;
+}
 export interface ConfirmationDefinitions {
-    addNetworkRequest: [ConfirmationsQueueItem<NetworkJson>, ConfirmationResult<NetworkJson>];
-    addTokenRequest: [ConfirmationsQueueItem<CustomToken>, ConfirmationResult<boolean>];
+    addNetworkRequest: [ConfirmationsQueueItem<_NetworkUpsertParams>, ConfirmationResult<null>];
+    addTokenRequest: [ConfirmationsQueueItem<AddTokenRequestExternal>, ConfirmationResult<boolean>];
     switchNetworkRequest: [ConfirmationsQueueItem<SwitchNetworkRequest>, ConfirmationResult<boolean>];
     evmSignatureRequest: [ConfirmationsQueueItem<EvmSignatureRequest>, ConfirmationResult<string>];
-    evmSignatureRequestExternal: [ConfirmationsQueueItem<EvmSignatureRequestExternal>, ConfirmationResultExternal<string>];
-    evmSendTransactionRequest: [ConfirmationsQueueItem<EvmSendTransactionRequest>, ConfirmationResult<boolean>];
-    evmSendTransactionRequestExternal: [ConfirmationsQueueItem<EvmSendTransactionRequestExternal>, ConfirmationResultExternal<boolean>];
+    evmSendTransactionRequest: [ConfirmationsQueueItem<EvmSendTransactionRequest>, ConfirmationResult<string>];
 }
 export declare type ConfirmationType = keyof ConfirmationDefinitions;
 export declare type ConfirmationsQueue = {
-    [ConfirmationType in keyof ConfirmationDefinitions]: Record<string, ConfirmationDefinitions[ConfirmationType][0]>;
+    [CT in ConfirmationType]: Record<string, ConfirmationDefinitions[CT][0]>;
 };
 export declare type RequestConfirmationsSubscribe = null;
 export declare type RequestConfirmationComplete = {
-    [ConfirmationType in keyof ConfirmationDefinitions]?: ConfirmationDefinitions[ConfirmationType][1];
+    [CT in ConfirmationType]?: ConfirmationDefinitions[CT][1];
 };
-export interface ValidatorInfo {
-    address: string;
-    totalStake: number;
-    ownStake: number;
-    otherStake: number;
-    nominatorCount: number;
-    commission: number;
-    expectedReturn: number;
-    blocked: boolean;
-    identity?: string;
-    isVerified: boolean;
-    minBond: number;
-    isNominated: boolean;
-    icon?: string;
-    hasScheduledRequest?: boolean;
-}
-export interface ExtraDelegationInfo {
-    chain: string;
-    address: string;
-    collatorAddress: string;
-}
 export interface BasicTxInfo {
     fee: string;
     balanceError: boolean;
     rawFee?: number;
 }
 export interface BondingOptionParams {
-    networkKey: string;
-    address: string;
+    chain: string;
+    type: StakingType;
 }
 export interface SingleModeJson {
     networkKeys: string[];
-    theme: ThemeTypes;
+    theme: ThemeNames;
     autoTriggerDomain: string;
 }
 export declare type NestedArray<T> = T | NestedArray<T>[];
-export interface EVMTransactionArg {
+export interface EvmTransactionArg {
     name: string;
     type: string;
     value: string;
-    children?: EVMTransactionArg[];
+    children?: EvmTransactionArg[];
 }
-export interface ParseEVMTransactionData {
+export interface ParseEvmTransactionData {
     method: string;
     methodName: string;
-    args: EVMTransactionArg[];
+    args: EvmTransactionArg[];
 }
-export interface RequestParseEVMContractInput {
+export interface RequestParseEvmContractInput {
     data: string;
     contract: string;
     chainId: number;
 }
-export interface ResponseParseEVMContractInput {
-    result: ParseEVMTransactionData | string;
+export declare type EvmTransactionData = ParseEvmTransactionData | string;
+export interface ResponseParseEvmContractInput {
+    result: EvmTransactionData;
 }
 export interface LedgerNetwork {
     genesisHash: string;
     displayName: string;
     network: string;
+    slug: string;
     icon: 'substrate' | 'ethereum';
     isDevMode: boolean;
 }
@@ -991,7 +980,7 @@ export interface RequestQrParseRLP {
     data: string;
 }
 export interface ResponseQrParseRLP {
-    data: ParseEVMTransactionData | string;
+    data: EvmTransactionData;
     input: string;
     nonce: number;
     to: string;
@@ -1010,21 +999,18 @@ export declare type SignerDataType = 'transaction' | 'message';
 export interface RequestQrSignSubstrate {
     address: string;
     data: string;
-    savePass: boolean;
     networkKey: string;
-    password?: string;
 }
 export interface ResponseQrSignSubstrate {
     signature: string;
 }
-export interface RequestQrSignEVM {
+export interface RequestQrSignEvm {
     address: string;
     message: string;
     type: 'message' | 'transaction';
     chainId?: number;
-    password: string;
 }
-export interface ResponseQrSignEVM {
+export interface ResponseQrSignEvm {
     signature: string;
 }
 export interface RequestCheckTransfer extends BaseRequestSign {
@@ -1033,17 +1019,14 @@ export interface RequestCheckTransfer extends BaseRequestSign {
     to: string;
     value?: string;
     transferAll?: boolean;
-    token?: string;
+    tokenSlug: string;
 }
-export interface ResponseCheckTransfer {
-    errors?: Array<BasicTxError>;
-    warnings?: Array<BasicTxWarning>;
-    fromAccountFree: string;
-    toAccountFree: string;
-    estimateFee?: string;
-    feeSymbol?: string;
+export interface ValidateTransactionResponse {
+    errors: TransactionError[];
+    warnings: TransactionWarning[];
+    transferNativeAmount?: string;
 }
-export declare type RequestTransfer = PasswordRequestSign<RequestCheckTransfer>;
+export declare type RequestTransfer = InternalRequestSign<RequestCheckTransfer>;
 export interface RequestCheckCrossChainTransfer extends BaseRequestSign {
     originNetworkKey: string;
     destinationNetworkKey: string;
@@ -1051,60 +1034,156 @@ export interface RequestCheckCrossChainTransfer extends BaseRequestSign {
     to: string;
     transferAll?: boolean;
     value: string;
-    token: string;
+    tokenSlug: string;
 }
-export declare type RequestCrossChainTransfer = PasswordRequestSign<RequestCheckCrossChainTransfer>;
-export interface ResponseCheckCrossChainTransfer {
-    errors?: Array<BasicTxError>;
-    feeString?: string;
-    estimatedFee: string;
-    feeSymbol: string;
+export declare type RequestCrossChainTransfer = InternalRequestSign<RequestCheckCrossChainTransfer>;
+export interface ChainStakingMetadata {
+    chain: string;
+    type: StakingType;
+    era: number;
+    expectedReturn?: number;
+    inflation?: number;
+    minJoinNominationPool?: string;
+    minStake: string;
+    maxValidatorPerNominator: number;
+    maxWithdrawalRequestPerValidator: number;
+    allowCancelUnstaking: boolean;
+    unstakingPeriod: number;
+}
+export interface NominationInfo {
+    chain: string;
+    validatorAddress: string;
+    validatorIdentity?: string;
+    activeStake: string;
+    hasUnstaking?: boolean;
+    validatorMinStake?: string;
+}
+export interface PalletNominationPoolsBondedPoolInner {
+    points: number;
+    state: 'Open' | 'Destroying';
+    memberCounter: number;
+    roles: {
+        depositor: string;
+        root: string;
+        nominator: string;
+        bouncer: string;
+    };
+}
+export interface NominationPoolInfo extends Pick<PalletNominationPoolsBondedPoolInner, 'roles' | 'memberCounter' | 'state'> {
+    id: number;
+    address: string;
+    name?: string;
+    bondedAmount: string;
 }
-export interface BondingOptionInfo {
+export declare enum UnstakingStatus {
+    CLAIMABLE = "CLAIMABLE",
+    UNLOCKING = "UNLOCKING"
+}
+export interface UnstakingInfo {
+    chain: string;
+    status: UnstakingStatus;
+    claimable: string;
+    waitingTime: number;
+    validatorAddress?: string;
+}
+export interface NominatorMetadata {
+    chain: string;
+    type: StakingType;
+    address: string;
+    activeStake: string;
+    nominations: NominationInfo[];
+    unstakings: UnstakingInfo[];
+    isBondedBefore?: boolean;
+}
+export interface ValidatorInfo {
+    address: string;
+    chain: string;
+    totalStake: string;
+    ownStake: string;
+    otherStake: string;
+    minBond: string;
+    nominatorCount: number;
+    commission: number;
+    expectedReturn?: number;
+    blocked: boolean;
+    identity?: string;
+    isVerified: boolean;
+    icon?: string;
+    isCrowded: boolean;
+}
+export interface NominationPoolMetadata {
+    id: string;
+    identity?: string;
+    address: string;
+    memberCount: number;
+    bondedAmount: string;
+}
+export interface NominatorInfo {
+    chain: string;
+    address: string;
     isBondedBefore: boolean;
-    era: number;
-    maxNominations: number;
-    maxNominatorPerValidator: number;
-    validators: ValidatorInfo[];
     bondedValidators: string[];
+    bondedPool: string[];
 }
-export interface ChainBondingBasics {
-    stakedReturn: number;
-    isMaxNominators: boolean;
-    validatorCount: number;
+export interface ChainBondingInfo {
+    chain: string;
+    estimatedReturn: number;
+    activeNominatorCount: number;
+    totalNominatorCount: number;
+    unbondingPeriod: number;
+    totalStake: string;
 }
 export interface BondingSubmitParams extends BaseRequestSign {
-    networkKey: string;
-    nominatorAddress: string;
-    amount: number;
-    validatorInfo: ValidatorInfo;
-    isBondedBefore: boolean;
-    bondedValidators: string[];
+    chain: string;
+    type: StakingType;
+    nominatorMetadata?: NominatorMetadata;
+    amount: string;
+    selectedValidators: ValidatorInfo[];
     lockPeriod?: number;
 }
-export declare type RequestBondingSubmit = PasswordRequestSign<BondingSubmitParams>;
+export declare type RequestBondingSubmit = InternalRequestSign<BondingSubmitParams>;
 export interface UnbondingSubmitParams extends BaseRequestSign {
-    amount: number;
-    networkKey: string;
-    address: string;
+    amount: string;
+    chain: string;
+    nominatorMetadata: NominatorMetadata;
     validatorAddress?: string;
-    unstakeAll?: boolean;
 }
-export declare type RequestUnbondingSubmit = PasswordRequestSign<UnbondingSubmitParams>;
+export declare type RequestUnbondingSubmit = InternalRequestSign<UnbondingSubmitParams>;
 export interface StakeWithdrawalParams extends BaseRequestSign {
-    address: string;
-    networkKey: string;
+    nominatorMetadata: NominatorMetadata;
+    unstakingInfo: UnstakingInfo;
+    chain: string;
     validatorAddress?: string;
-    action?: string;
 }
-export declare type RequestStakeWithdrawal = PasswordRequestSign<StakeWithdrawalParams>;
+export declare type RequestStakeWithdrawal = InternalRequestSign<StakeWithdrawalParams>;
 export interface StakeClaimRewardParams extends BaseRequestSign {
     address: string;
-    networkKey: string;
-    validatorAddress?: string;
+    chain: string;
     stakingType: StakingType;
+    unclaimedReward?: string;
+    bondReward?: boolean;
+}
+export declare type RequestStakeClaimReward = InternalRequestSign<StakeClaimRewardParams>;
+export interface StakeCancelWithdrawalParams extends BaseRequestSign {
+    address: string;
+    chain: string;
+    selectedUnstaking: UnstakingInfo;
+}
+export declare type RequestStakeCancelWithdrawal = InternalRequestSign<StakeCancelWithdrawalParams>;
+export interface StakePoolingBondingParams extends BaseRequestSign {
+    nominatorMetadata?: NominatorMetadata;
+    chain: string;
+    selectedPool: NominationPoolInfo;
+    amount: string;
+    address: string;
 }
-export declare type RequestStakeClaimReward = PasswordRequestSign<StakeClaimRewardParams>;
+export declare type RequestStakePoolingBonding = InternalRequestSign<StakePoolingBondingParams>;
+export interface StakePoolingUnbondingParams extends BaseRequestSign {
+    nominatorMetadata: NominatorMetadata;
+    chain: string;
+    amount: string;
+}
+export declare type RequestStakePoolingUnbonding = InternalRequestSign<StakePoolingUnbondingParams>;
 export interface DelegationItem {
     owner: string;
     amount: string;
@@ -1142,72 +1221,174 @@ export interface TuringStakeCompoundParams extends BaseRequestSign {
     accountMinimum: string;
     bondedAmount: string;
 }
-export declare type RequestTuringStakeCompound = PasswordRequestSign<TuringStakeCompoundParams>;
+export declare type RequestTuringStakeCompound = InternalRequestSign<TuringStakeCompoundParams>;
 export interface TuringCancelStakeCompoundParams extends BaseRequestSign {
     taskId: string;
     networkKey: string;
     address: string;
 }
-export declare type RequestTuringCancelStakeCompound = PasswordRequestSign<TuringCancelStakeCompoundParams>;
-export declare type RequestTransferExternal = ExternalRequestSign<RequestCheckTransfer>;
-export declare type RequestCrossChainTransferExternal = ExternalRequestSign<RequestCheckCrossChainTransfer>;
-export declare type RequestNftTransferExternalSubstrate = ExternalRequestSign<SubstrateNftSubmitTransaction>;
-export declare type RequestNftTransferExternalEVM = ExternalRequestSign<EvmNftSubmitTransaction>;
-export declare type RequestStakeExternal = ExternalRequestSign<BondingSubmitParams>;
-export declare type RequestUnStakeExternal = ExternalRequestSign<UnbondingSubmitParams>;
-export declare type RequestWithdrawStakeExternal = ExternalRequestSign<StakeWithdrawalParams>;
-export declare type RequestClaimRewardExternal = ExternalRequestSign<StakeClaimRewardParams>;
-export declare type RequestCreateCompoundStakeExternal = ExternalRequestSign<TuringStakeCompoundParams>;
-export declare type RequestCancelCompoundStakeExternal = ExternalRequestSign<TuringCancelStakeCompoundParams>;
+export declare type RequestTuringCancelStakeCompound = InternalRequestSign<TuringCancelStakeCompoundParams>;
+export declare type RequestTransferExternal = InternalRequestSign<RequestCheckTransfer>;
+export declare type RequestCrossChainTransferExternal = InternalRequestSign<RequestCheckCrossChainTransfer>;
+export declare type RequestNftTransferExternalSubstrate = InternalRequestSign<SubstrateNftSubmitTransaction>;
+export declare type RequestNftTransferExternalEvm = InternalRequestSign<EvmNftSubmitTransaction>;
+export declare type RequestStakeExternal = InternalRequestSign<BondingSubmitParams>;
+export declare type RequestUnStakeExternal = InternalRequestSign<UnbondingSubmitParams>;
+export declare type RequestWithdrawStakeExternal = InternalRequestSign<StakeWithdrawalParams>;
+export declare type RequestClaimRewardExternal = InternalRequestSign<StakeClaimRewardParams>;
+export declare type RequestCreateCompoundStakeExternal = InternalRequestSign<TuringStakeCompoundParams>;
+export declare type RequestCancelCompoundStakeExternal = InternalRequestSign<TuringCancelStakeCompoundParams>;
+export interface KeyringState {
+    isReady: boolean;
+    hasMasterPassword: boolean;
+    isLocked: boolean;
+}
+export interface RequestChangeMasterPassword {
+    oldPassword?: string;
+    newPassword: string;
+    createNew: boolean;
+}
+export declare enum ChainEditStandard {
+    EVM = "EVM",
+    SUBSTRATE = "SUBSTRATE",
+    UNKNOWN = "UNKNOWN",
+    MIXED = "MIXED"
+}
+export declare type ChainEditInfo = {
+    slug: string;
+    currentProvider: string;
+    providers: Record<string, string>;
+    name: string;
+    chainType: ChainEditStandard;
+    blockExplorer?: string;
+    crowdloanUrl?: string;
+    priceId?: string;
+    symbol: string;
+};
+export interface ChainSpecInfo {
+    addressPrefix: number;
+    genesisHash: string;
+    paraId: number | null;
+    evmChainId: number | null;
+    existentialDeposit: string;
+    decimals: number;
+}
+export interface ResponseChangeMasterPassword {
+    status: boolean;
+    errors: string[];
+}
+export interface RequestMigratePassword {
+    address: string;
+    password: string;
+}
+export interface ResponseMigratePassword {
+    status: boolean;
+    errors: string[];
+}
+export interface RequestUnlockKeyring {
+    password: string;
+}
+export interface ResponseUnlockKeyring {
+    status: boolean;
+    errors: string[];
+}
+export interface RequestKeyringExportMnemonic {
+    address: string;
+    password: string;
+}
+export interface ResponseKeyringExportMnemonic {
+    result: string;
+}
+export interface RequestSigningApprovePasswordV2 {
+    id: string;
+}
+export interface AssetSettingUpdateReq {
+    tokenSlug: string;
+    assetSetting: AssetSetting;
+}
+export interface RequestGetTransaction {
+    id: string;
+}
+export declare type SubscriptionServiceType = 'chainRegistry' | 'balance' | 'crowdloan' | 'staking';
+export declare type CronServiceType = 'price' | 'nft' | 'staking' | 'history' | 'recoverApi' | 'checkApiStatus';
+export declare type CronType = 'recoverApiMap' | 'checkApiMapStatus' | 'refreshHistory' | 'refreshNft' | 'refreshPrice' | 'refreshStakeUnlockingInfo' | 'refreshStakingReward' | 'refreshPoolingStakingReward';
+export interface RequestInitCronAndSubscription {
+    subscription: {
+        activeServices: SubscriptionServiceType[];
+    };
+    cron: {
+        intervalMap: Partial<Record<CronType, number>>;
+        activeServices: CronServiceType[];
+    };
+}
+export interface RequestCronAndSubscriptionAction {
+    subscriptionServices: SubscriptionServiceType[];
+    cronServices: CronServiceType[];
+}
+export interface ActiveCronAndSubscriptionMap {
+    subscription: Record<SubscriptionServiceType, boolean>;
+    cron: Record<CronServiceType, boolean>;
+}
+export declare enum NotificationType {
+    INFO = "info",
+    SUCCESS = "success",
+    WARNING = "warning",
+    ERROR = "error"
+}
+export interface Notification {
+    id: number;
+    type: NotificationType;
+    title: string;
+    message: string;
+    notifyViaBrowser?: boolean;
+    action?: {
+        url?: string;
+    };
+}
+export declare type NotificationParams = Omit<Notification, 'id'>;
 export interface KoniRequestSignatures {
-    'pri(staking.submitTuringCancelCompound)': [RequestTuringCancelStakeCompound, BasicTxResponse, BasicTxResponse];
-    'pri(staking.turingCancelCompound)': [TuringCancelStakeCompoundParams, BasicTxInfo];
-    'pri(staking.checkTuringCompoundTask)': [CheckExistingTuringCompoundParams, ExistingTuringCompoundTask];
-    'pri(staking.submitTuringCompound)': [RequestTuringStakeCompound, BasicTxResponse, BasicTxResponse];
-    'pri(staking.turingCompound)': [TuringStakeCompoundParams, TuringStakeCompoundResp];
-    'pri(staking.delegationInfo)': [StakeDelegationRequest, DelegationItem[]];
-    'pri(staking.submitClaimReward)': [RequestStakeClaimReward, BasicTxResponse, BasicTxResponse];
-    'pri(staking.claimRewardTxInfo)': [StakeClaimRewardParams, BasicTxInfo];
-    'pri(unbonding.submitWithdrawal)': [RequestStakeWithdrawal, BasicTxResponse, BasicTxResponse];
-    'pri(unbonding.withdrawalTxInfo)': [StakeWithdrawalParams, BasicTxInfo];
-    'pri(unbonding.subscribeUnlockingInfo)': [null, StakeUnlockingJson, StakeUnlockingJson];
-    'pri(unbonding.submitTransaction)': [RequestUnbondingSubmit, BasicTxResponse, BasicTxResponse];
-    'pri(unbonding.txInfo)': [UnbondingSubmitParams, BasicTxInfo];
-    'pri(bonding.txInfo)': [BondingSubmitParams, BasicTxInfo];
-    'pri(bonding.submitTransaction)': [RequestBondingSubmit, BasicTxResponse, BasicTxResponse];
-    'pri(bonding.getChainBondingBasics)': [NetworkJson[], Record<string, ChainBondingBasics>, Record<string, ChainBondingBasics>];
-    'pri(bonding.getBondingOptions)': [BondingOptionParams, BondingOptionInfo];
-    'pri(networkMap.recoverDotSama)': [string, boolean];
-    'pri(networkMap.disableAll)': [null, boolean];
-    'pri(networkMap.enableAll)': [null, boolean];
-    'pri(networkMap.resetDefault)': [null, boolean];
-    'pri(apiMap.validate)': [ValidateNetworkRequest, ValidateNetworkResponse];
-    'pri(networkMap.enableMany)': [string[], boolean];
-    'pri(networkMap.disableMany)': [string[], boolean];
-    'pri(networkMap.enableOne)': [string, boolean];
-    'pri(networkMap.disableOne)': [string, DisableNetworkResponse];
-    'pri(networkMap.removeOne)': [string, boolean];
-    'pri(networkMap.upsert)': [NetworkJson, boolean];
-    'pri(networkMap.getNetworkMap)': [null, Record<string, NetworkJson>];
-    'pri(networkMap.getSubscription)': [null, Record<string, NetworkJson>, Record<string, NetworkJson>];
-    'pri(customTokenState.validateCustomToken)': [ValidateCustomTokenRequest, ValidateCustomTokenResponse];
-    'pri(customTokenState.deleteMany)': [DeleteCustomTokenParams[], boolean];
-    'pri(customTokenState.upsertCustomTokenState)': [CustomToken, boolean];
-    'pri(customTokenState.getCustomTokenState)': [null, CustomTokenJson];
-    'pri(customTokenState.getSubscription)': [null, CustomTokenJson, CustomTokenJson];
-    'pri(evmNft.submitTransaction)': [RequestEvmNftSubmitTransaction, NftTransactionResponse, NftTransactionResponse];
+    'pri(staking.submitTuringCancelCompound)': [RequestTuringCancelStakeCompound, SWTransactionResponse];
+    'pri(staking.submitTuringCompound)': [RequestTuringStakeCompound, SWTransactionResponse];
+    'pri(staking.submitClaimReward)': [RequestStakeClaimReward, SWTransactionResponse];
+    'pri(staking.submitCancelWithdrawal)': [RequestStakeCancelWithdrawal, SWTransactionResponse];
+    'pri(unbonding.submitWithdrawal)': [RequestStakeWithdrawal, SWTransactionResponse];
+    'pri(unbonding.submitTransaction)': [RequestUnbondingSubmit, SWTransactionResponse];
+    'pri(bonding.submitBondingTransaction)': [RequestBondingSubmit, SWTransactionResponse];
+    'pri(bonding.subscribeChainStakingMetadata)': [null, ChainStakingMetadata[], ChainStakingMetadata[]];
+    'pri(bonding.subscribeNominatorMetadata)': [null, NominatorMetadata[], NominatorMetadata[]];
+    'pri(bonding.getBondingOptions)': [BondingOptionParams, ValidatorInfo[]];
+    'pri(bonding.getNominationPoolOptions)': [string, NominationPoolInfo[]];
+    'pri(bonding.nominationPool.submitBonding)': [RequestStakePoolingBonding, SWTransactionResponse];
+    'pri(bonding.nominationPool.submitUnbonding)': [RequestStakePoolingUnbonding, SWTransactionResponse];
+    'pri(chainService.subscribeChainInfoMap)': [null, Record<string, any>, Record<string, any>];
+    'pri(chainService.subscribeChainStateMap)': [null, Record<string, any>, Record<string, any>];
+    'pri(chainService.subscribeAssetRegistry)': [null, Record<string, any>, Record<string, any>];
+    'pri(chainService.subscribeMultiChainAssetMap)': [null, Record<string, _MultiChainAsset>, Record<string, _MultiChainAsset>];
+    'pri(chainService.subscribeXcmRefMap)': [null, Record<string, _AssetRef>, Record<string, _AssetRef>];
+    'pri(chainService.upsertChain)': [_NetworkUpsertParams, boolean];
+    'pri(chainService.enableChains)': [string[], boolean];
+    'pri(chainService.disableChains)': [string[], boolean];
+    'pri(chainService.enableChain)': [string, boolean];
+    'pri(chainService.disableChain)': [string, boolean];
+    'pri(chainService.removeChain)': [string, boolean];
+    'pri(chainService.deleteCustomAsset)': [string, boolean];
+    'pri(chainService.upsertCustomAsset)': [Record<string, any>, boolean];
+    'pri(chainService.validateCustomAsset)': [_ValidateCustomAssetRequest, _ValidateCustomAssetResponse];
+    'pri(chainService.resetDefaultChains)': [null, boolean];
+    'pri(chainService.getSupportedContractTypes)': [null, string[]];
+    'pri(chainService.validateCustomChain)': [ValidateNetworkRequest, ValidateNetworkResponse];
+    'pri(chainService.recoverSubstrateApi)': [string, boolean];
+    'pri(chainService.disableAllChains)': [null, boolean];
+    'pri(assetSetting.getSubscription)': [null, Record<string, AssetSetting>, Record<string, AssetSetting>];
+    'pri(assetSetting.update)': [AssetSettingUpdateReq, boolean];
+    'pri(evmNft.submitTransaction)': [NftTransactionRequest, SWTransactionResponse];
     'pri(evmNft.getTransaction)': [NftTransactionRequest, EvmNftTransaction];
-    'pri(substrateNft.submitTransaction)': [RequestSubstrateNftSubmitTransaction, NftTransactionResponse, NftTransactionResponse];
+    'pri(substrateNft.submitTransaction)': [RequestSubstrateNftSubmitTransaction, NftTransactionResponse];
     'pri(substrateNft.getTransaction)': [NftTransactionRequest, SubstrateNftTransaction];
-    'pri(nftTransfer.setNftTransfer)': [NftTransferExtra, boolean];
-    'pri(nftTransfer.getNftTransfer)': [null, NftTransferExtra];
-    'pri(nftTransfer.getSubscription)': [null, NftTransferExtra, NftTransferExtra];
-    'pri(nft.forceUpdate)': [RequestNftForceUpdate, boolean];
     'pri(nft.getNft)': [null, NftJson];
     'pri(nft.getSubscription)': [RequestSubscribeNft, NftJson, NftJson];
     'pri(nftCollection.getNftCollection)': [null, NftCollectionJson];
     'pri(nftCollection.getSubscription)': [null, NftCollection[], NftCollection[]];
-    'pri(wasmNft.getTransaction)': [NftTransactionRequest, SubstrateNftTransaction];
     'pri(staking.getStaking)': [null, StakingJson];
     'pri(staking.getSubscription)': [RequestSubscribeStaking, StakingJson, StakingJson];
     'pri(stakingReward.getStakingReward)': [null, StakingRewardJson];
@@ -1236,35 +1417,37 @@ export interface KoniRequestSignatures {
     'pri(accounts.create.suriV2)': [RequestAccountCreateSuriV2, ResponseAccountCreateSuriV2];
     'pri(accounts.create.externalV2)': [RequestAccountCreateExternalV2, AccountExternalError[]];
     'pri(accounts.create.hardwareV2)': [RequestAccountCreateHardwareV2, boolean];
+    'pri(accounts.create.hardwareMultiple)': [RequestAccountCreateHardwareMultiple, boolean];
     'pri(accounts.create.withSecret)': [RequestAccountCreateWithSecretKey, ResponseAccountCreateWithSecretKey];
     'pri(derivation.createV2)': [RequestDeriveCreateV2, boolean];
     'pri(json.restoreV2)': [RequestJsonRestoreV2, void];
     'pri(json.batchRestoreV2)': [RequestBatchRestoreV2, void];
     'pri(accounts.exportPrivateKey)': [RequestAccountExportPrivateKey, ResponseAccountExportPrivateKey];
     'pri(accounts.checkPublicAndSecretKey)': [RequestCheckPublicAndSecretKey, ResponseCheckPublicAndSecretKey];
-    'pri(accounts.subscribeWithCurrentAddress)': [RequestAccountSubscribe, boolean, AccountsWithCurrentAddress];
+    'pri(accounts.subscribeWithCurrentAddress)': [RequestAccountSubscribe, AccountsWithCurrentAddress, AccountsWithCurrentAddress];
     'pri(accounts.subscribeAccountsInputAddress)': [RequestAccountSubscribe, string, OptionInputAddress];
     'pri(accounts.saveRecent)': [RequestSaveRecentAccount, SingleAddress];
     'pri(accounts.triggerSubscription)': [null, boolean];
     'pri(accounts.get.meta)': [RequestAccountMeta, ResponseAccountMeta];
     'pri(accounts.updateCurrentAddress)': [string, boolean];
     'pri(currentAccount.saveAddress)': [RequestCurrentAccountAddress, boolean, CurrentAccountInfo];
-    'pri(settings.changeBalancesVisibility)': [null, boolean, ResponseSettingsType];
-    'pri(settings.subscribe)': [null, ResponseSettingsType, ResponseSettingsType];
-    'pri(settings.saveAccountAllLogo)': [string, boolean, ResponseSettingsType];
-    'pri(settings.saveTheme)': [ThemeTypes, boolean, ResponseSettingsType];
-    'pri(chainRegistry.getSubscription)': [null, Record<string, ChainRegistry>, Record<string, ChainRegistry>];
-    'pri(transaction.history.getSubscription)': [null, Record<string, TransactionHistoryItemType[]>, Record<string, TransactionHistoryItemType[]>];
-    'pri(transaction.history.add)': [RequestTransactionHistoryAdd, boolean, TransactionHistoryItemType[]];
+    'pri(settings.changeBalancesVisibility)': [null, boolean, UiSettings];
+    'pri(settings.subscribe)': [null, UiSettings, UiSettings];
+    'pri(settings.saveAccountAllLogo)': [string, boolean, UiSettings];
+    'pri(settings.saveTheme)': [ThemeNames, boolean, UiSettings];
+    'pri(settings.saveBrowserConfirmationType)': [BrowserConfirmationType, boolean, UiSettings];
+    'pri(settings.saveCamera)': [RequestCameraSettings, boolean];
+    'pri(transaction.history.getSubscription)': [null, TransactionHistoryItem[], TransactionHistoryItem[]];
     'pri(transfer.checkReferenceCount)': [RequestTransferCheckReferenceCount, boolean];
     'pri(transfer.checkSupporting)': [RequestTransferCheckSupporting, SupportTransferResponse];
     'pri(transfer.getExistentialDeposit)': [RequestTransferExistentialDeposit, string];
     'pri(subscription.cancel)': [string, boolean];
-    'pri(freeBalance.subscribe)': [RequestFreeBalance, string, string];
-    'pri(accounts.checkTransfer)': [RequestCheckTransfer, ResponseCheckTransfer];
-    'pri(accounts.transfer)': [RequestTransfer, BasicTxResponse, BasicTxResponse];
-    'pri(accounts.checkCrossChainTransfer)': [RequestCheckCrossChainTransfer, ResponseCheckCrossChainTransfer];
-    'pri(accounts.crossChainTransfer)': [RequestCrossChainTransfer, BasicTxResponse, BasicTxResponse];
+    'pri(freeBalance.get)': [RequestFreeBalance, AmountData];
+    'pri(freeBalance.subscribe)': [RequestFreeBalance, AmountData, AmountData];
+    'pri(accounts.checkTransfer)': [RequestCheckTransfer, ValidateTransactionResponse];
+    'pri(accounts.transfer)': [RequestTransfer, SWTransactionResponse];
+    'pri(accounts.checkCrossChainTransfer)': [RequestCheckCrossChainTransfer, ValidateTransactionResponse];
+    'pri(accounts.crossChainTransfer)': [RequestCrossChainTransfer, SWTransactionResponse];
     'pri(confirmations.subscribe)': [RequestConfirmationsSubscribe, ConfirmationsQueue, ConfirmationsQueue];
     'pri(confirmations.complete)': [RequestConfirmationComplete, boolean];
     'pub(utils.getRandom)': [RandomTestRequest, number];
@@ -1274,33 +1457,40 @@ export interface KoniRequestSignatures {
     'pri(qr.transaction.parse.substrate)': [RequestParseTransactionSubstrate, ResponseParseTransactionSubstrate];
     'pri(qr.transaction.parse.evm)': [RequestQrParseRLP, ResponseQrParseRLP];
     'pri(qr.sign.substrate)': [RequestQrSignSubstrate, ResponseQrSignSubstrate];
-    'pri(qr.sign.evm)': [RequestQrSignEVM, ResponseQrSignEVM];
+    'pri(qr.sign.evm)': [RequestQrSignEvm, ResponseQrSignEvm];
     'pri(account.external.reject)': [RequestRejectExternalRequest, ResponseRejectExternalRequest];
     'pri(account.external.resolve)': [RequestResolveExternalRequest, ResponseResolveExternalRequest];
     'evm(events.subscribe)': [RequestEvmEvents, boolean, EvmEvent];
     'evm(request)': [RequestArguments, unknown];
     'evm(provider.send)': [RequestEvmProviderSend, string | number, ResponseEvmProviderSend];
-    'pri(evm.transaction.parse.input)': [RequestParseEVMContractInput, ResponseParseEVMContractInput];
-    'pri(accounts.transfer.qr.create)': [RequestTransferExternal, BasicTxResponse, BasicTxResponse];
-    'pri(accounts.cross.transfer.qr.create)': [RequestCrossChainTransferExternal, BasicTxResponse, BasicTxResponse];
-    'pri(nft.transfer.qr.create.substrate)': [RequestNftTransferExternalSubstrate, NftTransactionResponse, NftTransactionResponse];
-    'pri(nft.transfer.qr.create.evm)': [RequestNftTransferExternalEVM, NftTransactionResponse, NftTransactionResponse];
-    'pri(stake.qr.create)': [RequestStakeExternal, BasicTxResponse, BasicTxResponse];
-    'pri(unStake.qr.create)': [RequestUnStakeExternal, BasicTxResponse, BasicTxResponse];
-    'pri(withdrawStake.qr.create)': [RequestWithdrawStakeExternal, BasicTxResponse, BasicTxResponse];
-    'pri(claimReward.qr.create)': [RequestClaimRewardExternal, BasicTxResponse, BasicTxResponse];
-    'pri(createCompound.qr.create)': [RequestCreateCompoundStakeExternal, BasicTxResponse, BasicTxResponse];
-    'pri(cancelCompound.qr.create)': [RequestCancelCompoundStakeExternal, BasicTxResponse, BasicTxResponse];
-    'pri(accounts.transfer.ledger.create)': [RequestTransferExternal, BasicTxResponse, BasicTxResponse];
-    'pri(accounts.cross.transfer.ledger.create)': [RequestCrossChainTransferExternal, BasicTxResponse, BasicTxResponse];
-    'pri(nft.transfer.ledger.create.substrate)': [RequestNftTransferExternalSubstrate, NftTransactionResponse, NftTransactionResponse];
-    'pri(stake.ledger.create)': [RequestStakeExternal, BasicTxResponse, BasicTxResponse];
-    'pri(unStake.ledger.create)': [RequestUnStakeExternal, BasicTxResponse, BasicTxResponse];
-    'pri(withdrawStake.ledger.create)': [RequestWithdrawStakeExternal, BasicTxResponse, BasicTxResponse];
-    'pri(claimReward.ledger.create)': [RequestClaimRewardExternal, BasicTxResponse, BasicTxResponse];
-    'pri(createCompound.ledger.create)': [RequestCreateCompoundStakeExternal, BasicTxResponse, BasicTxResponse];
-    'pri(cancelCompound.ledger.create)': [RequestCancelCompoundStakeExternal, BasicTxResponse, BasicTxResponse];
+    'pri(evm.transaction.parse.input)': [RequestParseEvmContractInput, ResponseParseEvmContractInput];
     'pri(authorize.subscribe)': [null, AuthUrls, AuthUrls];
+    'pri(keyring.subscribe)': [null, KeyringState, KeyringState];
+    'pri(keyring.change)': [RequestChangeMasterPassword, ResponseChangeMasterPassword];
+    'pri(keyring.migrate)': [RequestMigratePassword, ResponseMigratePassword];
+    'pri(keyring.unlock)': [RequestUnlockKeyring, ResponseUnlockKeyring];
+    'pri(keyring.lock)': [null, void];
+    'pri(keyring.export.mnemonic)': [RequestKeyringExportMnemonic, ResponseKeyringExportMnemonic];
+    'pri(signing.approve.passwordV2)': [RequestSigningApprovePasswordV2, boolean];
+    'pri(derivation.validateV2)': [RequestDeriveValidateV2, ResponseDeriveValidateV2];
+    'pri(derivation.getList)': [RequestGetDeriveAccounts, ResponseGetDeriveAccounts];
+    'pri(derivation.create.multiple)': [RequestDeriveCreateMultiple, boolean];
+    'pri(derivation.createV3)': [RequestDeriveCreateV3, boolean];
+    'pri(transactions.getOne)': [RequestGetTransaction, SWTransactionResult];
+    'pri(transactions.subscribe)': [null, Record<string, SWTransactionResult>, Record<string, SWTransactionResult>];
+    'pri(notifications.subscribe)': [null, Notification[], Notification[]];
+    'mobile(ping)': [null, string];
+    'mobile(cronAndSubscription.init)': [RequestInitCronAndSubscription, ActiveCronAndSubscriptionMap];
+    'mobile(cronAndSubscription.activeService.subscribe)': [null, ActiveCronAndSubscriptionMap, ActiveCronAndSubscriptionMap];
+    'mobile(cronAndSubscription.start)': [RequestCronAndSubscriptionAction, void];
+    'mobile(cronAndSubscription.stop)': [RequestCronAndSubscriptionAction, void];
+    'mobile(cronAndSubscription.restart)': [RequestCronAndSubscriptionAction, void];
+    'mobile(cron.start)': [CronServiceType[], void];
+    'mobile(cron.stop)': [CronServiceType[], void];
+    'mobile(cron.restart)': [CronServiceType[], void];
+    'mobile(subscription.start)': [SubscriptionServiceType[], void];
+    'mobile(subscription.stop)': [SubscriptionServiceType[], void];
+    'mobile(subscription.restart)': [SubscriptionServiceType[], void];
 }
 export interface ApplicationMetadataType {
     version: string;