@metamask/smart-accounts-kit 1.4.0 → 1.6.0

package/dist/{chunk-EEIIVBNV.mjs → chunk-TNGQTVSY.mjs}

@@ -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
+import {
+  createApprovalRevocationTerms
+} from "@metamask/delegation-core";
+var approvalRevocation = "approvalRevocation";
+var approvalRevocationBuilder = (environment, config) => {
+  const terms = createApprovalRevocationTerms(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
 import { createArgsEqualityCheckTerms } from "@metamask/delegation-core";
 import { isHex as isHex2 } from "viem";
@@ -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) => {
@@ -1364,6 +1391,7 @@ import {
   decodeERC20StreamingTerms,
   decodeERC20TransferAmountTerms,
   decodeERC20BalanceChangeTerms,
+  decodeApprovalRevocationTerms,
   decodeAllowedMethodsTerms,
   decodeAllowedTargetsTerms,
   decodeArgsEqualityCheckTerms,
@@ -1419,113 +1447,142 @@ var decodeCaveat = ({
 }) => {
   switch (enforcer.toLowerCase()) {
     case caveatEnforcers.AllowedCalldataEnforcer?.toLowerCase():
-      return { type: "allowedCalldata", ...decodeAllowedCalldataTerms(terms) };
+      return {
+        type: "allowedCalldata" /* AllowedCalldata */,
+        ...decodeAllowedCalldataTerms(terms)
+      };
     case caveatEnforcers.AllowedMethodsEnforcer?.toLowerCase():
-      return { type: "allowedMethods", ...decodeAllowedMethodsTerms(terms) };
+      return {
+        type: "allowedMethods" /* AllowedMethods */,
+        ...decodeAllowedMethodsTerms(terms)
+      };
+    case caveatEnforcers.ApprovalRevocationEnforcer?.toLowerCase():
+      return {
+        type: "approvalRevocation" /* ApprovalRevocation */,
+        ...decodeApprovalRevocationTerms(terms)
+      };
     case caveatEnforcers.AllowedTargetsEnforcer?.toLowerCase():
-      return { type: "allowedTargets", ...decodeAllowedTargetsTerms(terms) };
+      return {
+        type: "allowedTargets" /* AllowedTargets */,
+        ...decodeAllowedTargetsTerms(terms)
+      };
     case caveatEnforcers.ArgsEqualityCheckEnforcer?.toLowerCase():
       return {
-        type: "argsEqualityCheck",
+        type: "argsEqualityCheck" /* ArgsEqualityCheck */,
         ...decodeArgsEqualityCheckTerms(terms)
       };
     case caveatEnforcers.BlockNumberEnforcer?.toLowerCase():
-      return { type: "blockNumber", ...decodeBlockNumberTerms(terms) };
+      return { type: "blockNumber" /* BlockNumber */, ...decodeBlockNumberTerms(terms) };
     case caveatEnforcers.DeployedEnforcer?.toLowerCase():
-      return { type: "deployed", ...decodeDeployedTerms(terms) };
+      return { type: "deployed" /* Deployed */, ...decodeDeployedTerms(terms) };
     case caveatEnforcers.ERC20BalanceChangeEnforcer?.toLowerCase():
       return {
-        type: "erc20BalanceChange",
+        type: "erc20BalanceChange" /* Erc20BalanceChange */,
         ...decodeERC20BalanceChangeTerms(terms)
       };
     case caveatEnforcers.ERC20TransferAmountEnforcer?.toLowerCase():
       return {
-        type: "erc20TransferAmount",
+        type: "erc20TransferAmount" /* Erc20TransferAmount */,
         ...decodeERC20TransferAmountTerms(terms)
       };
     case caveatEnforcers.ERC20StreamingEnforcer?.toLowerCase():
-      return { type: "erc20Streaming", ...decodeERC20StreamingTerms(terms) };
+      return {
+        type: "erc20Streaming" /* Erc20Streaming */,
+        ...decodeERC20StreamingTerms(terms)
+      };
     case caveatEnforcers.ERC721BalanceChangeEnforcer?.toLowerCase():
       return {
-        type: "erc721BalanceChange",
+        type: "erc721BalanceChange" /* Erc721BalanceChange */,
         ...decodeERC721BalanceChangeTerms(terms)
       };
     case caveatEnforcers.ERC721TransferEnforcer?.toLowerCase():
-      return { type: "erc721Transfer", ...decodeERC721TransferTerms(terms) };
+      return {
+        type: "erc721Transfer" /* Erc721Transfer */,
+        ...decodeERC721TransferTerms(terms)
+      };
     case caveatEnforcers.ERC1155BalanceChangeEnforcer?.toLowerCase():
       return {
-        type: "erc1155BalanceChange",
+        type: "erc1155BalanceChange" /* Erc1155BalanceChange */,
         ...decodeERC1155BalanceChangeTerms(terms)
       };
     case caveatEnforcers.IdEnforcer?.toLowerCase():
-      return { type: "id", ...decodeIdTerms(terms) };
+      return { type: "id" /* Id */, ...decodeIdTerms(terms) };
     case caveatEnforcers.LimitedCallsEnforcer?.toLowerCase():
-      return { type: "limitedCalls", ...decodeLimitedCallsTerms(terms) };
+      return {
+        type: "limitedCalls" /* LimitedCalls */,
+        ...decodeLimitedCallsTerms(terms)
+      };
     case caveatEnforcers.NonceEnforcer?.toLowerCase():
-      return { type: "nonce", ...decodeNonceTerms(terms) };
+      return { type: "nonce" /* Nonce */, ...decodeNonceTerms(terms) };
     case caveatEnforcers.TimestampEnforcer?.toLowerCase():
-      return { type: "timestamp", ...decodeTimestampTerms(terms) };
+      return { type: "timestamp" /* Timestamp */, ...decodeTimestampTerms(terms) };
     case caveatEnforcers.ValueLteEnforcer?.toLowerCase():
-      return { type: "valueLte", ...decodeValueLteTerms(terms) };
+      return { type: "valueLte" /* ValueLte */, ...decodeValueLteTerms(terms) };
     case caveatEnforcers.NativeTokenTransferAmountEnforcer?.toLowerCase():
       return {
-        type: "nativeTokenTransferAmount",
+        type: "nativeTokenTransferAmount" /* NativeTokenTransferAmount */,
         ...decodeNativeTokenTransferAmountTerms(terms)
       };
     case caveatEnforcers.NativeBalanceChangeEnforcer?.toLowerCase():
       return {
-        type: "nativeBalanceChange",
+        type: "nativeBalanceChange" /* NativeBalanceChange */,
         ...decodeNativeBalanceChangeTerms(terms)
       };
     case caveatEnforcers.NativeTokenStreamingEnforcer?.toLowerCase():
       return {
-        type: "nativeTokenStreaming",
+        type: "nativeTokenStreaming" /* NativeTokenStreaming */,
         ...decodeNativeTokenStreamingTerms(terms)
       };
     case caveatEnforcers.NativeTokenPaymentEnforcer?.toLowerCase():
       return {
-        type: "nativeTokenPayment",
+        type: "nativeTokenPayment" /* NativeTokenPayment */,
         ...decodeNativeTokenPaymentTerms(terms)
       };
     case caveatEnforcers.RedeemerEnforcer?.toLowerCase():
-      return { type: "redeemer", ...decodeRedeemerTerms(terms) };
+      return { type: "redeemer" /* Redeemer */, ...decodeRedeemerTerms(terms) };
     case caveatEnforcers.SpecificActionERC20TransferBatchEnforcer?.toLowerCase():
       return {
-        type: "specificActionERC20TransferBatch",
+        type: "specificActionERC20TransferBatch" /* SpecificActionERC20TransferBatch */,
         ...decodeSpecificActionERC20TransferBatchTerms(terms)
       };
     case caveatEnforcers.ERC20PeriodTransferEnforcer?.toLowerCase():
       return {
-        type: "erc20PeriodTransfer",
+        type: "erc20PeriodTransfer" /* Erc20PeriodTransfer */,
         ...decodeERC20TokenPeriodTransferTerms(terms)
       };
     case caveatEnforcers.NativeTokenPeriodTransferEnforcer?.toLowerCase():
       return {
-        type: "nativeTokenPeriodTransfer",
+        type: "nativeTokenPeriodTransfer" /* NativeTokenPeriodTransfer */,
         ...decodeNativeTokenPeriodTransferTerms(terms)
       };
     case caveatEnforcers.ExactCalldataBatchEnforcer?.toLowerCase():
       return {
-        type: "exactCalldataBatch",
+        type: "exactCalldataBatch" /* ExactCalldataBatch */,
         ...decodeExactCalldataBatchTerms(terms)
       };
     case caveatEnforcers.ExactCalldataEnforcer?.toLowerCase():
-      return { type: "exactCalldata", ...decodeExactCalldataTerms(terms) };
+      return {
+        type: "exactCalldata" /* ExactCalldata */,
+        ...decodeExactCalldataTerms(terms)
+      };
     case caveatEnforcers.ExactExecutionEnforcer?.toLowerCase():
-      return { type: "exactExecution", ...decodeExactExecutionTerms(terms) };
+      return {
+        type: "exactExecution" /* ExactExecution */,
+        ...decodeExactExecutionTerms(terms)
+      };
     case caveatEnforcers.ExactExecutionBatchEnforcer?.toLowerCase():
       return {
-        type: "exactExecutionBatch",
+        type: "exactExecutionBatch" /* ExactExecutionBatch */,
         ...decodeExactExecutionBatchTerms(terms)
       };
     case caveatEnforcers.MultiTokenPeriodEnforcer?.toLowerCase():
       return {
-        type: "multiTokenPeriod",
+        type: "multiTokenPeriod" /* MultiTokenPeriod */,
         ...decodeMultiTokenPeriodTerms(terms)
       };
     case caveatEnforcers.OwnershipTransferEnforcer?.toLowerCase():
       return {
-        type: "ownershipTransfer",
+        type: "ownershipTransfer" /* OwnershipTransfer */,
         ...decodeOwnershipTransferTerms(terms)
       };
     default:
@@ -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) {
@@ -1943,14 +2000,16 @@ var hashDelegation = (input) => {
   const delegationStruct = toDelegationStruct(input);
   return hashDelegationCore(delegationStruct);
 };
-var resolveAuthority = (parentDelegation) => {
-  if (!parentDelegation) {
-    return 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,
@@ -1970,11 +2029,47 @@ var getCaveatNames = ({
   }
   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 ROOT_AUTHORITY;
+    }
+    if (typeof resolvedParentDelegation === "string") {
+      if (resolvedParentDelegation.toLowerCase() === ROOT_AUTHORITY.toLowerCase()) {
+        throw new Error(
+          `Invalid parent delegation - cannot be ${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: 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: options.scope?.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: 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: options.scope?.type ?? null,
     caveatNames: getCaveatNames({
       caveats,
       environment: options.environment
@@ -2002,9 +2097,9 @@ var createOpenDelegation = (options) => {
   return {
     delegate: ANY_BENEFICIARY,
     delegator: options.from,
-    authority: resolveAuthority(options.parentDelegation),
+    authority,
     caveats,
-    salt: options.salt ?? "0x00",
+    salt,
     signature: "0x"
   };
 };
@@ -2060,6 +2155,76 @@ var signDelegation = async ({
   });
 };
 
+// src/executions.ts
+import {
+  encodeAbiParameters as encodeAbiParameters2,
+  encodePacked
+} from "viem";
+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 encodePacked(
+    ["address", "uint256", "bytes"],
+    [execution.target, execution.value, execution.callData]
+  );
+};
+var encodeBatchExecution = (executions) => {
+  return encodeAbiParameters2(
+    [
+      {
+        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);
+};
+
 export {
   __export,
   trackSmartAccountsKitFunctionCall,
@@ -2071,6 +2236,7 @@ export {
   createCaveatBuilder,
   isDefined,
   toHexOrThrow,
+  resolveCaveats,
   createCaveat,
   decodeCaveat,
   ANY_BENEFICIARY,
@@ -2090,6 +2256,12 @@ export {
   createDelegation,
   createOpenDelegation,
   prepareSignDelegationTypedData,
-  signDelegation
+  signDelegation,
+  createExecution,
+  ExecutionMode,
+  encodeSingleExecution,
+  encodeBatchExecution,
+  encodeExecutionCalldata,
+  encodeExecutionCalldatas
 };
-//# sourceMappingURL=chunk-EEIIVBNV.mjs.map
+//# sourceMappingURL=chunk-TNGQTVSY.mjs.map