@subwallet/extension-base 1.2.32-0 → 1.2.33-0

package/cjs/utils/account/derive/info/solo.js

@@ -0,0 +1,246 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseUnifiedSuriToDerivationPath = exports.getSuri = exports.getSoloDerivationInfo = exports.findSoloNextDerive = exports.derivePair = void 0;
+var _keyring = require("@subwallet/keyring");
+var _types = require("@subwallet/keyring/types");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _i18next = require("i18next");
+var _util = require("@polkadot/util");
+var _validate = require("../validate");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const parseUnifiedSuriToDerivationPath = (suri, type) => {
+  const reg = /^\/\/(\d+)(\/\/\d+)?$/;
+  if (suri.match(reg)) {
+    const [, firstIndex, secondData] = suri.match(reg);
+    const first = parseInt(firstIndex, 10);
+    if (secondData) {
+      const [, secondIndex] = secondData.match(/\/\/(\d+)/);
+      if (type === 'ethereum') {
+        return `m/44'/60'/0'/0/${first}/${secondIndex}`;
+      } else if (type === 'ton') {
+        return `m/44'/607'/${first}'/${secondIndex}'`;
+      }
+    } else {
+      if (type === 'ethereum') {
+        return `m/44'/60'/0'/0/${first}`;
+      } else if (type === 'ton') {
+        return `m/44'/607'/${first}'`;
+      }
+    }
+    if (_types.SubstrateKeypairTypes.includes(type)) {
+      return suri;
+    }
+  }
+  return '';
+};
+exports.parseUnifiedSuriToDerivationPath = parseUnifiedSuriToDerivationPath;
+const getSoloDerivationInfo = function (type) {
+  let metadata = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const {
+    derivationPath: derivePath,
+    parentAddress,
+    suri
+  } = metadata;
+  if (suri) {
+    if (derivePath) {
+      const validateTypeFunc = type === 'ethereum' ? _validate.validateEvmDerivationPath : type === 'ton' ? _validate.validateTonDerivationPath : () => undefined;
+      const validateTypeRs = validateTypeFunc(derivePath);
+      if (validateTypeRs) {
+        return {
+          suri: validateTypeRs.suri,
+          depth: validateTypeRs.depth,
+          derivationPath: derivePath,
+          parentAddress,
+          autoIndexes: validateTypeRs.autoIndexes
+        };
+      } else {
+        return {
+          depth: 1,
+          derivationPath: derivePath,
+          parentAddress,
+          suri
+        };
+      }
+    } else {
+      if (_types.SubstrateKeypairTypes.includes(type)) {
+        const _type = type;
+        const validateTypeFunc = _type === 'sr25519' ? _validate.validateSr25519DerivationPath : raw => (0, _validate.validateOtherSubstrateDerivationPath)(raw, _type);
+        const validateTypeRs = validateTypeFunc(suri);
+        if (validateTypeRs) {
+          return {
+            suri: validateTypeRs.suri,
+            depth: validateTypeRs.depth,
+            parentAddress,
+            autoIndexes: validateTypeRs.autoIndexes
+          };
+        }
+      }
+      const validateUnifiedRs = (0, _validate.validateUnifiedDerivationPath)(suri);
+      if (validateUnifiedRs) {
+        const {
+          autoIndexes,
+          depth
+        } = validateUnifiedRs;
+        const derivationPath = parseUnifiedSuriToDerivationPath(suri, type);
+        return {
+          suri: suri,
+          depth,
+          derivationPath: derivationPath,
+          parentAddress,
+          autoIndexes
+        };
+      } else {
+        return {
+          depth: 1,
+          derivationPath: derivePath,
+          parentAddress,
+          suri
+        };
+      }
+    }
+  } else {
+    if (derivePath) {
+      const validateTypeFunc = type === 'ethereum' ? _validate.validateEvmDerivationPath : type === 'ton' ? _validate.validateTonDerivationPath : () => undefined;
+      const validateTypeRs = validateTypeFunc(derivePath);
+      if (validateTypeRs) {
+        return {
+          suri: validateTypeRs.suri,
+          depth: validateTypeRs.depth,
+          derivationPath: derivePath,
+          parentAddress,
+          autoIndexes: validateTypeRs.autoIndexes
+        };
+      } else {
+        return {
+          depth: 1,
+          derivationPath: derivePath,
+          parentAddress,
+          suri
+        };
+      }
+    }
+  }
+  return {
+    depth: 0,
+    parentAddress,
+    suri: suri
+  };
+};
+
+/**
+ * @func findSoloNextDerive
+ * @return {NextDerivePair}
+ * */
+exports.getSoloDerivationInfo = getSoloDerivationInfo;
+const findSoloNextDerive = parentAddress => {
+  var _deriveInfo$autoIndex;
+  let parentPair;
+  try {
+    parentPair = _uiKeyring.keyring.getPair(parentAddress);
+  } catch (e) {}
+  (0, _util.assert)(parentPair, (0, _i18next.t)('Unable to find account'));
+  const deriveInfo = getSoloDerivationInfo(parentPair.type, parentPair.meta);
+  const needChangeRoot = deriveInfo.depth > 0;
+  let rootPair;
+  if (needChangeRoot) {
+    try {
+      rootPair = _uiKeyring.keyring.getPair(parentPair.meta.parentAddress || '');
+    } catch (e) {}
+  } else {
+    rootPair = parentPair;
+  }
+  (0, _util.assert)(rootPair, (0, _i18next.t)('Unable to find parent account'));
+  const rootAddress = rootPair.address;
+  const currentDepth = deriveInfo.depth;
+  const currentIndex = (_deriveInfo$autoIndex = deriveInfo.autoIndexes) === null || _deriveInfo$autoIndex === void 0 ? void 0 : _deriveInfo$autoIndex[currentDepth - 1];
+  const pairs = _uiKeyring.keyring.getPairs();
+  const children = pairs.filter(p => p.meta.parentAddress === rootAddress);
+  const childrenMetadata = children.map(_ref => {
+    let {
+      meta,
+      type
+    } = _ref;
+    return getSoloDerivationInfo(type, meta);
+  }).filter(_ref2 => {
+    let {
+      autoIndexes,
+      depth
+    } = _ref2;
+    return depth === currentDepth + 1 && currentIndex === (autoIndexes === null || autoIndexes === void 0 ? void 0 : autoIndexes[currentDepth - 1]);
+  }).sort((a, b) => {
+    var _a$autoIndexes, _b$autoIndexes;
+    const aDeriveIndex = (_a$autoIndexes = a.autoIndexes) === null || _a$autoIndexes === void 0 ? void 0 : _a$autoIndexes[currentDepth];
+    const bDeriveIndex = (_b$autoIndexes = b.autoIndexes) === null || _b$autoIndexes === void 0 ? void 0 : _b$autoIndexes[currentDepth];
+    if (aDeriveIndex !== undefined && bDeriveIndex !== undefined) {
+      return aDeriveIndex - bDeriveIndex;
+    } else {
+      if (aDeriveIndex === undefined && bDeriveIndex === undefined) {
+        return 0;
+      } else {
+        return aDeriveIndex === undefined ? 1 : -1;
+      }
+    }
+  });
+  let index = currentDepth === 0 ? 1 : 0;
+  for (const {
+    autoIndexes,
+    suri
+  } of childrenMetadata) {
+    const _autoIndexes = autoIndexes;
+    const deriveIndex = _autoIndexes[currentDepth];
+    if (!suri || deriveIndex === undefined) {
+      break;
+    }
+    if (deriveIndex === index) {
+      index++;
+    } else {
+      break;
+    }
+  }
+  const isSubstrate = _types.SubstrateKeypairTypes.includes(parentPair.type);
+  const indexes = currentDepth > 0 ? deriveInfo.autoIndexes || [] : [];
+  indexes.push(index);
+  const suri = isSubstrate ? [deriveInfo.suri || '', index].join('//') : '//'.concat(indexes.join('//'));
+  return {
+    deriveIndex: index,
+    depth: currentDepth + 1,
+    derivationPath: parseUnifiedSuriToDerivationPath(suri, rootPair.type),
+    suri,
+    deriveAddress: rootAddress
+  };
+};
+exports.findSoloNextDerive = findSoloNextDerive;
+const derivePair = (parentPair, name, suri, derivationPath) => {
+  var _parentPair$ton;
+  if (parentPair.isLocked) {
+    _uiKeyring.keyring.unlockPair(parentPair.address);
+  }
+  const isEvm = _types.EthereumKeypairTypes.includes(parentPair.type);
+  const isTon = parentPair.type === 'ton';
+  const meta = {
+    name,
+    parentAddress: parentPair.address,
+    suri: suri,
+    derivationPath,
+    tonContractVersion: undefined
+  };
+  if (isTon && (_parentPair$ton = parentPair.ton) !== null && _parentPair$ton !== void 0 && _parentPair$ton.contractVersion) {
+    meta.tonContractVersion = parentPair.ton.contractVersion;
+  }
+  if (derivationPath && (isEvm || isTon)) {
+    return isEvm ? parentPair.evm.deriveCustom(derivationPath, meta) : parentPair.ton.deriveCustom(derivationPath, meta);
+  } else {
+    return parentPair.substrate.derive(suri, meta);
+  }
+};
+exports.derivePair = derivePair;
+const getSuri = (seed, type) => {
+  const extraPath = type ? (0, _keyring.getDerivePath)(type)(0) : '';
+  return seed + (extraPath ? '/' + extraPath : '');
+};
+exports.getSuri = getSuri;

