@subwallet/extension-base 0.8.4-0 → 1.0.2-1

package/services/storage-service/db-stores/NftCollection.js

@@ -0,0 +1,22 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { liveQuery } from 'dexie';
+import BaseStoreWithChain from "./BaseStoreWithChain.js";
+export default class NftCollectionStore extends BaseStoreWithChain {
+  subscribeNftCollection(chains) {
+    return liveQuery(() => this.getNftCollection(chains));
+  }
+  getNftCollection(chainList) {
+    if (chainList && chainList.length > 0) {
+      return this.table.where('chain').anyOfIgnoreCase(chainList).toArray();
+    }
+    return this.table.toArray();
+  }
+  removeCollection(chain, collectionId) {
+    return this.table.where({
+      chain,
+      collectionId
+    }).delete();
+  }
+}

package/services/storage-service/db-stores/NominatorMetadata.d.ts

@@ -0,0 +1,9 @@
+import { NominatorMetadata } from '@subwallet/extension-base/background/KoniTypes';
+import BaseStoreWithAddressAndChain from '@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithAddressAndChain';
+export default class NominatorMetadataStore extends BaseStoreWithAddressAndChain<NominatorMetadata> {
+    getAll(): Promise<NominatorMetadata[]>;
+    subscribeByAddress(address: string): import("dexie").Observable<NominatorMetadata[]>;
+    subscribeAll(): import("dexie").Observable<NominatorMetadata[]>;
+    getByAddress(address: string): import("dexie").PromiseExtended<NominatorMetadata[]>;
+    removeByAddress(address: string): Promise<number>;
+}

package/services/storage-service/db-stores/NominatorMetadata.js

@@ -0,0 +1,22 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseStoreWithAddressAndChain from '@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithAddressAndChain';
+import { liveQuery } from 'dexie';
+export default class NominatorMetadataStore extends BaseStoreWithAddressAndChain {
+  async getAll() {
+    return this.table.toArray();
+  }
+  subscribeByAddress(address) {
+    return liveQuery(() => this.getByAddress(address));
+  }
+  subscribeAll() {
+    return liveQuery(() => this.getAll());
+  }
+  getByAddress(address) {
+    return this.table.where('address').anyOfIgnoreCase(address).toArray();
+  }
+  async removeByAddress(address) {
+    return this.table.where('address').anyOfIgnoreCase(address).delete();
+  }
+}

package/services/storage-service/db-stores/Price.d.ts

@@ -0,0 +1,4 @@
+import { PriceJson } from '@subwallet/extension-base/background/KoniTypes';
+import BaseStore from './BaseStore';
+export default class Price extends BaseStore<PriceJson> {
+}

package/services/storage-service/db-stores/Price.js

@@ -0,0 +1,5 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseStore from "./BaseStore.js";
+export default class Price extends BaseStore {}

package/services/storage-service/db-stores/Staking.d.ts

