@subwallet/extension-base 1.3.72-0 → 1.3.74-0

package/cjs/services/keyring-service/context/handlers/Multisig.js

@@ -0,0 +1,186 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AccountMultisigHandler = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _Base = require("@subwallet/extension-base/services/keyring-service/context/handlers/Base");
+var _types = require("@subwallet/extension-base/types");
+var _utils = require("@subwallet/extension-base/utils");
+var _keyring = require("@subwallet/keyring");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _i18next = require("i18next");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @class AccountMultisigHandler
+ * @extends AccountBaseHandler
+ * @description Handler for multisig account
+ * */
+class AccountMultisigHandler extends _Base.AccountBaseHandler {
+  validateSigners(signers, threshold) {
+    const errors = [];
+    if (!signers || signers.length === 0) {
+      errors.push({
+        code: _KoniTypes.AccountMultisigErrorCode.INVALID_FILLED_ADDRESS,
+        message: (0, _i18next.t)('bg.ACCOUNT.services.keyring.handler.Multisig.signersRequired')
+      });
+    }
+    if (!signers || signers.length < 2) {
+      errors.push({
+        code: _KoniTypes.AccountMultisigErrorCode.INVALID_FILLED_ADDRESS,
+        message: (0, _i18next.t)('bg.ACCOUNT.services.keyring.handler.Multisig.multipleSignersRequired')
+      });
+    }
+    if (!threshold || threshold < 2 || threshold > signers.length) {
+      errors.push({
+        code: _KoniTypes.AccountMultisigErrorCode.INVALID_FILLED_THRESHOLD,
+        message: (0, _i18next.t)('bg.ACCOUNT.services.keyring.handler.Multisig.invalidThreshold')
+      });
+    }
+    for (const signer of signers) {
+      if (!signer || !(0, _keyring.isSubstrateAddress)(signer)) {
+        errors.push({
+          code: _KoniTypes.AccountMultisigErrorCode.INVALID_FILLED_ADDRESS,
+          message: (0, _i18next.t)('bg.ACCOUNT.services.keyring.handler.Multisig.mustBeSubstrateAddress')
+        });
+        break;
+      }
+    }
+    const distinctAddress = new Set();
+    for (const signer of signers) {
+      const rAddress = (0, _utils.reformatAddress)(signer);
+      if (distinctAddress.has(rAddress)) {
+        errors.push({
+          code: _KoniTypes.AccountMultisigErrorCode.DUPLICATE_FILLED_ADDRESS,
+          message: (0, _i18next.t)('bg.ACCOUNT.services.keyring.handler.Multisig.duplicateAddressFound')
+        });
+        break;
+      } else {
+        distinctAddress.add(rAddress);
+      }
+    }
+    return errors;
+  }
+  async accountsCreateMultisig(request) {
+    const {
+      name,
+      signers: _signer,
+      threshold
+    } = request;
+
+    // process signers
+    const signerError = this.validateSigners(_signer, threshold);
+    if (signerError.length > 0) {
+      return signerError;
+    }
+    const signers = _signer.map(address => (0, _utils.reformatAddress)(address));
+    const multisigKey = (0, _utilCrypto.createKeyMulti)(signers, threshold);
+    const multisigAddress = (0, _keyring.encodeAddress)(multisigKey);
+    try {
+      try {
+        const exists = _uiKeyring.keyring.getPair(multisigAddress);
+        if ((exists === null || exists === void 0 ? void 0 : exists.address) === (0, _utils.reformatAddress)(multisigAddress)) {
+          var _exists$meta;
+          const existingName = ((_exists$meta = exists.meta) === null || _exists$meta === void 0 ? void 0 : _exists$meta.name) || 'Unknown';
+          return [{
+            code: _KoniTypes.AccountMultisigErrorCode.INVALID_ADDRESS,
+            message: (0, _i18next.t)('bg.ACCOUNT.services.keyring.handler.Multisig.multisigAddressExists', {
+              replace: {
+                name: existingName
+              }
+            })
+          }];
+        }
+      } catch (e) {}
+      if (this.state.checkNameExists(name)) {
+        return [{
+          code: _KoniTypes.AccountMultisigErrorCode.INVALID_NAME,
+          message: (0, _i18next.t)('bg.ACCOUNT.services.keyring.handler.Secret.accountNameAlreadyExists')
+        }];
+      }
+      const meta = {
+        name,
+        threshold,
+        signers,
+        isExternal: true,
+        isMultisig: true,
+        genesisHash: ''
+      };
+      const multisigPair = _uiKeyring.keyring.keyring.addFromAddress(multisigAddress, meta);
+      _uiKeyring.keyring.saveAccount(multisigPair);
+      const address = multisigPair.address;
+      const modifiedPairs = this.state.modifyPairs;
+      modifiedPairs[address] = {
+        migrated: true,
+        key: address
+      };
+      this.state.upsertModifyPairs(modifiedPairs);
+      await new Promise(resolve => {
+        this.state.saveCurrentAccountProxyId(address, () => {
+          this.state._addAddressToAuthList(address, true);
+          resolve();
+        });
+      });
+      return [];
+    } catch (e) {
+      return [{
+        code: _KoniTypes.AccountMultisigErrorCode.KEYRING_ERROR,
+        message: e.message
+      }];
+    }
+  }
+
+  /**
+   * Get 1-level signatories
+   * Ignore multisig accounts that are also signatories
+   */
+  getSignableAccountInfos(request, chainInfo) {
+    var _chainInfo$substrateI;
+    const {
+      extrinsicType,
+      multisigProxyId
+    } = request;
+    if (!((_chainInfo$substrateI = chainInfo.substrateInfo) !== null && _chainInfo$substrateI !== void 0 && _chainInfo$substrateI.supportMultisig)) {
+      return {
+        signableProxies: []
+      };
+    }
+    const allMultisigAccounts = this.state.getMultisigAccounts();
+    const allAccounts = this.state.accounts;
+    const targetMultisigAccount = allMultisigAccounts.find(acc => acc.id === multisigProxyId);
+    if (!targetMultisigAccount) {
+      return {
+        signableProxies: []
+      };
+    }
+    const signableAccountInfo = [];
+    const signers = targetMultisigAccount.accounts[0].signers;
+    const allMultisigAccountAddress = allMultisigAccounts.map(acc => acc.id);
+    for (const signer of signers) {
+      if (allMultisigAccountAddress.includes(signer)) {
+        continue;
+      }
+      const proxyId = this.state.belongUnifiedAccount(signer) || (0, _utils.reformatAddress)(signer);
+      const accountProxy = allAccounts[proxyId];
+      const substrateAccount = accountProxy === null || accountProxy === void 0 ? void 0 : accountProxy.accounts.find(acc => acc.chainType === _types.AccountChainType.SUBSTRATE);
+      if (substrateAccount) {
+        // Check if the account can sign the extrinsic type
+        // Only support 1 level signatories
+        if (substrateAccount.transactionActions.includes(extrinsicType) && !substrateAccount.isMultisig) {
+          signableAccountInfo.push({
+            proxyId,
+            address: signer
+          });
+        }
+      }
+    }
+    return {
+      signableProxies: signableAccountInfo
+    };
+  }
+}
+exports.AccountMultisigHandler = AccountMultisigHandler;

package/cjs/services/keyring-service/context/state.js

@@ -537,6 +537,18 @@ class AccountState {
    * Account ref
    * */
 
+  /* Multisig */
+
+  getMultisigAccounts() {
+    return Object.values(this.accounts).filter(acc => acc.accountType === _types.AccountProxyType.MULTISIG);
+  }
+  getMultisigAddresses() {
+    const allAccounts = this.getMultisigAccounts();
+    return allAccounts.map(acc => acc.id);
+  }
+
+  /* Multisig */
+
   /* Others */
 
   removeNoneHardwareGenesisHash() {