package/cjs/utils/account/derive/info/unified.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getUnifiedDerivationInfo = exports.findUnifiedNextDerive = void 0;
+var _types = require("@subwallet/extension-base/types");
+var _validate = require("../validate");
+var _solo = require("./solo");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const getUnifiedDerivationInfo = suri => {
+  if (suri) {
+    const validateUnifiedRs = (0, _validate.validateUnifiedDerivationPath)(suri);
+    if (validateUnifiedRs) {
+      const {
+        autoIndexes,
+        depth
+      } = validateUnifiedRs;
+      return {
+        suri: suri,
+        depth,
+        autoIndexes
+      };
+    }
+  }
+  return {
+    depth: 0,
+    suri
+  };
+};
+
+/**
+ * @func findUnifiedNextDerive
+ * @return {NextDerivePair}
+ * */
+exports.getUnifiedDerivationInfo = getUnifiedDerivationInfo;
+const findUnifiedNextDerive = (proxyId, accounts) => {
+  var _deriveInfo$autoIndex, _parentProxy$children;
+  const currentProxy = accounts[proxyId];
+  const parentProxyId = currentProxy.parentId || currentProxy.id;
+  const parentProxy = accounts[parentProxyId];
+  const deriveInfo = getUnifiedDerivationInfo(currentProxy.suri);
+  const currentDepth = deriveInfo.depth;
+  const currentIndex = (_deriveInfo$autoIndex = deriveInfo.autoIndexes) === null || _deriveInfo$autoIndex === void 0 ? void 0 : _deriveInfo$autoIndex[currentDepth - 1];
+  const children = ((_parentProxy$children = parentProxy.children) === null || _parentProxy$children === void 0 ? void 0 : _parentProxy$children.map(id => accounts[id])) || [];
+  const childrenMetadata = children.map(_ref => {
+    let {
+      accountType,
+      accounts,
+      suri
+    } = _ref;
+    if (accountType === _types.AccountProxyType.UNIFIED) {
+      return getUnifiedDerivationInfo(suri);
+    } else {
+      const account = accounts[0];
+      return (0, _solo.getSoloDerivationInfo)(account.type, account);
+    }
+  }).filter(_ref2 => {
+    let {
+      autoIndexes,
+      depth
+    } = _ref2;
+    if (depth !== currentDepth + 1) {
+      return false;
+    }
+    if (autoIndexes !== null && autoIndexes !== void 0 && autoIndexes.includes(undefined)) {
+      return false;
+    }
+    return currentIndex === (autoIndexes === null || autoIndexes === void 0 ? void 0 : autoIndexes[currentDepth - 1]);
+  }).sort((a, b) => {
+    var _a$autoIndexes, _b$autoIndexes;
+    const aDeriveIndex = (_a$autoIndexes = a.autoIndexes) === null || _a$autoIndexes === void 0 ? void 0 : _a$autoIndexes[currentDepth];
+    const bDeriveIndex = (_b$autoIndexes = b.autoIndexes) === null || _b$autoIndexes === void 0 ? void 0 : _b$autoIndexes[currentDepth];
+    if (aDeriveIndex !== undefined && bDeriveIndex !== undefined) {
+      return aDeriveIndex - bDeriveIndex;
+    } else {
+      if (aDeriveIndex === undefined && bDeriveIndex === undefined) {
+        return 0;
+      } else {
+        return aDeriveIndex === undefined ? 1 : -1;
+      }
+    }
+  });
+  let index = currentDepth === 0 ? 1 : 0;
+  for (const {
+    autoIndexes,
+    suri
+  } of childrenMetadata) {
+    const _autoIndexes = autoIndexes;
+    const deriveIndex = _autoIndexes[currentDepth];
+    if (!suri || deriveIndex === undefined) {
+      break;
+    }
+    if (deriveIndex === index) {
+      index++;
+    } else {
+      break;
+    }
+  }
+  const indexes = currentDepth > 0 ? deriveInfo.autoIndexes || [] : [];
+  indexes.push(index);
+  const suri = '//'.concat(indexes.join('//'));
+  return {
+    deriveIndex: index,
+    depth: currentDepth + 1,
+    suri,
+    deriveAddress: parentProxy.id
+  };
+};
+exports.findUnifiedNextDerive = findUnifiedNextDerive;

