@subwallet/extension-base 1.3.69-0 → 1.3.70-2

package/services/open-gov/index.js

@@ -0,0 +1,265 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { BasicTxErrorType } from '@subwallet/extension-base/types';
+import { addLazy, createPromiseHandler, filterAddressByChainInfo } from '@subwallet/extension-base/utils';
+import { BehaviorSubject } from 'rxjs';
+import { ServiceStatus } from "../base/types.js";
+import { _GOVERNANCE_CHAIN_GROUP } from "../chain-service/constants.js";
+import { _isChainEnabled } from "../chain-service/utils/index.js";
+import BaseOpenGovHandler from "./handler.js";
+class OpenGovChainHandler extends BaseOpenGovHandler {
+  constructor(state, chain) {
+    super(state, chain);
+    this.slug = chain;
+  }
+}
+export default class OpenGovService {
+  handlers = {};
+
+  // subjects
+  govLockedInfoSubject = new BehaviorSubject({});
+  govLockedInfoListSubject = new BehaviorSubject([]);
+  govLockedInfoPersistQueue = [];
+  status = ServiceStatus.NOT_INITIALIZED;
+  startPromiseHandler = createPromiseHandler();
+  stopPromiseHandler = createPromiseHandler();
+  constructor(state) {
+    this.state = state;
+    this.eventService = state.eventService;
+    this.dbService = state.dbService;
+  }
+  async init() {
+    this.status = ServiceStatus.INITIALIZING;
+    this.eventService.emit('open-gov.ready', true);
+    await this.initHandlers();
+    await this.getGovLockedInfoFromDB();
+    this.status = ServiceStatus.INITIALIZED;
+    this.govLockedInfoListSubject.next(Object.values(this.govLockedInfoSubject.getValue()));
+    this.handleActions();
+  }
+  handleActions() {
+    this.eventService.onLazy((events, eventTypes) => {
+      let delayReload = false;
+      const removedAddresses = [];
+      const removeChains = [];
+      (async () => {
+        for (const event of events) {
+          if (event.type === 'account.remove') {
+            removedAddresses.push(event.data[0]);
+          }
+          if (event.type === 'account.add' || event.type === 'account.updateCurrent') {
+            delayReload = true;
+          }
+          if (event.type === 'chain.updateState') {
+            const chainKey = event.data[0];
+            const chainState = this.state.getChainStateByKey(chainKey);
+            if (chainState && !_isChainEnabled(chainState)) {
+              removeChains.push(chainKey);
+            }
+            delayReload = true;
+          }
+          if (event.type === 'transaction.done') {
+            const tx = event.data[0];
+            const govRelatedTypes = [ExtrinsicType.GOV_VOTE, ExtrinsicType.GOV_UNVOTE, ExtrinsicType.GOV_UNLOCK_VOTE];
+            if (govRelatedTypes.includes(tx.extrinsicType)) {
+              delayReload = true;
+            }
+          }
+        }
+        if (removeChains.length || removedAddresses.length) {
+          await this.removeGovLockedInfos(removeChains, removedAddresses);
+        }
+        if (eventTypes.includes('account.updateCurrent') || eventTypes.includes('account.remove') || eventTypes.includes('chain.updateState') || delayReload) {
+          if (delayReload) {
+            this.delayReloadTimeout = setTimeout(() => {
+              this.resetGovLockedInfo().then(() => this.runSubscribeGovLockedInfo()).catch(console.error);
+            }, 3000);
+          } else {
+            this.delayReloadTimeout && clearTimeout(this.delayReloadTimeout);
+            this.delayReloadTimeout = undefined;
+            await this.resetGovLockedInfo();
+            await this.runSubscribeGovLockedInfo();
+          }
+        }
+      })().catch(console.error);
+    });
+  }
+  async removeGovLockedInfos(chains, addresses) {
+    const current = this.govLockedInfoSubject.getValue();
+    const removeKeys = [];
+    if (chains && chains.length > 0) {
+      for (const [key, value] of Object.entries(current)) {
+        if (chains.includes(value.chain)) {
+          removeKeys.push(key);
+        }
+      }
+    }
+    if (addresses && addresses.length > 0) {
+      for (const [key, value] of Object.entries(current)) {
+        if (addresses.includes(value.address)) {
+          removeKeys.push(key);
+        }
+      }
+    }
+    for (const key of removeKeys) {
+      delete current[key];
+    }
+    this.govLockedInfoSubject.next(current);
+    this.govLockedInfoListSubject.next(Object.values(current));
+    if (addresses && addresses.length > 0) {
+      await this.dbService.removeGovLockedInfosByAddresses(addresses);
+    }
+    if (chains && chains.length > 0) {
+      await this.dbService.removeGovLockedInfosByChains(chains);
+    }
+  }
+  async initHandlers() {
+    await this.eventService.waitChainReady;
+    const chains = [];
+    const supportedSlugs = Object.values(_GOVERNANCE_CHAIN_GROUP).flat();
+    for (const chain of Object.values(this.state.getChainInfoMap())) {
+      if (chain.chainStatus === 'ACTIVE' && supportedSlugs.includes(chain.slug)) {
+        chains.push(chain.slug);
+      }
+    }
+    for (const chain of chains) {
+      this.handlers[chain] = new OpenGovChainHandler(this.state, chain);
+    }
+  }
+  async handleVote(request) {
+    const handler = this.handlers[request.chain];
+    if (!handler) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+    }
+    return handler.handleVote(request);
+  }
+  async handleRemoveVote(request) {
+    const handler = this.handlers[request.chain];
+    if (!handler) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+    }
+    return handler.handleRemoveVote(request);
+  }
+  async handleUnlockVote(request) {
+    const handler = this.handlers[request.chain];
+    if (!handler) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+    }
+    return handler.handleUnlockVote(request);
+  }
+
+  /* Gov Locked Info */
+
+  async runSubscribeGovLockedInfo() {
+    await this.eventService.waitKeyringReady;
+    this.runUnsubscribeGovLockedInfo();
+    const addresses = this.state.keyringService.context.getDecodedAddresses();
+    this.subscribeGovLockedInfos(addresses, data => {
+      this.updateGovLockedInfo(data);
+    }).then(rs => {
+      this.govLockedInfoUnsub = rs;
+    }).catch(console.error);
+  }
+  runUnsubscribeGovLockedInfo() {
+    var _this$govLockedInfoUn;
+    (_this$govLockedInfoUn = this.govLockedInfoUnsub) === null || _this$govLockedInfoUn === void 0 ? void 0 : _this$govLockedInfoUn.call(this);
+    this.govLockedInfoUnsub = undefined;
+    this.govLockedInfoPersistQueue = [];
+  }
+  async subscribeGovLockedInfos(addresses, cb) {
+    let cancel = false;
+    await this.eventService.waitChainReady;
+    const activeChains = this.state.activeChainSlugs;
+    const unsubList = [];
+    for (const handler of Object.values(this.handlers)) {
+      if (activeChains.includes(handler.chain)) {
+        const [useAddresses] = filterAddressByChainInfo(addresses, handler.chainInfo);
+        handler.subscribeGovLockedInfo(useAddresses, cb).then(unsub => {
+          if (cancel) {
+            unsub();
+          } else {
+            unsubList.push(unsub);
+          }
+        }).catch(console.error);
+      }
+    }
+    return () => {
+      cancel = true;
+      unsubList.forEach(unsub => unsub === null || unsub === void 0 ? void 0 : unsub());
+    };
+  }
+  updateGovLockedInfo(data) {
+    this.govLockedInfoPersistQueue.push(data);
+    addLazy('persistGovLockedInfo', () => {
+      const govInfo = this.govLockedInfoSubject.getValue();
+      const queue = [...this.govLockedInfoPersistQueue];
+      this.govLockedInfoPersistQueue = [];
+
+      // Update info in memory
+      queue.forEach(item => {
+        const key = `${item.chain}---${item.address}`;
+        govInfo[key] = item;
+      });
+      this.govLockedInfoSubject.next(govInfo);
+      this.govLockedInfoListSubject.next(Object.values(govInfo));
+
+      // Persist data
+      this.dbService.updateGovLockedInfos(queue).catch(console.warn);
+    }, 300, 900);
+  }
+  async resetGovLockedInfo() {
+    this.govLockedInfoPersistQueue = [];
+    await this.dbService.stores.govLockedInfo.clear();
+  }
+  async getGovLockedInfoFromDB() {
+    await this.eventService.waitChainReady;
+    await this.eventService.waitKeyringReady;
+    const addresses = this.state.keyringService.context.getDecodedAddresses();
+    const existedInfos = await this.dbService.getGovLockedInfos(addresses, this.state.activeChainSlugs);
+    const govInfo = this.govLockedInfoSubject.getValue();
+    existedInfos.forEach(item => {
+      govInfo[`${item.chain}---${item.address}`] = item;
+    });
+    this.govLockedInfoSubject.next(govInfo);
+    this.govLockedInfoListSubject.next(Object.values(govInfo));
+  }
+  subscribeGovLockedInfoSubject() {
+    return this.govLockedInfoListSubject;
+  }
+  async getGovLockedInfoInfo() {
+    await this.eventService.waitEarningReady;
+    return Promise.resolve(this.govLockedInfoListSubject.getValue());
+  }
+
+  /* --------- Start/Stop ---------- */
+  async start() {
+    if (this.status === ServiceStatus.STARTING || this.status === ServiceStatus.STARTED) {
+      return this.waitForStarted();
+    }
+    this.status = ServiceStatus.STARTING;
+    this.startPromiseHandler.resolve();
+    this.stopPromiseHandler = createPromiseHandler();
+    this.status = ServiceStatus.STARTED;
+  }
+  async stop() {
+    if (this.status === ServiceStatus.STOPPING || this.status === ServiceStatus.STOPPED) {
+      return this.waitForStopped();
+    }
+    this.status = ServiceStatus.STOPPING;
+    this.runUnsubscribeGovLockedInfo();
+    this.stopPromiseHandler.resolve();
+    this.startPromiseHandler = createPromiseHandler();
+    this.status = ServiceStatus.STOPPED;
+  }
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
+
+  /* Gov Locked Info */
+}

