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

package/cjs/services/multisig-service/utils.js

@@ -0,0 +1,242 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_MAX_WEIGHT = exports.DEFAULT_BLOCK_HASH = void 0;
+exports.calcDepositAmount = calcDepositAmount;
+exports.createInitMultisigExtrinsic = createInitMultisigExtrinsic;
+exports.decodeCallData = decodeCallData;
+exports.genPendingMultisigTxKey = genPendingMultisigTxKey;
+exports.getCallData = getCallData;
+exports.getMultisigTxType = getMultisigTxType;
+var _index = require("@subwallet/extension-base/services/multisig-service/index");
+var _utils = require("@subwallet/extension-base/utils");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const DEFAULT_BLOCK_HASH = '0x0000000000000000000000000000000000000000000000000000000000000000';
+exports.DEFAULT_BLOCK_HASH = DEFAULT_BLOCK_HASH;
+const DEFAULT_MAX_WEIGHT = {
+  refTime: '0',
+  proofSize: '0'
+};
+
+/**
+ * Request interface for getting call data from a block
+ */
+
+/**
+ * Request interface for decoding call data
+ */
+
+/**
+ * Response interface for decoded call data
+ */
+exports.DEFAULT_MAX_WEIGHT = DEFAULT_MAX_WEIGHT;
+/**
+ * Extracts call data from a block's extrinsic
+ * Finds the inner call within multisig extrinsic and verifies it matches the call hash
+ * @param block - Block containing the extrinsic
+ * @param callHash - Expected hash of the call data
+ * @param extrinsicIndex - Index of the extrinsic in the block
+ * @returns Hex-encoded call data if found and verified, undefined otherwise
+ */
+function getCallData(_ref) {
+  let {
+    block,
+    callHash,
+    extrinsicIndex
+  } = _ref;
+  const extrinsic = block.extrinsics[extrinsicIndex];
+  if (!extrinsic) {
+    return undefined;
+  }
+  const innerCall = findInnerExtrinsicCall(extrinsic);
+  if (!innerCall) {
+    return undefined;
+  }
+  const callData = innerCall === null || innerCall === void 0 ? void 0 : innerCall.toHex();
+  if (!callData || !((0, _utilCrypto.blake2AsHex)(callData) === callHash)) {
+    return undefined;
+  }
+  return callData;
+}
+
+/**
+ * Type guard to check if a codec is a Call type
+ * @param codec - Codec object to check
+ * @returns True if the codec is a Call, false otherwise
+ */
+function isCall(codec) {
+  return 'args' in codec && 'method' in codec && 'section' in codec;
+}
+
+/**
+ * Finds the inner call within a multisig extrinsic
+ * Handles nested calls in multisig.asMulti and batchAll operations
+ * @param extrinsic - Extrinsic to search for inner call
+ * @returns The inner Call if found, null otherwise
+ */
+function findInnerExtrinsicCall(extrinsic) {
+  const findAsMulti = method => {
+    const MULTISIG_EXTRINSIC_CALL_INDEX = 3;
+    const WRAP_EXTRINSIC_CALL_INDEX = 2;
+    if (!method) {
+      return null;
+    }
+    const {
+      method: callMethod,
+      section
+    } = method.toHuman();
+    if (callMethod === 'asMulti' && section === 'multisig') {
+      const arg = method.args[MULTISIG_EXTRINSIC_CALL_INDEX];
+      return isCall(arg) ? arg : null;
+    }
+    if (callMethod === 'batchAll' && method.args.length > 0) {
+      const firstArg = method.args[0];
+      for (const item of firstArg) {
+        if (isCall(item)) {
+          const result = findAsMulti(item);
+          if (result) {
+            return result;
+          }
+        }
+      }
+    }
+    if (method.args && method.args.length > WRAP_EXTRINSIC_CALL_INDEX) {
+      const wrappedArg = method.args[WRAP_EXTRINSIC_CALL_INDEX];
+      if (isCall(wrappedArg)) {
+        return findAsMulti(wrappedArg);
+      }
+    }
+    return null;
+  };
+  return findAsMulti(extrinsic.method);
+}
+
+/**
+ * Decodes call data into a human-readable format
+ * @param api - Polkadot API instance
+ * @param callData - Hex-encoded call data to decode
+ * @returns Decoded call data with method, section, and args, or undefined if callData is not provided
+ */
+function decodeCallData(_ref2) {
+  let {
+    api,
+    callData
+  } = _ref2;
+  if (callData) {
+    return api.createType('Call', callData).toHuman();
+  }
+  return undefined;
+}
+
+/**
+ * Determines the type of multisig extrinsic based on decoded call data
+ * Maps pallet methods to extrinsic types (Transfer, Staking, Lending, etc.)
+ * @param decodedCallData - Decoded call data containing section and method
+ * @returns The type of multisig extrinsic, or UNKNOWN if not recognized
+ */
+function getMultisigTxType(decodedCallData) {
+  if (!decodedCallData) {
+    return _index.MultisigTxType.UNKNOWN;
+  }
+  const sectionMethod = `${decodedCallData.section}.${decodedCallData.method}`;
+  if (_index.MULTISIG_TX_TYPE_MAP.transfer.includes(sectionMethod)) {
+    return _index.MultisigTxType.TRANSFER;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.transfer_nft.includes(sectionMethod)) {
+    return _index.MultisigTxType.TRANSFER_NFT;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.staking.includes(sectionMethod)) {
+    return _index.MultisigTxType.STAKING;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.redeem.includes(sectionMethod)) {
+    return _index.MultisigTxType.REDEEM;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.unstake.includes(sectionMethod)) {
+    return _index.MultisigTxType.UNSTAKE;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.withdraw.includes(sectionMethod)) {
+    return _index.MultisigTxType.WITHDRAW;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.cancelUnstake.includes(sectionMethod)) {
+    return _index.MultisigTxType.CANCEL_UNSTAKE;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.claim.includes(sectionMethod)) {
+    return _index.MultisigTxType.CLAIM_REWARD;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.nominate.includes(sectionMethod)) {
+    return _index.MultisigTxType.NOMINATE;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.lending.includes(sectionMethod)) {
+    return _index.MultisigTxType.LENDING;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.govVote.includes(sectionMethod)) {
+    return _index.MultisigTxType.GOV_VOTE;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.govUnlockVote.includes(sectionMethod)) {
+    return _index.MultisigTxType.GOV_UNLOCK_VOTE;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.govRemoveVote.includes(sectionMethod)) {
+    return _index.MultisigTxType.GOV_REMOVE_VOTE;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.swap.includes(sectionMethod)) {
+    return _index.MultisigTxType.SWAP;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.setTokenPayFee.includes(sectionMethod)) {
+    return _index.MultisigTxType.SET_TOKEN_PAY_FEE;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.addProxy.includes(sectionMethod)) {
+    return _index.MultisigTxType.ADD_PROXY;
+  }
+  if (_index.MULTISIG_TX_TYPE_MAP.removeProxy.includes(sectionMethod)) {
+    return _index.MultisigTxType.REMOVE_PROXY;
+  }
+  return _index.MultisigTxType.UNKNOWN;
+}
+
+/**
+ * Generates a unique key for a pending multisig extrinsic
+ * Used as the key in the PendingMultisigTxMap
+ * @param chain - Chain identifier
+ * @param multisigAddress - Multisig address
+ * @param signerAddress - Address of the signer
+ * @param extrinsicHash - Hash of the extrinsic
+ * @returns Unique key string for the extrinsic
+ */
+function genPendingMultisigTxKey(chain, multisigAddress, signerAddress, extrinsicHash) {
+  return `${chain}___${multisigAddress}___${signerAddress}______${extrinsicHash}`;
+}
+
+/**
+ * Calculate deposit amount: depositAmount = depositBase + threshold * depositFactor
+ * In case threshold equal to 1, return undefined
+ * @param depositBase - Base deposit amount as a string
+ * @param threshold - Multisig threshold
+ * @param depositFactor - Deposit factor per additional signer as a string
+ * @returns Calculated deposit amount as a string
+ */
+function calcDepositAmount(depositBase, threshold, depositFactor) {
+  if (threshold === 1) {
+    return '0';
+  }
+  return (BigInt(depositBase) + BigInt(threshold) * BigInt(depositFactor)).toString();
+}
+
+/**
+ * Creates an init multisig extrinsic using the asMulti method
+ * @param api - Polkadot API instance
+ * @param threshold - Multisig threshold
+ * @param signers - Array of signer addresses
+ * @param signer - Address of the current signer
+ * @param extrinsic - Original extrinsic to be wrapped in multisig
+ * @returns SubmittableExtrinsic representing the multisig transaction
+ */
+function createInitMultisigExtrinsic(api, threshold, signers, signer, extrinsic) {
+  const otherSignatories = signers.filter(s => !(0, _utils.isSameAddress)(s, signer));
+  return api.tx.multisig.asMulti(threshold, (0, _utilCrypto.sortAddresses)(otherSignatories), null, extrinsic, DEFAULT_MAX_WEIGHT // default max weight for init multisig tx
+  );
+}