@@ -0,0 +1,9 @@
+import { StakingItem, StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import BaseStoreWithAddressAndChain from '@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithAddressAndChain';
+export default class StakingStore extends BaseStoreWithAddressAndChain<StakingItem> {
+    getSingleRecord(chain: string, address: string, type: StakingType): import("dexie").PromiseExtended<StakingItem | undefined>;
+    getStakings(addresses: string[], chainList?: string[]): import("dexie").PromiseExtended<StakingItem[]>;
+    getStakingsByChains(chainList: string[]): import("dexie").PromiseExtended<StakingItem[]>;
+    getPooledStakings(addresses: string[], chainList?: string[]): import("dexie").PromiseExtended<StakingItem[]>;
+    subscribeStaking(addresses: string[], chainList?: string[]): import("dexie").Observable<StakingItem[]>;
+}

package/services/storage-service/db-stores/Staking.js

@@ -0,0 +1,29 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import BaseStoreWithAddressAndChain from '@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithAddressAndChain';
+import { liveQuery } from 'dexie';
+export default class StakingStore extends BaseStoreWithAddressAndChain {
+  getSingleRecord(chain, address, type) {
+    return this.table.where('[chain+address+type]').equals([chain, address, type]).first();
+  }
+  getStakings(addresses, chainList = []) {
+    if (addresses.length) {
+      return this.table.where('address').anyOfIgnoreCase(addresses).and(item => (!chainList.length || chainList.includes(item.chain)) && parseFloat(item.balance) > 0).toArray();
+    }
+    return this.table.filter(item => (!chainList.length || chainList.includes(item.chain)) && parseFloat(item.balance) > 0).toArray();
+  }
+  getStakingsByChains(chainList) {
+    return this.table.filter(item => chainList.includes(item.chain) && parseFloat(item.balance) > 0).toArray();
+  }
+  getPooledStakings(addresses, chainList = []) {
+    if (addresses.length) {
+      return this.table.where('address').anyOfIgnoreCase(addresses).and(item => (!chainList.length || chainList.includes(item.chain)) && parseFloat(item.balance) > 0 && item.type === StakingType.POOLED).toArray();
+    }
+    return this.table.filter(item => (!chainList.length || chainList.includes(item.chain)) && parseFloat(item.balance) > 0 && item.type === StakingType.POOLED).toArray();
+  }
+  subscribeStaking(addresses, chainList = []) {
+    return liveQuery(() => this.getStakings(addresses, chainList));
+  }
+}

package/services/storage-service/db-stores/Transaction.d.ts

@@ -0,0 +1,12 @@
+import BaseStoreWithAddressAndChain from '@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithAddressAndChain';
+import { ITransactionHistoryItem } from '../databases';
+export interface HistoryQuery {
+    chain?: string;
+    address?: string;
+    extrinsicHash?: string;
+}
+export default class TransactionStore extends BaseStoreWithAddressAndChain<ITransactionHistoryItem> {
+    getHistoryByAddressAsObject(address: string): Promise<ITransactionHistoryItem[]>;
+    queryHistory(query?: HistoryQuery): Promise<ITransactionHistoryItem[]>;
+    bulkUpsert(records: ITransactionHistoryItem[]): Promise<unknown>;
+}

package/services/storage-service/db-stores/Transaction.js

@@ -0,0 +1,44 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseStoreWithAddressAndChain from '@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithAddressAndChain';
+export default class TransactionStore extends BaseStoreWithAddressAndChain {
+  async getHistoryByAddressAsObject(address) {
+    if (address === 'ALL') {
+      // Todo: Migrate to all account key
+      return this.table.toArray();
+    }
+    return this.table.where('address').equals(address).toArray();
+  }
+  async queryHistory(query) {
+    if (!(query !== null && query !== void 0 && query.address) && !(query !== null && query !== void 0 && query.chain)) {
+      return this.table.toArray();
+    } else {
+      const queryObject = {};
+      if (query !== null && query !== void 0 && query.chain) {
+        queryObject.chain = query === null || query === void 0 ? void 0 : query.chain;
+      }
+      if (query !== null && query !== void 0 && query.extrinsicHash) {
+        queryObject.extrinsicHash = query === null || query === void 0 ? void 0 : query.extrinsicHash;
+      }
+      if (query !== null && query !== void 0 && query.address) {
+        queryObject.address = query === null || query === void 0 ? void 0 : query.address;
+      }
+      return this.table.where(queryObject).toArray();
+    }
+  }
+  async bulkUpsert(records) {
+    await this.table.bulkPut(records);
+
+    // await Promise.all(records.map((record) => {
+    //   return this.table.where({
+    //     chain: record.chain,
+    //     address: record.address,
+    //     extrinsicHash: record.extrinsicHash
+    //   }).filter((item) => (item.origin === 'app' && record.origin !== 'app'))
+    //     .delete();
+    // }));
+
+    return true;
+  }
+}

package/services/storage-service/db-stores/index.d.ts

@@ -0,0 +1,10 @@
+export { default as PriceStore } from './Price';
+export { default as BalanceStore } from './Balance';
+export { default as CrowdloanStore } from './Crowdloan';
+export { default as NftStore } from './Nft';
+export { default as NftCollectionStore } from './NftCollection';
+export { default as StakingStore } from './Staking';
+export { default as TransactionStore } from './Transaction';
+export { default as MigrationStore } from './Migration';
+export { default as ChainStore } from './Chain';
+export { default as AssetStore } from './Asset';

package/services/storage-service/db-stores/index.js

@@ -0,0 +1,13 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export { default as PriceStore } from "./Price.js";
+export { default as BalanceStore } from "./Balance.js";
+export { default as CrowdloanStore } from "./Crowdloan.js";
+export { default as NftStore } from "./Nft.js";
+export { default as NftCollectionStore } from "./NftCollection.js";
+export { default as StakingStore } from "./Staking.js";
+export { default as TransactionStore } from "./Transaction.js";
+export { default as MigrationStore } from "./Migration.js";
+export { default as ChainStore } from "./Chain.js";
+export { default as AssetStore } from "./Asset.js";

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

@@ -0,0 +1,20 @@
+import { IMultiChainBalance } from '@subwallet/extension-base/services/subscan-service/types';
+export declare class SubscanService {
+    private limitRate;
+    private intervalCheck;
+    private maxRetry;
+    private requestMap;
+    private nextId;
+    private isRunning;
+    private getId;
+    constructor(options?: {
+        limitRate?: number;
+        intervalCheck?: number;
+        maxRetry?: number;
+    });
+    private getApiUrl;
+    private postRequest;
+    private addRequest;
+    private process;
+    getMultiChainBalance(address: string): Promise<IMultiChainBalance[]>;
+}

package/services/subscan-service/index.js

@@ -0,0 +1,99 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// 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 fetch from 'cross-fetch';
+export class SubscanService {
+  limitRate = 2; // limit per interval check
+  intervalCheck = 1000; // interval check in ms
+  maxRetry = 9; // interval check in ms
+  requestMap = {};
+  nextId = 0;
+  isRunning = false;
+  getId() {
+    return this.nextId++;
+  }
+  constructor(options) {
+    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];
+    if (!subscanChain) {
+      throw new SWError('NOT_SUPPORTED', 'Chain is not supported');
+    }
+    return `https://${chain}.api.subscan.io/${path}`;
+  }
+  postRequest(url, body) {
+    return fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+  }
+  addRequest(run) {
+    const newId = this.getId();
+    return new Promise((resolve, reject) => {
+      this.requestMap[newId] = {
+        id: newId,
+        status: 'pending',
+        retry: -1,
+        run,
+        resolve,
+        reject
+      };
+      if (!this.isRunning) {
+        this.process();
+      }
+    });
+  }
+  process() {
+    this.isRunning = true;
+    const maxRetry = this.maxRetry;
+    const interval = setInterval(() => {
+      const remainingRequests = Object.values(this.requestMap);
+      if (remainingRequests.length === 0) {
+        this.isRunning = false;
+        clearInterval(interval);
+        return;
+      }
+
+      // Get first this.limit requests base on id
+      const requests = remainingRequests.filter(request => request.status !== 'running').sort((a, b) => a.id - b.id).slice(0, this.limitRate);
+
+      // Start requests
+      requests.forEach(request => {
+        request.status = 'running';
+        request.run().then(rs => {
+          request.resolve(rs);
+        }).catch(e => {
+          if (request.retry < maxRetry) {
+            request.status = 'pending';
+            request.retry++;
+          } else {
+            // Reject request
+            request.reject(new SWError('MAX_RETRY', String(e)));
+          }
+        });
+      });
+    }, this.intervalCheck);
+  }
+
+  // Implement Subscan API
+  getMultiChainBalance(address) {
+    return this.addRequest(async () => {
+      const rs = await this.postRequest(this.getApiUrl('polkadot', 'api/scan/multiChain/account'), {
+        address
+      });
+      if (rs.status !== 200) {
+        throw new SWError('SubscanService.getMultiChainBalance', await rs.text());
+      }
+      const jsonData = await rs.json();
+      return jsonData.data;
+    });
+  }
+}

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

