@subwallet/extension-base 1.1.22-0 → 1.1.24-0

package/services/storage-service/DatabaseService.d.ts

@@ -83,4 +83,7 @@ export default class DatabaseService {
     getProcessingCampaign(): Promise<import("@subwallet/extension-base/background/KoniTypes").CampaignData[]>;
     getCampaign(slug: string): Promise<import("@subwallet/extension-base/background/KoniTypes").CampaignData | undefined>;
     upsertCampaign(campaign: ICampaign): import("dexie").PromiseExtended<unknown>;
+    exportDB(): Promise<string>;
+    importDB(data: string): Promise<boolean>;
+    checkImportMetadata(data: string): Promise<import("dexie-export-import").DexieExportJsonMeta | null>;
 }

package/services/storage-service/DatabaseService.js

@@ -9,7 +9,9 @@ import ChainStakingMetadataStore from '@subwallet/extension-base/services/storag
 import MantaPayStore from '@subwallet/extension-base/services/storage-service/db-stores/MantaPay';
 import NominatorMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/NominatorMetadata';
 import { reformatAddress } from '@subwallet/extension-base/utils';
+import { exportDB, peakImportFile } from 'dexie-export-import';
 import { logger as createLogger } from '@polkadot/util';
+const EXPORT_EXCLUDE_TABLES = ['metadata'];
 export default class DatabaseService {
   // TODO: might remove this
 
@@ -279,4 +281,42 @@ export default class DatabaseService {
   upsertCampaign(campaign) {
     return this.stores.campaign.upsertCampaign(campaign);
   }
+  async exportDB() {
+    const blob = await exportDB(this._db, {
+      filter: (table, value, key) => {
+        if (EXPORT_EXCLUDE_TABLES.indexOf(table) >= 0) {
+          return false;
+        }
+        return true;
+      }
+    });
+    return await blob.text();
+  }
+  async importDB(data) {
+    try {
+      const blob = new Blob([data], {
+        type: 'application/json'
+      });
+      await this._db.import(blob, {
+        overwriteValues: true,
+        acceptMissingTables: true,
+        acceptVersionDiff: true
+      });
+      return true;
+    } catch (e) {
+      this.logger.error(e);
+      return false;
+    }
+  }
+  async checkImportMetadata(data) {
+    try {
+      const blob = new Blob([data], {
+        type: 'application/json'
+      });
+      return await peakImportFile(blob);
+    } catch (e) {
+      this.logger.error(e);
+      return null;
+    }
+  }
 }

package/services/subscan-service/index.d.ts

@@ -1,5 +1,6 @@
-import { IMultiChainBalance } from '@subwallet/extension-base/services/subscan-service/types';
+import { CrowdloanContributionsResponse, ExtrinsicItem, ExtrinsicsListResponse, IMultiChainBalance, TransferItem, TransfersListResponse } from '@subwallet/extension-base/services/subscan-service/types';
 export declare class SubscanService {
+    private subscanChainMap;
     private limitRate;
     private intervalCheck;
     private maxRetry;
@@ -7,7 +8,7 @@ export declare class SubscanService {
     private nextId;
     private isRunning;
     private getId;
-    constructor(options?: {
+    constructor(subscanChainMap: Record<string, string>, options?: {
         limitRate?: number;
         intervalCheck?: number;
         maxRetry?: number;
@@ -16,5 +17,12 @@ export declare class SubscanService {
     private postRequest;
     private addRequest;
     private process;
+    checkSupportedSubscanChain(chain: string): boolean;
+    setSubscanChainMap(subscanChainMap: Record<string, string>): void;
     getMultiChainBalance(address: string): Promise<IMultiChainBalance[]>;
+    getCrowdloanContributions(relayChain: string, address: string, page?: number): Promise<CrowdloanContributionsResponse>;
+    getExtrinsicsList(chain: string, address: string, page?: number): Promise<ExtrinsicsListResponse>;
+    fetchAllPossibleExtrinsicItems(chain: string, address: string, cbAfterEachRequest?: (items: ExtrinsicItem[]) => void): Promise<ExtrinsicItem[]>;
+    getTransfersList(chain: string, address: string, page?: number, direction?: 'sent' | 'received'): Promise<TransfersListResponse>;
+    fetchAllPossibleTransferItems(chain: string, address: string, direction?: 'sent' | 'received', cbAfterEachRequest?: (items: TransferItem[]) => void): Promise<TransferItem[]>;
 }

package/services/subscan-service/index.js

@@ -2,8 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { SWError } from '@subwallet/extension-base/background/errors/SWError';
-import SUBSCAN_CHAIN_MAP from '@subwallet/extension-base/services/subscan-service/subscan-chain-map';
+import { wait } from '@subwallet/extension-base/utils';
 import fetch from 'cross-fetch';
+const QUERY_ROW = 100;
 export class SubscanService {
   limitRate = 2; // limit per interval check
   intervalCheck = 1000; // interval check in ms
@@ -14,17 +15,18 @@ export class SubscanService {
   getId() {
     return this.nextId++;
   }
-  constructor(options) {
+  constructor(subscanChainMap, options) {
+    this.subscanChainMap = subscanChainMap;
     this.limitRate = (options === null || options === void 0 ? void 0 : options.limitRate) || this.limitRate;
     this.intervalCheck = (options === null || options === void 0 ? void 0 : options.intervalCheck) || this.intervalCheck;
     this.maxRetry = (options === null || options === void 0 ? void 0 : options.maxRetry) || this.maxRetry;
   }
   getApiUrl(chain, path) {
-    const subscanChain = SUBSCAN_CHAIN_MAP[chain];
+    const subscanChain = this.subscanChainMap[chain];
     if (!subscanChain) {
       throw new SWError('NOT_SUPPORTED', 'Chain is not supported');
     }
-    return `https://${chain}.api.subscan.io/${path}`;
+    return `https://${subscanChain}.api.subscan.io/${path}`;
   }
   postRequest(url, body) {
     return fetch(url, {
@@ -82,6 +84,12 @@ export class SubscanService {
       });
     }, this.intervalCheck);
   }
+  checkSupportedSubscanChain(chain) {
+    return !!this.subscanChainMap[chain];
+  }
+  setSubscanChainMap(subscanChainMap) {
+    this.subscanChainMap = subscanChainMap;
+  }
 
   // Implement Subscan API
   getMultiChainBalance(address) {
@@ -96,4 +104,97 @@ export class SubscanService {
       return jsonData.data;
     });
   }
+  getCrowdloanContributions(relayChain, address, page = 0) {
+    return this.addRequest(async () => {
+      const rs = await this.postRequest(this.getApiUrl(relayChain, 'api/scan/account/contributions'), {
+        include_total: true,
+        page,
+        row: QUERY_ROW,
+        who: address
+      });
+      if (rs.status !== 200) {
+        throw new SWError('SubscanService.getCrowdloanContributions', await rs.text());
+      }
+      const jsonData = await rs.json();
+      return jsonData.data;
+    });
+  }
+  getExtrinsicsList(chain, address, page = 0) {
+    return this.addRequest(async () => {
+      const rs = await this.postRequest(this.getApiUrl(chain, 'api/scan/extrinsics'), {
+        page,
+        row: QUERY_ROW,
+        address
+      });
+      if (rs.status !== 200) {
+        throw new SWError('SubscanService.getExtrinsicsList', await rs.text());
+      }
+      const jsonData = await rs.json();
+      return jsonData.data;
+    });
+  }
+  async fetchAllPossibleExtrinsicItems(chain, address, cbAfterEachRequest) {
+    let count = 0;
+    const resultMap = {};
+    const _getExtrinsicItems = async page => {
+      const res = await this.getExtrinsicsList(chain, address, page);
+      if (!res || !res.count || !res.extrinsics || !res.extrinsics.length) {
+        return;
+      }
+      if (res.count > count) {
+        count = res.count;
+      }
+      cbAfterEachRequest === null || cbAfterEachRequest === void 0 ? void 0 : cbAfterEachRequest(res.extrinsics);
+      res.extrinsics.forEach(item => {
+        resultMap[item.extrinsic_hash] = item;
+      });
+      if (Object.values(resultMap).length < count) {
+        await wait(100);
+        await _getExtrinsicItems(++page);
+      }
+    };
+    await _getExtrinsicItems(0);
+    return Object.values(resultMap);
+  }
+  getTransfersList(chain, address, page = 0, direction) {
+    const requestBody = {
+      page,
+      row: QUERY_ROW,
+      address
+    };
+    if (direction) {
+      requestBody.direction = direction;
+    }
+    return this.addRequest(async () => {
+      const rs = await this.postRequest(this.getApiUrl(chain, 'api/v2/scan/transfers'), requestBody);
+      if (rs.status !== 200) {
+        throw new SWError('SubscanService.getTransfersList', await rs.text());
+      }
+      const jsonData = await rs.json();
+      return jsonData.data;
+    });
+  }
+  async fetchAllPossibleTransferItems(chain, address, direction, cbAfterEachRequest) {
+    let count = 0;
+    const resultMap = {};
+    const _getTransferItems = async page => {
+      const res = await this.getTransfersList(chain, address, page, direction);
+      if (!res || !res.count || !res.transfers || !res.transfers.length) {
+        return;
+      }
+      if (res.count > count) {
+        count = res.count;
+      }
+      cbAfterEachRequest === null || cbAfterEachRequest === void 0 ? void 0 : cbAfterEachRequest(res.transfers);
+      res.transfers.forEach(item => {
+        resultMap[item.hash] = item;
+      });
+      if (Object.values(resultMap).length < count) {
+        await wait(100);
+        await _getTransferItems(++page);
+      }
+    };
+    await _getTransferItems(0);
+    return Object.values(resultMap);
+  }
 }

package/services/subscan-service/subscan-chain-map.d.ts

@@ -1,5 +1,11 @@
-declare const SUBSCAN_CHAIN_MAP: Record<string, string>;
-export declare const SUBSCAN_CHAIN_MAP_REVERSE: {
+/**
+ * Only use this for initiating SubscanService or unit test
+ */
+export declare const SUBSCAN_API_CHAIN_MAP: Record<string, string>;
+/**
+ * Map for token self-activation feature
+ */
+export declare const SUBSCAN_BALANCE_CHAIN_MAP: Record<string, string>;
+export declare const SUBSCAN_BALANCE_CHAIN_MAP_REVERSE: {
     [k: string]: string;
 };
-export default SUBSCAN_CHAIN_MAP;

package/services/subscan-service/subscan-chain-map.js

@@ -1,7 +1,76 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-const SUBSCAN_CHAIN_MAP = {
+/**
+ * Only use this for initiating SubscanService or unit test
+ */
+export const SUBSCAN_API_CHAIN_MAP = {
+  polkadot: 'polkadot',
+  kusama: 'kusama',
+  moonbeam: 'moonbeam',
+  pioneer: 'pioneer',
+  aleph: 'alephzero',
+  astar: 'astar',
+  statemint: 'assethub-polkadot',
+  acala: 'acala',
+  shiden: 'shiden',
+  shibuya: 'shibuya',
+  westend: 'westend',
+  rococo: 'rococo',
+  moonbase: 'moonbase',
+  moonriver: 'moonriver',
+  turing: 'turing',
+  bifrost: 'bifrost-kusama',
+  bifrost_dot: 'bifrost',
+  calamari: 'calamari',
+  parallel: 'parallel',
+  clover: 'clv',
+  hydradx_main: 'hydradx',
+  centrifuge: 'centrifuge',
+  interlay: 'interlay',
+  nodle: 'nodle',
+  darwinia2: 'darwinia',
+  polkadex: 'polkadex-parachain',
+  composableFinance: 'composable',
+  phala: 'phala',
+  crust: 'crust-parachain',
+  statemine: 'assethub-kusama',
+  karura: 'karura',
+  khala: 'khala',
+  kilt: 'spiritnet',
+  basilisk: 'basilisk',
+  altair: 'altair',
+  heiko: 'parallel-heiko',
+  kintsugi: 'kintsugi',
+  picasso: 'picasso',
+  unique_network: 'unique',
+  zeitgeist: 'zeitgeist',
+  sakura: 'sakura',
+  shadow: 'shadow',
+  robonomics: 'robonomics',
+  integritee: 'integritee',
+  crabParachain: 'crab',
+  acala_testnet: 'acala-testnet',
+  mangatax_para: 'mangatax',
+  origintrail: 'origintrail',
+  subspace_gemini_3g: 'subspace',
+  bajun: 'bajun',
+  tanganika: 'datahighway',
+  kilt_peregrine: 'kilt-testnet',
+  dockPosMainnet: 'dock',
+  polymesh: 'polymesh',
+  sora_substrate: 'sora',
+  joystream: 'joystream',
+  vara_network: 'vara',
+  krest_network: 'krest',
+  crust_mainnet: 'crust',
+  manta_network: 'manta'
+};
+
+/**
+ * Map for token self-activation feature
+ */
+export const SUBSCAN_BALANCE_CHAIN_MAP = {
   polkadot: 'polkadot',
   kusama: 'kusama',
   moonbeam: 'moonbeam',
@@ -21,7 +90,7 @@ const SUBSCAN_CHAIN_MAP = {
   clover: 'clover',
   hydradx_main: 'hydradx',
   edgeware: 'edgeware',
-  centrifuge: 'centrifuge',
+  centrifuge: 'centrifuge-parachain',
   interlay: 'interlay',
   nodle: 'nodle',
   darwinia: 'darwinia',
@@ -57,7 +126,11 @@ const SUBSCAN_CHAIN_MAP = {
   bajun: 'bajun',
   snow: 'snow',
   kilt_peregrine: 'kilt-testnet',
-  polymesh: 'polymesh'
+  polymesh: 'polymesh',
+  bifrost_dot: 'bifrost-p',
+  vara_network: 'vara',
+  bifrost: 'bifrost',
+  creditcoin: 'creditcoin',
+  joystream: 'joystream'
 };
-export const SUBSCAN_CHAIN_MAP_REVERSE = Object.fromEntries(Object.entries(SUBSCAN_CHAIN_MAP).map(([k, v]) => [v, k]));
-export default SUBSCAN_CHAIN_MAP;
+export const SUBSCAN_BALANCE_CHAIN_MAP_REVERSE = Object.fromEntries(Object.entries(SUBSCAN_BALANCE_CHAIN_MAP).map(([k, v]) => [v, k]));

package/services/subscan-service/types.d.ts

@@ -25,3 +25,149 @@ export interface IMultiChainBalance {
     democracy_lock: string;
     election_lock: string;
 }
+export interface CrowdloanContributionItem {
+    fund_id: string;
+    para_id: number;
+    contributed: string;
+    block_num: number;
+    block_timestamp: number;
+    extrinsic_index: string;
+    event_index: string;
+    status: number;
+    memo: string;
+    fund_status: number;
+    fund_event_index: string;
+    unlocking_block: number;
+    fund_auction_status: number;
+}
+export interface CrowdloanContributionsResponse {
+    count: number;
+    list: null | CrowdloanContributionItem[];
+    total: string;
+}
+export interface ExtrinsicItem {
+    id?: number;
+    block_num: number;
+    block_timestamp: number;
+    extrinsic_index: string;
+    call_module_function: string;
+    params: string;
+    account_id: string;
+    account_index: string;
+    signature: string;
+    call_module: string;
+    nonce: number;
+    extrinsic_hash: string;
+    success: boolean;
+    fee: string;
+    fee_used: string;
+    from_hex: string;
+    tip: string;
+    finalized: boolean;
+    account_display: {
+        address: string;
+    };
+}
+export interface ExtrinsicsListResponse {
+    count: number;
+    extrinsics: null | ExtrinsicItem[];
+}
+export interface ExtrinsicParam {
+    name: string;
+    type: string;
+    type_name: string;
+    value: any;
+}
+export interface ExtrinsicDetailEvent {
+    event_index: string;
+    block_num: number;
+    extrinsic_idx: number;
+    module_id: string;
+    event_id: string;
+    params: string;
+    phase: number;
+    event_idx: number;
+    extrinsic_hash: string;
+    finalized: boolean;
+    block_timestamp: number;
+}
+export interface ExtrinsicDetailError {
+    module: string;
+    name: string;
+    doc: string;
+    value: string;
+    batch_index: number;
+}
+export interface ExtrinsicDetail {
+    block_timestamp: number;
+    block_num: number;
+    extrinsic_index: string;
+    call_module_function: string;
+    call_module: string;
+    account_id: string;
+    signature: string;
+    nonce: number;
+    extrinsic_hash: string;
+    success: boolean;
+    params: ExtrinsicParam[];
+    transfer: {
+        from: string;
+        to: string;
+        module: string;
+        amount: string;
+        hash: string;
+        success: boolean;
+        asset_symbol: string;
+        to_account_display: {
+            address: string;
+        };
+    };
+    event: ExtrinsicDetailEvent[];
+    event_count: number;
+    fee: string;
+    fee_used: string;
+    error: null | ExtrinsicDetailError;
+    finalized: boolean;
+    lifetime: {
+        birth: number;
+        death: number;
+    };
+    tip: string;
+    account_display: {
+        address: string;
+    };
+    block_hash: string;
+    pending: boolean;
+}
+export interface TransferItem {
+    from: string;
+    to: string;
+    extrinsic_index: string;
+    success: boolean;
+    hash: string;
+    block_num: number;
+    block_timestamp: number;
+    module: string;
+    amount: string;
+    amount_v2: string;
+    usd_amount: string;
+    fee: string;
+    nonce: number;
+    asset_symbol: string;
+    asset_unique_id: string;
+    asset_type: string;
+    item_id: number | null;
+    from_account_display: {
+        address: string;
+        display?: string;
+    };
+    to_account_display: {
+        address: string;
+        display?: string;
+    };
+    event_idx: 0;
+}
+export interface TransfersListResponse {
+    count: number;
+    transfers: null | TransferItem[];
+}

package/utils/index.d.ts

@@ -39,6 +39,7 @@ export declare function isSameAddress(address1: string, address2: string): boole
 export declare function getDomainFromUrl(url: string): string;
 export declare function waitTimeout(ms: number): Promise<void>;
 export declare const stripUrl: (url: string) => string;
+export declare function wait(milliseconds: number): Promise<void>;
 export * from './array';
 export * from './environment';
 export * from './lazy';

package/utils/index.js

@@ -287,6 +287,13 @@ export const stripUrl = url => {
   const parts = url.split('/');
   return parts[2];
 };
+export function wait(milliseconds) {
+  return new Promise(resolve => {
+    setTimeout(() => {
+      resolve();
+    }, milliseconds);
+  });
+}
 export * from "./array.js";
 export * from "./environment.js";
 export * from "./lazy.js";