@metamask-previews/gator-permissions-controller 4.2.3-preview-3f58e8b65 → 4.2.3-preview-e0f702919

package/dist/decodePermission/decoders/erc20TokenStream.mjs

@@ -0,0 +1,77 @@
+import { hexToBigInt, hexToNumber } from "@metamask/utils";
+import { getByteLength, getTermsByEnforcer, splitHex, ZERO_32_BYTES } from "../utils.mjs";
+import { erc20PayeeRule } from "./erc20PayeeRule.mjs";
+import { expiryRule } from "./expiryRule.mjs";
+import { redeemerRule } from "./redeemerRule.mjs";
+/**
+ * Builds the configuration for the erc20-token-stream permission decoder.
+ *
+ * @param contractAddresses - Checksummed enforcer addresses for the chain.
+ * @returns The erc20-token-stream permission decoder configuration.
+ */
+export function makeErc20TokenStreamDecoderConfig(contractAddresses) {
+    const { timestampEnforcer, erc20StreamingEnforcer, valueLteEnforcer, nonceEnforcer, allowedCalldataEnforcer, redeemerEnforcer, } = contractAddresses;
+    return {
+        permissionType: 'erc20-token-stream',
+        contractAddresses,
+        optionalEnforcers: [
+            timestampEnforcer, // expiry rule
+            redeemerEnforcer, // redeemer rule
+            allowedCalldataEnforcer, // payee rule
+        ],
+        requiredEnforcers: {
+            [erc20StreamingEnforcer]: 1,
+            [valueLteEnforcer]: 1,
+            [nonceEnforcer]: 1,
+        },
+        rules: [expiryRule, redeemerRule, erc20PayeeRule],
+        validateAndDecodeData,
+    };
+}
+/**
+ * Decodes erc20-token-stream permission data from caveats; throws on invalid.
+ *
+ * @param caveats - Caveats from the permission context (checksummed).
+ * @param contractAddresses - Checksummed enforcer addresses for the chain.
+ * @returns Decoded stream terms.
+ */
+function validateAndDecodeData(caveats, contractAddresses) {
+    const { erc20StreamingEnforcer, valueLteEnforcer } = contractAddresses;
+    const valueLteTerms = getTermsByEnforcer({
+        caveats,
+        enforcer: valueLteEnforcer,
+    });
+    if (valueLteTerms !== ZERO_32_BYTES) {
+        throw new Error(`Invalid value-lte terms: must be ${ZERO_32_BYTES}`);
+    }
+    const terms = getTermsByEnforcer({
+        caveats,
+        enforcer: erc20StreamingEnforcer,
+    });
+    const EXPECTED_TERMS_BYTELENGTH = 148;
+    if (getByteLength(terms) !== EXPECTED_TERMS_BYTELENGTH) {
+        throw new Error('Invalid erc20-token-stream terms: expected 148 bytes');
+    }
+    const [tokenAddress, initialAmount, maxAmount, amountPerSecond, startTimeRaw,] = splitHex(terms, [20, 32, 32, 32, 32]);
+    const startTime = hexToNumber(startTimeRaw);
+    const initialAmountBigInt = hexToBigInt(initialAmount);
+    const maxAmountBigInt = hexToBigInt(maxAmount);
+    const amountPerSecondBigInt = hexToBigInt(amountPerSecond);
+    if (maxAmountBigInt <= initialAmountBigInt) {
+        throw new Error('Invalid erc20-token-stream terms: maxAmount must be greater than initialAmount');
+    }
+    if (amountPerSecondBigInt === 0n) {
+        throw new Error('Invalid erc20-token-stream terms: amountPerSecond must be a positive number');
+    }
+    if (startTime === 0) {
+        throw new Error('Invalid erc20-token-stream terms: startTime must be a positive number');
+    }
+    return {
+        tokenAddress,
+        initialAmount,
+        maxAmount,
+        amountPerSecond,
+        startTime,
+    };
+}
+//# sourceMappingURL=erc20TokenStream.mjs.map