package/cjs/utils/account/derive/validate.js

@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateUnifiedDerivationPath = exports.validateTonDerivationPath = exports.validateSr25519DerivationPath = exports.validateOtherSubstrateDerivationPath = exports.validateEvmDerivationPath = exports.validateDerivationPath = void 0;
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const validateUnifiedDerivationPath = raw => {
+  const reg = /^\/\/(\d+)(\/\/\d+)?$/;
+  if (raw.match(reg)) {
+    const [, firstIndex, secondData] = raw.match(reg);
+    const first = parseInt(firstIndex, 10);
+    const autoIndexes = [first];
+    let depth;
+    let suri = `//${first}`;
+    if (first === 0) {
+      depth = 0;
+    } else {
+      depth = 1;
+    }
+    if (secondData) {
+      const [, secondIndex] = secondData.match(/\/\/(\d+)/);
+      const second = parseInt(secondIndex, 10);
+      autoIndexes.push(second);
+      depth = 2;
+      suri += `//${second}`;
+    }
+    if (depth === 0) {
+      return undefined;
+    }
+    return {
+      depth,
+      type: 'unified',
+      suri,
+      autoIndexes
+    };
+  } else {
+    return undefined;
+  }
+};
+exports.validateUnifiedDerivationPath = validateUnifiedDerivationPath;
+const validateEvmDerivationPath = raw => {
+  const reg = /^m\/44'\/60'\/0'\/0\/(\d+)(\/\d+)?$/;
+  if (raw.match(reg)) {
+    const [, firstIndex, secondData] = raw.match(reg);
+    const first = parseInt(firstIndex, 10);
+    const autoIndexes = [first];
+    let depth;
+    let suri = `//${first}`;
+    if (first === 0) {
+      depth = 0;
+    } else {
+      depth = 1;
+    }
+    if (secondData) {
+      const [, secondIndex] = secondData.match(/\/(\d+)/);
+      const second = parseInt(secondIndex, 10);
+      autoIndexes.push(second);
+      depth = 2;
+      suri += `//${second}`;
+    }
+    return {
+      depth,
+      type: 'ethereum',
+      suri,
+      derivationPath: raw,
+      autoIndexes
+    };
+  } else {
+    return undefined;
+  }
+};
+exports.validateEvmDerivationPath = validateEvmDerivationPath;
+const validateTonDerivationPath = raw => {
+  const reg = /^m\/44'\/607'\/(\d+)'(\/\d+')?$/;
+  if (raw.match(reg)) {
+    const [, firstIndex, secondData] = raw.match(reg);
+    const first = parseInt(firstIndex, 10);
+    const autoIndexes = [first];
+    let depth;
+    let suri = `//${first}`;
+    if (first === 0) {
+      depth = 0;
+    } else {
+      depth = 1;
+    }
+    if (secondData) {
+      const [, secondIndex] = secondData.match(/\/(\d+)'/);
+      const second = parseInt(secondIndex, 10);
+      autoIndexes.push(second);
+      depth = 2;
+      suri += `//${second}`;
+    }
+    return {
+      depth,
+      type: 'ton',
+      suri,
+      derivationPath: raw,
+      autoIndexes
+    };
+  } else {
+    return undefined;
+  }
+};
+exports.validateTonDerivationPath = validateTonDerivationPath;
+const validateSr25519DerivationPath = raw => {
+  const reg = /\/(\/?)([^/]+)/g;
+  const parts = raw.match(reg);
+  let constructed = '';
+  if (parts) {
+    constructed = parts.join('');
+  }
+  if (constructed !== raw || !parts) {
+    return undefined;
+  }
+  const autoIndexes = parts.map(part => {
+    const reg = /^\/\/(\d+)$/;
+    if (part.match(reg)) {
+      return parseInt(part.replace('//', ''), 10);
+    } else {
+      return undefined;
+    }
+  });
+  return {
+    depth: parts.length,
+    type: 'sr25519',
+    suri: raw,
+    autoIndexes
+  };
+};
+exports.validateSr25519DerivationPath = validateSr25519DerivationPath;
+const validateOtherSubstrateDerivationPath = (raw, type) => {
+  const reg = /\/\/([^/]+)/g;
+  const parts = raw.match(reg);
+  let constructed = '';
+  if (parts) {
+    constructed = parts.join('');
+  }
+  if (constructed !== raw || !parts) {
+    return undefined;
+  }
+  const autoIndexes = parts.map(part => {
+    const reg = /^\/\/(\d+)$/;
+    if (part.match(reg)) {
+      return parseInt(part.replace('//', ''), 10);
+    } else {
+      return undefined;
+    }
+  });
+  return {
+    depth: parts.length,
+    type,
+    suri: raw,
+    autoIndexes
+  };
+};
+exports.validateOtherSubstrateDerivationPath = validateOtherSubstrateDerivationPath;
+const validateDerivationPath = (raw, type) => {
+  if (type) {
+    if (type === 'ethereum') {
+      return validateEvmDerivationPath(raw);
+    } else if (type === 'ton') {
+      return validateTonDerivationPath(raw);
+    } else if (type === 'sr25519') {
+      return validateSr25519DerivationPath(raw);
+    } else if (type === 'ed25519' || type === 'ecdsa') {
+      return validateOtherSubstrateDerivationPath(raw, type);
+    } else {
+      return undefined;
+    }
+  } else {
+    return validateUnifiedDerivationPath(raw) || validateEvmDerivationPath(raw) || validateTonDerivationPath(raw) || validateSr25519DerivationPath(raw);
+  }
+};
+exports.validateDerivationPath = validateDerivationPath;

package/cjs/utils/account/index.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _analyze = require("./analyze");
+Object.keys(_analyze).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _analyze[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _analyze[key];
+    }
+  });
+});
+var _common = require("./common");
+Object.keys(_common).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _common[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _common[key];
+    }
+  });
+});
+var _derive = require("./derive");
+Object.keys(_derive).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _derive[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _derive[key];
+    }
+  });
+});
+var _transform = require("./transform");
+Object.keys(_transform).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _transform[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _transform[key];
+    }
+  });
+});