@polymeshassociation/polymesh-sdk 31.1.0-beta.20 → 31.1.0-beta.22

package/utils/conversion.js

@@ -805,8 +805,11 @@ function splitTag(tag) {
 }
 /**
  * @hidden
+ *
+ * Group transaction tags by pallet. A pallet named whole maps to `null`, and a pallet named by
+ *   some of its transactions maps to their dispatchable names
  */
-function initExtrinsicDict(txValues, message) {
+function initExtrinsicDict(txValues) {
     const extrinsicDict = {};
     [...new Set(txValues)]
         .sort((a, b) => a.localeCompare(b))
@@ -817,7 +820,7 @@ function initExtrinsicDict(txValues, message) {
             if (pallet === null) {
                 throw new internal_1.PolymeshError({
                     code: types_3.ErrorCode.ValidationError,
-                    message,
+                    message: 'Attempting to add permissions for specific transactions as well as the entire module',
                     data: {
                         module: palletName,
                         transactions: [dispatchableName],
@@ -825,8 +828,8 @@ function initExtrinsicDict(txValues, message) {
                 });
             }
             else
-                pallet !== null && pallet !== void 0 ? pallet : (pallet = extrinsicDict[palletName] = { tx: [] });
-            pallet.tx.push(dispatchableName);
+                pallet !== null && pallet !== void 0 ? pallet : (pallet = extrinsicDict[palletName] = []);
+            pallet.push(dispatchableName);
         }
         else {
             extrinsicDict[(0, util_1.stringUpperFirst)(tag)] = null;
@@ -834,71 +837,33 @@ function initExtrinsicDict(txValues, message) {
     });
     return extrinsicDict;
 }
+/**
+ * @hidden
+ *
+ * Throw for transaction permissions that exclude transactions. The chain refuses `Except` extrinsic
+ *   permissions, at the pallet and the extrinsic level, because a new extrinsic would silently widen
+ *   them. Secondary keys have refused them since Polymesh 8.0, and agent groups and MultiSigs since 8.1.2
+ */
+function assertTransactionsNotExcluded({ type, exceptions = [] }) {
+    if (type === types_3.PermissionType.Exclude || exceptions.length) {
+        throw new internal_1.PolymeshError({
+            code: types_3.ErrorCode.ValidationError,
+            message: 'Transaction permissions cannot exclude transactions. List the transactions to allow instead',
+            data: { type, exceptions },
+        });
+    }
+}
 /**
  * @hidden
  */
 function buildPalletPermissions(transactions) {
-    let extrinsic;
-    const message = 'Attempting to add permissions for specific transactions as well as the entire module';
-    const { values: txValues, exceptions = [], type } = transactions;
-    const extrinsicDict = initExtrinsicDict(txValues, message);
-    exceptions.forEach(exception => {
-        const { palletName, dispatchableName } = splitTag(exception);
-        const pallet = extrinsicDict[palletName];
-        if (pallet === undefined) {
-            throw new internal_1.PolymeshError({
-                code: types_3.ErrorCode.ValidationError,
-                message: 'Attempting to add a transaction permission exception without its corresponding module being included/excluded',
-            });
-        }
-        else if (pallet === null) {
-            extrinsicDict[palletName] = { tx: [dispatchableName], exception: true };
-        }
-        else if (pallet.exception) {
-            pallet.tx.push(dispatchableName);
-        }
-        else {
-            throw new internal_1.PolymeshError({
-                code: types_3.ErrorCode.ValidationError,
-                message: 'Cannot simultaneously include and exclude transactions belonging to the same module',
-            });
-        }
-    });
-    const getDispatchables = (val) => {
-        let dispatchables;
-        if (val === null) {
-            dispatchables = 'Whole';
-        }
-        else {
-            const { tx, exception } = val;
-            if (exception) {
-                dispatchables = {
-                    Except: tx,
-                };
-            }
-            else {
-                dispatchables = {
-                    These: tx,
-                };
-            }
-        }
-        return dispatchables;
-    };
+    assertTransactionsNotExcluded(transactions);
+    const extrinsicDict = initExtrinsicDict(transactions.values);
     const pallets = new Map();
-    (0, lodash_1.forEach)(extrinsicDict, (val, key) => {
-        pallets.set(key, { extrinsics: getDispatchables(val) });
+    (0, lodash_1.forEach)(extrinsicDict, (tx, palletName) => {
+        pallets.set(palletName, { extrinsics: tx === null ? 'Whole' : { These: tx } });
     });
-    if (type === types_3.PermissionType.Include) {
-        extrinsic = {
-            These: pallets,
-        };
-    }
-    else {
-        extrinsic = {
-            Except: pallets,
-        };
-    }
-    return extrinsic;
+    return { These: pallets };
 }
 /**
  * @hidden