package/services/open-gov/interface.d.ts

@@ -0,0 +1,141 @@
+export declare enum GovVoteType {
+    AYE = "aye",
+    NAY = "nay",
+    SPLIT = "split",
+    ABSTAIN = "abstain"
+}
+interface BaseVoteRequest {
+    chain: string;
+    address: string;
+    referendumIndex: string;
+    trackId: number;
+    conviction: number;
+}
+export interface StandardVoteRequest extends BaseVoteRequest {
+    type: GovVoteType.AYE | GovVoteType.NAY;
+    amount: string;
+}
+export interface SplitVoteRequest extends BaseVoteRequest {
+    type: GovVoteType.SPLIT;
+    ayeAmount: string;
+    nayAmount: string;
+}
+export interface SplitAbstainVoteRequest extends BaseVoteRequest {
+    type: GovVoteType.ABSTAIN;
+    abstainAmount: string;
+    ayeAmount: string;
+    nayAmount: string;
+}
+export declare type GovVoteRequest = StandardVoteRequest | SplitVoteRequest | SplitAbstainVoteRequest;
+export interface RemoveVoteRequest {
+    address: string;
+    chain: string;
+    trackId: number;
+    referendumIndex: string;
+    amount?: string;
+    ayeAmount?: string;
+    nayAmount?: string;
+    abstainAmount?: string;
+    totalAmount: string;
+    type?: GovVoteType;
+}
+export declare enum Conviction {
+    None = "None",
+    Locked1x = "Locked1x",
+    Locked2x = "Locked2x",
+    Locked3x = "Locked3x",
+    Locked4x = "Locked4x",
+    Locked5x = "Locked5x",
+    Locked6x = "Locked6x"
+}
+export interface StandardVote {
+    standard: {
+        vote: {
+            conviction: Conviction;
+            aye: boolean;
+        };
+        balance: string;
+    };
+}
+export interface SplitVote {
+    split: {
+        aye: string;
+        nay: string;
+    };
+}
+export interface SplitAbstainVote {
+    splitAbstain: {
+        aye: string;
+        nay: string;
+        abstain: string;
+    };
+}
+export declare type Vote = StandardVote | SplitVote | SplitAbstainVote;
+export interface Casting {
+    prior: [string, string];
+    votes: [string, Vote][];
+    delegations: {
+        votes: string;
+        capital: string;
+    };
+}
+export interface Delegating {
+    prior: [string, string];
+    target: string;
+    balance: string;
+    conviction: Conviction;
+}
+export interface VotingFor {
+    casting?: Casting;
+    delegating?: Delegating;
+}
+export interface UnlockingReferendaData {
+    id?: string;
+    balance: string;
+    timestamp: number;
+}
+export interface GovVotingInfo {
+    chain: string;
+    address: string;
+    summary: {
+        delegated: string;
+        voted: string;
+        totalLocked: string;
+        unlocking: {
+            unlockingReferenda: UnlockingReferendaData[];
+        };
+        unlockable: {
+            balance: string;
+            trackIds: number[];
+            unlockableReferenda: string[];
+        };
+    };
+    tracks: GovTrackVoting[];
+}
+export interface GovTrackVoting {
+    trackId: number;
+    votes?: GovVoteDetail[];
+    delegation?: GovDelegationDetail;
+}
+export interface GovVoteDetail {
+    referendumIndex: string;
+    type: GovVoteType;
+    conviction: Conviction;
+    amount?: string;
+    ayeAmount?: string;
+    nayAmount?: string;
+    abstainAmount?: string;
+}
+export interface GovDelegationDetail {
+    balance: string;
+    target: string;
+    conviction: Conviction;
+}
+export interface UnlockVoteRequest {
+    address: string;
+    chain: string;
+    trackIds?: number[];
+    referendumIds?: string[];
+    amount: string;
+}
+export {};

