@subwallet/extension-base 0.8.4-0 → 1.0.1

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

@@ -0,0 +1,21 @@
+/// <reference types="chrome" />
+import { ActiveCronAndSubscriptionMap, CronServiceType, RequestCronAndSubscriptionAction, RequestInitCronAndSubscription, SubscriptionServiceType } from '@subwallet/extension-base/background/KoniTypes';
+import { MessageTypes, RequestTypes, ResponseType } from '@subwallet/extension-base/background/types';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+export default class Mobile {
+    private state;
+    constructor(state: KoniState);
+    ping(): string;
+    initCronAndSubscription({ cron: { activeServices, intervalMap }, subscription: { activeServices } }: RequestInitCronAndSubscription): ActiveCronAndSubscriptionMap;
+    subscribeActiveCronAndSubscriptionServiceMap(id: string, port: chrome.runtime.Port): ActiveCronAndSubscriptionMap;
+    startCronAndSubscriptionServices({ cronServices, subscriptionServices }: RequestCronAndSubscriptionAction): void;
+    stopCronAndSubscriptionServices({ cronServices, subscriptionServices }: RequestCronAndSubscriptionAction): void;
+    restartCronAndSubscriptionServices({ cronServices, subscriptionServices }: RequestCronAndSubscriptionAction): void;
+    startCronServices(services: CronServiceType[]): void;
+    stopCronServices(services: CronServiceType[]): void;
+    restartCronServices(services: CronServiceType[]): void;
+    startSubscriptionServices(services: SubscriptionServiceType[]): void;
+    stopSubscriptionServices(services: SubscriptionServiceType[]): void;
+    restartSubscriptionServices(services: SubscriptionServiceType[]): void;
+    handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], port: chrome.runtime.Port): Promise<ResponseType<TMessageType>>;
+}

package/koni/background/handlers/Mobile.js

@@ -0,0 +1,127 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const DEFAULT_SERVICE_MAP = {
+  subscription: {
+    chainRegistry: true,
+    balance: true,
+    crowdloan: true,
+    staking: true
+  },
+  cron: {
+    price: true,
+    nft: true,
+    staking: true,
+    history: true,
+    recoverApi: true,
+    checkApiStatus: true
+  }
+};
+export default class Mobile {
+  // @ts-ignore
+
+  constructor(state) {
+    this.state = state;
+  }
+  ping() {
+    return 'mobile:ping';
+  }
+  initCronAndSubscription({
+    cron: {
+      activeServices: activeCronServices,
+      intervalMap: cronIntervalMap
+    },
+    subscription: {
+      activeServices: activeSubscriptionServices
+    }
+  }) {
+    console.log('initCronAndSubscription');
+    return {
+      subscription: {
+        chainRegistry: true,
+        balance: true,
+        crowdloan: true,
+        staking: true
+      },
+      cron: {
+        price: true,
+        nft: true,
+        staking: true,
+        history: true,
+        recoverApi: true,
+        checkApiStatus: true
+      }
+    };
+  }
+  subscribeActiveCronAndSubscriptionServiceMap(id, port) {
+    return DEFAULT_SERVICE_MAP;
+  }
+  startCronAndSubscriptionServices({
+    cronServices,
+    subscriptionServices
+  }) {
+    console.log('startCronAndSubscriptionServices');
+  }
+  stopCronAndSubscriptionServices({
+    cronServices,
+    subscriptionServices
+  }) {
+    console.log('stopCronAndSubscriptionServices');
+  }
+  restartCronAndSubscriptionServices({
+    cronServices,
+    subscriptionServices
+  }) {
+    console.log('restartCronAndSubscriptionServices');
+  }
+  startCronServices(services) {
+    console.log('startCronServices');
+  }
+  stopCronServices(services) {
+    console.log('stopCronServices');
+  }
+  restartCronServices(services) {
+    console.log('stopCronServices');
+  }
+  startSubscriptionServices(services) {
+    console.log('startSubscriptionServices');
+  }
+  stopSubscriptionServices(services) {
+    console.log('stopSubscriptionServices');
+  }
+  restartSubscriptionServices(services) {
+    console.log('restartSubscriptionServices');
+  }
+
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async handle(id, type, request, port) {
+    switch (type) {
+      case 'mobile(ping)':
+        return this.ping();
+      case 'mobile(cronAndSubscription.init)':
+        return this.initCronAndSubscription(request);
+      case 'mobile(cronAndSubscription.activeService.subscribe)':
+        return this.subscribeActiveCronAndSubscriptionServiceMap(id, port);
+      case 'mobile(cronAndSubscription.start)':
+        return this.startCronAndSubscriptionServices(request);
+      case 'mobile(cronAndSubscription.stop)':
+        return this.stopCronAndSubscriptionServices(request);
+      case 'mobile(cronAndSubscription.restart)':
+        return this.restartCronAndSubscriptionServices(request);
+      case 'mobile(cron.start)':
+        return this.startCronServices(request);
+      case 'mobile(cron.stop)':
+        return this.stopCronServices(request);
+      case 'mobile(cron.restart)':
+        return this.restartCronServices(request);
+      case 'mobile(subscription.start)':
+        return this.startSubscriptionServices(request);
+      case 'mobile(subscription.stop)':
+        return this.stopSubscriptionServices(request);
+      case 'mobile(subscription.restart)':
+        return this.restartSubscriptionServices(request);
+      default:
+        throw new Error(`Unable to handle message of type ${type}`);
+    }
+  }
+}

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