package/dist/decodePermission/decoders/erc20TokenStream.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc20TokenStream.mjs","sourceRoot":"","sources":["../../../src/decodePermission/decoders/erc20TokenStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,wBAAwB;AAO3D,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,QAAQ,EACR,aAAa,EACd,qBAAoB;AACrB,OAAO,EAAE,cAAc,EAAE,6BAA4B;AACrD,OAAO,EAAE,UAAU,EAAE,yBAAwB;AAE7C,OAAO,EAAE,YAAY,EAAE,2BAA0B;AAEjD;;;;;GAKG;AACH,MAAM,UAAU,iCAAiC,CAC/C,iBAA6C;IAE7C,MAAM,EACJ,iBAAiB,EACjB,sBAAsB,EACtB,gBAAgB,EAChB,aAAa,EACb,uBAAuB,EACvB,gBAAgB,GACjB,GAAG,iBAAiB,CAAC;IAEtB,OAAO;QACL,cAAc,EAAE,oBAAoB;QACpC,iBAAiB;QACjB,iBAAiB,EAAE;YACjB,iBAAiB,EAAE,cAAc;YACjC,gBAAgB,EAAE,gBAAgB;YAClC,uBAAuB,EAAE,aAAa;SACvC;QACD,iBAAiB,EAAE;YACjB,CAAC,sBAAsB,CAAC,EAAE,CAAC;YAC3B,CAAC,gBAAgB,CAAC,EAAE,CAAC;YACrB,CAAC,aAAa,CAAC,EAAE,CAAC;SACnB;QACD,KAAK,EAAE,CAAC,UAAU,EAAE,YAAY,EAAE,cAAc,CAAC;QACjD,qBAAqB;KACtB,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,qBAAqB,CAC5B,OAAyB,EACzB,iBAA6C;IAE7C,MAAM,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,GAAG,iBAAiB,CAAC;IACvE,MAAM,aAAa,GAAG,kBAAkB,CAAC;QACvC,OAAO;QACP,QAAQ,EAAE,gBAAgB;KAC3B,CAAC,CAAC;IAEH,IAAI,aAAa,KAAK,aAAa,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CAAC,oCAAoC,aAAa,EAAE,CAAC,CAAC;IACvE,CAAC;IAED,MAAM,KAAK,GAAG,kBAAkB,CAAC;QAC/B,OAAO;QACP,QAAQ,EAAE,sBAAsB;KACjC,CAAC,CAAC;IAEH,MAAM,yBAAyB,GAAG,GAAG,CAAC;IAEtC,IAAI,aAAa,CAAC,KAAK,CAAC,KAAK,yBAAyB,EAAE,CAAC;QACvD,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IAED,MAAM,CACJ,YAAY,EACZ,aAAa,EACb,SAAS,EACT,eAAe,EACf,YAAY,EACb,GAAG,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IAE1C,MAAM,SAAS,GAAG,WAAW,CAAC,YAAY,CAAC,CAAC;IAC5C,MAAM,mBAAmB,GAAG,WAAW,CAAC,aAAa,CAAC,CAAC;IACvD,MAAM,eAAe,GAAG,WAAW,CAAC,SAAS,CAAC,CAAC;IAC/C,MAAM,qBAAqB,GAAG,WAAW,CAAC,eAAe,CAAC,CAAC;IAE3D,IAAI,eAAe,IAAI,mBAAmB,EAAE,CAAC;QAC3C,MAAM,IAAI,KAAK,CACb,gFAAgF,CACjF,CAAC;IACJ,CAAC;IAED,IAAI,qBAAqB,KAAK,EAAE,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CACb,6EAA6E,CAC9E,CAAC;IACJ,CAAC;IAED,IAAI,SAAS,KAAK,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CACb,uEAAuE,CACxE,CAAC;IACJ,CAAC;IAED,OAAO;QACL,YAAY;QACZ,aAAa;QACb,SAAS;QACT,eAAe;QACf,SAAS;KACV,CAAC;AACJ,CAAC","sourcesContent":["import { hexToBigInt, hexToNumber } from '@metamask/utils';\n\nimport type {\n  ChecksumCaveat,\n  ChecksumEnforcersByChainId,\n  DecodedPermission,\n} from '../types.js';\nimport {\n  getByteLength,\n  getTermsByEnforcer,\n  splitHex,\n  ZERO_32_BYTES,\n} from '../utils.js';\nimport { erc20PayeeRule } from './erc20PayeeRule.js';\nimport { expiryRule } from './expiryRule.js';\nimport type { MakePermissionDecoderConfig } from './makePermissionDecoder.js';\nimport { redeemerRule } from './redeemerRule.js';\n\n/**\n * Builds the configuration for the erc20-token-stream permission decoder.\n *\n * @param contractAddresses - Checksummed enforcer addresses for the chain.\n * @returns The erc20-token-stream permission decoder configuration.\n */\nexport function makeErc20TokenStreamDecoderConfig(\n  contractAddresses: ChecksumEnforcersByChainId,\n): MakePermissionDecoderConfig {\n  const {\n    timestampEnforcer,\n    erc20StreamingEnforcer,\n    valueLteEnforcer,\n    nonceEnforcer,\n    allowedCalldataEnforcer,\n    redeemerEnforcer,\n  } = contractAddresses;\n\n  return {\n    permissionType: 'erc20-token-stream',\n    contractAddresses,\n    optionalEnforcers: [\n      timestampEnforcer, // expiry rule\n      redeemerEnforcer, // redeemer rule\n      allowedCalldataEnforcer, // payee rule\n    ],\n    requiredEnforcers: {\n      [erc20StreamingEnforcer]: 1,\n      [valueLteEnforcer]: 1,\n      [nonceEnforcer]: 1,\n    },\n    rules: [expiryRule, redeemerRule, erc20PayeeRule],\n    validateAndDecodeData,\n  };\n}\n\n/**\n * Decodes erc20-token-stream permission data from caveats; throws on invalid.\n *\n * @param caveats - Caveats from the permission context (checksummed).\n * @param contractAddresses - Checksummed enforcer addresses for the chain.\n * @returns Decoded stream terms.\n */\nfunction validateAndDecodeData(\n  caveats: ChecksumCaveat[],\n  contractAddresses: ChecksumEnforcersByChainId,\n): DecodedPermission['permission']['data'] {\n  const { erc20StreamingEnforcer, valueLteEnforcer } = contractAddresses;\n  const valueLteTerms = getTermsByEnforcer({\n    caveats,\n    enforcer: valueLteEnforcer,\n  });\n\n  if (valueLteTerms !== ZERO_32_BYTES) {\n    throw new Error(`Invalid value-lte terms: must be ${ZERO_32_BYTES}`);\n  }\n\n  const terms = getTermsByEnforcer({\n    caveats,\n    enforcer: erc20StreamingEnforcer,\n  });\n\n  const EXPECTED_TERMS_BYTELENGTH = 148;\n\n  if (getByteLength(terms) !== EXPECTED_TERMS_BYTELENGTH) {\n    throw new Error('Invalid erc20-token-stream terms: expected 148 bytes');\n  }\n\n  const [\n    tokenAddress,\n    initialAmount,\n    maxAmount,\n    amountPerSecond,\n    startTimeRaw,\n  ] = splitHex(terms, [20, 32, 32, 32, 32]);\n\n  const startTime = hexToNumber(startTimeRaw);\n  const initialAmountBigInt = hexToBigInt(initialAmount);\n  const maxAmountBigInt = hexToBigInt(maxAmount);\n  const amountPerSecondBigInt = hexToBigInt(amountPerSecond);\n\n  if (maxAmountBigInt <= initialAmountBigInt) {\n    throw new Error(\n      'Invalid erc20-token-stream terms: maxAmount must be greater than initialAmount',\n    );\n  }\n\n  if (amountPerSecondBigInt === 0n) {\n    throw new Error(\n      'Invalid erc20-token-stream terms: amountPerSecond must be a positive number',\n    );\n  }\n\n  if (startTime === 0) {\n    throw new Error(\n      'Invalid erc20-token-stream terms: startTime must be a positive number',\n    );\n  }\n\n  return {\n    tokenAddress,\n    initialAmount,\n    maxAmount,\n    amountPerSecond,\n    startTime,\n  };\n}\n"]}

package/dist/decodePermission/decoders/expiryRule.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expiryRule = void 0;
+const constants_js_1 = require("../../constants.cjs");
+const utils_js_1 = require("../utils.cjs");
+/**
+ * Rule decoder that extracts the expiry timestamp from a TimestampEnforcer
+ * caveat, when present. Returns a standard {@link Rule} so that
+ * `makePermissionDecoder` can append it to the decoded permission's `rules`
+ * array. The decoder body additionally hoists the timestamp onto the
+ * top-level `expiry` field of the response.
+ *
+ * @param args - The arguments to this function.
+ * @param args.contractAddresses - Checksummed enforcer addresses for the chain.
+ * @param args.caveats - Checksummed caveats from the delegation.
+ * @returns A `{ type: 'expiry', data: { timestamp } }` rule when a
+ * TimestampEnforcer caveat exists, otherwise `null`.
+ */
+const expiryRule = ({ contractAddresses, caveats }) => {
+    const { timestampEnforcer } = contractAddresses;
+    const expiryTerms = (0, utils_js_1.getTermsByEnforcer)({
+        caveats,
+        enforcer: timestampEnforcer,
+        throwIfNotFound: false,
+    });
+    if (!expiryTerms) {
+        return null;
+    }
+    return {
+        type: constants_js_1.EXECUTION_PERMISSION_EXPIRY_RULE_TYPE,
+        data: { timestamp: (0, utils_js_1.extractExpiryFromCaveatTerms)(expiryTerms) },
+    };
+};
+exports.expiryRule = expiryRule;
+//# sourceMappingURL=expiryRule.cjs.map

package/dist/decodePermission/decoders/expiryRule.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"expiryRule.cjs","sourceRoot":"","sources":["../../../src/decodePermission/decoders/expiryRule.ts"],"names":[],"mappings":";;;AAAA,sDAA2E;AAE3E,2CAA+E;AAE/E;;;;;;;;;;;;GAYG;AACI,MAAM,UAAU,GAAgB,CAAC,EAAE,iBAAiB,EAAE,OAAO,EAAE,EAAE,EAAE;IACxE,MAAM,EAAE,iBAAiB,EAAE,GAAG,iBAAiB,CAAC;IAEhD,MAAM,WAAW,GAAG,IAAA,6BAAkB,EAAC;QACrC,OAAO;QACP,QAAQ,EAAE,iBAAiB;QAC3B,eAAe,EAAE,KAAK;KACvB,CAAC,CAAC;IAEH,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO;QACL,IAAI,EAAE,oDAAqC;QAC3C,IAAI,EAAE,EAAE,SAAS,EAAE,IAAA,uCAA4B,EAAC,WAAW,CAAC,EAAE;KAC/D,CAAC;AACJ,CAAC,CAAC;AAjBW,QAAA,UAAU,cAiBrB","sourcesContent":["import { EXECUTION_PERMISSION_EXPIRY_RULE_TYPE } from '../../constants.js';\nimport type { RuleDecoder } from '../types.js';\nimport { extractExpiryFromCaveatTerms, getTermsByEnforcer } from '../utils.js';\n\n/**\n * Rule decoder that extracts the expiry timestamp from a TimestampEnforcer\n * caveat, when present. Returns a standard {@link Rule} so that\n * `makePermissionDecoder` can append it to the decoded permission's `rules`\n * array. The decoder body additionally hoists the timestamp onto the\n * top-level `expiry` field of the response.\n *\n * @param args - The arguments to this function.\n * @param args.contractAddresses - Checksummed enforcer addresses for the chain.\n * @param args.caveats - Checksummed caveats from the delegation.\n * @returns A `{ type: 'expiry', data: { timestamp } }` rule when a\n * TimestampEnforcer caveat exists, otherwise `null`.\n */\nexport const expiryRule: RuleDecoder = ({ contractAddresses, caveats }) => {\n  const { timestampEnforcer } = contractAddresses;\n\n  const expiryTerms = getTermsByEnforcer({\n    caveats,\n    enforcer: timestampEnforcer,\n    throwIfNotFound: false,\n  });\n\n  if (!expiryTerms) {\n    return null;\n  }\n\n  return {\n    type: EXECUTION_PERMISSION_EXPIRY_RULE_TYPE,\n    data: { timestamp: extractExpiryFromCaveatTerms(expiryTerms) },\n  };\n};\n"]}

package/dist/decodePermission/decoders/expiryRule.d.cts

@@ -0,0 +1,16 @@
+import type { RuleDecoder } from "../types.cjs";
+/**
+ * Rule decoder that extracts the expiry timestamp from a TimestampEnforcer
+ * caveat, when present. Returns a standard {@link Rule} so that
+ * `makePermissionDecoder` can append it to the decoded permission's `rules`
+ * array. The decoder body additionally hoists the timestamp onto the
+ * top-level `expiry` field of the response.
+ *
+ * @param args - The arguments to this function.
+ * @param args.contractAddresses - Checksummed enforcer addresses for the chain.
+ * @param args.caveats - Checksummed caveats from the delegation.
+ * @returns A `{ type: 'expiry', data: { timestamp } }` rule when a
+ * TimestampEnforcer caveat exists, otherwise `null`.
+ */
+export declare const expiryRule: RuleDecoder;
+//# sourceMappingURL=expiryRule.d.cts.map

package/dist/decodePermission/decoders/expiryRule.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expiryRule.d.cts","sourceRoot":"","sources":["../../../src/decodePermission/decoders/expiryRule.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAoB;AAG/C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,EAAE,WAiBxB,CAAC"}

package/dist/decodePermission/decoders/expiryRule.d.mts

@@ -0,0 +1,16 @@
+import type { RuleDecoder } from "../types.mjs";
+/**
+ * Rule decoder that extracts the expiry timestamp from a TimestampEnforcer
+ * caveat, when present. Returns a standard {@link Rule} so that
+ * `makePermissionDecoder` can append it to the decoded permission's `rules`
+ * array. The decoder body additionally hoists the timestamp onto the
+ * top-level `expiry` field of the response.
+ *
+ * @param args - The arguments to this function.
+ * @param args.contractAddresses - Checksummed enforcer addresses for the chain.
+ * @param args.caveats - Checksummed caveats from the delegation.
+ * @returns A `{ type: 'expiry', data: { timestamp } }` rule when a
+ * TimestampEnforcer caveat exists, otherwise `null`.
+ */
+export declare const expiryRule: RuleDecoder;
+//# sourceMappingURL=expiryRule.d.mts.map

package/dist/decodePermission/decoders/expiryRule.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expiryRule.d.mts","sourceRoot":"","sources":["../../../src/decodePermission/decoders/expiryRule.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAoB;AAG/C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,EAAE,WAiBxB,CAAC"}

package/dist/decodePermission/decoders/expiryRule.mjs

@@ -0,0 +1,31 @@
+import { EXECUTION_PERMISSION_EXPIRY_RULE_TYPE } from "../../constants.mjs";
+import { extractExpiryFromCaveatTerms, getTermsByEnforcer } from "../utils.mjs";
+/**
+ * Rule decoder that extracts the expiry timestamp from a TimestampEnforcer
+ * caveat, when present. Returns a standard {@link Rule} so that
+ * `makePermissionDecoder` can append it to the decoded permission's `rules`
+ * array. The decoder body additionally hoists the timestamp onto the
+ * top-level `expiry` field of the response.
+ *
+ * @param args - The arguments to this function.
+ * @param args.contractAddresses - Checksummed enforcer addresses for the chain.
+ * @param args.caveats - Checksummed caveats from the delegation.
+ * @returns A `{ type: 'expiry', data: { timestamp } }` rule when a
+ * TimestampEnforcer caveat exists, otherwise `null`.
+ */
+export const expiryRule = ({ contractAddresses, caveats }) => {
+    const { timestampEnforcer } = contractAddresses;
+    const expiryTerms = getTermsByEnforcer({
+        caveats,
+        enforcer: timestampEnforcer,
+        throwIfNotFound: false,
+    });
+    if (!expiryTerms) {
+        return null;
+    }
+    return {
+        type: EXECUTION_PERMISSION_EXPIRY_RULE_TYPE,
+        data: { timestamp: extractExpiryFromCaveatTerms(expiryTerms) },
+    };
+};
+//# sourceMappingURL=expiryRule.mjs.map

package/dist/decodePermission/decoders/expiryRule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"expiryRule.mjs","sourceRoot":"","sources":["../../../src/decodePermission/decoders/expiryRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qCAAqC,EAAE,4BAA2B;AAE3E,OAAO,EAAE,4BAA4B,EAAE,kBAAkB,EAAE,qBAAoB;AAE/E;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,UAAU,GAAgB,CAAC,EAAE,iBAAiB,EAAE,OAAO,EAAE,EAAE,EAAE;IACxE,MAAM,EAAE,iBAAiB,EAAE,GAAG,iBAAiB,CAAC;IAEhD,MAAM,WAAW,GAAG,kBAAkB,CAAC;QACrC,OAAO;QACP,QAAQ,EAAE,iBAAiB;QAC3B,eAAe,EAAE,KAAK;KACvB,CAAC,CAAC;IAEH,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO;QACL,IAAI,EAAE,qCAAqC;QAC3C,IAAI,EAAE,EAAE,SAAS,EAAE,4BAA4B,CAAC,WAAW,CAAC,EAAE;KAC/D,CAAC;AACJ,CAAC,CAAC","sourcesContent":["import { EXECUTION_PERMISSION_EXPIRY_RULE_TYPE } from '../../constants.js';\nimport type { RuleDecoder } from '../types.js';\nimport { extractExpiryFromCaveatTerms, getTermsByEnforcer } from '../utils.js';\n\n/**\n * Rule decoder that extracts the expiry timestamp from a TimestampEnforcer\n * caveat, when present. Returns a standard {@link Rule} so that\n * `makePermissionDecoder` can append it to the decoded permission's `rules`\n * array. The decoder body additionally hoists the timestamp onto the\n * top-level `expiry` field of the response.\n *\n * @param args - The arguments to this function.\n * @param args.contractAddresses - Checksummed enforcer addresses for the chain.\n * @param args.caveats - Checksummed caveats from the delegation.\n * @returns A `{ type: 'expiry', data: { timestamp } }` rule when a\n * TimestampEnforcer caveat exists, otherwise `null`.\n */\nexport const expiryRule: RuleDecoder = ({ contractAddresses, caveats }) => {\n  const { timestampEnforcer } = contractAddresses;\n\n  const expiryTerms = getTermsByEnforcer({\n    caveats,\n    enforcer: timestampEnforcer,\n    throwIfNotFound: false,\n  });\n\n  if (!expiryTerms) {\n    return null;\n  }\n\n  return {\n    type: EXECUTION_PERMISSION_EXPIRY_RULE_TYPE,\n    data: { timestamp: extractExpiryFromCaveatTerms(expiryTerms) },\n  };\n};\n"]}

package/dist/decodePermission/decoders/index.cjs

@@ -1,8 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPermissionDecodersForContracts = void 0;
-const _7715_permission_types_1 = require("@metamask/7715-permission-types");
+const utils_js_1 = require("../utils.cjs");
+const erc20TokenAllowance_js_1 = require("./erc20TokenAllowance.cjs");
+const erc20TokenPeriodic_js_1 = require("./erc20TokenPeriodic.cjs");
+const erc20TokenRevocation_js_1 = require("./erc20TokenRevocation.cjs");
+const erc20TokenStream_js_1 = require("./erc20TokenStream.cjs");
 const makePermissionDecoder_js_1 = require("./makePermissionDecoder.cjs");
+const nativeTokenAllowance_js_1 = require("./nativeTokenAllowance.cjs");
+const nativeTokenPeriodic_js_1 = require("./nativeTokenPeriodic.cjs");
+const nativeTokenStream_js_1 = require("./nativeTokenStream.cjs");
+const tokenApprovalRevocation_js_1 = require("./tokenApprovalRevocation.cjs");
 /**
  * Builds the canonical set of permission decoders for a chain.
  *
@@ -10,17 +18,22 @@ const makePermissionDecoder_js_1 = require("./makePermissionDecoder.cjs");
  * and provides `caveatAddressesMatch` and `validateAndDecodePermission` so the
  * entire decode flow can be driven by the decoders.
  *
- * `contracts` should already be checksummed (see {@link toEnforcerAddressesByName}).
- * `makePermissionDecoderConfigs` checksums them again, and {@link makePermissionDecoder}
- * normalizes enforcer sets once more — see the module comment in
- * `makePermissionDecoder.ts` for why checksumming is layered this way.
- *
- * @param contracts - The deployed enforcer addresses for the chain.
+ * @param contracts - The deployed contracts for the chain.
  * @returns A list of permission decoders used to identify and decode permission types.
  * @throws Propagates any errors from resolving enforcer addresses.
  */
 const createPermissionDecodersForContracts = (contracts) => {
-    return (0, _7715_permission_types_1.makePermissionDecoderConfigs)(contracts).map(makePermissionDecoder_js_1.makePermissionDecoder);
+    const contractAddresses = (0, utils_js_1.getChecksumEnforcersByChainId)(contracts);
+    return [
+        (0, nativeTokenStream_js_1.makeNativeTokenStreamDecoderConfig)(contractAddresses),
+        (0, nativeTokenPeriodic_js_1.makeNativeTokenPeriodicDecoderConfig)(contractAddresses),
+        (0, nativeTokenAllowance_js_1.makeNativeTokenAllowanceDecoderConfig)(contractAddresses),
+        (0, erc20TokenStream_js_1.makeErc20TokenStreamDecoderConfig)(contractAddresses),
+        (0, erc20TokenPeriodic_js_1.makeErc20TokenPeriodicDecoderConfig)(contractAddresses),
+        (0, erc20TokenAllowance_js_1.makeErc20TokenAllowanceDecoderConfig)(contractAddresses),
+        (0, erc20TokenRevocation_js_1.makeErc20TokenRevocationDecoderConfig)(contractAddresses),
+        (0, tokenApprovalRevocation_js_1.makeTokenApprovalRevocationDecoderConfig)(contractAddresses),
+    ].map(makePermissionDecoder_js_1.makePermissionDecoder);
 };
 exports.createPermissionDecodersForContracts = createPermissionDecodersForContracts;
 //# sourceMappingURL=index.cjs.map

package/dist/decodePermission/decoders/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../../../src/decodePermission/decoders/index.ts"],"names":[],"mappings":";;;AAAA,4EAA+E;AAI/E,0EAAmE;AAEnE;;;;;;;;;;;;;;;GAeG;AACI,MAAM,oCAAoC,GAAG,CAClD,SAAkC,EACb,EAAE;IACvB,OAAO,IAAA,qDAA4B,EAAC,SAAS,CAAC,CAAC,GAAG,CAAC,gDAAqB,CAAC,CAAC;AAC5E,CAAC,CAAC;AAJW,QAAA,oCAAoC,wCAI/C","sourcesContent":["import { makePermissionDecoderConfigs } from '@metamask/7715-permission-types';\nimport type { EnforcerAddressesByName } from '@metamask/7715-permission-types';\n\nimport type { PermissionDecoder } from '../types.js';\nimport { makePermissionDecoder } from './makePermissionDecoder.js';\n\n/**\n * Builds the canonical set of permission decoders for a chain.\n *\n * Each decoder specifies the `permissionType`, required/optional enforcers,\n * and provides `caveatAddressesMatch` and `validateAndDecodePermission` so the\n * entire decode flow can be driven by the decoders.\n *\n * `contracts` should already be checksummed (see {@link toEnforcerAddressesByName}).\n * `makePermissionDecoderConfigs` checksums them again, and {@link makePermissionDecoder}\n * normalizes enforcer sets once more — see the module comment in\n * `makePermissionDecoder.ts` for why checksumming is layered this way.\n *\n * @param contracts - The deployed enforcer addresses for the chain.\n * @returns A list of permission decoders used to identify and decode permission types.\n * @throws Propagates any errors from resolving enforcer addresses.\n */\nexport const createPermissionDecodersForContracts = (\n  contracts: EnforcerAddressesByName,\n): PermissionDecoder[] => {\n  return makePermissionDecoderConfigs(contracts).map(makePermissionDecoder);\n};\n"]}
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../../../src/decodePermission/decoders/index.ts"],"names":[],"mappings":";;;AACA,2CAA4D;AAC5D,sEAAgF;AAChF,oEAA8E;AAC9E,wEAAkF;AAClF,gEAA0E;AAC1E,0EAAmE;AACnE,wEAAkF;AAClF,sEAAgF;AAChF,kEAA4E;AAC5E,8EAAwF;AAExF;;;;;;;;;;GAUG;AACI,MAAM,oCAAoC,GAAG,CAClD,SAAkC,EACb,EAAE;IACvB,MAAM,iBAAiB,GAAG,IAAA,wCAA6B,EAAC,SAAS,CAAC,CAAC;IACnE,OAAO;QACL,IAAA,yDAAkC,EAAC,iBAAiB,CAAC;QACrD,IAAA,6DAAoC,EAAC,iBAAiB,CAAC;QACvD,IAAA,+DAAqC,EAAC,iBAAiB,CAAC;QACxD,IAAA,uDAAiC,EAAC,iBAAiB,CAAC;QACpD,IAAA,2DAAmC,EAAC,iBAAiB,CAAC;QACtD,IAAA,6DAAoC,EAAC,iBAAiB,CAAC;QACvD,IAAA,+DAAqC,EAAC,iBAAiB,CAAC;QACxD,IAAA,qEAAwC,EAAC,iBAAiB,CAAC;KAC5D,CAAC,GAAG,CAAC,gDAAqB,CAAC,CAAC;AAC/B,CAAC,CAAC;AAdW,QAAA,oCAAoC,wCAc/C","sourcesContent":["import type { DeployedContractsByName, PermissionDecoder } from '../types.js';\nimport { getChecksumEnforcersByChainId } from '../utils.js';\nimport { makeErc20TokenAllowanceDecoderConfig } from './erc20TokenAllowance.js';\nimport { makeErc20TokenPeriodicDecoderConfig } from './erc20TokenPeriodic.js';\nimport { makeErc20TokenRevocationDecoderConfig } from './erc20TokenRevocation.js';\nimport { makeErc20TokenStreamDecoderConfig } from './erc20TokenStream.js';\nimport { makePermissionDecoder } from './makePermissionDecoder.js';\nimport { makeNativeTokenAllowanceDecoderConfig } from './nativeTokenAllowance.js';\nimport { makeNativeTokenPeriodicDecoderConfig } from './nativeTokenPeriodic.js';\nimport { makeNativeTokenStreamDecoderConfig } from './nativeTokenStream.js';\nimport { makeTokenApprovalRevocationDecoderConfig } from './tokenApprovalRevocation.js';\n\n/**\n * Builds the canonical set of permission decoders for a chain.\n *\n * Each decoder specifies the `permissionType`, required/optional enforcers,\n * and provides `caveatAddressesMatch` and `validateAndDecodePermission` so the\n * entire decode flow can be driven by the decoders.\n *\n * @param contracts - The deployed contracts for the chain.\n * @returns A list of permission decoders used to identify and decode permission types.\n * @throws Propagates any errors from resolving enforcer addresses.\n */\nexport const createPermissionDecodersForContracts = (\n  contracts: DeployedContractsByName,\n): PermissionDecoder[] => {\n  const contractAddresses = getChecksumEnforcersByChainId(contracts);\n  return [\n    makeNativeTokenStreamDecoderConfig(contractAddresses),\n    makeNativeTokenPeriodicDecoderConfig(contractAddresses),\n    makeNativeTokenAllowanceDecoderConfig(contractAddresses),\n    makeErc20TokenStreamDecoderConfig(contractAddresses),\n    makeErc20TokenPeriodicDecoderConfig(contractAddresses),\n    makeErc20TokenAllowanceDecoderConfig(contractAddresses),\n    makeErc20TokenRevocationDecoderConfig(contractAddresses),\n    makeTokenApprovalRevocationDecoderConfig(contractAddresses),\n  ].map(makePermissionDecoder);\n};\n"]}

package/dist/decodePermission/decoders/index.d.cts

@@ -1,5 +1,4 @@
-import type { EnforcerAddressesByName } from "@metamask/7715-permission-types";
-import type { PermissionDecoder } from "../types.cjs";
+import type { DeployedContractsByName, PermissionDecoder } from "../types.cjs";
 /**
  * Builds the canonical set of permission decoders for a chain.
  *
@@ -7,14 +6,9 @@ import type { PermissionDecoder } from "../types.cjs";
  * and provides `caveatAddressesMatch` and `validateAndDecodePermission` so the
  * entire decode flow can be driven by the decoders.
  *
- * `contracts` should already be checksummed (see {@link toEnforcerAddressesByName}).
- * `makePermissionDecoderConfigs` checksums them again, and {@link makePermissionDecoder}
- * normalizes enforcer sets once more — see the module comment in
- * `makePermissionDecoder.ts` for why checksumming is layered this way.
- *
- * @param contracts - The deployed enforcer addresses for the chain.
+ * @param contracts - The deployed contracts for the chain.
  * @returns A list of permission decoders used to identify and decode permission types.
  * @throws Propagates any errors from resolving enforcer addresses.
  */
-export declare const createPermissionDecodersForContracts: (contracts: EnforcerAddressesByName) => PermissionDecoder[];
+export declare const createPermissionDecodersForContracts: (contracts: DeployedContractsByName) => PermissionDecoder[];
 //# sourceMappingURL=index.d.cts.map

package/dist/decodePermission/decoders/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../../../src/decodePermission/decoders/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,wCAAwC;AAE/E,OAAO,KAAK,EAAE,iBAAiB,EAAE,qBAAoB;AAGrD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oCAAoC,cACpC,uBAAuB,KACjC,iBAAiB,EAEnB,CAAC"}
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../../../src/decodePermission/decoders/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,qBAAoB;AAY9E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oCAAoC,cACpC,uBAAuB,KACjC,iBAAiB,EAYnB,CAAC"}

package/dist/decodePermission/decoders/index.d.mts

@@ -1,5 +1,4 @@
-import type { EnforcerAddressesByName } from "@metamask/7715-permission-types";
-import type { PermissionDecoder } from "../types.mjs";
+import type { DeployedContractsByName, PermissionDecoder } from "../types.mjs";
 /**
  * Builds the canonical set of permission decoders for a chain.
  *
@@ -7,14 +6,9 @@ import type { PermissionDecoder } from "../types.mjs";
  * and provides `caveatAddressesMatch` and `validateAndDecodePermission` so the
  * entire decode flow can be driven by the decoders.
  *
- * `contracts` should already be checksummed (see {@link toEnforcerAddressesByName}).
- * `makePermissionDecoderConfigs` checksums them again, and {@link makePermissionDecoder}
- * normalizes enforcer sets once more — see the module comment in
- * `makePermissionDecoder.ts` for why checksumming is layered this way.
- *
- * @param contracts - The deployed enforcer addresses for the chain.
+ * @param contracts - The deployed contracts for the chain.
  * @returns A list of permission decoders used to identify and decode permission types.
  * @throws Propagates any errors from resolving enforcer addresses.
  */
-export declare const createPermissionDecodersForContracts: (contracts: EnforcerAddressesByName) => PermissionDecoder[];
+export declare const createPermissionDecodersForContracts: (contracts: DeployedContractsByName) => PermissionDecoder[];
 //# sourceMappingURL=index.d.mts.map

package/dist/decodePermission/decoders/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/decodePermission/decoders/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,wCAAwC;AAE/E,OAAO,KAAK,EAAE,iBAAiB,EAAE,qBAAoB;AAGrD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oCAAoC,cACpC,uBAAuB,KACjC,iBAAiB,EAEnB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/decodePermission/decoders/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,qBAAoB;AAY9E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oCAAoC,cACpC,uBAAuB,KACjC,iBAAiB,EAYnB,CAAC"}

package/dist/decodePermission/decoders/index.mjs

@@ -1,5 +1,13 @@
-import { makePermissionDecoderConfigs } from "@metamask/7715-permission-types";
+import { getChecksumEnforcersByChainId } from "../utils.mjs";
+import { makeErc20TokenAllowanceDecoderConfig } from "./erc20TokenAllowance.mjs";
+import { makeErc20TokenPeriodicDecoderConfig } from "./erc20TokenPeriodic.mjs";
+import { makeErc20TokenRevocationDecoderConfig } from "./erc20TokenRevocation.mjs";
+import { makeErc20TokenStreamDecoderConfig } from "./erc20TokenStream.mjs";
 import { makePermissionDecoder } from "./makePermissionDecoder.mjs";
+import { makeNativeTokenAllowanceDecoderConfig } from "./nativeTokenAllowance.mjs";
+import { makeNativeTokenPeriodicDecoderConfig } from "./nativeTokenPeriodic.mjs";
+import { makeNativeTokenStreamDecoderConfig } from "./nativeTokenStream.mjs";
+import { makeTokenApprovalRevocationDecoderConfig } from "./tokenApprovalRevocation.mjs";
 /**
  * Builds the canonical set of permission decoders for a chain.
  *
@@ -7,16 +15,21 @@ import { makePermissionDecoder } from "./makePermissionDecoder.mjs";
  * and provides `caveatAddressesMatch` and `validateAndDecodePermission` so the
  * entire decode flow can be driven by the decoders.
  *
- * `contracts` should already be checksummed (see {@link toEnforcerAddressesByName}).
- * `makePermissionDecoderConfigs` checksums them again, and {@link makePermissionDecoder}
- * normalizes enforcer sets once more — see the module comment in
- * `makePermissionDecoder.ts` for why checksumming is layered this way.
- *
- * @param contracts - The deployed enforcer addresses for the chain.
+ * @param contracts - The deployed contracts for the chain.
  * @returns A list of permission decoders used to identify and decode permission types.
  * @throws Propagates any errors from resolving enforcer addresses.
  */
 export const createPermissionDecodersForContracts = (contracts) => {
-    return makePermissionDecoderConfigs(contracts).map(makePermissionDecoder);
+    const contractAddresses = getChecksumEnforcersByChainId(contracts);
+    return [
+        makeNativeTokenStreamDecoderConfig(contractAddresses),
+        makeNativeTokenPeriodicDecoderConfig(contractAddresses),
+        makeNativeTokenAllowanceDecoderConfig(contractAddresses),
+        makeErc20TokenStreamDecoderConfig(contractAddresses),
+        makeErc20TokenPeriodicDecoderConfig(contractAddresses),
+        makeErc20TokenAllowanceDecoderConfig(contractAddresses),
+        makeErc20TokenRevocationDecoderConfig(contractAddresses),
+        makeTokenApprovalRevocationDecoderConfig(contractAddresses),
+    ].map(makePermissionDecoder);
 };
 //# sourceMappingURL=index.mjs.map

package/dist/decodePermission/decoders/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../src/decodePermission/decoders/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,wCAAwC;AAI/E,OAAO,EAAE,qBAAqB,EAAE,oCAAmC;AAEnE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAAG,CAClD,SAAkC,EACb,EAAE;IACvB,OAAO,4BAA4B,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;AAC5E,CAAC,CAAC","sourcesContent":["import { makePermissionDecoderConfigs } from '@metamask/7715-permission-types';\nimport type { EnforcerAddressesByName } from '@metamask/7715-permission-types';\n\nimport type { PermissionDecoder } from '../types.js';\nimport { makePermissionDecoder } from './makePermissionDecoder.js';\n\n/**\n * Builds the canonical set of permission decoders for a chain.\n *\n * Each decoder specifies the `permissionType`, required/optional enforcers,\n * and provides `caveatAddressesMatch` and `validateAndDecodePermission` so the\n * entire decode flow can be driven by the decoders.\n *\n * `contracts` should already be checksummed (see {@link toEnforcerAddressesByName}).\n * `makePermissionDecoderConfigs` checksums them again, and {@link makePermissionDecoder}\n * normalizes enforcer sets once more — see the module comment in\n * `makePermissionDecoder.ts` for why checksumming is layered this way.\n *\n * @param contracts - The deployed enforcer addresses for the chain.\n * @returns A list of permission decoders used to identify and decode permission types.\n * @throws Propagates any errors from resolving enforcer addresses.\n */\nexport const createPermissionDecodersForContracts = (\n  contracts: EnforcerAddressesByName,\n): PermissionDecoder[] => {\n  return makePermissionDecoderConfigs(contracts).map(makePermissionDecoder);\n};\n"]}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../src/decodePermission/decoders/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,6BAA6B,EAAE,qBAAoB;AAC5D,OAAO,EAAE,oCAAoC,EAAE,kCAAiC;AAChF,OAAO,EAAE,mCAAmC,EAAE,iCAAgC;AAC9E,OAAO,EAAE,qCAAqC,EAAE,mCAAkC;AAClF,OAAO,EAAE,iCAAiC,EAAE,+BAA8B;AAC1E,OAAO,EAAE,qBAAqB,EAAE,oCAAmC;AACnE,OAAO,EAAE,qCAAqC,EAAE,mCAAkC;AAClF,OAAO,EAAE,oCAAoC,EAAE,kCAAiC;AAChF,OAAO,EAAE,kCAAkC,EAAE,gCAA+B;AAC5E,OAAO,EAAE,wCAAwC,EAAE,sCAAqC;AAExF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAAG,CAClD,SAAkC,EACb,EAAE;IACvB,MAAM,iBAAiB,GAAG,6BAA6B,CAAC,SAAS,CAAC,CAAC;IACnE,OAAO;QACL,kCAAkC,CAAC,iBAAiB,CAAC;QACrD,oCAAoC,CAAC,iBAAiB,CAAC;QACvD,qCAAqC,CAAC,iBAAiB,CAAC;QACxD,iCAAiC,CAAC,iBAAiB,CAAC;QACpD,mCAAmC,CAAC,iBAAiB,CAAC;QACtD,oCAAoC,CAAC,iBAAiB,CAAC;QACvD,qCAAqC,CAAC,iBAAiB,CAAC;QACxD,wCAAwC,CAAC,iBAAiB,CAAC;KAC5D,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;AAC/B,CAAC,CAAC","sourcesContent":["import type { DeployedContractsByName, PermissionDecoder } from '../types.js';\nimport { getChecksumEnforcersByChainId } from '../utils.js';\nimport { makeErc20TokenAllowanceDecoderConfig } from './erc20TokenAllowance.js';\nimport { makeErc20TokenPeriodicDecoderConfig } from './erc20TokenPeriodic.js';\nimport { makeErc20TokenRevocationDecoderConfig } from './erc20TokenRevocation.js';\nimport { makeErc20TokenStreamDecoderConfig } from './erc20TokenStream.js';\nimport { makePermissionDecoder } from './makePermissionDecoder.js';\nimport { makeNativeTokenAllowanceDecoderConfig } from './nativeTokenAllowance.js';\nimport { makeNativeTokenPeriodicDecoderConfig } from './nativeTokenPeriodic.js';\nimport { makeNativeTokenStreamDecoderConfig } from './nativeTokenStream.js';\nimport { makeTokenApprovalRevocationDecoderConfig } from './tokenApprovalRevocation.js';\n\n/**\n * Builds the canonical set of permission decoders for a chain.\n *\n * Each decoder specifies the `permissionType`, required/optional enforcers,\n * and provides `caveatAddressesMatch` and `validateAndDecodePermission` so the\n * entire decode flow can be driven by the decoders.\n *\n * @param contracts - The deployed contracts for the chain.\n * @returns A list of permission decoders used to identify and decode permission types.\n * @throws Propagates any errors from resolving enforcer addresses.\n */\nexport const createPermissionDecodersForContracts = (\n  contracts: DeployedContractsByName,\n): PermissionDecoder[] => {\n  const contractAddresses = getChecksumEnforcersByChainId(contracts);\n  return [\n    makeNativeTokenStreamDecoderConfig(contractAddresses),\n    makeNativeTokenPeriodicDecoderConfig(contractAddresses),\n    makeNativeTokenAllowanceDecoderConfig(contractAddresses),\n    makeErc20TokenStreamDecoderConfig(contractAddresses),\n    makeErc20TokenPeriodicDecoderConfig(contractAddresses),\n    makeErc20TokenAllowanceDecoderConfig(contractAddresses),\n    makeErc20TokenRevocationDecoderConfig(contractAddresses),\n    makeTokenApprovalRevocationDecoderConfig(contractAddresses),\n  ].map(makePermissionDecoder);\n};\n"]}

package/dist/decodePermission/decoders/makePermissionDecoder.cjs

@@ -4,39 +4,13 @@ exports.makePermissionDecoder = void 0;
 const utils_1 = require("@metamask/utils");
 const constants_js_1 = require("../../constants.cjs");
 const utils_js_1 = require("../utils.cjs");
-/**
- * Address checksumming in the permission decode flow.
- *
- * Enforcer addresses come from three sources, each of which may use a
- * different hex encoding (EIP-55 checksummed vs lowercase). Comparisons rely
- * on strict equality, so we normalize at function boundaries instead of
- * requiring callers to pass a specific encoding. `getChecksumAddress` is
- * idempotent, so repeated normalization is intentional and cheap.
- *
- * 1. **Canonical contract addresses** (`EnforcerAddressesByName`): normalized
- *    in {@link toEnforcerAddressesByName}, again in
- *    `makePermissionDecoderConfigs` (`checksumEnforcerAddresses` in
- *    `@metamask/7715-permission-types`), and once more below when building
- *    each decoder's required/optional enforcer sets.
- *
- * 2. **Delegation caveat enforcers**: read from the encoded permission
- *    context with unpredictable casing. Normalized in
- *    {@link buildEnforcerCountsAndSet} during address matching and again in
- *    `validateAndDecodePermission` before term decoding (rule decoders and
- *    `getTermsByEnforcer` compare enforcer addresses with `===`).
- *
- * 3. **Decoder required/optional enforcers**: populated from contract
- *    addresses by `makePermissionDecoderConfigs`; normalized at decoder
- *    construction so `caveatAddressesMatch` compares like-for-like with
- *    caveat addresses from source (2).
- */
 /**
  * Creates a single {@link PermissionDecoder} with the given type, enforcer
  * sets, rule decoders, and decode/validate callback.
  *
  * @param config - The configuration describing the permission type's
  * enforcers, rule decoders, and data decoder. See
- * {@link PermissionDecoderConfig} for field documentation.
+ * {@link MakePermissionDecoderConfig} for field documentation.
  * @param config.permissionType - The type of permission to decode.
  * @param config.contractAddresses - Checksummed enforcer addresses for the chain.
  * @param config.optionalEnforcers - Optional enforcers for the permission.
@@ -47,11 +21,8 @@ const utils_js_1 = require("../utils.cjs");
  * `validateAndDecodePermission`.
  */
 function makePermissionDecoder({ permissionType, contractAddresses, optionalEnforcers, requiredEnforcers, rules, validateAndDecodeData, }) {
-    const optionalEnforcersSet = new Set(optionalEnforcers.map(utils_1.getChecksumAddress));
-    const requiredEnforcersMap = new Map(Object.entries(requiredEnforcers).map(([enforcer, count]) => [
-        (0, utils_1.getChecksumAddress)(enforcer),
-        count,
-    ]));
+    const optionalEnforcersSet = new Set(optionalEnforcers);
+    const requiredEnforcersMap = new Map(Object.entries(requiredEnforcers));
     const caveatAddressesMatch = (caveatAddresses) => {
         const { counts, enforcersSet } = (0, utils_js_1.buildEnforcerCountsAndSet)(caveatAddresses);
         return (0, utils_js_1.enforcersMatchRule)(counts, enforcersSet, requiredEnforcersMap, optionalEnforcersSet);

package/dist/decodePermission/decoders/makePermissionDecoder.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"makePermissionDecoder.cjs","sourceRoot":"","sources":["../../../src/decodePermission/decoders/makePermissionDecoder.ts"],"names":[],"mappings":";;;AAKA,2CAAwE;AAGxE,sDAA2E;AAE3E,2CAA4E;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,qBAAqB,CAAC,EACpC,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,KAAK,EACL,qBAAqB,GACG;IACxB,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAClC,iBAAiB,CAAC,GAAG,CAAC,0BAAkB,CAAC,CAC1C,CAAC;IACF,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAClC,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC;QAC3D,IAAA,0BAAkB,EAAC,QAAe,CAAC;QACnC,KAAK;KACN,CAAC,CACH,CAAC;IAEF,MAAM,oBAAoB,GAAG,CAAC,eAAsB,EAAW,EAAE;QAC/D,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,IAAA,oCAAyB,EAAC,eAAe,CAAC,CAAC;QAE5E,OAAO,IAAA,6BAAkB,EACvB,MAAM,EACN,YAAY,EACZ,oBAAoB,EACpB,oBAAoB,CACrB,CAAC;IACJ,CAAC,CAAC;IAEF,MAAM,2BAA2B,GAAG,CAClC,OAAsB,EACG,EAAE;QAC3B,MAAM,eAAe,GAAkB,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;YAC9D,GAAG,MAAM;YACT,QAAQ,EAAE,IAAA,0BAAkB,EAAC,MAAM,CAAC,QAAQ,CAAC;SAC9C,CAAC,CAAC,CAAC;QACJ,IAAI,CAAC;YACH,MAAM,YAAY,GAAG,eAAe,CAAC,MAAM;YACzC,8DAA8D;YAC9D,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,KAAK,KAAK,IAAI,IAAI,CAAC,IAAA,yBAAiB,EAAC,KAAK,CAAC,CAC3D,CAAC;YAEF,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC5B,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;YACzD,CAAC;YAED,IAAI,MAAM,GAAkB,IAAI,CAAC;YACjC,MAAM,YAAY,GAAW,EAAE,CAAC;YAEhC,KAAK,MAAM,MAAM,IAAI,KAAK,EAAE,CAAC;gBAC3B,MAAM,IAAI,GAAG,MAAM,CAAC;oBAClB,iBAAiB;oBACjB,OAAO,EAAE,eAAe;oBACxB,iBAAiB,EAAE,oBAAoB;iBACxC,CAAC,CAAC;gBAEH,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;oBAClB,SAAS;gBACX,CAAC;gBAED,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAExB,IAAI,IAAI,CAAC,IAAI,KAAK,oDAAqC,EAAE,CAAC;oBACxD,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,SAAmB,CAAC;gBACzC,CAAC;YACH,CAAC;YAED,MAAM,IAAI,GAAG,qBAAqB,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAAC;YAEvE,OAAO;gBACL,OAAO,EAAE,IAAI;gBACb,MAAM;gBACN,IAAI;gBACJ,KAAK,EAAE,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS;aAC1D,CAAC;QACJ,CAAC;QAAC,OAAO,WAAW,EAAE,CAAC;YACrB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,WAAoB,EAAE,CAAC;QACzD,CAAC;IACH,CAAC,CAAC;IAEF,OAAO;QACL,cAAc;QACd,oBAAoB;QACpB,2BAA2B;QAC3B,iBAAiB,EAAE,oBAAoB;QACvC,iBAAiB,EAAE,oBAAoB;KACxC,CAAC;AACJ,CAAC;AAvFD,sDAuFC","sourcesContent":["import type {\n  PermissionDecoderConfig,\n  Rule,\n} from '@metamask/7715-permission-types';\nimport type { Caveat } from '@metamask/delegation-core';\nimport { getChecksumAddress, isStrictHexString } from '@metamask/utils';\nimport type { Hex } from '@metamask/utils';\n\nimport { EXECUTION_PERMISSION_EXPIRY_RULE_TYPE } from '../../constants.js';\nimport type { PermissionDecoder, ValidateAndDecodeResult } from '../types.js';\nimport { buildEnforcerCountsAndSet, enforcersMatchRule } from '../utils.js';\n\n/**\n * Address checksumming in the permission decode flow.\n *\n * Enforcer addresses come from three sources, each of which may use a\n * different hex encoding (EIP-55 checksummed vs lowercase). Comparisons rely\n * on strict equality, so we normalize at function boundaries instead of\n * requiring callers to pass a specific encoding. `getChecksumAddress` is\n * idempotent, so repeated normalization is intentional and cheap.\n *\n * 1. **Canonical contract addresses** (`EnforcerAddressesByName`): normalized\n *    in {@link toEnforcerAddressesByName}, again in\n *    `makePermissionDecoderConfigs` (`checksumEnforcerAddresses` in\n *    `@metamask/7715-permission-types`), and once more below when building\n *    each decoder's required/optional enforcer sets.\n *\n * 2. **Delegation caveat enforcers**: read from the encoded permission\n *    context with unpredictable casing. Normalized in\n *    {@link buildEnforcerCountsAndSet} during address matching and again in\n *    `validateAndDecodePermission` before term decoding (rule decoders and\n *    `getTermsByEnforcer` compare enforcer addresses with `===`).\n *\n * 3. **Decoder required/optional enforcers**: populated from contract\n *    addresses by `makePermissionDecoderConfigs`; normalized at decoder\n *    construction so `caveatAddressesMatch` compares like-for-like with\n *    caveat addresses from source (2).\n */\n\n/**\n * Creates a single {@link PermissionDecoder} with the given type, enforcer\n * sets, rule decoders, and decode/validate callback.\n *\n * @param config - The configuration describing the permission type's\n * enforcers, rule decoders, and data decoder. See\n * {@link PermissionDecoderConfig} for field documentation.\n * @param config.permissionType - The type of permission to decode.\n * @param config.contractAddresses - Checksummed enforcer addresses for the chain.\n * @param config.optionalEnforcers - Optional enforcers for the permission.\n * @param config.requiredEnforcers - Required enforcers for the permission.\n * @param config.rules - Rule decoders for the permission.\n * @param config.validateAndDecodeData - Data decoder for the permission.\n * @returns A {@link PermissionDecoder} with `caveatAddressesMatch` and\n * `validateAndDecodePermission`.\n */\nexport function makePermissionDecoder({\n  permissionType,\n  contractAddresses,\n  optionalEnforcers,\n  requiredEnforcers,\n  rules,\n  validateAndDecodeData,\n}: PermissionDecoderConfig): PermissionDecoder {\n  const optionalEnforcersSet = new Set(\n    optionalEnforcers.map(getChecksumAddress),\n  );\n  const requiredEnforcersMap = new Map(\n    Object.entries(requiredEnforcers).map(([enforcer, count]) => [\n      getChecksumAddress(enforcer as Hex),\n      count,\n    ]),\n  );\n\n  const caveatAddressesMatch = (caveatAddresses: Hex[]): boolean => {\n    const { counts, enforcersSet } = buildEnforcerCountsAndSet(caveatAddresses);\n\n    return enforcersMatchRule(\n      counts,\n      enforcersSet,\n      requiredEnforcersMap,\n      optionalEnforcersSet,\n    );\n  };\n\n  const validateAndDecodePermission = (\n    caveats: Caveat<Hex>[],\n  ): ValidateAndDecodeResult => {\n    const checksumCaveats: Caveat<Hex>[] = caveats.map((caveat) => ({\n      ...caveat,\n      enforcer: getChecksumAddress(caveat.enforcer),\n    }));\n    try {\n      const invalidTerms = checksumCaveats.filter(\n        // isStrictHexString rejects '0x' which is a valid terms value\n        ({ terms }) => terms !== '0x' && !isStrictHexString(terms),\n      );\n\n      if (invalidTerms.length > 0) {\n        throw new Error('Invalid terms: must be a hex string');\n      }\n\n      let expiry: number | null = null;\n      const decodedRules: Rule[] = [];\n\n      for (const decode of rules) {\n        const rule = decode({\n          contractAddresses,\n          caveats: checksumCaveats,\n          requiredEnforcers: requiredEnforcersMap,\n        });\n\n        if (rule === null) {\n          continue;\n        }\n\n        decodedRules.push(rule);\n\n        if (rule.type === EXECUTION_PERMISSION_EXPIRY_RULE_TYPE) {\n          expiry = rule.data.timestamp as number;\n        }\n      }\n\n      const data = validateAndDecodeData(checksumCaveats, contractAddresses);\n\n      return {\n        isValid: true,\n        expiry,\n        data,\n        rules: decodedRules.length > 0 ? decodedRules : undefined,\n      };\n    } catch (caughtError) {\n      return { isValid: false, error: caughtError as Error };\n    }\n  };\n\n  return {\n    permissionType,\n    caveatAddressesMatch,\n    validateAndDecodePermission,\n    optionalEnforcers: optionalEnforcersSet,\n    requiredEnforcers: requiredEnforcersMap,\n  };\n}\n"]}
+{"version":3,"file":"makePermissionDecoder.cjs","sourceRoot":"","sources":["../../../src/decodePermission/decoders/makePermissionDecoder.ts"],"names":[],"mappings":";;;AAEA,2CAAwE;AAGxE,sDAA2E;AAU3E,2CAA4E;AAoB5E;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,qBAAqB,CAAC,EACpC,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,KAAK,EACL,qBAAqB,GACO;IAC5B,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAAC,iBAAiB,CAAC,CAAC;IACxD,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAClC,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,CACd,CAAC;IAEtB,MAAM,oBAAoB,GAAG,CAAC,eAAsB,EAAW,EAAE;QAC/D,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,IAAA,oCAAyB,EAAC,eAAe,CAAC,CAAC;QAE5E,OAAO,IAAA,6BAAkB,EACvB,MAAM,EACN,YAAY,EACZ,oBAAoB,EACpB,oBAAoB,CACrB,CAAC;IACJ,CAAC,CAAC;IAEF,MAAM,2BAA2B,GAAG,CAClC,OAAsB,EACG,EAAE;QAC3B,MAAM,eAAe,GAAqB,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;YACjE,GAAG,MAAM;YACT,QAAQ,EAAE,IAAA,0BAAkB,EAAC,MAAM,CAAC,QAAQ,CAAC;SAC9C,CAAC,CAAC,CAAC;QACJ,IAAI,CAAC;YACH,MAAM,YAAY,GAAG,eAAe,CAAC,MAAM;YACzC,8DAA8D;YAC9D,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,KAAK,KAAK,IAAI,IAAI,CAAC,IAAA,yBAAiB,EAAC,KAAK,CAAC,CAC3D,CAAC;YAEF,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC5B,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;YACzD,CAAC;YAED,IAAI,MAAM,GAAkB,IAAI,CAAC;YACjC,MAAM,YAAY,GAAW,EAAE,CAAC;YAEhC,KAAK,MAAM,MAAM,IAAI,KAAK,EAAE,CAAC;gBAC3B,MAAM,IAAI,GAAG,MAAM,CAAC;oBAClB,iBAAiB;oBACjB,OAAO,EAAE,eAAe;oBACxB,iBAAiB,EAAE,oBAAoB;iBACxC,CAAC,CAAC;gBAEH,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;oBAClB,SAAS;gBACX,CAAC;gBAED,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAExB,IAAI,IAAI,CAAC,IAAI,KAAK,oDAAqC,EAAE,CAAC;oBACxD,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,SAAmB,CAAC;gBACzC,CAAC;YACH,CAAC;YAED,MAAM,IAAI,GAAG,qBAAqB,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAAC;YAEvE,OAAO;gBACL,OAAO,EAAE,IAAI;gBACb,MAAM;gBACN,IAAI;gBACJ,KAAK,EAAE,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS;aAC1D,CAAC;QACJ,CAAC;QAAC,OAAO,WAAW,EAAE,CAAC;YACrB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,WAAoB,EAAE,CAAC;QACzD,CAAC;IACH,CAAC,CAAC;IAEF,OAAO;QACL,cAAc;QACd,oBAAoB;QACpB,2BAA2B;QAC3B,iBAAiB,EAAE,oBAAoB;QACvC,iBAAiB,EAAE,oBAAoB;KACxC,CAAC;AACJ,CAAC;AAlFD,sDAkFC","sourcesContent":["import type { Rule } from '@metamask/7715-permission-types';\nimport type { Caveat } from '@metamask/delegation-core';\nimport { getChecksumAddress, isStrictHexString } from '@metamask/utils';\nimport type { Hex } from '@metamask/utils';\n\nimport { EXECUTION_PERMISSION_EXPIRY_RULE_TYPE } from '../../constants.js';\nimport type {\n  ChecksumCaveat,\n  ChecksumEnforcersByChainId,\n  DecodedPermission,\n  PermissionDecoder,\n  PermissionType,\n  RuleDecoder,\n  ValidateAndDecodeResult,\n} from '../types.js';\nimport { buildEnforcerCountsAndSet, enforcersMatchRule } from '../utils.js';\n\n/**\n * Configuration object describing how to decode a single permission type.\n *\n * Returned by each `make<PermissionType>DecoderConfig` factory and consumed by\n * {@link makePermissionDecoder} to produce a {@link PermissionDecoder}.\n */\nexport type MakePermissionDecoderConfig = {\n  permissionType: PermissionType;\n  contractAddresses: ChecksumEnforcersByChainId;\n  optionalEnforcers: Hex[];\n  requiredEnforcers: Record<Hex, number>;\n  rules: RuleDecoder[];\n  validateAndDecodeData: (\n    caveats: ChecksumCaveat[],\n    contractAddresses: ChecksumEnforcersByChainId,\n  ) => DecodedPermission['permission']['data'];\n};\n\n/**\n * Creates a single {@link PermissionDecoder} with the given type, enforcer\n * sets, rule decoders, and decode/validate callback.\n *\n * @param config - The configuration describing the permission type's\n * enforcers, rule decoders, and data decoder. See\n * {@link MakePermissionDecoderConfig} for field documentation.\n * @param config.permissionType - The type of permission to decode.\n * @param config.contractAddresses - Checksummed enforcer addresses for the chain.\n * @param config.optionalEnforcers - Optional enforcers for the permission.\n * @param config.requiredEnforcers - Required enforcers for the permission.\n * @param config.rules - Rule decoders for the permission.\n * @param config.validateAndDecodeData - Data decoder for the permission.\n * @returns A {@link PermissionDecoder} with `caveatAddressesMatch` and\n * `validateAndDecodePermission`.\n */\nexport function makePermissionDecoder({\n  permissionType,\n  contractAddresses,\n  optionalEnforcers,\n  requiredEnforcers,\n  rules,\n  validateAndDecodeData,\n}: MakePermissionDecoderConfig): PermissionDecoder {\n  const optionalEnforcersSet = new Set(optionalEnforcers);\n  const requiredEnforcersMap = new Map(\n    Object.entries(requiredEnforcers),\n  ) as Map<Hex, number>;\n\n  const caveatAddressesMatch = (caveatAddresses: Hex[]): boolean => {\n    const { counts, enforcersSet } = buildEnforcerCountsAndSet(caveatAddresses);\n\n    return enforcersMatchRule(\n      counts,\n      enforcersSet,\n      requiredEnforcersMap,\n      optionalEnforcersSet,\n    );\n  };\n\n  const validateAndDecodePermission = (\n    caveats: Caveat<Hex>[],\n  ): ValidateAndDecodeResult => {\n    const checksumCaveats: ChecksumCaveat[] = caveats.map((caveat) => ({\n      ...caveat,\n      enforcer: getChecksumAddress(caveat.enforcer),\n    }));\n    try {\n      const invalidTerms = checksumCaveats.filter(\n        // isStrictHexString rejects '0x' which is a valid terms value\n        ({ terms }) => terms !== '0x' && !isStrictHexString(terms),\n      );\n\n      if (invalidTerms.length > 0) {\n        throw new Error('Invalid terms: must be a hex string');\n      }\n\n      let expiry: number | null = null;\n      const decodedRules: Rule[] = [];\n\n      for (const decode of rules) {\n        const rule = decode({\n          contractAddresses,\n          caveats: checksumCaveats,\n          requiredEnforcers: requiredEnforcersMap,\n        });\n\n        if (rule === null) {\n          continue;\n        }\n\n        decodedRules.push(rule);\n\n        if (rule.type === EXECUTION_PERMISSION_EXPIRY_RULE_TYPE) {\n          expiry = rule.data.timestamp as number;\n        }\n      }\n\n      const data = validateAndDecodeData(checksumCaveats, contractAddresses);\n\n      return {\n        isValid: true,\n        expiry,\n        data,\n        rules: decodedRules.length > 0 ? decodedRules : undefined,\n      };\n    } catch (caughtError) {\n      return { isValid: false, error: caughtError as Error };\n    }\n  };\n\n  return {\n    permissionType,\n    caveatAddressesMatch,\n    validateAndDecodePermission,\n    optionalEnforcers: optionalEnforcersSet,\n    requiredEnforcers: requiredEnforcersMap,\n  };\n}\n"]}

package/dist/decodePermission/decoders/makePermissionDecoder.d.cts

@@ -1,38 +1,26 @@
-import type { PermissionDecoderConfig } from "@metamask/7715-permission-types";
-import type { PermissionDecoder } from "../types.cjs";
+import type { Hex } from "@metamask/utils";
+import type { ChecksumCaveat, ChecksumEnforcersByChainId, DecodedPermission, PermissionDecoder, PermissionType, RuleDecoder } from "../types.cjs";
 /**
- * Address checksumming in the permission decode flow.
+ * Configuration object describing how to decode a single permission type.
  *
- * Enforcer addresses come from three sources, each of which may use a
- * different hex encoding (EIP-55 checksummed vs lowercase). Comparisons rely
- * on strict equality, so we normalize at function boundaries instead of
- * requiring callers to pass a specific encoding. `getChecksumAddress` is
- * idempotent, so repeated normalization is intentional and cheap.
- *
- * 1. **Canonical contract addresses** (`EnforcerAddressesByName`): normalized
- *    in {@link toEnforcerAddressesByName}, again in
- *    `makePermissionDecoderConfigs` (`checksumEnforcerAddresses` in
- *    `@metamask/7715-permission-types`), and once more below when building
- *    each decoder's required/optional enforcer sets.
- *
- * 2. **Delegation caveat enforcers**: read from the encoded permission
- *    context with unpredictable casing. Normalized in
- *    {@link buildEnforcerCountsAndSet} during address matching and again in
- *    `validateAndDecodePermission` before term decoding (rule decoders and
- *    `getTermsByEnforcer` compare enforcer addresses with `===`).
- *
- * 3. **Decoder required/optional enforcers**: populated from contract
- *    addresses by `makePermissionDecoderConfigs`; normalized at decoder
- *    construction so `caveatAddressesMatch` compares like-for-like with
- *    caveat addresses from source (2).
+ * Returned by each `make<PermissionType>DecoderConfig` factory and consumed by
+ * {@link makePermissionDecoder} to produce a {@link PermissionDecoder}.
  */
+export type MakePermissionDecoderConfig = {
+    permissionType: PermissionType;
+    contractAddresses: ChecksumEnforcersByChainId;
+    optionalEnforcers: Hex[];
+    requiredEnforcers: Record<Hex, number>;
+    rules: RuleDecoder[];
+    validateAndDecodeData: (caveats: ChecksumCaveat[], contractAddresses: ChecksumEnforcersByChainId) => DecodedPermission['permission']['data'];
+};
 /**
  * Creates a single {@link PermissionDecoder} with the given type, enforcer
  * sets, rule decoders, and decode/validate callback.
  *
  * @param config - The configuration describing the permission type's
  * enforcers, rule decoders, and data decoder. See
- * {@link PermissionDecoderConfig} for field documentation.
+ * {@link MakePermissionDecoderConfig} for field documentation.
  * @param config.permissionType - The type of permission to decode.
  * @param config.contractAddresses - Checksummed enforcer addresses for the chain.
  * @param config.optionalEnforcers - Optional enforcers for the permission.
@@ -42,5 +30,5 @@ import type { PermissionDecoder } from "../types.cjs";
  * @returns A {@link PermissionDecoder} with `caveatAddressesMatch` and
  * `validateAndDecodePermission`.
  */
-export declare function makePermissionDecoder({ permissionType, contractAddresses, optionalEnforcers, requiredEnforcers, rules, validateAndDecodeData, }: PermissionDecoderConfig): PermissionDecoder;
+export declare function makePermissionDecoder({ permissionType, contractAddresses, optionalEnforcers, requiredEnforcers, rules, validateAndDecodeData, }: MakePermissionDecoderConfig): PermissionDecoder;
 //# sourceMappingURL=makePermissionDecoder.d.cts.map

package/dist/decodePermission/decoders/makePermissionDecoder.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"makePermissionDecoder.d.cts","sourceRoot":"","sources":["../../../src/decodePermission/decoders/makePermissionDecoder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EAExB,wCAAwC;AAMzC,OAAO,KAAK,EAAE,iBAAiB,EAA2B,qBAAoB;AAG9E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,KAAK,EACL,qBAAqB,GACtB,EAAE,uBAAuB,GAAG,iBAAiB,CAgF7C"}
+{"version":3,"file":"makePermissionDecoder.d.cts","sourceRoot":"","sources":["../../../src/decodePermission/decoders/makePermissionDecoder.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,wBAAwB;AAG3C,OAAO,KAAK,EACV,cAAc,EACd,0BAA0B,EAC1B,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,WAAW,EAEZ,qBAAoB;AAGrB;;;;;GAKG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACxC,cAAc,EAAE,cAAc,CAAC;IAC/B,iBAAiB,EAAE,0BAA0B,CAAC;IAC9C,iBAAiB,EAAE,GAAG,EAAE,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IACvC,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,qBAAqB,EAAE,CACrB,OAAO,EAAE,cAAc,EAAE,EACzB,iBAAiB,EAAE,0BAA0B,KAC1C,iBAAiB,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;CAC9C,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,KAAK,EACL,qBAAqB,GACtB,EAAE,2BAA2B,GAAG,iBAAiB,CA2EjD"}