package/services/open-gov/interface.js

@@ -0,0 +1,21 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export let GovVoteType;
+(function (GovVoteType) {
+  GovVoteType["AYE"] = "aye";
+  GovVoteType["NAY"] = "nay";
+  GovVoteType["SPLIT"] = "split";
+  GovVoteType["ABSTAIN"] = "abstain";
+})(GovVoteType || (GovVoteType = {}));
+/* Lock inteface */
+export let Conviction;
+(function (Conviction) {
+  Conviction["None"] = "None";
+  Conviction["Locked1x"] = "Locked1x";
+  Conviction["Locked2x"] = "Locked2x";
+  Conviction["Locked3x"] = "Locked3x";
+  Conviction["Locked4x"] = "Locked4x";
+  Conviction["Locked5x"] = "Locked5x";
+  Conviction["Locked6x"] = "Locked6x";
+})(Conviction || (Conviction = {}));

package/services/open-gov/utils.d.ts

@@ -0,0 +1,14 @@
+import { Conviction } from './interface';
+export declare const numberToConviction: Record<number, Conviction>;
+export declare const defaultConvictionDays: Record<Conviction, number>;
+export declare const specialChainLockConfig: {
+    chains: string[];
+    daysMap: Record<Conviction, number>;
+}[];
+export declare function getConvictionDays(chain: string, conviction: Conviction): number;
+export declare function getGovConvictionOptions(chain: string): {
+    value: number;
+    label: string;
+    description: string;
+}[];
+export declare const MIGRATED_CHAINS: string[];