@@ -0,0 +1,5 @@
+declare const SUBSCAN_CHAIN_MAP: Record<string, string>;
+export declare const SUBSCAN_CHAIN_MAP_REVERSE: {
+    [k: string]: string;
+};
+export default SUBSCAN_CHAIN_MAP;

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

@@ -0,0 +1,63 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const SUBSCAN_CHAIN_MAP = {
+  polkadot: 'polkadot',
+  kusama: 'kusama',
+  moonbeam: 'moonbeam',
+  acala: 'acala',
+  astar: 'astar',
+  shiden: 'shiden',
+  shibuya: 'shibuya',
+  westend: 'westend',
+  moonbase: 'moonbase',
+  moonriver: 'moonriver',
+  turing: 'turing',
+  bifrost_testnet: 'bifrost-testnet',
+  calamari: 'calamari',
+  statemint: 'statemint',
+  pioneer: 'pioneer',
+  parallel: 'parallel',
+  clover: 'clover',
+  hydradx_main: 'hydradx',
+  edgeware: 'edgeware',
+  centrifuge: 'centrifuge',
+  interlay: 'interlay',
+  nodle: 'nodle',
+  darwinia: 'darwinia',
+  polkadex: 'polkadex',
+  aleph: 'alephzero',
+  dolphin: 'dolphin',
+  efinity: 'efinity',
+  composableFinance: 'composable',
+  phala: 'phala',
+  crust: 'crust',
+  statemine: 'statemine',
+  karura: 'karura',
+  khala: 'khala',
+  kilt: 'spiritnet',
+  basilisk: 'basilisk',
+  altair: 'altair',
+  heiko: 'parallel-heiko',
+  kintsugi: 'kintsugi',
+  picasso: 'picasso',
+  quartz: 'quartz',
+  unique_network: 'unique',
+  genshiro: 'genshiro',
+  zeitgeist: 'zeitgeist',
+  sakura: 'sakura',
+  shadow: 'shadow',
+  robonomics: 'robonomics',
+  integritee: 'integritee',
+  acala_testnet: 'acala-testnet',
+  mangatax: 'mangatax',
+  encointer: 'encointer',
+  subspace_gemini_2a: 'subspace',
+  origintrail: 'origintrail',
+  bajun: 'bajun',
+  snow: 'snow',
+  kilt_peregrine: 'kilt-testnet',
+  polymesh: 'polymesh'
+};
+export const SUBSCAN_CHAIN_MAP_REVERSE = Object.fromEntries(Object.entries(SUBSCAN_CHAIN_MAP).map(([k, v]) => [v, k]));
+export default SUBSCAN_CHAIN_MAP;

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