package/cjs/services/request-service/handler/SubstrateRequestHandler.js

@@ -5,7 +5,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _RequestExtrinsicSign = _interopRequireDefault(require("@subwallet/extension-base/background/RequestExtrinsicSign"));
+var _types = require("@subwallet/extension-base/types");
 var _getId = require("@subwallet/extension-base/utils/getId");
 var _request = require("@subwallet/extension-base/utils/request");
 var _rxjs = require("rxjs");
@@ -104,6 +106,29 @@ class SubstrateRequestHandler {
       onSign === null || onSign === void 0 ? void 0 : onSign(id);
     });
   }
+
+  // used for wrapped tx where we don't want to show popup for internal requests
+  // transaction is multisig or proxy transaction
+  async signWrappedTransaction(id, address, url, payload, onSign) {
+    const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+    if (isAlwaysRequired && !onSign) {
+      this.#requestService.keyringService.lock();
+    }
+    if (!this.#substrateRequests[id]) {
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
+    }
+    return new Promise((resolve, reject) => {
+      this.#substrateRequests[id] = {
+        ...this.signComplete(id, resolve, reject),
+        address,
+        id,
+        request: new _RequestExtrinsicSign.default(payload),
+        url: url
+      };
+      this.signSubject.next(this.allSubstrateRequests);
+      onSign === null || onSign === void 0 ? void 0 : onSign(id);
+    });
+  }
   resetWallet() {
     for (const request of Object.values(this.#substrateRequests)) {
       request.reject(new Error('Reset wallet'));

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

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _BitcoinRequestHandler = _interopRequireDefault(require("@subwallet/extension-base/services/request-service/handler/BitcoinRequestHandler"));
 var _CardanoRequestHandler = _interopRequireDefault(require("@subwallet/extension-base/services/request-service/handler/CardanoRequestHandler"));
+var _types = require("@subwallet/extension-base/services/transaction-service/types");
 var _TonRequestHandler = _interopRequireDefault(require("./handler/TonRequestHandler"));
 var _handler = require("./handler");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
@@ -174,7 +175,10 @@ class RequestService {
   getSignRequest(id) {
     return this.#substrateRequestHandler.getSignRequest(id);
   }
-  async signInternalTransaction(id, address, url, payload, onSign) {
+  async signInternalTransaction(id, address, url, payload, onSign, isWrappedTx) {
+    if (isWrappedTx === _types.SubstrateTransactionWrappingStatus.WRAP_RESULT) {
+      return this.#substrateRequestHandler.signWrappedTransaction(id, address, url, payload, onSign);
+    }
     return this.#substrateRequestHandler.signTransaction(id, address, url, payload, onSign);
   }
   addConfirmation(id, url, type, payload) {

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

@@ -590,6 +590,9 @@ class DatabaseService {
   cleanUpOldNotifications(overdueTime) {
     return this.stores.inappNotification.cleanUpOldNotifications(overdueTime);
   }
+  cleanUpNotificationByIds(ids) {
+    return this.stores.inappNotification.cleanUpNotificationsByIds(ids);
+  }
   subscribeUnreadNotificationsCountMap() {
     return this.stores.inappNotification.subscribeUnreadNotificationsCount();
   }
@@ -599,8 +602,8 @@ class DatabaseService {
   upsertNotifications(notifications) {
     return this.stores.inappNotification.bulkUpsert(notifications);
   }
-  markAllRead(proxyId) {
-    return this.stores.inappNotification.markAllRead(proxyId);
+  markAllRead(params) {
+    return this.stores.inappNotification.markAllRead(params);
   }
   switchReadStatus(params) {
     return this.stores.inappNotification.switchReadStatus(params);

package/cjs/services/storage-service/db-stores/InappNotification.js

@@ -9,6 +9,7 @@ var _constants = require("@subwallet/extension-base/constants");
 var _interfaces = require("@subwallet/extension-base/services/inapp-notification-service/interfaces");
 var _utils = require("@subwallet/extension-base/services/inapp-notification-service/utils");
 var _BaseStore = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/BaseStore"));
+var _utils2 = require("@subwallet/extension-base/utils");
 var _dexie = require("dexie");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -22,6 +23,7 @@ class InappNotificationStore extends _BaseStore.default {
   }
   async getNotificationsByParams(params) {
     const {
+      metadata,
       notificationTab,
       proxyId
     } = params;
@@ -33,6 +35,15 @@ class InappNotificationStore extends _BaseStore.default {
     const filteredTable = this.table.filter(item => {
       const matchesProxyId = item.proxyId === proxyId;
       const matchesReadStatus = item.isRead === (0, _utils.getIsTabRead)(notificationTab);
+      if (metadata !== null && metadata !== void 0 && metadata.multisigAddress && metadata !== null && metadata !== void 0 && metadata.chain && notificationTab === _interfaces.NotificationTab.MULTISIG) {
+        // @Todo This condition is service only for multisig subscribe service to get all filter by multisig address
+        // then clear it when tx is completed
+        // So, if use this condition to service other feature, need to re-check carefully
+        const multisigMetadata = item.metadata;
+        const multisigAddressOfNotification = multisigMetadata === null || multisigMetadata === void 0 ? void 0 : multisigMetadata.multisigAddress;
+        const chain = multisigMetadata === null || multisigMetadata === void 0 ? void 0 : multisigMetadata.chain;
+        return !!multisigAddressOfNotification && (0, _utils2.isSameAddress)(multisigAddressOfNotification, metadata.multisigAddress) && chain === metadata.chain;
+      }
       if (isTabAll) {
         return matchesProxyId;
       }
@@ -53,6 +64,9 @@ class InappNotificationStore extends _BaseStore.default {
     const currentTimestamp = Date.now();
     return this.table.filter(item => item.time <= currentTimestamp - overdueTime).delete();
   }
+  async cleanUpNotificationsByIds(ids) {
+    return this.table.where('id').anyOf(ids).delete();
+  }
   subscribeUnreadNotificationsCount() {
     return (0, _dexie.liveQuery)(async () => {
       return await this.getUnreadNotificationsCountMap();
@@ -65,9 +79,13 @@ class InappNotificationStore extends _BaseStore.default {
       return countMap;
     }, {});
   }
-  markAllRead(proxyId) {
+  markAllRead(params) {
+    const {
+      proxyId,
+      excludeNotificationIds = []
+    } = params;
     if (proxyId === _constants.ALL_ACCOUNT_KEY) {
-      return this.table.toCollection().modify({
+      return this.table.toCollection().filter(notification => !excludeNotificationIds.includes(notification.id)).modify({
         isRead: true
       });
     }

package/cjs/services/substrate-proxy-service/index.js

@@ -4,6 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.createInitSubstrateProxyExtrinsic = createInitSubstrateProxyExtrinsic;
 exports.default = void 0;
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _types = require("@subwallet/extension-base/types");
@@ -13,6 +14,9 @@ var _constant = require("./constant");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
+function createInitSubstrateProxyExtrinsic(api, proxiedAddress, extrinsic) {
+  return api.tx.proxy.proxy(proxiedAddress, null, extrinsic);
+}
 class SubstrateProxyAccountService {
   constructor(state) {
     this.state = state;
@@ -39,6 +43,7 @@ class SubstrateProxyAccountService {
     const baseDeposit = ((_substrateApi$api$con = substrateApi.api.consts.proxy.proxyDepositBase) === null || _substrateApi$api$con === void 0 ? void 0 : _substrateApi$api$con.toString()) || '0';
     const factorDeposit = ((_substrateApi$api$con2 = substrateApi.api.consts.proxy.proxyDepositFactor) === null || _substrateApi$api$con2 === void 0 ? void 0 : _substrateApi$api$con2.toString()) || '0';
     const deposit = new _bignumber.default(baseDeposit).plus(factorDeposit);
+    const allAccounts = this.state.keyringService.context.accounts;
     const [_substrateProxyAccounts, currentSubstrateProxyDeposit] = result.toPrimitive();
 
     // Mapping on-chain data to our defined type
@@ -53,11 +58,21 @@ class SubstrateProxyAccountService {
     });
     if (type) {
       const allowedSet = new Set([...(_constant.txTypeToSubstrateProxyMap[type] || []), 'Any']);
-      substrateProxyAccounts = substrateProxyAccounts.filter(p => allowedSet.has(p.substrateProxyType));
+      substrateProxyAccounts = substrateProxyAccounts.filter(p => {
+        if (!p.proxyId) {
+          return false;
+        }
+        const accountProxy = allAccounts[p.proxyId];
+        const substrateAccount = accountProxy === null || accountProxy === void 0 ? void 0 : accountProxy.accounts.find(acc => acc.chainType === _types.AccountChainType.SUBSTRATE);
+        if (!substrateAccount || !substrateAccount.transactionActions.includes(type)) {
+          return false;
+        }
+        return allowedSet.has(p.substrateProxyType);
+      });
     }
     if (excludedSubstrateProxyAccounts && excludedSubstrateProxyAccounts.length > 0) {
       substrateProxyAccounts = substrateProxyAccounts.filter(p => {
-        return !excludedSubstrateProxyAccounts.some(excluded => excluded.address === p.substrateProxyAddress && excluded.substrateProxyType === p.substrateProxyType);
+        return !excludedSubstrateProxyAccounts.some(excluded => excluded.substrateProxyAddress === p.substrateProxyAddress && excluded.substrateProxyType === p.substrateProxyType);
       });
     }
     const estimateSubstrateProxyDeposit = new _bignumber.default(currentSubstrateProxyDeposit).plus(factorDeposit);
@@ -86,7 +101,7 @@ class SubstrateProxyAccountService {
   }
 
   // Validate adding proxy account
-  async validateAddSubstrateProxyAccount(params, signerSubstrateProxyAddress) {
+  async validateAddSubstrateProxyAccount(params) {
     var _substrateApi$api$con3, _substrateApi$api$con4, _substrateApi$api$con5, _substrateApi$api$con6;
     const {
       address,
@@ -95,6 +110,9 @@ class SubstrateProxyAccountService {
     } = params;
     const substrateApi = this.getSubstrateApi(chain);
     await substrateApi.isReady;
+    if (!substrateApi.api.tx.proxy || !substrateApi.api.tx.proxy.addProxy) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED)];
+    }
     const addProxyTx = substrateApi.api.tx.proxy.addProxy;
     const proxyTypeArg = addProxyTx.meta.args.find(arg => arg.name.toString() === 'proxyType');
     if (proxyTypeArg) {
@@ -105,9 +123,6 @@ class SubstrateProxyAccountService {
         return [new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED, 'This proxy type is not supported on the chosen network. Select another one and try again')];
       }
     }
-    if (!substrateApi.api.tx.proxy || !substrateApi.api.tx.proxy.addProxy) {
-      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED)];
-    }
 
     // Validate max proxies accounts limit
     const maxSubstrateProxies = ((_substrateApi$api$con3 = substrateApi.api.consts.proxy.maxProxies) === null || _substrateApi$api$con3 === void 0 ? void 0 : (_substrateApi$api$con4 = _substrateApi$api$con3.toNumber) === null || _substrateApi$api$con4 === void 0 ? void 0 : _substrateApi$api$con4.call(_substrateApi$api$con3)) || 0;
@@ -125,7 +140,7 @@ class SubstrateProxyAccountService {
     const baseDeposit = ((_substrateApi$api$con5 = substrateApi.api.consts.proxy.proxyDepositBase) === null || _substrateApi$api$con5 === void 0 ? void 0 : _substrateApi$api$con5.toString()) || '0';
     const factorDeposit = ((_substrateApi$api$con6 = substrateApi.api.consts.proxy.proxyDepositFactor) === null || _substrateApi$api$con6 === void 0 ? void 0 : _substrateApi$api$con6.toString()) || '0';
     const requiredDeposit = proxyList.length === 0 ? new _bignumber.default(baseDeposit).plus(factorDeposit) : new _bignumber.default(factorDeposit);
-    const totalRequired = new _bignumber.default(requiredDeposit).plus(!signerSubstrateProxyAddress ? estimatedFee : 0);
+    const totalRequired = new _bignumber.default(requiredDeposit).plus(estimatedFee);
     if (bnTransferableBalance.lt(totalRequired)) {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_BALANCE)];
     }

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

@@ -82,6 +82,14 @@ const typeName = type => {
       return 'Unlock votes';
     case _KoniTypes.ExtrinsicType.CHANGE_EARNING_VALIDATOR:
       return 'Change validator';
+    case _KoniTypes.ExtrinsicType.MULTISIG_APPROVE_TX:
+      return 'Approve multisig extrinsic';
+    case _KoniTypes.ExtrinsicType.MULTISIG_EXECUTE_TX:
+      return 'Execute multisig extrinsic';
+    case _KoniTypes.ExtrinsicType.MULTISIG_CANCEL_TX:
+      return 'Cancel multisig extrinsic';
+    case _KoniTypes.ExtrinsicType.MULTISIG_INIT_TX:
+      return 'Initiate multisig extrinsic';
     case _KoniTypes.ExtrinsicType.UNKNOWN:
     default:
       return 'unknown';