package/services/open-gov/utils.js

@@ -0,0 +1,52 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { Conviction } from "./interface.js";
+export const numberToConviction = {
+  0: Conviction.None,
+  1: Conviction.Locked1x,
+  2: Conviction.Locked2x,
+  3: Conviction.Locked3x,
+  4: Conviction.Locked4x,
+  5: Conviction.Locked5x,
+  6: Conviction.Locked6x
+};
+export const defaultConvictionDays = {
+  [Conviction.None]: 0,
+  [Conviction.Locked1x]: 7,
+  [Conviction.Locked2x]: 14,
+  [Conviction.Locked3x]: 28,
+  [Conviction.Locked4x]: 56,
+  [Conviction.Locked5x]: 112,
+  [Conviction.Locked6x]: 224
+};
+export const specialChainLockConfig = [{
+  chains: ['bifrost_dot', 'bifrost'],
+  daysMap: {
+    [Conviction.None]: 0,
+    [Conviction.Locked1x]: 1,
+    [Conviction.Locked2x]: 2,
+    [Conviction.Locked3x]: 4,
+    [Conviction.Locked4x]: 8,
+    [Conviction.Locked5x]: 16,
+    [Conviction.Locked6x]: 32
+  }
+}];
+export function getConvictionDays(chain, conviction) {
+  var _group$daysMap, _daysMap$conviction;
+  const lowerChain = chain.toLowerCase();
+  const group = specialChainLockConfig.find(g => g.chains.includes(lowerChain));
+  const daysMap = (_group$daysMap = group === null || group === void 0 ? void 0 : group.daysMap) !== null && _group$daysMap !== void 0 ? _group$daysMap : defaultConvictionDays;
+  return (_daysMap$conviction = daysMap[conviction]) !== null && _daysMap$conviction !== void 0 ? _daysMap$conviction : 0;
+}
+export function getGovConvictionOptions(chain) {
+  return Object.entries(numberToConviction).map(([value, conviction]) => {
+    const days = getConvictionDays(chain, conviction);
+    return {
+      value: Number(value),
+      label: value === '0' ? '0.1x' : `${value}x`,
+      description: days === 0 ? 'No lockup' : `~${days}d`
+    };
+  });
+}
+export const MIGRATED_CHAINS = ['statemine', 'statemint', 'paseo_assethub', 'westend_assethub'];

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

