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

package/cjs/services/open-gov/index.js

@@ -0,0 +1,273 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _types = require("@subwallet/extension-base/types");
+var _utils = require("@subwallet/extension-base/utils");
+var _rxjs = require("rxjs");
+var _types2 = require("../base/types");
+var _constants = require("../chain-service/constants");
+var _utils2 = require("../chain-service/utils");
+var _handler = _interopRequireDefault(require("./handler"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class OpenGovChainHandler extends _handler.default {
+  constructor(state, chain) {
+    super(state, chain);
+    this.slug = chain;
+  }
+}
+class OpenGovService {
+  handlers = {};
+
+  // subjects
+  govLockedInfoSubject = new _rxjs.BehaviorSubject({});
+  govLockedInfoListSubject = new _rxjs.BehaviorSubject([]);
+  govLockedInfoPersistQueue = [];
+  status = _types2.ServiceStatus.NOT_INITIALIZED;
+  startPromiseHandler = (0, _utils.createPromiseHandler)();
+  stopPromiseHandler = (0, _utils.createPromiseHandler)();
+  constructor(state) {
+    this.state = state;
+    this.eventService = state.eventService;
+    this.dbService = state.dbService;
+  }
+  async init() {
+    this.status = _types2.ServiceStatus.INITIALIZING;
+    this.eventService.emit('open-gov.ready', true);
+    await this.initHandlers();
+    await this.getGovLockedInfoFromDB();
+    this.status = _types2.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 && !(0, _utils2._isChainEnabled)(chainState)) {
+              removeChains.push(chainKey);
+            }
+            delayReload = true;
+          }
+          if (event.type === 'transaction.done') {
+            const tx = event.data[0];
+            const govRelatedTypes = [_KoniTypes.ExtrinsicType.GOV_VOTE, _KoniTypes.ExtrinsicType.GOV_UNVOTE, _KoniTypes.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(_constants._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.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
+    }
+    return handler.handleVote(request);
+  }
+  async handleRemoveVote(request) {
+    const handler = this.handlers[request.chain];
+    if (!handler) {
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
+    }
+    return handler.handleRemoveVote(request);
+  }
+  async handleUnlockVote(request) {
+    const handler = this.handlers[request.chain];
+    if (!handler) {
+      return Promise.reject(new _TransactionError.TransactionError(_types.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] = (0, _utils.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);
+    (0, _utils.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 === _types2.ServiceStatus.STARTING || this.status === _types2.ServiceStatus.STARTED) {
+      return this.waitForStarted();
+    }
+    this.status = _types2.ServiceStatus.STARTING;
+    this.startPromiseHandler.resolve();
+    this.stopPromiseHandler = (0, _utils.createPromiseHandler)();
+    this.status = _types2.ServiceStatus.STARTED;
+  }
+  async stop() {
+    if (this.status === _types2.ServiceStatus.STOPPING || this.status === _types2.ServiceStatus.STOPPED) {
+      return this.waitForStopped();
+    }
+    this.status = _types2.ServiceStatus.STOPPING;
+    this.runUnsubscribeGovLockedInfo();
+    this.stopPromiseHandler.resolve();
+    this.startPromiseHandler = (0, _utils.createPromiseHandler)();
+    this.status = _types2.ServiceStatus.STOPPED;
+  }
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
+
+  /* Gov Locked Info */
+}
+exports.default = OpenGovService;

package/cjs/services/open-gov/interface.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GovVoteType = exports.Conviction = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+let GovVoteType;
+exports.GovVoteType = GovVoteType;
+(function (GovVoteType) {
+  GovVoteType["AYE"] = "aye";
+  GovVoteType["NAY"] = "nay";
+  GovVoteType["SPLIT"] = "split";
+  GovVoteType["ABSTAIN"] = "abstain";
+})(GovVoteType || (exports.GovVoteType = GovVoteType = {}));
+/* Lock inteface */
+let Conviction;
+exports.Conviction = 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 || (exports.Conviction = Conviction = {}));

package/cjs/services/open-gov/utils.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultConvictionDays = exports.MIGRATED_CHAINS = void 0;
+exports.getConvictionDays = getConvictionDays;
+exports.getGovConvictionOptions = getGovConvictionOptions;
+exports.specialChainLockConfig = exports.numberToConviction = void 0;
+var _interface = require("./interface");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const numberToConviction = {
+  0: _interface.Conviction.None,
+  1: _interface.Conviction.Locked1x,
+  2: _interface.Conviction.Locked2x,
+  3: _interface.Conviction.Locked3x,
+  4: _interface.Conviction.Locked4x,
+  5: _interface.Conviction.Locked5x,
+  6: _interface.Conviction.Locked6x
+};
+exports.numberToConviction = numberToConviction;
+const defaultConvictionDays = {
+  [_interface.Conviction.None]: 0,
+  [_interface.Conviction.Locked1x]: 7,
+  [_interface.Conviction.Locked2x]: 14,
+  [_interface.Conviction.Locked3x]: 28,
+  [_interface.Conviction.Locked4x]: 56,
+  [_interface.Conviction.Locked5x]: 112,
+  [_interface.Conviction.Locked6x]: 224
+};
+exports.defaultConvictionDays = defaultConvictionDays;
+const specialChainLockConfig = [{
+  chains: ['bifrost_dot', 'bifrost'],
+  daysMap: {
+    [_interface.Conviction.None]: 0,
+    [_interface.Conviction.Locked1x]: 1,
+    [_interface.Conviction.Locked2x]: 2,
+    [_interface.Conviction.Locked3x]: 4,
+    [_interface.Conviction.Locked4x]: 8,
+    [_interface.Conviction.Locked5x]: 16,
+    [_interface.Conviction.Locked6x]: 32
+  }
+}];
+exports.specialChainLockConfig = specialChainLockConfig;
+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;
+}
+function getGovConvictionOptions(chain) {
+  return Object.entries(numberToConviction).map(_ref => {
+    let [value, conviction] = _ref;
+    const days = getConvictionDays(chain, conviction);
+    return {
+      value: Number(value),
+      label: value === '0' ? '0.1x' : `${value}x`,
+      description: days === 0 ? 'No lockup' : `~${days}d`
+    };
+  });
+}
+const MIGRATED_CHAINS = ['statemine', 'statemint', 'paseo_assethub', 'westend_assethub'];
+exports.MIGRATED_CHAINS = MIGRATED_CHAINS;

package/cjs/services/storage-service/DatabaseService.js

@@ -21,6 +21,7 @@ var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _dexieExportImport = require("dexie-export-import");
 var _util = require("@polkadot/util");
+var _GovLockedInfoStore = _interopRequireDefault(require("./db-stores/GovLockedInfoStore"));
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -62,7 +63,9 @@ class DatabaseService {
       // inapp notification
       inappNotification: new _InappNotification.default(this._db.inappNotification),
       // process transaction
-      processTransactions: new _dbStores.ProcessTransactionStore(this._db.processTransactions)
+      processTransactions: new _dbStores.ProcessTransactionStore(this._db.processTransactions),
+      // gov
+      govLockedInfo: new _GovLockedInfoStore.default(this._db.govLockedInfos)
     };
   }
   async updatePriceStore(priceData) {
@@ -610,6 +613,21 @@ 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 (0, _dexieExportImport.exportDB)(this._db, {
       filter: (table, value, key) => {

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

@@ -59,6 +59,9 @@ class KoniDatabase extends _dexie.default {
     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/cjs/services/storage-service/db-stores/GovLockedInfoStore.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _BaseStore = _interopRequireDefault(require("./BaseStore"));
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class GovLockedInfoStore extends _BaseStore.default {
+  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();
+  }
+}
+exports.default = GovLockedInfoStore;

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

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

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

@@ -32,6 +32,7 @@ var _eventemitter = _interopRequireDefault(require("eventemitter3"));
 var _i18next = require("i18next");
 var _rxjs = require("rxjs");
 var _util = require("@polkadot/util");
+var _interface = require("../open-gov/interface");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -1078,6 +1079,48 @@ class TransactionService {
           historyItem.additionalInfo = data;
           break;
         }
+      case _KoniTypes.ExtrinsicType.GOV_VOTE:
+        {
+          const data = (0, _utils3.parseTransactionData)(transaction.data);
+          let totalAmount = new _bignumber.default(0);
+          switch (data.type) {
+            case _interface.GovVoteType.AYE:
+            case _interface.GovVoteType.NAY:
+              totalAmount = new _bignumber.default(data.amount || '0');
+              break;
+            case _interface.GovVoteType.SPLIT:
+              totalAmount = new _bignumber.default(data.ayeAmount || '0').plus(data.nayAmount || '0');
+              break;
+            case _interface.GovVoteType.ABSTAIN:
+              totalAmount = new _bignumber.default(data.ayeAmount || '0').plus(data.nayAmount || '0').plus(data.abstainAmount || '0');
+              break;
+          }
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: totalAmount.toString()
+          };
+          historyItem.additionalInfo = data;
+          break;
+        }
+      case _KoniTypes.ExtrinsicType.GOV_UNVOTE:
+        {
+          const data = (0, _utils3.parseTransactionData)(transaction.data);
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: new _bignumber.default(data.ayeAmount || '0').plus(data.nayAmount || '0').plus(data.abstainAmount || '0').plus(data.amount || 0).toString()
+          };
+          historyItem.additionalInfo = data;
+          break;
+        }
+      case _KoniTypes.ExtrinsicType.GOV_UNLOCK_VOTE:
+        {
+          const data = (0, _utils3.parseTransactionData)(transaction.data);
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.amount
+          };
+          break;
+        }
       case _KoniTypes.ExtrinsicType.UNKNOWN:
         break;
     }

package/cjs/utils/account/transform.js

@@ -164,12 +164,13 @@ const EARN_STDOT_ACTIONS = [_KoniTypes.ExtrinsicType.MINT_STDOT, _KoniTypes.Extr
 const EARN_VMANTA_ACTIONS = [_KoniTypes.ExtrinsicType.MINT_VMANTA, _KoniTypes.ExtrinsicType.REDEEM_VMANTA, _KoniTypes.ExtrinsicType.UNSTAKE_VMANTA];
 const EVM_ACTIONS = [_KoniTypes.ExtrinsicType.TOKEN_SPENDING_APPROVAL, _KoniTypes.ExtrinsicType.EVM_EXECUTE];
 const CLAIM_AVAIL_BRIDGE = [_KoniTypes.ExtrinsicType.CLAIM_BRIDGE];
+const OPEN_GOV_ACTIONS = [_KoniTypes.ExtrinsicType.GOV_VOTE, _KoniTypes.ExtrinsicType.GOV_UNVOTE, _KoniTypes.ExtrinsicType.GOV_UNLOCK_VOTE];
 const OTHER_ACTIONS = [_KoniTypes.ExtrinsicType.TRANSFER_XCM, _KoniTypes.ExtrinsicType.SEND_NFT, _KoniTypes.ExtrinsicType.SWAP, _KoniTypes.ExtrinsicType.CROWDLOAN];
 const getAccountTransactionActions = (signMode, networkType, type, _meta, _specialNetwork) => {
   if ([_types2.AccountSignMode.PASSWORD, _types2.AccountSignMode.INJECTED].includes(signMode)) {
     switch (networkType) {
       case _types2.AccountChainType.SUBSTRATE:
-        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS, ...EARN_QDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OTHER_ACTIONS];
+        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS, ...EARN_QDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OPEN_GOV_ACTIONS, ...OTHER_ACTIONS];
       case _types2.AccountChainType.ETHEREUM:
         return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_STDOT_ACTIONS, ...OTHER_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...EVM_ACTIONS];
       case _types2.AccountChainType.TON:
@@ -182,7 +183,7 @@ const getAccountTransactionActions = (signMode, networkType, type, _meta, _speci
   } else if (signMode === _types2.AccountSignMode.QR) {
     switch (networkType) {
       case _types2.AccountChainType.SUBSTRATE:
-        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS, ...EARN_QDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OTHER_ACTIONS];
+        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS, ...EARN_QDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OPEN_GOV_ACTIONS, ...OTHER_ACTIONS];
       case _types2.AccountChainType.ETHEREUM:
         return [...(_constants.isProductionMode ? [] : [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_STDOT_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OTHER_ACTIONS, ...EVM_ACTIONS])];
       case _types2.AccountChainType.TON:
@@ -197,7 +198,7 @@ const getAccountTransactionActions = (signMode, networkType, type, _meta, _speci
       case _types2.AccountChainType.SUBSTRATE:
         return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS,
         // ...EARN_QDOT_ACTIONS,
-        ...OTHER_ACTIONS];
+        ...OPEN_GOV_ACTIONS, ...OTHER_ACTIONS];
       case _types2.AccountChainType.ETHEREUM:
         return [...BASE_TRANSFER_ACTIONS, ...EARN_STDOT_ACTIONS, ...EVM_ACTIONS, ...CLAIM_AVAIL_BRIDGE, _KoniTypes.ExtrinsicType.STAKING_WITHDRAW,
         // For liquid staking
@@ -246,7 +247,7 @@ const getAccountTransactionActions = (signMode, networkType, type, _meta, _speci
   } else if (signMode === _types2.AccountSignMode.ECDSA_SUBSTRATE_LEDGER) {
     // Only for account substrate with ECDSA scheme format
     const result = [];
-    result.push(...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, _KoniTypes.ExtrinsicType.TRANSFER_XCM, _KoniTypes.ExtrinsicType.SWAP, _KoniTypes.ExtrinsicType.CROWDLOAN);
+    result.push(...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...OPEN_GOV_ACTIONS, _KoniTypes.ExtrinsicType.TRANSFER_XCM, _KoniTypes.ExtrinsicType.SWAP, _KoniTypes.ExtrinsicType.CROWDLOAN);
     return result;
   }
   return [];

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

@@ -291,5 +291,9 @@ export default class KoniExtension {
     private migrateUnifiedAndFetchEligibleSoloAccounts;
     private migrateSoloAccount;
     private pingSession;
+    private handleVote;
+    private handleRemoveVote;
+    private handleUnlockVote;
+    private subscribeGovLockedInfo;
     handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], port: chrome.runtime.Port): Promise<ResponseType<TMessageType>>;
 }