@@ -0,0 +1,224 @@
+/// <reference types="chrome" />
+import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
+import { AddTokenRequestExternal, ApiMap, AuthRequestV2, BalanceItem, BalanceJson, BrowserConfirmationType, ChainStakingMetadata, ConfirmationsQueue, CrowdloanItem, CrowdloanJson, CurrentAccountInfo, EvmSendTransactionParams, ExternalRequestPromise, KeyringState, NftCollection, NftItem, NftJson, NominatorMetadata, RequestAccountExportPrivateKey, RequestCheckPublicAndSecretKey, RequestConfirmationComplete, RequestSettingsType, ResponseAccountExportPrivateKey, ResponseCheckPublicAndSecretKey, ServiceInfo, SingleModeJson, StakingItem, StakingJson, StakingRewardItem, StakingRewardJson, StakingType, ThemeNames, UiSettings } from '@subwallet/extension-base/background/KoniTypes';
+import { AccountJson, RequestAuthorizeTab, RequestRpcSend, RequestRpcSubscribe, RequestRpcUnsubscribe, RequestSign, ResponseRpcListProviders, ResponseSigning } from '@subwallet/extension-base/background/types';
+import { BalanceService } from '@subwallet/extension-base/services/balance-service';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { _ChainConnectionStatus, _ChainState, _NetworkUpsertParams, _ValidateCustomAssetRequest } from '@subwallet/extension-base/services/chain-service/types';
+import { HistoryService } from '@subwallet/extension-base/services/history-service';
+import MigrationService from '@subwallet/extension-base/services/migration-service';
+import NotificationService from '@subwallet/extension-base/services/notification-service/NotificationService';
+import { PriceService } from '@subwallet/extension-base/services/price-service';
+import RequestService from '@subwallet/extension-base/services/request-service';
+import { AuthUrls, MetaRequest, SignRequest } from '@subwallet/extension-base/services/request-service/types';
+import SettingService from '@subwallet/extension-base/services/setting-service/SettingService';
+import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+import TransactionService from '@subwallet/extension-base/services/transaction-service';
+import { MetadataDef, ProviderMeta } from '@subwallet/extension-inject/types';
+import SimpleKeyring from 'eth-simple-keyring';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { JsonRpcResponse, ProviderInterface, ProviderInterfaceCallback } from '@polkadot/rpc-provider/types';
+declare type Providers = Record<string, {
+    meta: ProviderMeta;
+    start: () => ProviderInterface;
+}>;
+export default class KoniState {
+    private injectedProviders;
+    private readonly providers;
+    private readonly unsubscriptionMap;
+    private readonly currentAccountStore;
+    private readonly accountRefStore;
+    private readonly keyringStateSubject;
+    private externalRequest;
+    private keyringState;
+    private serviceInfoSubject;
+    private balanceMap;
+    private balanceSubject;
+    private crowdloanMap;
+    private crowdloanSubject;
+    private nftSubject;
+    private stakingSubject;
+    private chainStakingMetadataSubject;
+    private stakingNominatorMetadataSubject;
+    private stakingRewardSubject;
+    private stakingRewardState;
+    private lazyMap;
+    readonly notificationService: NotificationService;
+    readonly chainService: ChainService;
+    readonly dbService: DatabaseService;
+    private cron;
+    private subscription;
+    private logger;
+    private ready;
+    readonly settingService: SettingService;
+    readonly requestService: RequestService;
+    readonly transactionService: TransactionService;
+    readonly historyService: HistoryService;
+    readonly priceService: PriceService;
+    readonly balanceService: BalanceService;
+    readonly migrationService: MigrationService;
+    constructor(providers?: Providers);
+    get knownMetadata(): MetadataDef[];
+    injectMetadata(url: string, request: MetadataDef): Promise<boolean>;
+    getMetaRequest(id: string): MetaRequest;
+    getSignRequest(id: string): SignRequest | undefined;
+    rpcListProviders(): Promise<ResponseRpcListProviders>;
+    rpcSend(request: RequestRpcSend, port: chrome.runtime.Port): Promise<JsonRpcResponse>;
+    rpcStartProvider(key: string, port: chrome.runtime.Port): Promise<ProviderMeta>;
+    rpcSubscribe({ method, params, type }: RequestRpcSubscribe, cb: ProviderInterfaceCallback, port: chrome.runtime.Port): Promise<number | string>;
+    rpcSubscribeConnected(_request: null, cb: ProviderInterfaceCallback, port: chrome.runtime.Port): void;
+    rpcUnsubscribe(request: RequestRpcUnsubscribe, port: chrome.runtime.Port): Promise<boolean>;
+    saveMetadata(meta: MetadataDef): void;
+    sign(url: string, request: RequestSign, account: AccountJson): Promise<ResponseSigning>;
+    get authSubjectV2(): BehaviorSubject<import("@subwallet/extension-base/background/types").AuthorizeRequest[]>;
+    generateDefaultBalanceMap(): Record<string, BalanceItem>;
+    init(): Promise<void>;
+    private startSubscription;
+    onReady(): void;
+    isReady(): boolean;
+    getKeyringState(): KeyringState;
+    subscribeKeyringState(): Subject<KeyringState>;
+    setKeyringState(data: KeyringState, callback?: () => void): void;
+    private lazyNext;
+    getAuthRequestV2(id: string): AuthRequestV2;
+    setAuthorize(data: AuthUrls, callback?: () => void): void;
+    getAuthorize(update: (value: AuthUrls) => void): void;
+    subscribeEvmChainChange(): Subject<AuthUrls>;
+    subscribeAuthorizeUrlSubject(): Subject<AuthUrls>;
+    getAuthList(): Promise<AuthUrls>;
+    getAddressList(value?: boolean): Record<string, boolean>;
+    authorizeUrlV2(url: string, request: RequestAuthorizeTab): Promise<boolean>;
+    getNativeTokenInfo(networkKey: string): _ChainAsset;
+    getChainInfo(networkKey: string): _ChainInfo;
+    getChainStakingMetadata(): Promise<ChainStakingMetadata[]>;
+    getStakingMetadataByChain(chain: string, type: StakingType): Promise<ChainStakingMetadata | undefined>;
+    getNominatorMetadata(): Promise<NominatorMetadata[]>;
+    getStaking(): Promise<StakingJson>;
+    getStakingOwnersByChains(chains: string[]): Promise<string[]>;
+    getPooledStakingRecordsByAddress(addresses: string[]): Promise<StakingItem[]>;
+    subscribeStaking(): Subject<StakingJson>;
+    subscribeChainStakingMetadata(): Subject<ChainStakingMetadata[]>;
+    subscribeNominatorMetadata(): Subject<NominatorMetadata[]>;
+    ensureUrlAuthorizedV2(url: string): Promise<boolean>;
+    setStakingItem(networkKey: string, item: StakingItem): void;
+    updateChainStakingMetadata(item: ChainStakingMetadata): void;
+    updateStakingNominatorMetadata(item: NominatorMetadata): void;
+    setNftCollection(network: string, data: NftCollection, callback?: (data: NftCollection) => void): void;
+    getNftCollection(): import("dexie").PromiseExtended<NftCollection[]>;
+    subscribeNftCollection(): import("dexie").Observable<NftCollection[]>;
+    resetNft(newAddress: string): Promise<void>;
+    updateNftData(network: string, nftData: NftItem, address: string, callback?: (nftData: NftItem) => void): void;
+    removeNfts(chain: string, address: string, collectionId: string, nftIds: string[]): import("dexie").PromiseExtended<number>;
+    deleteNftCollection(chain: string, collectionId: string): Promise<void>;
+    getNft(): Promise<NftJson | undefined>;
+    subscribeNft(): Subject<NftJson>;
+    resetStakingReward(): void;
+    updateStakingReward(stakingRewardData: StakingRewardItem[], type: 'slowInterval' | 'fastInterval', callback?: (stakingRewardData: StakingRewardJson) => void): void;
+    updateStakingRewardReady(ready: boolean): void;
+    getAccountRefMap(callback: (refMap: Record<string, Array<string>>) => void): void;
+    addAccountRef(addresses: string[], callback: () => void): void;
+    removeAccountRef(address: string, callback: () => void): void;
+    getStakingReward(update: (value: StakingRewardJson) => void): void;
+    subscribeStakingReward(): Subject<StakingRewardJson>;
+    getCurrentAccount(update: (value: CurrentAccountInfo) => void): void;
+    setCurrentAccount(data: CurrentAccountInfo, callback?: () => void): void;
+    setAccountTie(address: string, genesisHash: string | null): boolean;
+    switchEvmNetworkByUrl(shortenUrl: string, networkKey: string): Promise<void>;
+    switchNetworkAccount(id: string, url: string, networkKey: string, changeAddress?: string): Promise<boolean>;
+    addNetworkConfirm(id: string, url: string, networkData: _NetworkUpsertParams): Promise<null>;
+    addTokenConfirm(id: string, url: string, tokenInfo: AddTokenRequestExternal): Promise<true>;
+    get metaSubject(): BehaviorSubject<import("@subwallet/extension-base/background/types").MetadataRequest[]>;
+    get signSubject(): BehaviorSubject<import("@subwallet/extension-base/background/types").SigningRequest[]>;
+    getSettings(callback: (settings: UiSettings) => void): void;
+    setSettings(settings: UiSettings, callback?: () => void): void;
+    setTheme(theme: ThemeNames, callback?: (settingData: UiSettings) => void): void;
+    setBrowserConfirmationType(browserConfirmationType: BrowserConfirmationType, callback?: (settingData: UiSettings) => void): void;
+    setCamera(value: boolean): void;
+    subscribeSettingsSubject(): Subject<RequestSettingsType>;
+    subscribeCurrentAccount(): Subject<CurrentAccountInfo>;
+    getAccountAddress(): Promise<string | null | undefined>;
+    getDecodedAddresses(address?: string): Promise<string[]>;
+    getAllAddresses(): string[];
+    private removeInactiveChainBalances;
+    getBalance(reset?: boolean): BalanceJson;
+    getStoredBalance(address: string): Promise<Record<string, BalanceItem>>;
+    switchAccount(newAddress: string): Promise<void>;
+    resetBalanceMap(newAddress: string): Promise<void>;
+    resetCrowdloanMap(newAddress: string): Promise<void>;
+    resetStaking(newAddress: string): Promise<void>;
+    setBalanceItem(tokenSlug: string, item: BalanceItem): void;
+    private updateBalanceStore;
+    subscribeBalance(): Subject<BalanceJson>;
+    getCrowdloan(reset?: boolean): CrowdloanJson;
+    getStoredCrowdloan(address: string): Promise<Record<string, import("../../../services/storage-service/databases").ICrowdloanItem>>;
+    setCrowdloanItem(networkKey: string, item: CrowdloanItem): void;
+    private updateCrowdloanStore;
+    subscribeCrowdloan(): Subject<CrowdloanJson>;
+    getAllPriceIds(): string[];
+    getSmartContractNfts(): _ChainAsset[];
+    getChainInfoMap(): Record<string, _ChainInfo>;
+    getChainStateMap(): Record<string, _ChainState>;
+    getAssetRefMap(): Record<string, _AssetRef>;
+    getChainStateByKey(key: string): _ChainState;
+    getAssetRegistry(): Record<string, _ChainAsset>;
+    getMultiChainAssetMap(): Record<string, _MultiChainAsset>;
+    getXcmRefMap(): Record<string, _AssetRef>;
+    getAssetByChainAndAsset(chain: string, assetTypes: _AssetType[]): Record<string, _ChainAsset>;
+    getAssetBySlug(slug: string): _ChainAsset;
+    getXcmEqualAssetByChain(destinationChain: string, originTokenSlug: string): _ChainAsset | undefined;
+    subscribeChainInfoMap(): Subject<Record<string, _ChainInfo>>;
+    subscribeChainStateMap(): Subject<Record<string, _ChainState>>;
+    subscribeAssetRegistry(): Subject<Record<string, _ChainAsset>>;
+    subscribeMultiChainAssetMap(): Subject<Record<string, _MultiChainAsset>>;
+    subscribeXcmRefMap(): Subject<Record<string, _AssetRef>>;
+    upsertCustomToken(data: _ChainAsset): Promise<void>;
+    deleteCustomAssets(targetTokens: string[]): void;
+    validateCustomChain(provider: string, existedChainSlug?: string): Promise<import("@subwallet/extension-base/background/KoniTypes").ValidateNetworkResponse>;
+    getSupportedSmartContractTypes(): _AssetType[];
+    validateCustomAsset(data: _ValidateCustomAssetRequest): Promise<import("@subwallet/extension-base/services/chain-service/types")._ValidateCustomAssetResponse>;
+    getActiveChainInfoMap(): Record<string, _ChainInfo>;
+    upsertChainInfo(data: _NetworkUpsertParams): Promise<boolean>;
+    removeCustomChain(networkKey: string): boolean;
+    private getDefaultNetworkKeys;
+    disableChain(chainSlug: string): Promise<boolean>;
+    enableChain(chainSlug: string, enableTokens?: boolean): Promise<boolean>;
+    resetDefaultChains(): boolean;
+    updateNetworkStatus(networkKey: string, status: _ChainConnectionStatus): void;
+    getSubstrateApiMap(): Record<string, import("@subwallet/extension-base/services/chain-service/types")._SubstrateApi>;
+    getSubstrateApi(networkKey: string): import("@subwallet/extension-base/services/chain-service/types")._SubstrateApi;
+    getEvmApiMap(): Record<string, import("@subwallet/extension-base/services/chain-service/types")._EvmApi>;
+    getEvmApi(networkKey: string): import("@subwallet/extension-base/services/chain-service/types")._EvmApi;
+    getApiMap(): ApiMap;
+    refreshSubstrateApi(key: string): boolean;
+    refreshWeb3Api(key: string): void;
+    subscribeServiceInfo(): Subject<ServiceInfo>;
+    updateServiceInfo(): void;
+    getExternalRequestMap(): Record<string, ExternalRequestPromise>;
+    setExternalRequestMap(id: string, value: ExternalRequestPromise): void;
+    getExternalRequest(id: string): ExternalRequestPromise;
+    updateExternalRequest(id: string, value: Partial<ExternalRequestPromise>): void;
+    cleanExternalRequest(): void;
+    pauseAllNetworks(code?: number, reason?: string): Promise<void[]>;
+    resumeAllNetworks(): Promise<void[]>;
+    private publishBalance;
+    private publishCrowdloan;
+    findNetworkKeyByGenesisHash(genesisHash?: string | null): [string | undefined, _ChainInfo | undefined];
+    findChainIdGenesisHash(genesisHash?: string | null): number | undefined;
+    findNetworkKeyByChainId(chainId?: number | null): [string | undefined, _ChainInfo | undefined];
+    findSingleMode(genesisHash: string): SingleModeJson | undefined;
+    accountExportPrivateKey({ address, password }: RequestAccountExportPrivateKey): ResponseAccountExportPrivateKey;
+    checkPublicAndSecretKey({ publicKey, secretKey }: RequestCheckPublicAndSecretKey): ResponseCheckPublicAndSecretKey;
+    getEthKeyring(address: string, password: string): Promise<SimpleKeyring>;
+    evmSign(id: string, url: string, method: string, params: any, allowedAccounts: string[]): Promise<string | undefined>;
+    evmSendTransaction(id: string, url: string, networkKey: string, allowedAccounts: string[], transactionParams: EvmSendTransactionParams): Promise<string | undefined>;
+    getConfirmationsQueueSubject(): BehaviorSubject<ConfirmationsQueue>;
+    completeConfirmation(request: RequestConfirmationComplete): Promise<boolean>;
+    onInstall(): void;
+    get activeNetworks(): Record<string, _ChainInfo>;
+    get activeChainSlugs(): string[];
+    sleep(): Promise<void>;
+    wakeup(): Promise<void>;
+    cancelSubscription(id: string): boolean;
+    createUnsubscriptionHandle(id: string, unsubscribe: () => void): void;
+}
+export {};