@@ -0,0 +1,27 @@
+export interface SubscanRequest<T> {
+    id: number;
+    retry: number;
+    status: 'pending' | 'running';
+    run: () => Promise<any>;
+    resolve: (value: any) => T;
+    reject: (error?: any) => void;
+}
+export interface SubscanResponse<T = any> {
+    code: number;
+    message: string;
+    data: T;
+}
+export interface IMultiChainBalance {
+    network: string;
+    symbol: string;
+    decimal: number;
+    price: string;
+    category: string;
+    balance: string;
+    locked: string;
+    reserved: string;
+    bonded: string;
+    unbonding: string;
+    democracy_lock: string;
+    election_lock: string;
+}

package/services/subscan-service/types.js

@@ -0,0 +1 @@
+export {};

package/services/transaction-service/event-parser/index.d.ts

@@ -0,0 +1,5 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import { EventRecord } from '@polkadot/types/interfaces';
+export declare function parseXcmEventLogs(historyItem: Partial<TransactionHistoryItem>, eventLogs: EventRecord[], chain: string, sendingTokenInfo: _ChainAsset, chainInfo: _ChainInfo): void;
+export declare function parseTransferEventLogs(historyItem: Partial<TransactionHistoryItem>, eventLogs: EventRecord[], chain: string, sendingTokenInfo: _ChainAsset, chainInfo: _ChainInfo): void;

package/services/transaction-service/event-parser/index.js