package/koni/background/handlers/Extension.js

@@ -4744,6 +4744,58 @@ export default class KoniExtension {
   }
   /* Migrate Unified Account */
 
+  /* Open Gov */
+
+  async handleVote(request) {
+    const extrinsic = await this.#koniState.openGovService.handleVote(request);
+    return await this.#koniState.transactionService.handleTransaction({
+      address: request.address,
+      chain: request.chain,
+      transaction: extrinsic,
+      data: request,
+      extrinsicType: ExtrinsicType.GOV_VOTE,
+      chainType: ChainType.SUBSTRATE
+    });
+  }
+  async handleRemoveVote(request) {
+    const extrinsic = await this.#koniState.openGovService.handleRemoveVote(request);
+    return await this.#koniState.transactionService.handleTransaction({
+      address: request.address,
+      chain: request.chain,
+      transaction: extrinsic,
+      data: request,
+      extrinsicType: ExtrinsicType.GOV_UNVOTE,
+      chainType: ChainType.SUBSTRATE
+    });
+  }
+  async handleUnlockVote(request) {
+    const extrinsic = await this.#koniState.openGovService.handleUnlockVote(request);
+    return await this.#koniState.transactionService.handleTransaction({
+      address: request.address,
+      chain: request.chain,
+      transaction: extrinsic,
+      data: request,
+      extrinsicType: ExtrinsicType.GOV_UNLOCK_VOTE,
+      chainType: ChainType.SUBSTRATE
+    });
+  }
+  async subscribeGovLockedInfo(id, port) {
+    const cb = createSubscription(id, port);
+    await this.#koniState.openGovService.waitForStarted();
+    const govLockedInfoSubscription = this.#koniState.openGovService.subscribeGovLockedInfoSubject().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, govLockedInfoSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return await this.#koniState.openGovService.getGovLockedInfoInfo();
+  }
+
+  /* Open Gov */
+
   // --------------------------------------------------------------
   // eslint-disable-next-line @typescript-eslint/require-await
   async handle(id, type, request, port) {
@@ -5402,6 +5454,16 @@ export default class KoniExtension {
         return this.migrateSoloAccount(request);
       case 'pri(migrate.pingSession)':
         return this.pingSession(request);
+
+      /* Gov */
+      case 'pri(openGov.vote)':
+        return this.handleVote(request);
+      case 'pri(openGov.unvote)':
+        return this.handleRemoveVote(request);
+      case 'pri(openGov.unlockVote)':
+        return this.handleUnlockVote(request);
+      case 'pri(openGov.subscribeGovLockedInfo)':
+        return this.subscribeGovLockedInfo(id, port);
       // Default
       default:
         throw new Error(`Unable to handle message of type ${type}`);

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

@@ -21,6 +21,7 @@ import MintCampaignService from '@subwallet/extension-base/services/mint-campaig
 import MktCampaignService from '@subwallet/extension-base/services/mkt-campaign-service';
 import NftService from '@subwallet/extension-base/services/nft-service';
 import NotificationService from '@subwallet/extension-base/services/notification-service/NotificationService';
+import OpenGovService from '@subwallet/extension-base/services/open-gov';
 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';
@@ -81,6 +82,7 @@ export default class KoniState {
     readonly swapService: SwapService;
     readonly inappNotificationService: InappNotificationService;
     readonly chainOnlineService: ChainOnlineService;
+    readonly openGovService: OpenGovService;
     private generalStatus;
     private waitSleeping;
     private waitStarting;