@metamask/smart-accounts-kit 0.4.0-beta.0 → 0.4.0-beta.2

package/dist/{chunk-TEH426Y4.mjs → chunk-C5ZEEH2Z.mjs}

@@ -4,6 +4,70 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/constants.ts
+var Implementation = /* @__PURE__ */ ((Implementation2) => {
+  Implementation2["MultiSig"] = "MultiSig";
+  Implementation2["Hybrid"] = "Hybrid";
+  Implementation2["Stateless7702"] = "Stateless7702";
+  return Implementation2;
+})(Implementation || {});
+var TransferWindow = /* @__PURE__ */ ((TransferWindow2) => {
+  TransferWindow2[TransferWindow2["Hourly"] = 3600] = "Hourly";
+  TransferWindow2[TransferWindow2["Daily"] = 86400] = "Daily";
+  TransferWindow2[TransferWindow2["Weekly"] = 604800] = "Weekly";
+  TransferWindow2[TransferWindow2["BiWeekly"] = 1209600] = "BiWeekly";
+  TransferWindow2[TransferWindow2["Monthly"] = 2592e3] = "Monthly";
+  TransferWindow2[TransferWindow2["Quarterly"] = 7776e3] = "Quarterly";
+  TransferWindow2[TransferWindow2["Yearly"] = 31536e3] = "Yearly";
+  return TransferWindow2;
+})(TransferWindow || {});
+var ScopeType = /* @__PURE__ */ ((ScopeType2) => {
+  ScopeType2["Erc20TransferAmount"] = "erc20TransferAmount";
+  ScopeType2["Erc20Streaming"] = "erc20Streaming";
+  ScopeType2["Erc20PeriodTransfer"] = "erc20PeriodTransfer";
+  ScopeType2["NativeTokenTransferAmount"] = "nativeTokenTransferAmount";
+  ScopeType2["NativeTokenStreaming"] = "nativeTokenStreaming";
+  ScopeType2["NativeTokenPeriodTransfer"] = "nativeTokenPeriodTransfer";
+  ScopeType2["Erc721Transfer"] = "erc721Transfer";
+  ScopeType2["OwnershipTransfer"] = "ownershipTransfer";
+  ScopeType2["FunctionCall"] = "functionCall";
+  return ScopeType2;
+})(ScopeType || {});
+var CaveatType = /* @__PURE__ */ ((CaveatType2) => {
+  CaveatType2["AllowedMethods"] = "allowedMethods";
+  CaveatType2["AllowedTargets"] = "allowedTargets";
+  CaveatType2["Deployed"] = "deployed";
+  CaveatType2["AllowedCalldata"] = "allowedCalldata";
+  CaveatType2["Erc20BalanceChange"] = "erc20BalanceChange";
+  CaveatType2["Erc721BalanceChange"] = "erc721BalanceChange";
+  CaveatType2["Erc1155BalanceChange"] = "erc1155BalanceChange";
+  CaveatType2["ValueLte"] = "valueLte";
+  CaveatType2["LimitedCalls"] = "limitedCalls";
+  CaveatType2["Id"] = "id";
+  CaveatType2["Nonce"] = "nonce";
+  CaveatType2["Timestamp"] = "timestamp";
+  CaveatType2["BlockNumber"] = "blockNumber";
+  CaveatType2["Erc20TransferAmount"] = "erc20TransferAmount";
+  CaveatType2["Erc20Streaming"] = "erc20Streaming";
+  CaveatType2["NativeTokenStreaming"] = "nativeTokenStreaming";
+  CaveatType2["Erc721Transfer"] = "erc721Transfer";
+  CaveatType2["NativeTokenTransferAmount"] = "nativeTokenTransferAmount";
+  CaveatType2["NativeBalanceChange"] = "nativeBalanceChange";
+  CaveatType2["Redeemer"] = "redeemer";
+  CaveatType2["NativeTokenPayment"] = "nativeTokenPayment";
+  CaveatType2["ArgsEqualityCheck"] = "argsEqualityCheck";
+  CaveatType2["SpecificActionERC20TransferBatch"] = "specificActionERC20TransferBatch";
+  CaveatType2["Erc20PeriodTransfer"] = "erc20PeriodTransfer";
+  CaveatType2["NativeTokenPeriodTransfer"] = "nativeTokenPeriodTransfer";
+  CaveatType2["ExactCalldataBatch"] = "exactCalldataBatch";
+  CaveatType2["ExactCalldata"] = "exactCalldata";
+  CaveatType2["ExactExecution"] = "exactExecution";
+  CaveatType2["ExactExecutionBatch"] = "exactExecutionBatch";
+  CaveatType2["MultiTokenPeriod"] = "multiTokenPeriod";
+  CaveatType2["OwnershipTransfer"] = "ownershipTransfer";
+  return CaveatType2;
+})(CaveatType || {});
+
 // src/caveatBuilder/caveatBuilder.ts
 var INSECURE_UNRESTRICTED_DELEGATION_ERROR_MESSAGE = "No caveats found. If you definitely want to create an empty caveat collection, set `allowInsecureUnrestrictedDelegation` to `true`.";
 var CaveatBuilder = class _CaveatBuilder {
@@ -38,7 +102,7 @@ var CaveatBuilder = class _CaveatBuilder {
   addCaveat(nameOrCaveat, config) {
     if (typeof nameOrCaveat === "object") {
       const caveat = {
-        args: "0x",
+        args: "0x00",
         ...nameOrCaveat
       };
       this.#results = [...this.#results, caveat];
@@ -93,12 +157,13 @@ var allowedCalldataBuilder = (environment, config) => {
   return {
     enforcer: AllowedCalldataEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/allowedMethodsBuilder.ts
-import { isHex, concat, toFunctionSelector } from "viem";
+import { createAllowedMethodsTerms } from "@metamask/delegation-core";
+import { isHex, toFunctionSelector } from "viem";
 var allowedMethods = "allowedMethods";
 var FUNCTION_SELECTOR_STRING_LENGTH = 10;
 var allowedMethodsBuilder = (environment, config) => {
@@ -107,7 +172,7 @@ var allowedMethodsBuilder = (environment, config) => {
     throw new Error("Invalid selectors: must provide at least one selector");
   }
   const parsedSelectors = selectors.map(parseSelector);
-  const terms = concat(parsedSelectors);
+  const terms = createAllowedMethodsTerms({ selectors: parsedSelectors });
   const {
     caveatEnforcers: { AllowedMethodsEnforcer }
   } = environment;
@@ -117,7 +182,7 @@ var allowedMethodsBuilder = (environment, config) => {
   return {
     enforcer: AllowedMethodsEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 function parseSelector(selector) {
@@ -140,7 +205,8 @@ function parseSelector(selector) {
 }
 
 // src/caveatBuilder/allowedTargetsBuilder.ts
-import { concat as concat2, isAddress } from "viem";
+import { createAllowedTargetsTerms } from "@metamask/delegation-core";
+import { isAddress } from "viem";
 var allowedTargets = "allowedTargets";
 var allowedTargetsBuilder = (environment, config) => {
   const { targets } = config;
@@ -155,7 +221,7 @@ var allowedTargetsBuilder = (environment, config) => {
   if (invalidAddresses.length > 0) {
     throw new Error("Invalid targets: must be valid addresses");
   }
-  const terms = concat2(targets);
+  const terms = createAllowedTargetsTerms({ targets });
   const {
     caveatEnforcers: { AllowedTargetsEnforcer }
   } = environment;
@@ -165,11 +231,12 @@ var allowedTargetsBuilder = (environment, config) => {
   return {
     enforcer: AllowedTargetsEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/argsEqualityCheckBuilder.ts
+import { createArgsEqualityCheckTerms } from "@metamask/delegation-core";
 import { isHex as isHex2 } from "viem";
 var argsEqualityCheck = "argsEqualityCheck";
 var argsEqualityCheckBuilder = (environment, config) => {
@@ -185,13 +252,13 @@ var argsEqualityCheckBuilder = (environment, config) => {
   }
   return {
     enforcer: ArgsEqualityCheckEnforcer,
-    terms: args,
-    args: "0x"
+    terms: createArgsEqualityCheckTerms({ args }),
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/blockNumberBuilder.ts
-import { concat as concat3, toHex } from "viem";
+import { createBlockNumberTerms } from "@metamask/delegation-core";
 var blockNumber = "blockNumber";
 var blockNumberBuilder = (environment, config) => {
   const { afterThreshold, beforeThreshold } = config;
@@ -205,14 +272,7 @@ var blockNumberBuilder = (environment, config) => {
       "Invalid thresholds: afterThreshold must be less than beforeThreshold if both are specified"
     );
   }
-  const terms = concat3([
-    toHex(afterThreshold, {
-      size: 16
-    }),
-    toHex(beforeThreshold, {
-      size: 16
-    })
-  ]);
+  const terms = createBlockNumberTerms({ afterThreshold, beforeThreshold });
   const {
     caveatEnforcers: { BlockNumberEnforcer }
   } = environment;
@@ -222,12 +282,13 @@ var blockNumberBuilder = (environment, config) => {
   return {
     enforcer: BlockNumberEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/deployedBuilder.ts
-import { concat as concat4, isAddress as isAddress2, isHex as isHex3, pad } from "viem";
+import { createDeployedTerms } from "@metamask/delegation-core";
+import { isAddress as isAddress2, isHex as isHex3 } from "viem";
 var deployed = "deployed";
 var deployedBuilder = (environment, config) => {
   const { contractAddress, salt, bytecode } = config;
@@ -242,7 +303,7 @@ var deployedBuilder = (environment, config) => {
   if (!isHex3(bytecode)) {
     throw new Error("Invalid bytecode: must be a valid hexadecimal string");
   }
-  const terms = concat4([contractAddress, pad(salt, { size: 32 }), bytecode]);
+  const terms = createDeployedTerms({ contractAddress, salt, bytecode });
   const {
     caveatEnforcers: { DeployedEnforcer }
   } = environment;
@@ -252,12 +313,13 @@ var deployedBuilder = (environment, config) => {
   return {
     enforcer: DeployedEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/erc1155BalanceChangeBuilder.ts
-import { isAddress as isAddress3, encodePacked } from "viem";
+import { createERC1155BalanceChangeTerms } from "@metamask/delegation-core";
+import { isAddress as isAddress3 } from "viem";
 var erc1155BalanceChange = "erc1155BalanceChange";
 var erc1155BalanceChangeBuilder = (environment, config) => {
   const { tokenAddress, recipient, tokenId, balance, changeType } = config;
@@ -276,10 +338,13 @@ var erc1155BalanceChangeBuilder = (environment, config) => {
   if (changeType !== 0 /* Increase */ && changeType !== 1 /* Decrease */) {
     throw new Error("Invalid changeType: must be either Increase or Decrease");
   }
-  const terms = encodePacked(
-    ["uint8", "address", "address", "uint256", "uint256"],
-    [changeType, tokenAddress, recipient, tokenId, balance]
-  );
+  const terms = createERC1155BalanceChangeTerms({
+    tokenAddress,
+    recipient,
+    tokenId,
+    balance,
+    changeType
+  });
   const {
     caveatEnforcers: { ERC1155BalanceChangeEnforcer }
   } = environment;
@@ -289,12 +354,13 @@ var erc1155BalanceChangeBuilder = (environment, config) => {
   return {
     enforcer: ERC1155BalanceChangeEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/erc20BalanceChangeBuilder.ts
-import { isAddress as isAddress4, encodePacked as encodePacked2 } from "viem";
+import { createERC20BalanceChangeTerms } from "@metamask/delegation-core";
+import { isAddress as isAddress4 } from "viem";
 var erc20BalanceChange = "erc20BalanceChange";
 var erc20BalanceChangeBuilder = (environment, config) => {
   const { tokenAddress, recipient, balance, changeType } = config;
@@ -307,10 +373,12 @@ var erc20BalanceChangeBuilder = (environment, config) => {
   if (changeType !== 0 /* Increase */ && changeType !== 1 /* Decrease */) {
     throw new Error("Invalid changeType: must be either Increase or Decrease");
   }
-  const terms = encodePacked2(
-    ["uint8", "address", "address", "uint256"],
-    [changeType, tokenAddress, recipient, balance]
-  );
+  const terms = createERC20BalanceChangeTerms({
+    tokenAddress,
+    recipient,
+    balance,
+    changeType
+  });
   const {
     caveatEnforcers: { ERC20BalanceChangeEnforcer }
   } = environment;
@@ -320,7 +388,7 @@ var erc20BalanceChangeBuilder = (environment, config) => {
   return {
     enforcer: ERC20BalanceChangeEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
@@ -344,7 +412,7 @@ var erc20PeriodTransferBuilder = (environment, config) => {
   return {
     enforcer: ERC20PeriodTransferEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
@@ -369,12 +437,13 @@ var erc20StreamingBuilder = (environment, config) => {
   return {
     enforcer: ERC20StreamingEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/erc20TransferAmountBuilder.ts
-import { concat as concat5, isAddress as isAddress5, toHex as toHex2 } from "viem";
+import { createERC20TransferAmountTerms } from "@metamask/delegation-core";
+import { isAddress as isAddress5 } from "viem";
 var erc20TransferAmount = "erc20TransferAmount";
 var erc20TransferAmountBuilder = (environment, config) => {
   const { tokenAddress, maxAmount } = config;
@@ -384,7 +453,7 @@ var erc20TransferAmountBuilder = (environment, config) => {
   if (maxAmount <= 0n) {
     throw new Error("Invalid maxAmount: must be a positive number");
   }
-  const terms = concat5([tokenAddress, toHex2(maxAmount, { size: 32 })]);
+  const terms = createERC20TransferAmountTerms({ tokenAddress, maxAmount });
   const {
     caveatEnforcers: { ERC20TransferAmountEnforcer }
   } = environment;
@@ -394,12 +463,13 @@ var erc20TransferAmountBuilder = (environment, config) => {
   return {
     enforcer: ERC20TransferAmountEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/erc721BalanceChangeBuilder.ts
-import { isAddress as isAddress6, encodePacked as encodePacked3 } from "viem";
+import { createERC721BalanceChangeTerms } from "@metamask/delegation-core";
+import { isAddress as isAddress6 } from "viem";
 var erc721BalanceChange = "erc721BalanceChange";
 var erc721BalanceChangeBuilder = (environment, config) => {
   const { tokenAddress, recipient, amount, changeType } = config;
@@ -415,10 +485,12 @@ var erc721BalanceChangeBuilder = (environment, config) => {
   if (changeType !== 0 /* Increase */ && changeType !== 1 /* Decrease */) {
     throw new Error("Invalid changeType: must be either Increase or Decrease");
   }
-  const terms = encodePacked3(
-    ["uint8", "address", "address", "uint256"],
-    [changeType, tokenAddress, recipient, amount]
-  );
+  const terms = createERC721BalanceChangeTerms({
+    tokenAddress,
+    recipient,
+    amount,
+    changeType
+  });
   const {
     caveatEnforcers: { ERC721BalanceChangeEnforcer }
   } = environment;
@@ -428,12 +500,13 @@ var erc721BalanceChangeBuilder = (environment, config) => {
   return {
     enforcer: ERC721BalanceChangeEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/erc721TransferBuilder.ts
-import { isAddress as isAddress7, toHex as toHex3, concat as concat6 } from "viem";
+import { createERC721TransferTerms } from "@metamask/delegation-core";
+import { isAddress as isAddress7 } from "viem";
 var erc721Transfer = "erc721Transfer";
 var erc721TransferBuilder = (environment, config) => {
   const { tokenAddress, tokenId } = config;
@@ -443,7 +516,7 @@ var erc721TransferBuilder = (environment, config) => {
   if (tokenId < 0n) {
     throw new Error("Invalid tokenId: must be a non-negative number");
   }
-  const terms = concat6([tokenAddress, toHex3(tokenId, { size: 32 })]);
+  const terms = createERC721TransferTerms({ tokenAddress, tokenId });
   const {
     caveatEnforcers: { ERC721TransferEnforcer }
   } = environment;
@@ -453,12 +526,13 @@ var erc721TransferBuilder = (environment, config) => {
   return {
     enforcer: ERC721TransferEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/exactCalldataBatchBuilder.ts
-import { encodeAbiParameters, isAddress as isAddress8 } from "viem";
+import { createExactCalldataBatchTerms } from "@metamask/delegation-core";
+import { isAddress as isAddress8 } from "viem";
 var exactCalldataBatch = "exactCalldataBatch";
 var exactCalldataBatchBuilder = (environment, config) => {
   const { executions } = config;
@@ -478,19 +552,7 @@ var exactCalldataBatchBuilder = (environment, config) => {
       );
     }
   }
-  const terms = encodeAbiParameters(
-    [
-      {
-        type: "tuple[]",
-        components: [
-          { type: "address", name: "target" },
-          { type: "uint256", name: "value" },
-          { type: "bytes", name: "callData" }
-        ]
-      }
-    ],
-    [executions]
-  );
+  const terms = createExactCalldataBatchTerms({ executions });
   const {
     caveatEnforcers: { ExactCalldataBatchEnforcer }
   } = environment;
@@ -500,7 +562,7 @@ var exactCalldataBatchBuilder = (environment, config) => {
   return {
     enforcer: ExactCalldataBatchEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
@@ -519,12 +581,13 @@ var exactCalldataBuilder = (environment, config) => {
   return {
     enforcer: ExactCalldataEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/exactExecutionBatchBuilder.ts
-import { encodeAbiParameters as encodeAbiParameters2, isAddress as isAddress9 } from "viem";
+import { createExactExecutionBatchTerms } from "@metamask/delegation-core";
+import { isAddress as isAddress9 } from "viem";
 var exactExecutionBatch = "exactExecutionBatch";
 var exactExecutionBatchBuilder = (environment, config) => {
   const { executions } = config;
@@ -544,19 +607,7 @@ var exactExecutionBatchBuilder = (environment, config) => {
       );
     }
   }
-  const terms = encodeAbiParameters2(
-    [
-      {
-        type: "tuple[]",
-        components: [
-          { type: "address", name: "target" },
-          { type: "uint256", name: "value" },
-          { type: "bytes", name: "callData" }
-        ]
-      }
-    ],
-    [executions]
-  );
+  const terms = createExactExecutionBatchTerms({ executions });
   const {
     caveatEnforcers: { ExactExecutionBatchEnforcer }
   } = environment;
@@ -566,12 +617,13 @@ var exactExecutionBatchBuilder = (environment, config) => {
   return {
     enforcer: ExactExecutionBatchEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/exactExecutionBuilder.ts
-import { isAddress as isAddress10, concat as concat7, toHex as toHex4 } from "viem";
+import { createExactExecutionTerms } from "@metamask/delegation-core";
+import { isAddress as isAddress10 } from "viem";
 var exactExecution = "exactExecution";
 var exactExecutionBuilder = (environment, config) => {
   const { execution } = config;
@@ -584,11 +636,7 @@ var exactExecutionBuilder = (environment, config) => {
   if (!execution.callData.startsWith("0x")) {
     throw new Error("Invalid calldata: must be a hex string starting with 0x");
   }
-  const terms = concat7([
-    execution.target,
-    toHex4(execution.value, { size: 32 }),
-    execution.callData
-  ]);
+  const terms = createExactExecutionTerms({ execution });
   const {
     caveatEnforcers: { ExactExecutionEnforcer }
   } = environment;
@@ -598,12 +646,13 @@ var exactExecutionBuilder = (environment, config) => {
   return {
     enforcer: ExactExecutionEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/idBuilder.ts
-import { maxUint256, toHex as toHex5 } from "viem";
+import { createIdTerms } from "@metamask/delegation-core";
+import { maxUint256 } from "viem";
 var id = "id";
 var idBuilder = (environment, config) => {
   const { id: idValue } = config;
@@ -624,7 +673,7 @@ var idBuilder = (environment, config) => {
   if (idBigInt > maxUint256) {
     throw new Error("Invalid id: must be less than 2^256");
   }
-  const terms = toHex5(idBigInt, { size: 32 });
+  const terms = createIdTerms({ id: idBigInt });
   const {
     caveatEnforcers: { IdEnforcer }
   } = environment;
@@ -634,12 +683,12 @@ var idBuilder = (environment, config) => {
   return {
     enforcer: IdEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/limitedCallsBuilder.ts
-import { toHex as toHex6, pad as pad2 } from "viem";
+import { createLimitedCallsTerms } from "@metamask/delegation-core";
 var limitedCalls = "limitedCalls";
 var limitedCallsBuilder = (environment, config) => {
   const { limit } = config;
@@ -649,7 +698,7 @@ var limitedCallsBuilder = (environment, config) => {
   if (limit <= 0) {
     throw new Error("Invalid limit: must be a positive integer");
   }
-  const terms = pad2(toHex6(limit), { size: 32 });
+  const terms = createLimitedCallsTerms({ limit });
   const {
     caveatEnforcers: { LimitedCallsEnforcer }
   } = environment;
@@ -659,12 +708,13 @@ var limitedCallsBuilder = (environment, config) => {
   return {
     enforcer: LimitedCallsEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/multiTokenPeriodBuilder.ts
-import { concat as concat8, isAddress as isAddress11, pad as pad3, toHex as toHex7 } from "viem";
+import { createMultiTokenPeriodTerms } from "@metamask/delegation-core";
+import { isAddress as isAddress11 } from "viem";
 var multiTokenPeriod = "multiTokenPeriod";
 var multiTokenPeriodBuilder = (environment, config) => {
   if (!config?.tokenConfigs || config.tokenConfigs.length === 0) {
@@ -683,17 +733,9 @@ var multiTokenPeriodBuilder = (environment, config) => {
       throw new Error("Invalid period duration: must be greater than 0");
     }
   });
-  const termsArray = config.tokenConfigs.reduce(
-    (acc, { token, periodAmount, periodDuration, startDate }) => [
-      ...acc,
-      pad3(token, { size: 20 }),
-      toHex7(periodAmount, { size: 32 }),
-      toHex7(periodDuration, { size: 32 }),
-      toHex7(startDate, { size: 32 })
-    ],
-    []
-  );
-  const terms = concat8(termsArray);
+  const terms = createMultiTokenPeriodTerms({
+    tokenConfigs: config.tokenConfigs
+  });
   const {
     caveatEnforcers: { MultiTokenPeriodEnforcer }
   } = environment;
@@ -703,12 +745,13 @@ var multiTokenPeriodBuilder = (environment, config) => {
   return {
     enforcer: MultiTokenPeriodEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/nativeBalanceChangeBuilder.ts
-import { isAddress as isAddress12, encodePacked as encodePacked4 } from "viem";
+import { createNativeBalanceChangeTerms } from "@metamask/delegation-core";
+import { isAddress as isAddress12 } from "viem";
 var nativeBalanceChange = "nativeBalanceChange";
 var nativeBalanceChangeBuilder = (environment, config) => {
   const { recipient, balance, changeType } = config;
@@ -721,10 +764,11 @@ var nativeBalanceChangeBuilder = (environment, config) => {
   if (changeType !== 0 /* Increase */ && changeType !== 1 /* Decrease */) {
     throw new Error("Invalid changeType: must be either Increase or Decrease");
   }
-  const terms = encodePacked4(
-    ["uint8", "address", "uint256"],
-    [changeType, recipient, balance]
-  );
+  const terms = createNativeBalanceChangeTerms({
+    recipient,
+    balance,
+    changeType
+  });
   const {
     caveatEnforcers: { NativeBalanceChangeEnforcer }
   } = environment;
@@ -734,12 +778,13 @@ var nativeBalanceChangeBuilder = (environment, config) => {
   return {
     enforcer: NativeBalanceChangeEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/nativeTokenPaymentBuilder.ts
-import { encodePacked as encodePacked5, isAddress as isAddress13 } from "viem";
+import { createNativeTokenPaymentTerms } from "@metamask/delegation-core";
+import { isAddress as isAddress13 } from "viem";
 var nativeTokenPayment = "nativeTokenPayment";
 var nativeTokenPaymentBuilder = (environment, config) => {
   const { recipient, amount } = config;
@@ -749,7 +794,7 @@ var nativeTokenPaymentBuilder = (environment, config) => {
   if (!isAddress13(recipient)) {
     throw new Error("Invalid recipient: must be a valid address");
   }
-  const terms = encodePacked5(["address", "uint256"], [recipient, amount]);
+  const terms = createNativeTokenPaymentTerms({ recipient, amount });
   const {
     caveatEnforcers: { NativeTokenPaymentEnforcer }
   } = environment;
@@ -759,7 +804,7 @@ var nativeTokenPaymentBuilder = (environment, config) => {
   return {
     enforcer: NativeTokenPaymentEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
@@ -784,7 +829,7 @@ var nativeTokenPeriodTransferBuilder = (environment, config) => {
   return {
     enforcer: NativeTokenPeriodTransferEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
@@ -808,19 +853,19 @@ var nativeTokenStreamingBuilder = (environment, config) => {
   return {
     enforcer: NativeTokenStreamingEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/nativeTokenTransferAmountBuilder.ts
-import { encodePacked as encodePacked6 } from "viem";
+import { createNativeTokenTransferAmountTerms } from "@metamask/delegation-core";
 var nativeTokenTransferAmount = "nativeTokenTransferAmount";
 var nativeTokenTransferAmountBuilder = (environment, config) => {
   const { maxAmount } = config;
   if (maxAmount < 0n) {
     throw new Error("Invalid maxAmount: must be zero or positive");
   }
-  const terms = encodePacked6(["uint256"], [maxAmount]);
+  const terms = createNativeTokenTransferAmountTerms({ maxAmount });
   const {
     caveatEnforcers: { NativeTokenTransferAmountEnforcer }
   } = environment;
@@ -832,7 +877,7 @@ var nativeTokenTransferAmountBuilder = (environment, config) => {
   return {
     enforcer: NativeTokenTransferAmountEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
@@ -851,11 +896,12 @@ var nonceBuilder = (environment, config) => {
   return {
     enforcer: NonceEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/ownershipTransferBuilder.ts
+import { createOwnershipTransferTerms } from "@metamask/delegation-core";
 import { isAddress as isAddress14 } from "viem";
 var ownershipTransfer = "ownershipTransfer";
 var ownershipTransferBuilder = (environment, config) => {
@@ -863,7 +909,7 @@ var ownershipTransferBuilder = (environment, config) => {
   if (!isAddress14(contractAddress, { strict: false })) {
     throw new Error("Invalid contractAddress: must be a valid address");
   }
-  const terms = contractAddress;
+  const terms = createOwnershipTransferTerms({ contractAddress });
   const {
     caveatEnforcers: { OwnershipTransferEnforcer }
   } = environment;
@@ -873,12 +919,13 @@ var ownershipTransferBuilder = (environment, config) => {
   return {
     enforcer: OwnershipTransferEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/redeemerBuilder.ts
-import { concat as concat9, isAddress as isAddress15 } from "viem";
+import { createRedeemerTerms } from "@metamask/delegation-core";
+import { isAddress as isAddress15 } from "viem";
 var redeemer = "redeemer";
 var redeemerBuilder = (environment, config) => {
   const { redeemers } = config;
@@ -892,7 +939,7 @@ var redeemerBuilder = (environment, config) => {
       throw new Error("Invalid redeemers: must be a valid address");
     }
   }
-  const terms = concat9(redeemers);
+  const terms = createRedeemerTerms({ redeemers });
   const {
     caveatEnforcers: { RedeemerEnforcer }
   } = environment;
@@ -902,12 +949,13 @@ var redeemerBuilder = (environment, config) => {
   return {
     enforcer: RedeemerEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/specificActionERC20TransferBatchBuilder.ts
-import { concat as concat10, isAddress as isAddress16, toHex as toHex8 } from "viem";
+import { createSpecificActionERC20TransferBatchTerms } from "@metamask/delegation-core";
+import { isAddress as isAddress16 } from "viem";
 var specificActionERC20TransferBatch = "specificActionERC20TransferBatch";
 var specificActionERC20TransferBatchBuilder = (environment, config) => {
   const { tokenAddress, recipient, amount, target, calldata } = config;
@@ -923,13 +971,13 @@ var specificActionERC20TransferBatchBuilder = (environment, config) => {
   if (amount <= 0n) {
     throw new Error("Invalid amount: must be a positive number");
   }
-  const terms = concat10([
+  const terms = createSpecificActionERC20TransferBatchTerms({
     tokenAddress,
     recipient,
-    toHex8(amount, { size: 32 }),
+    amount,
     target,
     calldata
-  ]);
+  });
   const {
     caveatEnforcers: { SpecificActionERC20TransferBatchEnforcer }
   } = environment;
@@ -941,7 +989,7 @@ var specificActionERC20TransferBatchBuilder = (environment, config) => {
   return {
     enforcer: SpecificActionERC20TransferBatchEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
@@ -963,7 +1011,7 @@ var timestampBuilder = (environment, config) => {
   return {
     enforcer: TimestampEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
@@ -982,7 +1030,7 @@ var valueLteBuilder = (environment, config) => {
   return {
     enforcer: ValueLteEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
@@ -1031,7 +1079,7 @@ function createErc20TransferCaveatBuilder(environment, config) {
 }
 
 // src/utils.ts
-import { isHex as isHex4, toHex as toHex9 } from "viem";
+import { isHex as isHex4, toHex } from "viem";
 var hasProperties = (object, properties) => {
   return properties.every(
     (prop) => prop in object && object[prop] !== void 0
@@ -1057,7 +1105,7 @@ function toHexOrThrow(value, parameterName) {
     }
     return value;
   }
-  return toHex9(value);
+  return toHex(value);
 }
 
 // src/caveatBuilder/scope/erc721Scope.ts
@@ -1219,28 +1267,56 @@ function createOwnershipCaveatBuilder(environment, config) {
 }
 
 // src/caveatBuilder/scope/index.ts
+var normalizeScopeConfig = (config) => {
+  return {
+    ...config,
+    type: config.type
+  };
+};
 var createCaveatBuilderFromScope = (environment, scopeConfig) => {
-  switch (scopeConfig.type) {
-    case erc20TransferAmount:
-      return createErc20TransferCaveatBuilder(environment, scopeConfig);
-    case erc20Streaming:
-      return createErc20StreamingCaveatBuilder(environment, scopeConfig);
-    case erc20PeriodTransfer:
-      return createErc20PeriodicCaveatBuilder(environment, scopeConfig);
-    case nativeTokenTransferAmount:
-      return createNativeTokenTransferCaveatBuilder(environment, scopeConfig);
-    case nativeTokenStreaming:
-      return createNativeTokenStreamingCaveatBuilder(environment, scopeConfig);
-    case nativeTokenPeriodTransfer:
-      return createNativeTokenPeriodicCaveatBuilder(environment, scopeConfig);
-    case erc721Transfer:
-      return createErc721CaveatBuilder(environment, scopeConfig);
-    case ownershipTransfer:
-      return createOwnershipCaveatBuilder(environment, scopeConfig);
-    case "functionCall":
-      return createFunctionCallCaveatBuilder(environment, scopeConfig);
+  const normalizedScopeConfig = normalizeScopeConfig(scopeConfig);
+  switch (normalizedScopeConfig.type) {
+    case "erc20TransferAmount" /* Erc20TransferAmount */:
+      return createErc20TransferCaveatBuilder(
+        environment,
+        normalizedScopeConfig
+      );
+    case "erc20Streaming" /* Erc20Streaming */:
+      return createErc20StreamingCaveatBuilder(
+        environment,
+        normalizedScopeConfig
+      );
+    case "erc20PeriodTransfer" /* Erc20PeriodTransfer */:
+      return createErc20PeriodicCaveatBuilder(
+        environment,
+        normalizedScopeConfig
+      );
+    case "nativeTokenTransferAmount" /* NativeTokenTransferAmount */:
+      return createNativeTokenTransferCaveatBuilder(
+        environment,
+        normalizedScopeConfig
+      );
+    case "nativeTokenStreaming" /* NativeTokenStreaming */:
+      return createNativeTokenStreamingCaveatBuilder(
+        environment,
+        normalizedScopeConfig
+      );
+    case "nativeTokenPeriodTransfer" /* NativeTokenPeriodTransfer */:
+      return createNativeTokenPeriodicCaveatBuilder(
+        environment,
+        normalizedScopeConfig
+      );
+    case "erc721Transfer" /* Erc721Transfer */:
+      return createErc721CaveatBuilder(environment, normalizedScopeConfig);
+    case "ownershipTransfer" /* OwnershipTransfer */:
+      return createOwnershipCaveatBuilder(environment, normalizedScopeConfig);
+    case "functionCall" /* FunctionCall */:
+      return createFunctionCallCaveatBuilder(
+        environment,
+        normalizedScopeConfig
+      );
     default:
-      const exhaustivenessCheck = scopeConfig;
+      const exhaustivenessCheck = normalizedScopeConfig;
       throw new Error(
         `Invalid scope type: ${exhaustivenessCheck.type}`
       );
@@ -1279,11 +1355,10 @@ var resolveCaveats = ({
 
 // src/caveats.ts
 import {
-  encodePacked as encodePacked7,
-  encodeAbiParameters as encodeAbiParameters3,
+  encodeAbiParameters,
   parseAbiParameters,
   keccak256,
-  toHex as toHex10
+  toHex as toHex2
 } from "viem";
 var CAVEAT_ABI_TYPE_COMPONENTS = [
   { type: "address", name: "enforcer" },
@@ -1291,9 +1366,9 @@ var CAVEAT_ABI_TYPE_COMPONENTS = [
   { type: "bytes", name: "args" }
 ];
 var CAVEAT_TYPEHASH = keccak256(
-  toHex10("Caveat(address enforcer,bytes terms)")
+  toHex2("Caveat(address enforcer,bytes terms)")
 );
-var createCaveat = (enforcer, terms, args = "0x") => ({
+var createCaveat = (enforcer, terms, args = "0x00") => ({
   enforcer,
   terms,
   args
@@ -1303,13 +1378,15 @@ var createCaveat = (enforcer, terms, args = "0x") => ({
 import {
   encodeDelegations as encodeDelegationsCore,
   decodeDelegations as decodeDelegationsCore,
-  hashDelegation,
+  encodeDelegation as encodeDelegationCore,
+  decodeDelegation as decodeDelegationCore,
+  hashDelegation as hashDelegationCore,
   ANY_BENEFICIARY,
   DELEGATION_TYPEHASH,
   CAVEAT_TYPEHASH as CAVEAT_TYPEHASH2,
   ROOT_AUTHORITY
 } from "@metamask/delegation-core";
-import { hashMessage, toBytes, toHex as toHex11, getAddress } from "viem";
+import { toHex as toHex3, getAddress, isHex as isHex5 } from "viem";
 import { signTypedData } from "viem/accounts";
 var DELEGATION_ABI_TYPE_COMPONENTS = [
   { type: "address", name: "delegate" },
@@ -1338,25 +1415,38 @@ var toDelegationStruct = (delegation) => {
 var toDelegation = (delegationStruct) => {
   return {
     ...delegationStruct,
-    salt: toHex11(delegationStruct.salt)
+    salt: toHex3(delegationStruct.salt)
   };
 };
 var encodeDelegations = (delegations) => {
-  const delegationStructs = delegations.map(toDelegationStruct);
-  return encodeDelegationsCore(delegationStructs);
-};
-var encodePermissionContexts = (delegations) => {
-  const encodedDelegations = delegations.map(
-    (delegationChain) => encodeDelegations(delegationChain)
+  if (Array.isArray(delegations)) {
+    const delegationStructs = delegations.map(toDelegationStruct);
+    return encodeDelegationsCore(delegationStructs);
+  }
+  if (isHex5(delegations)) {
+    return delegations;
+  }
+  throw new Error(
+    "Invalid delegations - must be an array of delegations or a hex string"
   );
-  return encodedDelegations;
 };
-var decodeDelegations = (encoded) => {
-  return decodeDelegationsCore(encoded).map(toDelegation);
+var encodeDelegation = (delegation) => {
+  const delegationStruct = toDelegationStruct(delegation);
+  return encodeDelegationCore(delegationStruct);
+};
+var decodeDelegations = (delegations) => {
+  if (Array.isArray(delegations)) {
+    return delegations;
+  }
+  if (isHex5(delegations)) {
+    return decodeDelegationsCore(delegations).map(toDelegation);
+  }
+  throw new Error(
+    "Invalid delegations - must be an array of delegations or a hex string"
+  );
 };
-var decodePermissionContexts = (encoded) => {
-  const delegationChains = encoded.map(decodeDelegations);
-  return delegationChains;
+var decodeDelegation = (encoded) => {
+  return toDelegation(decodeDelegationCore(encoded));
 };
 var SIGNABLE_DELEGATION_TYPED_DATA = {
   Caveat: [
@@ -1375,9 +1465,13 @@ var DELEGATION_ARRAY_ABI_TYPE = {
   type: "tuple[]",
   components: DELEGATION_ABI_TYPE_COMPONENTS
 };
-var getDelegationHashOffchain = (input) => {
+var DELEGATION_ABI_TYPE = {
+  type: "tuple",
+  components: DELEGATION_ABI_TYPE_COMPONENTS
+};
+var hashDelegation = (input) => {
   const delegationStruct = toDelegationStruct(input);
-  return hashDelegation(delegationStruct);
+  return hashDelegationCore(delegationStruct);
 };
 var resolveAuthority = (parentDelegation) => {
   if (!parentDelegation) {
@@ -1386,7 +1480,7 @@ var resolveAuthority = (parentDelegation) => {
   if (typeof parentDelegation === "string") {
     return parentDelegation;
   }
-  return getDelegationHashOffchain(parentDelegation);
+  return hashDelegation(parentDelegation);
 };
 var createDelegation = (options) => {
   return {
@@ -1394,7 +1488,7 @@ var createDelegation = (options) => {
     delegator: options.from,
     authority: resolveAuthority(options.parentDelegation),
     caveats: resolveCaveats(options),
-    salt: options.salt ?? "0x",
+    salt: options.salt ?? "0x00",
     signature: "0x"
   };
 };
@@ -1404,7 +1498,7 @@ var createOpenDelegation = (options) => {
     delegator: options.from,
     authority: resolveAuthority(options.parentDelegation),
     caveats: resolveCaveats(options),
-    salt: options.salt ?? "0x",
+    salt: options.salt ?? "0x00",
     signature: "0x"
   };
 };
@@ -1462,6 +1556,10 @@ var signDelegation = async ({
 
 export {
   __export,
+  Implementation,
+  TransferWindow,
+  ScopeType,
+  CaveatType,
   CaveatBuilder,
   BalanceChangeType,
   createCaveatBuilder,
@@ -1475,15 +1573,16 @@ export {
   toDelegationStruct,
   toDelegation,
   encodeDelegations,
-  encodePermissionContexts,
+  encodeDelegation,
   decodeDelegations,
-  decodePermissionContexts,
+  decodeDelegation,
   SIGNABLE_DELEGATION_TYPED_DATA,
   DELEGATION_ARRAY_ABI_TYPE,
-  getDelegationHashOffchain,
+  DELEGATION_ABI_TYPE,
+  hashDelegation,
   createDelegation,
   createOpenDelegation,
   prepareSignDelegationTypedData,
   signDelegation
 };
-//# sourceMappingURL=chunk-TEH426Y4.mjs.map
+//# sourceMappingURL=chunk-C5ZEEH2Z.mjs.map