@@ -0,0 +1,96 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { _getAssetDecimals, _getChainNativeTokenBasicInfo, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+export function parseXcmEventLogs(historyItem, eventLogs, chain, sendingTokenInfo, chainInfo) {
+  let isFeeUseMainTokenSymbol = true;
+  for (let index = 0; index < eventLogs.length; index++) {
+    const record = eventLogs[index];
+    if (['karura', 'acala', 'acala_testnet'].includes(chain) && sendingTokenInfo && !_isNativeToken(sendingTokenInfo)) {
+      if (record.event.section === 'currencies' && record.event.method.toLowerCase() === 'transferred') {
+        if (index === 0) {
+          var _record$event$data$;
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          historyItem.fee = {
+            value: ((_record$event$data$ = record.event.data[3]) === null || _record$event$data$ === void 0 ? void 0 : _record$event$data$.toString()) || '0',
+            symbol: sendingTokenInfo.symbol,
+            decimals: _getAssetDecimals(sendingTokenInfo)
+          };
+          isFeeUseMainTokenSymbol = false;
+        }
+      }
+    }
+    const {
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    } = _getChainNativeTokenBasicInfo(chainInfo);
+    if (isFeeUseMainTokenSymbol && record.event.section === 'balances' && record.event.method.toLowerCase() === 'withdraw') {
+      var _record$event$data$2;
+      if ((_record$event$data$2 = record.event.data[1]) !== null && _record$event$data$2 !== void 0 && _record$event$data$2.toString()) {
+        var _record$event$data$3;
+        historyItem.fee = {
+          value: (_record$event$data$3 = record.event.data[1]) === null || _record$event$data$3 === void 0 ? void 0 : _record$event$data$3.toString(),
+          symbol: nativeSymbol,
+          decimals: nativeDecimals
+        };
+      }
+    } else if (isFeeUseMainTokenSymbol && record.event.section === 'tokens' && record.event.method.toLowerCase() === 'withdrawn') {
+      var _record$event$data$4;
+      if ((_record$event$data$4 = record.event.data[2]) !== null && _record$event$data$4 !== void 0 && _record$event$data$4.toString()) {
+        var _record$event$data$5;
+        historyItem.fee = {
+          value: (_record$event$data$5 = record.event.data[2]) === null || _record$event$data$5 === void 0 ? void 0 : _record$event$data$5.toString(),
+          symbol: nativeSymbol,
+          decimals: nativeDecimals
+        };
+      }
+    }
+  }
+}
+export function parseTransferEventLogs(historyItem, eventLogs, chain, sendingTokenInfo, chainInfo) {
+  let isFeeUseMainTokenSymbol = true;
+  for (let index = 0; index < eventLogs.length; index++) {
+    const record = eventLogs[index];
+    if (['karura', 'acala', 'acala_testnet'].includes(chain) && !_isNativeToken(sendingTokenInfo)) {
+      if (record.event.section === 'currencies' && record.event.method.toLowerCase() === 'transferred') {
+        if (index === 0) {
+          var _record$event$data$6;
+          historyItem.fee = {
+            value: ((_record$event$data$6 = record.event.data[3]) === null || _record$event$data$6 === void 0 ? void 0 : _record$event$data$6.toString()) || '0',
+            symbol: sendingTokenInfo.symbol,
+            decimals: _getAssetDecimals(sendingTokenInfo)
+          };
+          isFeeUseMainTokenSymbol = false;
+        }
+      }
+    } else if (['genshiro_testnet', 'genshiro', 'equilibrium_parachain'].includes(chain) && sendingTokenInfo) {
+      if (record.event.section === 'transactionPayment' && record.event.method.toLowerCase() === 'transactionfeepaid') {
+        var _record$event$data$7;
+        if ((_record$event$data$7 = record.event.data[1]) !== null && _record$event$data$7 !== void 0 && _record$event$data$7.toString()) {
+          var _record$event$data$8;
+          historyItem.fee = {
+            value: ((_record$event$data$8 = record.event.data[1]) === null || _record$event$data$8 === void 0 ? void 0 : _record$event$data$8.toString()) || '0',
+            symbol: sendingTokenInfo.symbol,
+            decimals: _getAssetDecimals(sendingTokenInfo)
+          };
+        }
+      }
+    }
+    const {
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    } = _getChainNativeTokenBasicInfo(chainInfo);
+    if (isFeeUseMainTokenSymbol && record.event.section === 'balances' && record.event.method.toLowerCase() === 'withdraw') {
+      var _record$event$data$9;
+      if ((_record$event$data$9 = record.event.data[1]) !== null && _record$event$data$9 !== void 0 && _record$event$data$9.toString()) {
+        var _record$event$data$10;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        historyItem.fee = {
+          value: ((_record$event$data$10 = record.event.data[1]) === null || _record$event$data$10 === void 0 ? void 0 : _record$event$data$10.toString()) || '0',
+          symbol: nativeSymbol,
+          decimals: nativeDecimals
+        };
+      }
+    }
+  }
+}

package/services/transaction-service/helpers/index.d.ts

@@ -0,0 +1,5 @@
+import { SWTransaction } from '@subwallet/extension-base/services/transaction-service/types';
+import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
+export declare const getTransactionId: (chainType: string, chain: string, isInternal: boolean) => string;
+export declare const getValidationId: (chainType: string, chain: string) => string;
+export declare const isSubstrateTransaction: (tx: SWTransaction['transaction']) => tx is SubmittableExtrinsic;

package/services/transaction-service/helpers/index.js

@@ -0,0 +1,14 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+let transactionCount = 0;
+let validationCount = 0;
+export const getTransactionId = (chainType, chain, isInternal) => {
+  return `${isInternal ? 'internal' : 'external'}.${chainType}.${chain}.${Date.now()}.${++transactionCount}`;
+};
+export const getValidationId = (chainType, chain) => {
+  return `${chainType}.${chain}.${Date.now()}.${++validationCount}`;
+};
+export const isSubstrateTransaction = tx => {
+  return !!tx.send;
+};

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

@@ -0,0 +1,46 @@
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BalanceService } from '@subwallet/extension-base/services/balance-service';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { EventService } from '@subwallet/extension-base/services/event-service';
+import { HistoryService } from '@subwallet/extension-base/services/history-service';
+import NotificationService from '@subwallet/extension-base/services/notification-service/NotificationService';
+import RequestService from '@subwallet/extension-base/services/request-service';
+import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+import { SWTransaction, SWTransactionInput, SWTransactionResponse, TransactionEmitter } from '@subwallet/extension-base/services/transaction-service/types';
+import { BehaviorSubject } from 'rxjs';
+import { TransactionConfig } from 'web3-core';
+import { HexString } from '@polkadot/util/types';
+export default class TransactionService {
+    private readonly chainService;
+    private readonly eventService;
+    private readonly databaseService;
+    private readonly requestService;
+    private readonly balanceService;
+    private readonly historyService;
+    private readonly notificationService;
+    private readonly transactionSubject;
+    private get transactions();
+    constructor(chainService: ChainService, eventService: EventService, requestService: RequestService, balanceService: BalanceService, historyService: HistoryService, notificationService: NotificationService, databaseService: DatabaseService);
+    private get allTransactions();
+    private get processingTransactions();
+    getTransaction(id: string): SWTransaction;
+    private checkDuplicate;
+    generalValidate(validationInput: SWTransactionInput): Promise<SWTransactionResponse>;
+    getTransactionSubject(): BehaviorSubject<Record<string, SWTransaction>>;
+    private fillTransactionDefaultInfo;
+    addTransaction(inputTransaction: SWTransactionInput): Promise<TransactionEmitter>;
+    generateBeforeHandleResponseErrors(errors: TransactionError[]): SWTransactionResponse;
+    handleTransaction(transaction: SWTransactionInput): Promise<SWTransactionResponse>;
+    private sendTransaction;
+    private removeTransaction;
+    private updateTransaction;
+    private getTransactionLink;
+    private transactionToHistories;
+    private onHasTransactionHash;
+    private handlePostProcessing;
+    private onSuccess;
+    private onFailed;
+    generateHashPayload(chain: string, transaction: TransactionConfig): HexString;
+    private signAndSendEvmTransaction;
+    private signAndSendSubstrateTransaction;
+}