@metamask/smart-accounts-kit 1.4.0 → 1.6.0

package/dist/{chunk-TMO23YRP.cjs → chunk-W6HPAK4M.cjs}

@@ -36,6 +36,7 @@ var ScopeType = /* @__PURE__ */ ((ScopeType2) => {
 var CaveatType = /* @__PURE__ */ ((CaveatType2) => {
   CaveatType2["AllowedMethods"] = "allowedMethods";
   CaveatType2["AllowedTargets"] = "allowedTargets";
+  CaveatType2["ApprovalRevocation"] = "approvalRevocation";
   CaveatType2["Deployed"] = "deployed";
   CaveatType2["AllowedCalldata"] = "allowedCalldata";
   CaveatType2["Erc20BalanceChange"] = "erc20BalanceChange";
@@ -228,6 +229,26 @@ var allowedTargetsBuilder = (environment, config) => {
   };
 };
 
+// src/caveatBuilder/approvalRevocationBuilder.ts
+
+
+
+var approvalRevocation = "approvalRevocation";
+var approvalRevocationBuilder = (environment, config) => {
+  const terms = _delegationcore.createApprovalRevocationTerms.call(void 0, config);
+  const {
+    caveatEnforcers: { ApprovalRevocationEnforcer }
+  } = environment;
+  if (!ApprovalRevocationEnforcer) {
+    throw new Error("ApprovalRevocationEnforcer not found in environment");
+  }
+  return {
+    enforcer: ApprovalRevocationEnforcer,
+    terms,
+    args: "0x00"
+  };
+};
+
 // src/caveatBuilder/argsEqualityCheckBuilder.ts
 
 
@@ -1041,7 +1062,7 @@ var valueLteBuilder = (environment, config) => {
 
 // src/caveatBuilder/coreCaveatBuilder.ts
 var createCaveatBuilder = (environment, config) => {
-  const caveatBuilder = new CaveatBuilder(environment, config).extend(allowedMethods, allowedMethodsBuilder).extend(allowedTargets, allowedTargetsBuilder).extend(deployed, deployedBuilder).extend(allowedCalldata, allowedCalldataBuilder).extend(erc20BalanceChange, erc20BalanceChangeBuilder).extend(erc721BalanceChange, erc721BalanceChangeBuilder).extend(erc1155BalanceChange, erc1155BalanceChangeBuilder).extend(valueLte, valueLteBuilder).extend(limitedCalls, limitedCallsBuilder).extend(id, idBuilder).extend(nonce, nonceBuilder).extend(timestamp, timestampBuilder).extend(blockNumber, blockNumberBuilder).extend(erc20TransferAmount, erc20TransferAmountBuilder).extend(erc20Streaming, erc20StreamingBuilder).extend(nativeTokenStreaming, nativeTokenStreamingBuilder).extend(erc721Transfer, erc721TransferBuilder).extend(nativeTokenTransferAmount, nativeTokenTransferAmountBuilder).extend(nativeBalanceChange, nativeBalanceChangeBuilder).extend(redeemer, redeemerBuilder).extend(nativeTokenPayment, nativeTokenPaymentBuilder).extend(argsEqualityCheck, argsEqualityCheckBuilder).extend(
+  const caveatBuilder = new CaveatBuilder(environment, config).extend(allowedMethods, allowedMethodsBuilder).extend(allowedTargets, allowedTargetsBuilder).extend(approvalRevocation, approvalRevocationBuilder).extend(deployed, deployedBuilder).extend(allowedCalldata, allowedCalldataBuilder).extend(erc20BalanceChange, erc20BalanceChangeBuilder).extend(erc721BalanceChange, erc721BalanceChangeBuilder).extend(erc1155BalanceChange, erc1155BalanceChangeBuilder).extend(valueLte, valueLteBuilder).extend(limitedCalls, limitedCallsBuilder).extend(id, idBuilder).extend(nonce, nonceBuilder).extend(timestamp, timestampBuilder).extend(blockNumber, blockNumberBuilder).extend(erc20TransferAmount, erc20TransferAmountBuilder).extend(erc20Streaming, erc20StreamingBuilder).extend(nativeTokenStreaming, nativeTokenStreamingBuilder).extend(erc721Transfer, erc721TransferBuilder).extend(nativeTokenTransferAmount, nativeTokenTransferAmountBuilder).extend(nativeBalanceChange, nativeBalanceChangeBuilder).extend(redeemer, redeemerBuilder).extend(nativeTokenPayment, nativeTokenPaymentBuilder).extend(argsEqualityCheck, argsEqualityCheckBuilder).extend(
     specificActionERC20TransferBatch,
     specificActionERC20TransferBatchBuilder
   ).extend(erc20PeriodTransfer, erc20PeriodTransferBuilder).extend(nativeTokenPeriodTransfer, nativeTokenPeriodTransferBuilder).extend(exactCalldataBatch, exactCalldataBatchBuilder).extend(exactCalldata, exactCalldataBuilder).extend(exactExecution, exactExecutionBuilder).extend(exactExecutionBatch, exactExecutionBatchBuilder).extend(multiTokenPeriod, multiTokenPeriodBuilder).extend(ownershipTransfer, ownershipTransferBuilder);
@@ -1332,9 +1353,15 @@ var createCaveatBuilderFromScope = (environment, scopeConfig) => {
 var resolveCaveats = ({
   environment,
   scope,
-  caveats
+  caveats,
+  isScopeOptional
 }) => {
-  const scopeCaveatBuilder = createCaveatBuilderFromScope(environment, scope);
+  if (!scope && !isScopeOptional) {
+    throw new Error("Scope is required");
+  }
+  const scopeCaveatBuilder = scope ? createCaveatBuilderFromScope(environment, scope) : createCaveatBuilder(environment, {
+    allowInsecureUnrestrictedDelegation: true
+  });
   if (caveats) {
     if ("build" in caveats && typeof caveats.build === "function") {
       caveats.build().forEach((caveat) => {
@@ -1396,6 +1423,7 @@ var resolveCaveats = ({
 
 
 
+
 
 
 var CAVEAT_ABI_TYPE_COMPONENTS = [
@@ -1419,113 +1447,142 @@ var decodeCaveat = ({
 }) => {
   switch (enforcer.toLowerCase()) {
     case _optionalChain([caveatEnforcers, 'access', _2 => _2.AllowedCalldataEnforcer, 'optionalAccess', _3 => _3.toLowerCase, 'call', _4 => _4()]):
-      return { type: "allowedCalldata", ..._delegationcore.decodeAllowedCalldataTerms.call(void 0, terms) };
+      return {
+        type: "allowedCalldata" /* AllowedCalldata */,
+        ..._delegationcore.decodeAllowedCalldataTerms.call(void 0, terms)
+      };
     case _optionalChain([caveatEnforcers, 'access', _5 => _5.AllowedMethodsEnforcer, 'optionalAccess', _6 => _6.toLowerCase, 'call', _7 => _7()]):
-      return { type: "allowedMethods", ..._delegationcore.decodeAllowedMethodsTerms.call(void 0, terms) };
-    case _optionalChain([caveatEnforcers, 'access', _8 => _8.AllowedTargetsEnforcer, 'optionalAccess', _9 => _9.toLowerCase, 'call', _10 => _10()]):
-      return { type: "allowedTargets", ..._delegationcore.decodeAllowedTargetsTerms.call(void 0, terms) };
-    case _optionalChain([caveatEnforcers, 'access', _11 => _11.ArgsEqualityCheckEnforcer, 'optionalAccess', _12 => _12.toLowerCase, 'call', _13 => _13()]):
       return {
-        type: "argsEqualityCheck",
+        type: "allowedMethods" /* AllowedMethods */,
+        ..._delegationcore.decodeAllowedMethodsTerms.call(void 0, terms)
+      };
+    case _optionalChain([caveatEnforcers, 'access', _8 => _8.ApprovalRevocationEnforcer, 'optionalAccess', _9 => _9.toLowerCase, 'call', _10 => _10()]):
+      return {
+        type: "approvalRevocation" /* ApprovalRevocation */,
+        ..._delegationcore.decodeApprovalRevocationTerms.call(void 0, terms)
+      };
+    case _optionalChain([caveatEnforcers, 'access', _11 => _11.AllowedTargetsEnforcer, 'optionalAccess', _12 => _12.toLowerCase, 'call', _13 => _13()]):
+      return {
+        type: "allowedTargets" /* AllowedTargets */,
+        ..._delegationcore.decodeAllowedTargetsTerms.call(void 0, terms)
+      };
+    case _optionalChain([caveatEnforcers, 'access', _14 => _14.ArgsEqualityCheckEnforcer, 'optionalAccess', _15 => _15.toLowerCase, 'call', _16 => _16()]):
+      return {
+        type: "argsEqualityCheck" /* ArgsEqualityCheck */,
         ..._delegationcore.decodeArgsEqualityCheckTerms.call(void 0, terms)
       };
-    case _optionalChain([caveatEnforcers, 'access', _14 => _14.BlockNumberEnforcer, 'optionalAccess', _15 => _15.toLowerCase, 'call', _16 => _16()]):
-      return { type: "blockNumber", ..._delegationcore.decodeBlockNumberTerms.call(void 0, terms) };
-    case _optionalChain([caveatEnforcers, 'access', _17 => _17.DeployedEnforcer, 'optionalAccess', _18 => _18.toLowerCase, 'call', _19 => _19()]):
-      return { type: "deployed", ..._delegationcore.decodeDeployedTerms.call(void 0, terms) };
-    case _optionalChain([caveatEnforcers, 'access', _20 => _20.ERC20BalanceChangeEnforcer, 'optionalAccess', _21 => _21.toLowerCase, 'call', _22 => _22()]):
+    case _optionalChain([caveatEnforcers, 'access', _17 => _17.BlockNumberEnforcer, 'optionalAccess', _18 => _18.toLowerCase, 'call', _19 => _19()]):
+      return { type: "blockNumber" /* BlockNumber */, ..._delegationcore.decodeBlockNumberTerms.call(void 0, terms) };
+    case _optionalChain([caveatEnforcers, 'access', _20 => _20.DeployedEnforcer, 'optionalAccess', _21 => _21.toLowerCase, 'call', _22 => _22()]):
+      return { type: "deployed" /* Deployed */, ..._delegationcore.decodeDeployedTerms.call(void 0, terms) };
+    case _optionalChain([caveatEnforcers, 'access', _23 => _23.ERC20BalanceChangeEnforcer, 'optionalAccess', _24 => _24.toLowerCase, 'call', _25 => _25()]):
       return {
-        type: "erc20BalanceChange",
+        type: "erc20BalanceChange" /* Erc20BalanceChange */,
         ..._delegationcore.decodeERC20BalanceChangeTerms.call(void 0, terms)
       };
-    case _optionalChain([caveatEnforcers, 'access', _23 => _23.ERC20TransferAmountEnforcer, 'optionalAccess', _24 => _24.toLowerCase, 'call', _25 => _25()]):
+    case _optionalChain([caveatEnforcers, 'access', _26 => _26.ERC20TransferAmountEnforcer, 'optionalAccess', _27 => _27.toLowerCase, 'call', _28 => _28()]):
       return {
-        type: "erc20TransferAmount",
+        type: "erc20TransferAmount" /* Erc20TransferAmount */,
         ..._delegationcore.decodeERC20TransferAmountTerms.call(void 0, terms)
       };
-    case _optionalChain([caveatEnforcers, 'access', _26 => _26.ERC20StreamingEnforcer, 'optionalAccess', _27 => _27.toLowerCase, 'call', _28 => _28()]):
-      return { type: "erc20Streaming", ..._delegationcore.decodeERC20StreamingTerms.call(void 0, terms) };
-    case _optionalChain([caveatEnforcers, 'access', _29 => _29.ERC721BalanceChangeEnforcer, 'optionalAccess', _30 => _30.toLowerCase, 'call', _31 => _31()]):
+    case _optionalChain([caveatEnforcers, 'access', _29 => _29.ERC20StreamingEnforcer, 'optionalAccess', _30 => _30.toLowerCase, 'call', _31 => _31()]):
+      return {
+        type: "erc20Streaming" /* Erc20Streaming */,
+        ..._delegationcore.decodeERC20StreamingTerms.call(void 0, terms)
+      };
+    case _optionalChain([caveatEnforcers, 'access', _32 => _32.ERC721BalanceChangeEnforcer, 'optionalAccess', _33 => _33.toLowerCase, 'call', _34 => _34()]):
       return {
-        type: "erc721BalanceChange",
+        type: "erc721BalanceChange" /* Erc721BalanceChange */,
         ..._delegationcore.decodeERC721BalanceChangeTerms.call(void 0, terms)
       };
-    case _optionalChain([caveatEnforcers, 'access', _32 => _32.ERC721TransferEnforcer, 'optionalAccess', _33 => _33.toLowerCase, 'call', _34 => _34()]):
-      return { type: "erc721Transfer", ..._delegationcore.decodeERC721TransferTerms.call(void 0, terms) };
-    case _optionalChain([caveatEnforcers, 'access', _35 => _35.ERC1155BalanceChangeEnforcer, 'optionalAccess', _36 => _36.toLowerCase, 'call', _37 => _37()]):
+    case _optionalChain([caveatEnforcers, 'access', _35 => _35.ERC721TransferEnforcer, 'optionalAccess', _36 => _36.toLowerCase, 'call', _37 => _37()]):
+      return {
+        type: "erc721Transfer" /* Erc721Transfer */,
+        ..._delegationcore.decodeERC721TransferTerms.call(void 0, terms)
+      };
+    case _optionalChain([caveatEnforcers, 'access', _38 => _38.ERC1155BalanceChangeEnforcer, 'optionalAccess', _39 => _39.toLowerCase, 'call', _40 => _40()]):
       return {
-        type: "erc1155BalanceChange",
+        type: "erc1155BalanceChange" /* Erc1155BalanceChange */,
         ..._delegationcore.decodeERC1155BalanceChangeTerms.call(void 0, terms)
       };
-    case _optionalChain([caveatEnforcers, 'access', _38 => _38.IdEnforcer, 'optionalAccess', _39 => _39.toLowerCase, 'call', _40 => _40()]):
-      return { type: "id", ..._delegationcore.decodeIdTerms.call(void 0, terms) };
-    case _optionalChain([caveatEnforcers, 'access', _41 => _41.LimitedCallsEnforcer, 'optionalAccess', _42 => _42.toLowerCase, 'call', _43 => _43()]):
-      return { type: "limitedCalls", ..._delegationcore.decodeLimitedCallsTerms.call(void 0, terms) };
-    case _optionalChain([caveatEnforcers, 'access', _44 => _44.NonceEnforcer, 'optionalAccess', _45 => _45.toLowerCase, 'call', _46 => _46()]):
-      return { type: "nonce", ..._delegationcore.decodeNonceTerms.call(void 0, terms) };
-    case _optionalChain([caveatEnforcers, 'access', _47 => _47.TimestampEnforcer, 'optionalAccess', _48 => _48.toLowerCase, 'call', _49 => _49()]):
-      return { type: "timestamp", ..._delegationcore.decodeTimestampTerms.call(void 0, terms) };
-    case _optionalChain([caveatEnforcers, 'access', _50 => _50.ValueLteEnforcer, 'optionalAccess', _51 => _51.toLowerCase, 'call', _52 => _52()]):
-      return { type: "valueLte", ..._delegationcore.decodeValueLteTerms.call(void 0, terms) };
-    case _optionalChain([caveatEnforcers, 'access', _53 => _53.NativeTokenTransferAmountEnforcer, 'optionalAccess', _54 => _54.toLowerCase, 'call', _55 => _55()]):
+    case _optionalChain([caveatEnforcers, 'access', _41 => _41.IdEnforcer, 'optionalAccess', _42 => _42.toLowerCase, 'call', _43 => _43()]):
+      return { type: "id" /* Id */, ..._delegationcore.decodeIdTerms.call(void 0, terms) };
+    case _optionalChain([caveatEnforcers, 'access', _44 => _44.LimitedCallsEnforcer, 'optionalAccess', _45 => _45.toLowerCase, 'call', _46 => _46()]):
+      return {
+        type: "limitedCalls" /* LimitedCalls */,
+        ..._delegationcore.decodeLimitedCallsTerms.call(void 0, terms)
+      };
+    case _optionalChain([caveatEnforcers, 'access', _47 => _47.NonceEnforcer, 'optionalAccess', _48 => _48.toLowerCase, 'call', _49 => _49()]):
+      return { type: "nonce" /* Nonce */, ..._delegationcore.decodeNonceTerms.call(void 0, terms) };
+    case _optionalChain([caveatEnforcers, 'access', _50 => _50.TimestampEnforcer, 'optionalAccess', _51 => _51.toLowerCase, 'call', _52 => _52()]):
+      return { type: "timestamp" /* Timestamp */, ..._delegationcore.decodeTimestampTerms.call(void 0, terms) };
+    case _optionalChain([caveatEnforcers, 'access', _53 => _53.ValueLteEnforcer, 'optionalAccess', _54 => _54.toLowerCase, 'call', _55 => _55()]):
+      return { type: "valueLte" /* ValueLte */, ..._delegationcore.decodeValueLteTerms.call(void 0, terms) };
+    case _optionalChain([caveatEnforcers, 'access', _56 => _56.NativeTokenTransferAmountEnforcer, 'optionalAccess', _57 => _57.toLowerCase, 'call', _58 => _58()]):
       return {
-        type: "nativeTokenTransferAmount",
+        type: "nativeTokenTransferAmount" /* NativeTokenTransferAmount */,
         ..._delegationcore.decodeNativeTokenTransferAmountTerms.call(void 0, terms)
       };
-    case _optionalChain([caveatEnforcers, 'access', _56 => _56.NativeBalanceChangeEnforcer, 'optionalAccess', _57 => _57.toLowerCase, 'call', _58 => _58()]):
+    case _optionalChain([caveatEnforcers, 'access', _59 => _59.NativeBalanceChangeEnforcer, 'optionalAccess', _60 => _60.toLowerCase, 'call', _61 => _61()]):
       return {
-        type: "nativeBalanceChange",
+        type: "nativeBalanceChange" /* NativeBalanceChange */,
         ..._delegationcore.decodeNativeBalanceChangeTerms.call(void 0, terms)
       };
-    case _optionalChain([caveatEnforcers, 'access', _59 => _59.NativeTokenStreamingEnforcer, 'optionalAccess', _60 => _60.toLowerCase, 'call', _61 => _61()]):
+    case _optionalChain([caveatEnforcers, 'access', _62 => _62.NativeTokenStreamingEnforcer, 'optionalAccess', _63 => _63.toLowerCase, 'call', _64 => _64()]):
       return {
-        type: "nativeTokenStreaming",
+        type: "nativeTokenStreaming" /* NativeTokenStreaming */,
         ..._delegationcore.decodeNativeTokenStreamingTerms.call(void 0, terms)
       };
-    case _optionalChain([caveatEnforcers, 'access', _62 => _62.NativeTokenPaymentEnforcer, 'optionalAccess', _63 => _63.toLowerCase, 'call', _64 => _64()]):
+    case _optionalChain([caveatEnforcers, 'access', _65 => _65.NativeTokenPaymentEnforcer, 'optionalAccess', _66 => _66.toLowerCase, 'call', _67 => _67()]):
       return {
-        type: "nativeTokenPayment",
+        type: "nativeTokenPayment" /* NativeTokenPayment */,
         ..._delegationcore.decodeNativeTokenPaymentTerms.call(void 0, terms)
       };
-    case _optionalChain([caveatEnforcers, 'access', _65 => _65.RedeemerEnforcer, 'optionalAccess', _66 => _66.toLowerCase, 'call', _67 => _67()]):
-      return { type: "redeemer", ..._delegationcore.decodeRedeemerTerms.call(void 0, terms) };
-    case _optionalChain([caveatEnforcers, 'access', _68 => _68.SpecificActionERC20TransferBatchEnforcer, 'optionalAccess', _69 => _69.toLowerCase, 'call', _70 => _70()]):
+    case _optionalChain([caveatEnforcers, 'access', _68 => _68.RedeemerEnforcer, 'optionalAccess', _69 => _69.toLowerCase, 'call', _70 => _70()]):
+      return { type: "redeemer" /* Redeemer */, ..._delegationcore.decodeRedeemerTerms.call(void 0, terms) };
+    case _optionalChain([caveatEnforcers, 'access', _71 => _71.SpecificActionERC20TransferBatchEnforcer, 'optionalAccess', _72 => _72.toLowerCase, 'call', _73 => _73()]):
       return {
-        type: "specificActionERC20TransferBatch",
+        type: "specificActionERC20TransferBatch" /* SpecificActionERC20TransferBatch */,
         ..._delegationcore.decodeSpecificActionERC20TransferBatchTerms.call(void 0, terms)
       };
-    case _optionalChain([caveatEnforcers, 'access', _71 => _71.ERC20PeriodTransferEnforcer, 'optionalAccess', _72 => _72.toLowerCase, 'call', _73 => _73()]):
+    case _optionalChain([caveatEnforcers, 'access', _74 => _74.ERC20PeriodTransferEnforcer, 'optionalAccess', _75 => _75.toLowerCase, 'call', _76 => _76()]):
       return {
-        type: "erc20PeriodTransfer",
+        type: "erc20PeriodTransfer" /* Erc20PeriodTransfer */,
         ..._delegationcore.decodeERC20TokenPeriodTransferTerms.call(void 0, terms)
       };
-    case _optionalChain([caveatEnforcers, 'access', _74 => _74.NativeTokenPeriodTransferEnforcer, 'optionalAccess', _75 => _75.toLowerCase, 'call', _76 => _76()]):
+    case _optionalChain([caveatEnforcers, 'access', _77 => _77.NativeTokenPeriodTransferEnforcer, 'optionalAccess', _78 => _78.toLowerCase, 'call', _79 => _79()]):
       return {
-        type: "nativeTokenPeriodTransfer",
+        type: "nativeTokenPeriodTransfer" /* NativeTokenPeriodTransfer */,
         ..._delegationcore.decodeNativeTokenPeriodTransferTerms.call(void 0, terms)
       };
-    case _optionalChain([caveatEnforcers, 'access', _77 => _77.ExactCalldataBatchEnforcer, 'optionalAccess', _78 => _78.toLowerCase, 'call', _79 => _79()]):
+    case _optionalChain([caveatEnforcers, 'access', _80 => _80.ExactCalldataBatchEnforcer, 'optionalAccess', _81 => _81.toLowerCase, 'call', _82 => _82()]):
       return {
-        type: "exactCalldataBatch",
+        type: "exactCalldataBatch" /* ExactCalldataBatch */,
         ..._delegationcore.decodeExactCalldataBatchTerms.call(void 0, terms)
       };
-    case _optionalChain([caveatEnforcers, 'access', _80 => _80.ExactCalldataEnforcer, 'optionalAccess', _81 => _81.toLowerCase, 'call', _82 => _82()]):
-      return { type: "exactCalldata", ..._delegationcore.decodeExactCalldataTerms.call(void 0, terms) };
-    case _optionalChain([caveatEnforcers, 'access', _83 => _83.ExactExecutionEnforcer, 'optionalAccess', _84 => _84.toLowerCase, 'call', _85 => _85()]):
-      return { type: "exactExecution", ..._delegationcore.decodeExactExecutionTerms.call(void 0, terms) };
-    case _optionalChain([caveatEnforcers, 'access', _86 => _86.ExactExecutionBatchEnforcer, 'optionalAccess', _87 => _87.toLowerCase, 'call', _88 => _88()]):
+    case _optionalChain([caveatEnforcers, 'access', _83 => _83.ExactCalldataEnforcer, 'optionalAccess', _84 => _84.toLowerCase, 'call', _85 => _85()]):
       return {
-        type: "exactExecutionBatch",
+        type: "exactCalldata" /* ExactCalldata */,
+        ..._delegationcore.decodeExactCalldataTerms.call(void 0, terms)
+      };
+    case _optionalChain([caveatEnforcers, 'access', _86 => _86.ExactExecutionEnforcer, 'optionalAccess', _87 => _87.toLowerCase, 'call', _88 => _88()]):
+      return {
+        type: "exactExecution" /* ExactExecution */,
+        ..._delegationcore.decodeExactExecutionTerms.call(void 0, terms)
+      };
+    case _optionalChain([caveatEnforcers, 'access', _89 => _89.ExactExecutionBatchEnforcer, 'optionalAccess', _90 => _90.toLowerCase, 'call', _91 => _91()]):
+      return {
+        type: "exactExecutionBatch" /* ExactExecutionBatch */,
         ..._delegationcore.decodeExactExecutionBatchTerms.call(void 0, terms)
       };
-    case _optionalChain([caveatEnforcers, 'access', _89 => _89.MultiTokenPeriodEnforcer, 'optionalAccess', _90 => _90.toLowerCase, 'call', _91 => _91()]):
+    case _optionalChain([caveatEnforcers, 'access', _92 => _92.MultiTokenPeriodEnforcer, 'optionalAccess', _93 => _93.toLowerCase, 'call', _94 => _94()]):
       return {
-        type: "multiTokenPeriod",
+        type: "multiTokenPeriod" /* MultiTokenPeriod */,
         ..._delegationcore.decodeMultiTokenPeriodTerms.call(void 0, terms)
       };
-    case _optionalChain([caveatEnforcers, 'access', _92 => _92.OwnershipTransferEnforcer, 'optionalAccess', _93 => _93.toLowerCase, 'call', _94 => _94()]):
+    case _optionalChain([caveatEnforcers, 'access', _95 => _95.OwnershipTransferEnforcer, 'optionalAccess', _96 => _96.toLowerCase, 'call', _97 => _97()]):
       return {
-        type: "ownershipTransfer",
+        type: "ownershipTransfer" /* OwnershipTransfer */,
         ..._delegationcore.decodeOwnershipTransferTerms.call(void 0, terms)
       };
     default:
@@ -1554,7 +1611,7 @@ var _openapifetch = require('openapi-fetch'); var _openapifetch2 = _interopRequi
 // src/analytics/environment.ts
 var session;
 function createAnonId() {
-  if (typeof _optionalChain([globalThis, 'access', _95 => _95.crypto, 'optionalAccess', _96 => _96.randomUUID]) === "function") {
+  if (typeof _optionalChain([globalThis, 'access', _98 => _98.crypto, 'optionalAccess', _99 => _99.randomUUID]) === "function") {
     return globalThis.crypto.randomUUID();
   }
   return `00000000-0000-4000-8000-${Math.random().toString(16).slice(2, 14).padEnd(12, "0")}`;
@@ -1564,7 +1621,7 @@ function inferPlatform() {
     return "nodejs";
   }
   const nav = globalThis.navigator;
-  const ua = typeof _optionalChain([nav, 'optionalAccess', _97 => _97.userAgent]) === "string" ? nav.userAgent : "";
+  const ua = typeof _optionalChain([nav, 'optionalAccess', _100 => _100.userAgent]) === "string" ? nav.userAgent : "";
   if (/Mobile|Android|iPhone|iPod|webOS|BlackBerry|IEMobile|Opera Mini/iu.test(ua)) {
     return "web-mobile";
   }
@@ -1573,7 +1630,7 @@ function inferPlatform() {
 function inferDomain() {
   if (typeof globalThis !== "undefined" && "window" in globalThis) {
     const win = globalThis;
-    const hostname = _optionalChain([win, 'access', _98 => _98.location, 'optionalAccess', _99 => _99.hostname]);
+    const hostname = _optionalChain([win, 'access', _101 => _101.location, 'optionalAccess', _102 => _102.hostname]);
     if (typeof hostname === "string" && hostname.length > 0) {
       return { domain: hostname };
     }
@@ -1693,7 +1750,7 @@ var Sender = class {
 };
 
 // package.json
-var version = "1.4.0";
+var version = "1.6.0";
 
 // src/analytics/index.ts
 function isCompleteBase(value) {
@@ -1820,8 +1877,8 @@ var analytics = new Analytics(METAMASK_ANALYTICS_ENDPOINT);
 function isAnalyticsDisabled() {
   const dntValues = [];
   if (typeof process !== "undefined") {
-    dntValues.push(_optionalChain([process, 'access', _100 => _100.env, 'optionalAccess', _101 => _101.CI]));
-    dntValues.push(_optionalChain([process, 'access', _102 => _102.env, 'optionalAccess', _103 => _103.DO_NOT_TRACK]));
+    dntValues.push(_optionalChain([process, 'access', _103 => _103.env, 'optionalAccess', _104 => _104.CI]));
+    dntValues.push(_optionalChain([process, 'access', _105 => _105.env, 'optionalAccess', _106 => _106.DO_NOT_TRACK]));
   }
   if (typeof navigator !== "undefined") {
     dntValues.push(navigator.doNotTrack);
@@ -1830,7 +1887,7 @@ function isAnalyticsDisabled() {
     dntValues.push(window.doNotTrack);
   }
   return dntValues.some(
-    (dntValue) => dntValue === "1" || _optionalChain([dntValue, 'optionalAccess', _104 => _104.toLowerCase, 'call', _105 => _105()]) === "yes" || _optionalChain([dntValue, 'optionalAccess', _106 => _106.toLowerCase, 'call', _107 => _107()]) === "true"
+    (dntValue) => dntValue === "1" || _optionalChain([dntValue, 'optionalAccess', _107 => _107.toLowerCase, 'call', _108 => _108()]) === "yes" || _optionalChain([dntValue, 'optionalAccess', _109 => _109.toLowerCase, 'call', _110 => _110()]) === "true"
   );
 }
 var hasBootstrapped = false;
@@ -1943,14 +2000,16 @@ var hashDelegation = (input) => {
   const delegationStruct = toDelegationStruct(input);
   return _delegationcore.hashDelegation.call(void 0, delegationStruct);
 };
-var resolveAuthority = (parentDelegation) => {
-  if (!parentDelegation) {
-    return _delegationcore.ROOT_AUTHORITY;
+var extractLeafDelegation = (permissionContext) => {
+  const delegations = decodeDelegations(permissionContext);
+  if (delegations.length === 0) {
+    throw new Error("Permission context must contain at least one delegation");
   }
-  if (typeof parentDelegation === "string") {
-    return parentDelegation;
+  const leafDelegation = delegations[0];
+  if (!leafDelegation) {
+    throw new Error("Failed to extract leaf delegation");
   }
-  return hashDelegation(parentDelegation);
+  return leafDelegation;
 };
 var getCaveatNames = ({
   caveats,
@@ -1961,20 +2020,56 @@ var getCaveatNames = ({
       ([name, address]) => ({ name, address: address.toLowerCase() })
     );
     return caveats.map((caveat) => {
-      const enforcerAddressLowercase = _optionalChain([caveat, 'access', _108 => _108.enforcer, 'optionalAccess', _109 => _109.toLowerCase, 'call', _110 => _110()]);
+      const enforcerAddressLowercase = _optionalChain([caveat, 'access', _111 => _111.enforcer, 'optionalAccess', _112 => _112.toLowerCase, 'call', _113 => _113()]);
       const matchingCaveat = knownEnforcers.find(
         ({ address }) => address === enforcerAddressLowercase
       );
-      return _nullishCoalesce(_optionalChain([matchingCaveat, 'optionalAccess', _111 => _111.name]), () => ( "Unknown"));
+      return _nullishCoalesce(_optionalChain([matchingCaveat, 'optionalAccess', _114 => _114.name]), () => ( "Unknown"));
     });
   }
   return [];
 };
+var resolveDelegationArgs = (options) => {
+  const optionsHasParentPermissionContext = "parentPermissionContext" in options && options.parentPermissionContext;
+  const resolvedParentDelegation = optionsHasParentPermissionContext ? extractLeafDelegation(options.parentPermissionContext) : options.parentDelegation;
+  const authority = (() => {
+    if (!resolvedParentDelegation) {
+      if (!options.scope) {
+        throw new Error(
+          "Invalid arguments - must specify either parentDelegation, parentPermissionContext, or scope"
+        );
+      }
+      return _delegationcore.ROOT_AUTHORITY;
+    }
+    if (typeof resolvedParentDelegation === "string") {
+      if (resolvedParentDelegation.toLowerCase() === _delegationcore.ROOT_AUTHORITY.toLowerCase()) {
+        throw new Error(
+          `Invalid parent delegation - cannot be ${_delegationcore.ROOT_AUTHORITY}`
+        );
+      }
+      return resolvedParentDelegation;
+    }
+    return hashDelegation(resolvedParentDelegation);
+  })();
+  const hasInheritance = resolvedParentDelegation !== void 0;
+  const caveats = resolveCaveats({
+    environment: options.environment,
+    scope: options.scope,
+    caveats: options.caveats,
+    isScopeOptional: hasInheritance
+  });
+  return {
+    authority,
+    caveats,
+    hasInheritance,
+    salt: _nullishCoalesce(options.salt, () => ( "0x00"))
+  };
+};
 var createDelegation = (options) => {
-  const caveats = resolveCaveats(options);
+  const { authority, caveats, hasInheritance, salt } = resolveDelegationArgs(options);
   trackSmartAccountsKitFunctionCall("createDelegation", {
-    hasParentDelegation: options.parentDelegation !== void 0,
-    scope: options.scope.type,
+    hasInheritance,
+    scope: _nullishCoalesce(_optionalChain([options, 'access', _115 => _115.scope, 'optionalAccess', _116 => _116.type]), () => ( null)),
     caveatNames: getCaveatNames({
       caveats,
       environment: options.environment
@@ -1983,17 +2078,17 @@ var createDelegation = (options) => {
   return {
     delegate: options.to,
     delegator: options.from,
-    authority: resolveAuthority(options.parentDelegation),
+    authority,
     caveats,
-    salt: _nullishCoalesce(options.salt, () => ( "0x00")),
+    salt,
     signature: "0x"
   };
 };
 var createOpenDelegation = (options) => {
-  const caveats = resolveCaveats(options);
+  const { authority, caveats, hasInheritance, salt } = resolveDelegationArgs(options);
   trackSmartAccountsKitFunctionCall("createOpenDelegation", {
-    hasParentDelegation: options.parentDelegation !== void 0,
-    scope: options.scope.type,
+    hasInheritance,
+    scope: _nullishCoalesce(_optionalChain([options, 'access', _117 => _117.scope, 'optionalAccess', _118 => _118.type]), () => ( null)),
     caveatNames: getCaveatNames({
       caveats,
       environment: options.environment
@@ -2002,9 +2097,9 @@ var createOpenDelegation = (options) => {
   return {
     delegate: _delegationcore.ANY_BENEFICIARY,
     delegator: options.from,
-    authority: resolveAuthority(options.parentDelegation),
+    authority,
     caveats,
-    salt: _nullishCoalesce(options.salt, () => ( "0x00")),
+    salt,
     signature: "0x"
   };
 };
@@ -2060,6 +2155,83 @@ var signDelegation = async ({
   });
 };
 
+// src/executions.ts
+
+
+
+
+var createExecution = ({
+  target,
+  value = 0n,
+  callData = "0x"
+}) => {
+  return {
+    target,
+    value,
+    callData
+  };
+};
+var ExecutionMode = /* @__PURE__ */ ((ExecutionMode2) => {
+  ExecutionMode2["SingleDefault"] = "0x0000000000000000000000000000000000000000000000000000000000000000";
+  ExecutionMode2["SingleTry"] = "0x0001000000000000000000000000000000000000000000000000000000000000";
+  ExecutionMode2["BatchDefault"] = "0x0100000000000000000000000000000000000000000000000000000000000000";
+  ExecutionMode2["BatchTry"] = "0x0101000000000000000000000000000000000000000000000000000000000000";
+  return ExecutionMode2;
+})(ExecutionMode || {});
+var EXECUTION_ABI_TYPE_COMPONENTS = [
+  { type: "address", name: "target" },
+  { type: "uint256", name: "value" },
+  { type: "bytes", name: "callData" }
+];
+var encodeSingleExecution = (execution) => {
+  return _viem.encodePacked.call(void 0, 
+    ["address", "uint256", "bytes"],
+    [execution.target, execution.value, execution.callData]
+  );
+};
+var encodeBatchExecution = (executions) => {
+  return _viem.encodeAbiParameters.call(void 0, 
+    [
+      {
+        components: EXECUTION_ABI_TYPE_COMPONENTS,
+        name: "executions",
+        type: "tuple[]"
+      }
+    ],
+    [executions]
+  );
+};
+var encodeExecutionCalldata = (executions) => {
+  if (executions.length === 0) {
+    throw new Error(
+      "Error while getting the execution calldatas, executions is empty"
+    );
+  }
+  if (executions.length === 1) {
+    const execution = executions[0];
+    if (!execution) {
+      throw new Error("Execution not found");
+    }
+    return encodeSingleExecution(execution);
+  }
+  return encodeBatchExecution(executions);
+};
+var encodeExecutionCalldatas = (executionsBatch) => {
+  if (executionsBatch.length === 0) {
+    throw new Error(
+      "Error while getting the execution calldatas, executionsBatch is empty"
+    );
+  }
+  return executionsBatch.map(encodeExecutionCalldata);
+};
+
+
+
+
+
+
+
+
 
 
 
@@ -2091,5 +2263,5 @@ var signDelegation = async ({
 
 
 
-exports.__export = __export; exports.trackSmartAccountsKitFunctionCall = trackSmartAccountsKitFunctionCall; exports.Implementation = Implementation; exports.TransferWindow = TransferWindow; exports.ScopeType = ScopeType; exports.CaveatType = CaveatType; exports.CaveatBuilder = CaveatBuilder; exports.createCaveatBuilder = createCaveatBuilder; exports.isDefined = isDefined; exports.toHexOrThrow = toHexOrThrow; exports.createCaveat = createCaveat; exports.decodeCaveat = decodeCaveat; exports.ANY_BENEFICIARY = _delegationcore.ANY_BENEFICIARY; exports.DELEGATION_TYPEHASH = _delegationcore.DELEGATION_TYPEHASH; exports.ROOT_AUTHORITY = _delegationcore.ROOT_AUTHORITY; exports.DELEGATION_ABI_TYPE_COMPONENTS = DELEGATION_ABI_TYPE_COMPONENTS; exports.toDelegationStruct = toDelegationStruct; exports.toDelegation = toDelegation; exports.encodeDelegations = encodeDelegations; exports.encodeDelegation = encodeDelegation; exports.decodeDelegations = decodeDelegations; exports.decodeDelegation = decodeDelegation; exports.SIGNABLE_DELEGATION_TYPED_DATA = SIGNABLE_DELEGATION_TYPED_DATA; exports.DELEGATION_ARRAY_ABI_TYPE = DELEGATION_ARRAY_ABI_TYPE; exports.DELEGATION_ABI_TYPE = DELEGATION_ABI_TYPE; exports.hashDelegation = hashDelegation; exports.createDelegation = createDelegation; exports.createOpenDelegation = createOpenDelegation; exports.prepareSignDelegationTypedData = prepareSignDelegationTypedData; exports.signDelegation = signDelegation;
-//# sourceMappingURL=chunk-TMO23YRP.cjs.map
+exports.__export = __export; exports.trackSmartAccountsKitFunctionCall = trackSmartAccountsKitFunctionCall; exports.Implementation = Implementation; exports.TransferWindow = TransferWindow; exports.ScopeType = ScopeType; exports.CaveatType = CaveatType; exports.CaveatBuilder = CaveatBuilder; exports.createCaveatBuilder = createCaveatBuilder; exports.isDefined = isDefined; exports.toHexOrThrow = toHexOrThrow; exports.resolveCaveats = resolveCaveats; exports.createCaveat = createCaveat; exports.decodeCaveat = decodeCaveat; exports.ANY_BENEFICIARY = _delegationcore.ANY_BENEFICIARY; exports.DELEGATION_TYPEHASH = _delegationcore.DELEGATION_TYPEHASH; exports.ROOT_AUTHORITY = _delegationcore.ROOT_AUTHORITY; exports.DELEGATION_ABI_TYPE_COMPONENTS = DELEGATION_ABI_TYPE_COMPONENTS; exports.toDelegationStruct = toDelegationStruct; exports.toDelegation = toDelegation; exports.encodeDelegations = encodeDelegations; exports.encodeDelegation = encodeDelegation; exports.decodeDelegations = decodeDelegations; exports.decodeDelegation = decodeDelegation; exports.SIGNABLE_DELEGATION_TYPED_DATA = SIGNABLE_DELEGATION_TYPED_DATA; exports.DELEGATION_ARRAY_ABI_TYPE = DELEGATION_ARRAY_ABI_TYPE; exports.DELEGATION_ABI_TYPE = DELEGATION_ABI_TYPE; exports.hashDelegation = hashDelegation; exports.createDelegation = createDelegation; exports.createOpenDelegation = createOpenDelegation; exports.prepareSignDelegationTypedData = prepareSignDelegationTypedData; exports.signDelegation = signDelegation; exports.createExecution = createExecution; exports.ExecutionMode = ExecutionMode; exports.encodeSingleExecution = encodeSingleExecution; exports.encodeBatchExecution = encodeBatchExecution; exports.encodeExecutionCalldata = encodeExecutionCalldata; exports.encodeExecutionCalldatas = encodeExecutionCalldatas;
+//# sourceMappingURL=chunk-W6HPAK4M.cjs.map