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

package/dist/{chunk-MIP7KJYH.cjs → chunk-YDLLC6PP.cjs}

@@ -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,11 +157,12 @@ var allowedCalldataBuilder = (environment, config) => {
   return {
     enforcer: AllowedCalldataEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/allowedMethodsBuilder.ts
+
 var _viem = require('viem');
 var allowedMethods = "allowedMethods";
 var FUNCTION_SELECTOR_STRING_LENGTH = 10;
@@ -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 = _viem.concat.call(void 0, parsedSelectors);
+  const terms = _delegationcore.createAllowedMethodsTerms.call(void 0, { 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) {
@@ -141,6 +206,7 @@ function parseSelector(selector) {
 
 // src/caveatBuilder/allowedTargetsBuilder.ts
 
+
 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 = _viem.concat.call(void 0, targets);
+  const terms = _delegationcore.createAllowedTargetsTerms.call(void 0, { targets });
   const {
     caveatEnforcers: { AllowedTargetsEnforcer }
   } = environment;
@@ -165,12 +231,13 @@ var allowedTargetsBuilder = (environment, config) => {
   return {
     enforcer: AllowedTargetsEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/argsEqualityCheckBuilder.ts
 
+
 var argsEqualityCheck = "argsEqualityCheck";
 var argsEqualityCheckBuilder = (environment, config) => {
   const { args } = config;
@@ -185,8 +252,8 @@ var argsEqualityCheckBuilder = (environment, config) => {
   }
   return {
     enforcer: ArgsEqualityCheckEnforcer,
-    terms: args,
-    args: "0x"
+    terms: _delegationcore.createArgsEqualityCheckTerms.call(void 0, { args }),
+    args: "0x00"
   };
 };
 
@@ -205,14 +272,7 @@ var blockNumberBuilder = (environment, config) => {
       "Invalid thresholds: afterThreshold must be less than beforeThreshold if both are specified"
     );
   }
-  const terms = _viem.concat.call(void 0, [
-    _viem.toHex.call(void 0, afterThreshold, {
-      size: 16
-    }),
-    _viem.toHex.call(void 0, beforeThreshold, {
-      size: 16
-    })
-  ]);
+  const terms = _delegationcore.createBlockNumberTerms.call(void 0, { 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
 
+
 var deployed = "deployed";
 var deployedBuilder = (environment, config) => {
   const { contractAddress, salt, bytecode } = config;
@@ -242,7 +303,7 @@ var deployedBuilder = (environment, config) => {
   if (!_viem.isHex.call(void 0, bytecode)) {
     throw new Error("Invalid bytecode: must be a valid hexadecimal string");
   }
-  const terms = _viem.concat.call(void 0, [contractAddress, _viem.pad.call(void 0, salt, { size: 32 }), bytecode]);
+  const terms = _delegationcore.createDeployedTerms.call(void 0, { 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
 
+
 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 = _viem.encodePacked.call(void 0, 
-    ["uint8", "address", "address", "uint256", "uint256"],
-    [changeType, tokenAddress, recipient, tokenId, balance]
-  );
+  const terms = _delegationcore.createERC1155BalanceChangeTerms.call(void 0, {
+    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
 
+
 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 = _viem.encodePacked.call(void 0, 
-    ["uint8", "address", "address", "uint256"],
-    [changeType, tokenAddress, recipient, balance]
-  );
+  const terms = _delegationcore.createERC20BalanceChangeTerms.call(void 0, {
+    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
 
+
 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 = _viem.concat.call(void 0, [tokenAddress, _viem.toHex.call(void 0, maxAmount, { size: 32 })]);
+  const terms = _delegationcore.createERC20TransferAmountTerms.call(void 0, { 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
 
+
 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 = _viem.encodePacked.call(void 0, 
-    ["uint8", "address", "address", "uint256"],
-    [changeType, tokenAddress, recipient, amount]
-  );
+  const terms = _delegationcore.createERC721BalanceChangeTerms.call(void 0, {
+    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
 
+
 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 = _viem.concat.call(void 0, [tokenAddress, _viem.toHex.call(void 0, tokenId, { size: 32 })]);
+  const terms = _delegationcore.createERC721TransferTerms.call(void 0, { 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
 
+
 var exactCalldataBatch = "exactCalldataBatch";
 var exactCalldataBatchBuilder = (environment, config) => {
   const { executions } = config;
@@ -478,19 +552,7 @@ var exactCalldataBatchBuilder = (environment, config) => {
       );
     }
   }
-  const terms = _viem.encodeAbiParameters.call(void 0, 
-    [
-      {
-        type: "tuple[]",
-        components: [
-          { type: "address", name: "target" },
-          { type: "uint256", name: "value" },
-          { type: "bytes", name: "callData" }
-        ]
-      }
-    ],
-    [executions]
-  );
+  const terms = _delegationcore.createExactCalldataBatchTerms.call(void 0, { 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
 
+
 var exactExecutionBatch = "exactExecutionBatch";
 var exactExecutionBatchBuilder = (environment, config) => {
   const { executions } = config;
@@ -544,19 +607,7 @@ var exactExecutionBatchBuilder = (environment, config) => {
       );
     }
   }
-  const terms = _viem.encodeAbiParameters.call(void 0, 
-    [
-      {
-        type: "tuple[]",
-        components: [
-          { type: "address", name: "target" },
-          { type: "uint256", name: "value" },
-          { type: "bytes", name: "callData" }
-        ]
-      }
-    ],
-    [executions]
-  );
+  const terms = _delegationcore.createExactExecutionBatchTerms.call(void 0, { 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
 
+
 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 = _viem.concat.call(void 0, [
-    execution.target,
-    _viem.toHex.call(void 0, execution.value, { size: 32 }),
-    execution.callData
-  ]);
+  const terms = _delegationcore.createExactExecutionTerms.call(void 0, { 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
 
+
 var id = "id";
 var idBuilder = (environment, config) => {
   const { id: idValue } = config;
@@ -624,7 +673,7 @@ var idBuilder = (environment, config) => {
   if (idBigInt > _viem.maxUint256) {
     throw new Error("Invalid id: must be less than 2^256");
   }
-  const terms = _viem.toHex.call(void 0, idBigInt, { size: 32 });
+  const terms = _delegationcore.createIdTerms.call(void 0, { id: idBigInt });
   const {
     caveatEnforcers: { IdEnforcer }
   } = environment;
@@ -634,7 +683,7 @@ var idBuilder = (environment, config) => {
   return {
     enforcer: IdEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
@@ -649,7 +698,7 @@ var limitedCallsBuilder = (environment, config) => {
   if (limit <= 0) {
     throw new Error("Invalid limit: must be a positive integer");
   }
-  const terms = _viem.pad.call(void 0, _viem.toHex.call(void 0, limit), { size: 32 });
+  const terms = _delegationcore.createLimitedCallsTerms.call(void 0, { 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
 
+
 var multiTokenPeriod = "multiTokenPeriod";
 var multiTokenPeriodBuilder = (environment, config) => {
   if (!_optionalChain([config, 'optionalAccess', _ => _.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,
-      _viem.pad.call(void 0, token, { size: 20 }),
-      _viem.toHex.call(void 0, periodAmount, { size: 32 }),
-      _viem.toHex.call(void 0, periodDuration, { size: 32 }),
-      _viem.toHex.call(void 0, startDate, { size: 32 })
-    ],
-    []
-  );
-  const terms = _viem.concat.call(void 0, termsArray);
+  const terms = _delegationcore.createMultiTokenPeriodTerms.call(void 0, {
+    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
 
+
 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 = _viem.encodePacked.call(void 0, 
-    ["uint8", "address", "uint256"],
-    [changeType, recipient, balance]
-  );
+  const terms = _delegationcore.createNativeBalanceChangeTerms.call(void 0, {
+    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
 
+
 var nativeTokenPayment = "nativeTokenPayment";
 var nativeTokenPaymentBuilder = (environment, config) => {
   const { recipient, amount } = config;
@@ -749,7 +794,7 @@ var nativeTokenPaymentBuilder = (environment, config) => {
   if (!_viem.isAddress.call(void 0, recipient)) {
     throw new Error("Invalid recipient: must be a valid address");
   }
-  const terms = _viem.encodePacked.call(void 0, ["address", "uint256"], [recipient, amount]);
+  const terms = _delegationcore.createNativeTokenPaymentTerms.call(void 0, { 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,7 +853,7 @@ var nativeTokenStreamingBuilder = (environment, config) => {
   return {
     enforcer: NativeTokenStreamingEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
@@ -820,7 +865,7 @@ var nativeTokenTransferAmountBuilder = (environment, config) => {
   if (maxAmount < 0n) {
     throw new Error("Invalid maxAmount: must be zero or positive");
   }
-  const terms = _viem.encodePacked.call(void 0, ["uint256"], [maxAmount]);
+  const terms = _delegationcore.createNativeTokenTransferAmountTerms.call(void 0, { maxAmount });
   const {
     caveatEnforcers: { NativeTokenTransferAmountEnforcer }
   } = environment;
@@ -832,7 +877,7 @@ var nativeTokenTransferAmountBuilder = (environment, config) => {
   return {
     enforcer: NativeTokenTransferAmountEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
@@ -851,19 +896,20 @@ var nonceBuilder = (environment, config) => {
   return {
     enforcer: NonceEnforcer,
     terms,
-    args: "0x"
+    args: "0x00"
   };
 };
 
 // src/caveatBuilder/ownershipTransferBuilder.ts
 
+
 var ownershipTransfer = "ownershipTransfer";
 var ownershipTransferBuilder = (environment, config) => {
   const { contractAddress } = config;
   if (!_viem.isAddress.call(void 0, contractAddress, { strict: false })) {
     throw new Error("Invalid contractAddress: must be a valid address");
   }
-  const terms = contractAddress;
+  const terms = _delegationcore.createOwnershipTransferTerms.call(void 0, { 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
 
+
 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 = _viem.concat.call(void 0, redeemers);
+  const terms = _delegationcore.createRedeemerTerms.call(void 0, { 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
 
+
 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 = _viem.concat.call(void 0, [
+  const terms = _delegationcore.createSpecificActionERC20TransferBatchTerms.call(void 0, {
     tokenAddress,
     recipient,
-    _viem.toHex.call(void 0, 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"
   };
 };
 
@@ -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}`
       );
@@ -1284,7 +1360,6 @@ var resolveCaveats = ({
 
 
 
-
 var CAVEAT_ABI_TYPE_COMPONENTS = [
   { type: "address", name: "enforcer" },
   { type: "bytes", name: "terms" },
@@ -1293,7 +1368,7 @@ var CAVEAT_ABI_TYPE_COMPONENTS = [
 var CAVEAT_TYPEHASH = _viem.keccak256.call(void 0, 
   _viem.toHex.call(void 0, "Caveat(address enforcer,bytes terms)")
 );
-var createCaveat = (enforcer, terms, args = "0x") => ({
+var createCaveat = (enforcer, terms, args = "0x00") => ({
   enforcer,
   terms,
   args
@@ -1310,6 +1385,8 @@ var createCaveat = (enforcer, terms, args = "0x") => ({
 
 
 
+
+
 var _accounts = require('viem/accounts');
 var DELEGATION_ABI_TYPE_COMPONENTS = [
   { type: "address", name: "delegate" },
@@ -1342,21 +1419,34 @@ var toDelegation = (delegationStruct) => {
   };
 };
 var encodeDelegations = (delegations) => {
-  const delegationStructs = delegations.map(toDelegationStruct);
-  return _delegationcore.encodeDelegations.call(void 0, delegationStructs);
-};
-var encodePermissionContexts = (delegations) => {
-  const encodedDelegations = delegations.map(
-    (delegationChain) => encodeDelegations(delegationChain)
+  if (Array.isArray(delegations)) {
+    const delegationStructs = delegations.map(toDelegationStruct);
+    return _delegationcore.encodeDelegations.call(void 0, delegationStructs);
+  }
+  if (_viem.isHex.call(void 0, delegations)) {
+    return delegations;
+  }
+  throw new Error(
+    "Invalid delegations - must be an array of delegations or a hex string"
   );
-  return encodedDelegations;
 };
-var decodeDelegations = (encoded) => {
-  return _delegationcore.decodeDelegations.call(void 0, encoded).map(toDelegation);
+var encodeDelegation = (delegation) => {
+  const delegationStruct = toDelegationStruct(delegation);
+  return _delegationcore.encodeDelegation.call(void 0, delegationStruct);
+};
+var decodeDelegations = (delegations) => {
+  if (Array.isArray(delegations)) {
+    return delegations;
+  }
+  if (_viem.isHex.call(void 0, delegations)) {
+    return _delegationcore.decodeDelegations.call(void 0, 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(_delegationcore.decodeDelegation.call(void 0, encoded));
 };
 var SIGNABLE_DELEGATION_TYPED_DATA = {
   Caveat: [
@@ -1375,7 +1465,11 @@ 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 _delegationcore.hashDelegation.call(void 0, delegationStruct);
 };
@@ -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: _nullishCoalesce(options.salt, () => ( "0x")),
+    salt: _nullishCoalesce(options.salt, () => ( "0x00")),
     signature: "0x"
   };
 };
@@ -1404,7 +1498,7 @@ var createOpenDelegation = (options) => {
     delegator: options.from,
     authority: resolveAuthority(options.parentDelegation),
     caveats: resolveCaveats(options),
-    salt: _nullishCoalesce(options.salt, () => ( "0x")),
+    salt: _nullishCoalesce(options.salt, () => ( "0x00")),
     signature: "0x"
   };
 };
@@ -1485,5 +1579,10 @@ var signDelegation = async ({
 
 
 
-exports.__export = __export; exports.CaveatBuilder = CaveatBuilder; exports.BalanceChangeType = BalanceChangeType; exports.createCaveatBuilder = createCaveatBuilder; exports.isDefined = isDefined; exports.toHexOrThrow = toHexOrThrow; exports.createCaveat = createCaveat; 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.encodePermissionContexts = encodePermissionContexts; exports.decodeDelegations = decodeDelegations; exports.decodePermissionContexts = decodePermissionContexts; exports.SIGNABLE_DELEGATION_TYPED_DATA = SIGNABLE_DELEGATION_TYPED_DATA; exports.DELEGATION_ARRAY_ABI_TYPE = DELEGATION_ARRAY_ABI_TYPE; exports.getDelegationHashOffchain = getDelegationHashOffchain; exports.createDelegation = createDelegation; exports.createOpenDelegation = createOpenDelegation; exports.prepareSignDelegationTypedData = prepareSignDelegationTypedData; exports.signDelegation = signDelegation;
-//# sourceMappingURL=chunk-MIP7KJYH.cjs.map
+
+
+
+
+
+exports.__export = __export; exports.Implementation = Implementation; exports.TransferWindow = TransferWindow; exports.ScopeType = ScopeType; exports.CaveatType = CaveatType; exports.CaveatBuilder = CaveatBuilder; exports.BalanceChangeType = BalanceChangeType; exports.createCaveatBuilder = createCaveatBuilder; exports.isDefined = isDefined; exports.toHexOrThrow = toHexOrThrow; exports.createCaveat = createCaveat; 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-YDLLC6PP.cjs.map