@@ -16,6 +16,8 @@ import { BalanceItem, ProcessTransactionData, YieldPoolInfo, YieldPoolType, Yiel
 import { GetNotificationParams, RequestSwitchStatusParams } from '@subwallet/extension-base/types/notification';
 import { Subscription } from 'dexie';
 import { DexieExportJsonStructure } from 'dexie-export-import';
+import { GovVotingInfo } from '../open-gov/interface';
+import GovLockedInfoStore from './db-stores/GovLockedInfoStore';
 export declare const DEXIE_BACKUP_TABLES: string[];
 export default class DatabaseService {
     private eventService;
@@ -41,6 +43,7 @@ export default class DatabaseService {
         campaign: CampaignStore;
         inappNotification: InappNotificationStore;
         processTransactions: ProcessTransactionStore;
+        govLockedInfo: GovLockedInfoStore;
     };
     private logger;
     private nftSubscription;
@@ -135,6 +138,10 @@ export default class DatabaseService {
     switchReadStatus(params: RequestSwitchStatusParams): import("dexie").PromiseExtended<number>;
     removeAccountNotifications(proxyId: string): import("dexie").PromiseExtended<number>;
     updateNotificationProxyId(proxyIds: string[], newProxyId: string, newName: string): void;
+    getGovLockedInfos(addresses: string[], chains: string[]): Promise<GovVotingInfo[]>;
+    updateGovLockedInfos(infos: GovVotingInfo[]): Promise<unknown>;
+    removeGovLockedInfosByAddresses(addresses: string[]): import("dexie").PromiseExtended<number>;
+    removeGovLockedInfosByChains(chains: string[]): import("dexie").PromiseExtended<number>;
     exportDB(): Promise<string>;
     importDB(data: string): Promise<boolean>;
     getExportJson(): Promise<DexieExportJsonStructure>;

package/services/storage-service/DatabaseService.js

@@ -17,6 +17,7 @@ import keyring from '@subwallet/ui-keyring';
 import BigN from 'bignumber.js';
 import { exportDB } from 'dexie-export-import';
 import { logger as createLogger } from '@polkadot/util';
+import GovLockedInfoStore from "./db-stores/GovLockedInfoStore.js";
 export const DEXIE_BACKUP_TABLES = ['chain', 'asset', 'migrations', 'transactions', 'campaign'];
 export default class DatabaseService {
   // TODO: might remove this
@@ -54,7 +55,9 @@ export default class DatabaseService {
       // inapp notification
       inappNotification: new InappNotificationStore(this._db.inappNotification),
       // process transaction
-      processTransactions: new ProcessTransactionStore(this._db.processTransactions)
+      processTransactions: new ProcessTransactionStore(this._db.processTransactions),
+      // gov
+      govLockedInfo: new GovLockedInfoStore(this._db.govLockedInfos)
     };
   }
   async updatePriceStore(priceData) {
@@ -598,6 +601,21 @@ export default class DatabaseService {
   updateNotificationProxyId(proxyIds, newProxyId, newName) {
     return this.stores.inappNotification.updateNotificationProxyId(proxyIds, newProxyId, newName);
   }
+
+  /* Gov */
+
+  async getGovLockedInfos(addresses, chains) {
+    return this.stores.govLockedInfo.getByAddressesAndChains(addresses, chains);
+  }
+  async updateGovLockedInfos(infos) {
+    return this.stores.govLockedInfo.upsertMany(infos);
+  }
+  removeGovLockedInfosByAddresses(addresses) {
+    return this.stores.govLockedInfo.removeByAddresses(addresses);
+  }
+  removeGovLockedInfosByChains(chains) {
+    return this.stores.govLockedInfo.removeByChains(chains);
+  }
   async exportDB() {
     const blob = await exportDB(this._db, {
       filter: (table, value, key) => {

package/services/storage-service/databases/index.d.ts

@@ -3,6 +3,7 @@ import { CampaignData, ChainStakingMetadata, CrowdloanItem, MetadataItem, Metada
 import { _NotificationInfo } from '@subwallet/extension-base/services/inapp-notification-service/interfaces';
 import { BalanceItem, ProcessTransactionData, YieldPoolInfo, YieldPositionInfo } from '@subwallet/extension-base/types';
 import Dexie, { Table } from 'dexie';
+import { GovVotingInfo } from '../../open-gov/interface';
 export declare const DEFAULT_DATABASE = "SubWalletDB_v2";
 export interface DefaultChainDoc {
     chain: string;
@@ -66,6 +67,7 @@ export default class KoniDatabase extends Dexie {
     inappNotification: Table<_NotificationInfo, object>;
     processTransactions: Table<ProcessTransactionData, object>;
     private schemaVersion;
+    govLockedInfos: Table<GovVotingInfo, object>;
     constructor(name?: string, schemaVersion?: number);
     private conditionalVersion;
     static instance: KoniDatabase;

package/services/storage-service/databases/index.js

@@ -49,6 +49,9 @@ export default class KoniDatabase extends Dexie {
     this.conditionalVersion(9, {
       processTransactions: 'id, address'
     });
+    this.conditionalVersion(10, {
+      govLockedInfos: '[chain+address], chain, address'
+    });
   }
   conditionalVersion(version, schema, upgrade) {
     if (this.schemaVersion != null && this.schemaVersion < version) {

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

@@ -0,0 +1,10 @@
+import { GovVotingInfo } from '../../open-gov/interface';
+import BaseStore from './BaseStore';
+export default class GovLockedInfoStore extends BaseStore<GovVotingInfo> {
+    getAll(): Promise<GovVotingInfo[]>;
+    getByAddresses(addresses: string[]): Promise<GovVotingInfo[]>;
+    getByAddressesAndChains(addresses: string[], chains: string[]): Promise<GovVotingInfo[]>;
+    upsertMany(infos: GovVotingInfo[]): Promise<unknown>;
+    removeByAddresses(addresses: string[]): import("dexie").PromiseExtended<number>;
+    removeByChains(chains: string[]): import("dexie").PromiseExtended<number>;
+}

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

@@ -0,0 +1,27 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseStore from "./BaseStore.js";
+export default class GovLockedInfoStore extends BaseStore {
+  async getAll() {
+    return this.table.toArray();
+  }
+  async getByAddresses(addresses) {
+    if (addresses.length === 0) {
+      return this.getAll();
+    }
+    return this.table.where('address').anyOfIgnoreCase(addresses).toArray();
+  }
+  async getByAddressesAndChains(addresses, chains) {
+    return this.table.where('address').anyOfIgnoreCase(addresses).filter(item => chains.includes(item.chain)).toArray();
+  }
+  async upsertMany(infos) {
+    return this.table.bulkPut(infos);
+  }
+  removeByAddresses(addresses) {
+    return this.table.where('address').anyOf(addresses).delete();
+  }
+  removeByChains(chains) {
+    return this.table.where('chain').anyOf(chains).delete();
+  }
+}

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

@@ -61,6 +61,12 @@ const typeName = type => {
       return 'Withdraw pool';
     case ExtrinsicType.JOIN_YIELD_POOL:
       return 'Start earning';
+    case ExtrinsicType.GOV_VOTE:
+      return 'Vote';
+    case ExtrinsicType.GOV_UNVOTE:
+      return 'Remove vote';
+    case ExtrinsicType.GOV_UNLOCK_VOTE:
+      return 'Unlock votes';
     case ExtrinsicType.CHANGE_EARNING_VALIDATOR:
       return 'Change validator';
     case ExtrinsicType.UNKNOWN: