@metamask/delegation-core 1.0.0 → 2.0.0

package/dist/index.cjs

@@ -1,4 +1,11 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/internalUtils.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/caveats/types.ts
+var BalanceChangeType = /* @__PURE__ */ ((BalanceChangeType2) => {
+  BalanceChangeType2[BalanceChangeType2["Increase"] = 0] = "Increase";
+  BalanceChangeType2[BalanceChangeType2["Decrease"] = 1] = "Decrease";
+  return BalanceChangeType2;
+})(BalanceChangeType || {});
+
+// src/internalUtils.ts
 
 
 
@@ -47,6 +54,52 @@ var normalizeAddressLowercase = (value, errorMessage) => {
 var concatHex = (parts) => {
   return `0x${parts.map(_utils.remove0x).join("")}`;
 };
+var extractBigInt = (value, offset, size) => {
+  const start = 2 + offset * 2;
+  const end = start + size * 2;
+  const slice = value.slice(start, end);
+  return BigInt(`0x${slice}`);
+};
+var extractNumber = (value, offset, size) => {
+  const bigIntValue = extractBigInt(value, offset, size);
+  if (bigIntValue > Number.MAX_SAFE_INTEGER) {
+    throw new Error("Number is too large");
+  }
+  return Number(bigIntValue);
+};
+var extractAddress = (value, offset) => {
+  const start = 2 + offset * 2;
+  const end = start + 40;
+  return `0x${value.slice(start, end)}`;
+};
+var extractHex = (value, offset, size) => {
+  const start = 2 + offset * 2;
+  const end = start + size * 2;
+  return `0x${value.slice(start, end)}`;
+};
+var extractRemainingHex = (value, offset) => {
+  const start = 2 + offset * 2;
+  return `0x${value.slice(start)}`;
+};
+function getByteLength(value) {
+  return (value.length - 2) / 2;
+}
+function assertHexByteExactLength(hexTerms, expectedBytes, errorMessage) {
+  if (getByteLength(hexTerms) !== expectedBytes) {
+    throw new Error(errorMessage);
+  }
+}
+function assertHexByteLengthAtLeastOneMultipleOf(hexTerms, unitBytes, errorMessage) {
+  const byteLength = getByteLength(hexTerms);
+  if (byteLength === 0 || byteLength % unitBytes !== 0) {
+    throw new Error(errorMessage);
+  }
+}
+function assertHexBytesMinLength(hexTerms, minBytes, errorMessage) {
+  if (getByteLength(hexTerms) < minBytes) {
+    throw new Error(errorMessage);
+  }
+}
 
 // src/returns.ts
 
@@ -81,47 +134,64 @@ function createValueLteTerms(terms, options = defaultOptions) {
   const hexValue = toHexString({ value: maxValue, size: 32 });
   return prepareResult(hexValue, options);
 }
+function decodeValueLteTerms(terms) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    32,
+    "Invalid ValueLte terms: must be exactly 32 bytes"
+  );
+  const maxValue = extractBigInt(hexTerms, 0, 32);
+  return { maxValue };
+}
 
 // src/caveats/timestamp.ts
 var TIMESTAMP_UPPER_BOUND_SECONDS = 253402300799;
 function createTimestampTerms(terms, encodingOptions = defaultOptions) {
-  const { timestampAfterThreshold, timestampBeforeThreshold } = terms;
-  if (timestampAfterThreshold < 0) {
-    throw new Error(
-      "Invalid timestampAfterThreshold: must be zero or positive"
-    );
+  const { afterThreshold, beforeThreshold } = terms;
+  if (afterThreshold < 0) {
+    throw new Error("Invalid afterThreshold: must be zero or positive");
   }
-  if (timestampBeforeThreshold < 0) {
-    throw new Error(
-      "Invalid timestampBeforeThreshold: must be zero or positive"
-    );
+  if (beforeThreshold < 0) {
+    throw new Error("Invalid beforeThreshold: must be zero or positive");
   }
-  if (timestampBeforeThreshold > TIMESTAMP_UPPER_BOUND_SECONDS) {
+  if (beforeThreshold > TIMESTAMP_UPPER_BOUND_SECONDS) {
     throw new Error(
-      `Invalid timestampBeforeThreshold: must be less than or equal to ${TIMESTAMP_UPPER_BOUND_SECONDS}`
+      `Invalid beforeThreshold: must be less than or equal to ${TIMESTAMP_UPPER_BOUND_SECONDS}`
     );
   }
-  if (timestampAfterThreshold > TIMESTAMP_UPPER_BOUND_SECONDS) {
+  if (afterThreshold > TIMESTAMP_UPPER_BOUND_SECONDS) {
     throw new Error(
-      `Invalid timestampAfterThreshold: must be less than or equal to ${TIMESTAMP_UPPER_BOUND_SECONDS}`
+      `Invalid afterThreshold: must be less than or equal to ${TIMESTAMP_UPPER_BOUND_SECONDS}`
     );
   }
-  if (timestampBeforeThreshold !== 0 && timestampAfterThreshold >= timestampBeforeThreshold) {
+  if (beforeThreshold !== 0 && afterThreshold >= beforeThreshold) {
     throw new Error(
-      "Invalid thresholds: timestampBeforeThreshold must be greater than timestampAfterThreshold when both are specified"
+      "Invalid thresholds: beforeThreshold must be greater than afterThreshold when both are specified"
     );
   }
   const afterThresholdHex = toHexString({
-    value: timestampAfterThreshold,
+    value: afterThreshold,
     size: 16
   });
   const beforeThresholdHex = toHexString({
-    value: timestampBeforeThreshold,
+    value: beforeThreshold,
     size: 16
   });
   const hexValue = `0x${afterThresholdHex}${beforeThresholdHex}`;
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeTimestampTerms(terms) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    32,
+    "Invalid Timestamp terms: must be exactly 32 bytes"
+  );
+  const afterThreshold = extractNumber(hexTerms, 0, 16);
+  const beforeThreshold = extractNumber(hexTerms, 16, 16);
+  return { afterThreshold, beforeThreshold };
+}
 
 // src/caveats/nativeTokenPeriodTransfer.ts
 function createNativeTokenPeriodTransferTerms(terms, encodingOptions = defaultOptions) {
@@ -141,6 +211,18 @@ function createNativeTokenPeriodTransferTerms(terms, encodingOptions = defaultOp
   const hexValue = `0x${periodAmountHex}${periodDurationHex}${startDateHex}`;
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeNativeTokenPeriodTransferTerms(terms) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    96,
+    "Invalid NativeTokenPeriodTransfer terms: must be exactly 96 bytes"
+  );
+  const periodAmount = extractBigInt(hexTerms, 0, 32);
+  const periodDuration = extractNumber(hexTerms, 32, 32);
+  const startDate = extractNumber(hexTerms, 64, 32);
+  return { periodAmount, periodDuration, startDate };
+}
 
 // src/caveats/exactCalldata.ts
 function createExactCalldataTerms(terms, encodingOptions = defaultOptions) {
@@ -153,6 +235,11 @@ function createExactCalldataTerms(terms, encodingOptions = defaultOptions) {
   }
   return prepareResult(calldata, encodingOptions);
 }
+function decodeExactCalldataTerms(terms, encodingOptions = defaultOptions) {
+  const calldataHex = bytesLikeToHex(terms);
+  const calldata = prepareResult(calldataHex, encodingOptions);
+  return { calldata };
+}
 
 // src/caveats/exactCalldataBatch.ts
 var _abiutils = require('@metamask/abi-utils');
@@ -187,6 +274,18 @@ function createExactCalldataBatchTerms(terms, encodingOptions = defaultOptions)
   const hexValue = _abiutils.encodeSingle.call(void 0, EXECUTION_ARRAY_ABI, encodableExecutions);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeExactCalldataBatchTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  const decoded = _abiutils.decodeSingle.call(void 0, EXECUTION_ARRAY_ABI, hexTerms);
+  const executions = decoded.map(
+    ([target, value, callData]) => ({
+      target: prepareResult(target, encodingOptions),
+      value,
+      callData: prepareResult(_utils.bytesToHex.call(void 0, callData), encodingOptions)
+    })
+  );
+  return { executions };
+}
 
 // src/caveats/exactExecution.ts
 
@@ -214,6 +313,24 @@ function createExactExecutionTerms(terms, encodingOptions = defaultOptions) {
   const hexValue = concatHex([targetHex, valueHex, callDataHex]);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeExactExecutionTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexBytesMinLength(
+    hexTerms,
+    52,
+    "Invalid ExactExecution terms: must be at least 52 bytes"
+  );
+  const targetHex = extractAddress(hexTerms, 0);
+  const value = extractBigInt(hexTerms, 20, 32);
+  const callDataHex = extractRemainingHex(hexTerms, 52);
+  return {
+    execution: {
+      target: prepareResult(targetHex, encodingOptions),
+      value,
+      callData: prepareResult(callDataHex, encodingOptions)
+    }
+  };
+}
 
 // src/caveats/exactExecutionBatch.ts
 
@@ -248,6 +365,18 @@ function createExactExecutionBatchTerms(terms, encodingOptions = defaultOptions)
   const hexValue = _abiutils.encodeSingle.call(void 0, EXECUTION_ARRAY_ABI2, encodableExecutions);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeExactExecutionBatchTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  const decoded = _abiutils.decodeSingle.call(void 0, EXECUTION_ARRAY_ABI2, hexTerms);
+  const executions = decoded.map(
+    ([target, value, callData]) => ({
+      target: prepareResult(target, encodingOptions),
+      value,
+      callData: prepareResult(_utils.bytesToHex.call(void 0, callData), encodingOptions)
+    })
+  );
+  return { executions };
+}
 
 // src/caveats/nativeTokenStreaming.ts
 var TIMESTAMP_UPPER_BOUND_SECONDS2 = 253402300799;
@@ -280,6 +409,19 @@ function createNativeTokenStreamingTerms(terms, encodingOptions = defaultOptions
   const hexValue = `0x${initialAmountHex}${maxAmountHex}${amountPerSecondHex}${startTimeHex}`;
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeNativeTokenStreamingTerms(terms) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    128,
+    "Invalid NativeTokenStreaming terms: must be exactly 128 bytes"
+  );
+  const initialAmount = extractBigInt(hexTerms, 0, 32);
+  const maxAmount = extractBigInt(hexTerms, 32, 32);
+  const amountPerSecond = extractBigInt(hexTerms, 64, 32);
+  const startTime = extractNumber(hexTerms, 96, 32);
+  return { initialAmount, maxAmount, amountPerSecond, startTime };
+}
 
 // src/caveats/nativeTokenTransferAmount.ts
 function createNativeTokenTransferAmountTerms(terms, encodingOptions = defaultOptions) {
@@ -290,6 +432,16 @@ function createNativeTokenTransferAmountTerms(terms, encodingOptions = defaultOp
   const hexValue = `0x${toHexString({ value: maxAmount, size: 32 })}`;
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeNativeTokenTransferAmountTerms(terms) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    32,
+    "Invalid NativeTokenTransferAmount terms: must be exactly 32 bytes"
+  );
+  const maxAmount = extractBigInt(hexTerms, 0, 32);
+  return { maxAmount };
+}
 
 // src/caveats/nativeTokenPayment.ts
 function createNativeTokenPaymentTerms(terms, encodingOptions = defaultOptions) {
@@ -305,10 +457,24 @@ function createNativeTokenPaymentTerms(terms, encodingOptions = defaultOptions)
   const hexValue = concatHex([recipientHex, amountHex]);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeNativeTokenPaymentTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    52,
+    "Invalid NativeTokenPayment terms: must be exactly 52 bytes"
+  );
+  const recipientHex = extractAddress(hexTerms, 0);
+  const amount = extractBigInt(hexTerms, 20, 32);
+  return {
+    recipient: prepareResult(recipientHex, encodingOptions),
+    amount
+  };
+}
 
 // src/caveats/nativeBalanceChange.ts
 function createNativeBalanceChangeTerms(terms, encodingOptions = defaultOptions) {
-  const { recipient, balance, changeType: changeTypeNumber } = terms;
+  const { recipient, balance, changeType } = terms;
   const recipientHex = normalizeAddressLowercase(
     recipient,
     "Invalid recipient: must be a valid Address"
@@ -316,7 +482,6 @@ function createNativeBalanceChangeTerms(terms, encodingOptions = defaultOptions)
   if (balance <= 0n) {
     throw new Error("Invalid balance: must be a positive number");
   }
-  const changeType = changeTypeNumber;
   if (changeType !== 0 /* Increase */ && changeType !== 1 /* Decrease */) {
     throw new Error("Invalid changeType: must be either Increase or Decrease");
   }
@@ -325,6 +490,22 @@ function createNativeBalanceChangeTerms(terms, encodingOptions = defaultOptions)
   const hexValue = concatHex([changeTypeHex, recipientHex, balanceHex]);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeNativeBalanceChangeTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    53,
+    "Invalid NativeBalanceChange terms: must be exactly 53 bytes"
+  );
+  const changeType = extractNumber(hexTerms, 0, 1);
+  const recipientHex = extractAddress(hexTerms, 1);
+  const balance = extractBigInt(hexTerms, 21, 32);
+  return {
+    changeType,
+    recipient: prepareResult(recipientHex, encodingOptions),
+    balance
+  };
+}
 
 // src/caveats/erc20Streaming.ts
 
@@ -373,6 +554,26 @@ function createERC20StreamingTerms(terms, encodingOptions = defaultOptions) {
   const hexValue = `${prefixedTokenAddressHex}${initialAmountHex}${maxAmountHex}${amountPerSecondHex}${startTimeHex}`;
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeERC20StreamingTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    148,
+    "Invalid ERC20Streaming terms: must be exactly 148 bytes"
+  );
+  const tokenAddressHex = extractAddress(hexTerms, 0);
+  const initialAmount = extractBigInt(hexTerms, 20, 32);
+  const maxAmount = extractBigInt(hexTerms, 52, 32);
+  const amountPerSecond = extractBigInt(hexTerms, 84, 32);
+  const startTime = extractNumber(hexTerms, 116, 32);
+  return {
+    tokenAddress: prepareResult(tokenAddressHex, encodingOptions),
+    initialAmount,
+    maxAmount,
+    amountPerSecond,
+    startTime
+  };
+}
 
 // src/caveats/erc20TokenPeriodTransfer.ts
 
@@ -408,6 +609,24 @@ function createERC20TokenPeriodTransferTerms(terms, encodingOptions = defaultOpt
   const hexValue = `${prefixedTokenAddressHex}${periodAmountHex}${periodDurationHex}${startDateHex}`;
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeERC20TokenPeriodTransferTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    116,
+    "Invalid ERC20TokenPeriodTransfer terms: must be exactly 116 bytes"
+  );
+  const tokenAddressHex = extractAddress(hexTerms, 0);
+  const periodAmount = extractBigInt(hexTerms, 20, 32);
+  const periodDuration = extractNumber(hexTerms, 52, 32);
+  const startDate = extractNumber(hexTerms, 84, 32);
+  return {
+    tokenAddress: prepareResult(tokenAddressHex, encodingOptions),
+    periodAmount,
+    periodDuration,
+    startDate
+  };
+}
 
 // src/caveats/erc20TransferAmount.ts
 function createERC20TransferAmountTerms(terms, encodingOptions = defaultOptions) {
@@ -423,15 +642,24 @@ function createERC20TransferAmountTerms(terms, encodingOptions = defaultOptions)
   const hexValue = concatHex([tokenAddressHex, maxAmountHex]);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeERC20TransferAmountTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    52,
+    "Invalid ERC20TransferAmount terms: must be exactly 52 bytes"
+  );
+  const tokenAddressHex = extractAddress(hexTerms, 0);
+  const maxAmount = extractBigInt(hexTerms, 20, 32);
+  return {
+    tokenAddress: prepareResult(tokenAddressHex, encodingOptions),
+    maxAmount
+  };
+}
 
 // src/caveats/erc20BalanceChange.ts
 function createERC20BalanceChangeTerms(terms, encodingOptions = defaultOptions) {
-  const {
-    tokenAddress,
-    recipient,
-    balance,
-    changeType: changeTypeNumber
-  } = terms;
+  const { tokenAddress, recipient, balance, changeType } = terms;
   const tokenAddressHex = normalizeAddressLowercase(
     tokenAddress,
     "Invalid tokenAddress: must be a valid address"
@@ -443,7 +671,6 @@ function createERC20BalanceChangeTerms(terms, encodingOptions = defaultOptions)
   if (balance <= 0n) {
     throw new Error("Invalid balance: must be a positive number");
   }
-  const changeType = changeTypeNumber;
   if (changeType !== 0 /* Increase */ && changeType !== 1 /* Decrease */) {
     throw new Error("Invalid changeType: must be either Increase or Decrease");
   }
@@ -457,15 +684,28 @@ function createERC20BalanceChangeTerms(terms, encodingOptions = defaultOptions)
   ]);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeERC20BalanceChangeTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    73,
+    "Invalid ERC20BalanceChange terms: must be exactly 73 bytes"
+  );
+  const changeType = extractNumber(hexTerms, 0, 1);
+  const tokenAddressHex = extractAddress(hexTerms, 1);
+  const recipientHex = extractAddress(hexTerms, 21);
+  const balance = extractBigInt(hexTerms, 41, 32);
+  return {
+    changeType,
+    tokenAddress: prepareResult(tokenAddressHex, encodingOptions),
+    recipient: prepareResult(recipientHex, encodingOptions),
+    balance
+  };
+}
 
 // src/caveats/erc721BalanceChange.ts
 function createERC721BalanceChangeTerms(terms, encodingOptions = defaultOptions) {
-  const {
-    tokenAddress,
-    recipient,
-    amount,
-    changeType: changeTypeNumber
-  } = terms;
+  const { tokenAddress, recipient, amount, changeType } = terms;
   const tokenAddressHex = normalizeAddressLowercase(
     tokenAddress,
     "Invalid tokenAddress: must be a valid address"
@@ -477,7 +717,6 @@ function createERC721BalanceChangeTerms(terms, encodingOptions = defaultOptions)
   if (amount <= 0n) {
     throw new Error("Invalid balance: must be a positive number");
   }
-  const changeType = changeTypeNumber;
   if (changeType !== 0 /* Increase */ && changeType !== 1 /* Decrease */) {
     throw new Error("Invalid changeType: must be either Increase or Decrease");
   }
@@ -491,6 +730,24 @@ function createERC721BalanceChangeTerms(terms, encodingOptions = defaultOptions)
   ]);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeERC721BalanceChangeTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    73,
+    "Invalid ERC721BalanceChange terms: must be exactly 73 bytes"
+  );
+  const changeType = extractNumber(hexTerms, 0, 1);
+  const tokenAddressHex = extractAddress(hexTerms, 1);
+  const recipientHex = extractAddress(hexTerms, 21);
+  const amount = extractBigInt(hexTerms, 41, 32);
+  return {
+    changeType,
+    tokenAddress: prepareResult(tokenAddressHex, encodingOptions),
+    recipient: prepareResult(recipientHex, encodingOptions),
+    amount
+  };
+}
 
 // src/caveats/erc721Transfer.ts
 function createERC721TransferTerms(terms, encodingOptions = defaultOptions) {
@@ -506,16 +763,24 @@ function createERC721TransferTerms(terms, encodingOptions = defaultOptions) {
   const hexValue = concatHex([tokenAddressHex, tokenIdHex]);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeERC721TransferTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    52,
+    "Invalid ERC721Transfer terms: must be exactly 52 bytes"
+  );
+  const tokenAddressHex = extractAddress(hexTerms, 0);
+  const tokenId = extractBigInt(hexTerms, 20, 32);
+  return {
+    tokenAddress: prepareResult(tokenAddressHex, encodingOptions),
+    tokenId
+  };
+}
 
 // src/caveats/erc1155BalanceChange.ts
 function createERC1155BalanceChangeTerms(terms, encodingOptions = defaultOptions) {
-  const {
-    tokenAddress,
-    recipient,
-    tokenId,
-    balance,
-    changeType: changeTypeNumber
-  } = terms;
+  const { tokenAddress, recipient, tokenId, balance, changeType } = terms;
   const tokenAddressHex = normalizeAddressLowercase(
     tokenAddress,
     "Invalid tokenAddress: must be a valid address"
@@ -530,7 +795,6 @@ function createERC1155BalanceChangeTerms(terms, encodingOptions = defaultOptions
   if (tokenId < 0n) {
     throw new Error("Invalid tokenId: must be a non-negative number");
   }
-  const changeType = changeTypeNumber;
   if (changeType !== 0 /* Increase */ && changeType !== 1 /* Decrease */) {
     throw new Error("Invalid changeType: must be either Increase or Decrease");
   }
@@ -546,6 +810,26 @@ function createERC1155BalanceChangeTerms(terms, encodingOptions = defaultOptions
   ]);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeERC1155BalanceChangeTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    105,
+    "Invalid ERC1155BalanceChange terms: must be exactly 105 bytes"
+  );
+  const changeType = extractNumber(hexTerms, 0, 1);
+  const tokenAddressHex = extractAddress(hexTerms, 1);
+  const recipientHex = extractAddress(hexTerms, 21);
+  const tokenId = extractBigInt(hexTerms, 41, 32);
+  const balance = extractBigInt(hexTerms, 73, 32);
+  return {
+    changeType,
+    tokenAddress: prepareResult(tokenAddressHex, encodingOptions),
+    recipient: prepareResult(recipientHex, encodingOptions),
+    tokenId,
+    balance
+  };
+}
 
 // src/caveats/nonce.ts
 
@@ -573,6 +857,16 @@ function createNonceTerms(terms, encodingOptions = defaultOptions) {
   const hexValue = `0x${paddedNonce}`;
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeNonceTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    32,
+    "Invalid Nonce terms: must be exactly 32 bytes"
+  );
+  const nonce = prepareResult(hexTerms, encodingOptions);
+  return { nonce };
+}
 
 // src/caveats/allowedCalldata.ts
 
@@ -596,6 +890,18 @@ function createAllowedCalldataTerms(terms, encodingOptions = defaultOptions) {
   const indexHex = toHexString({ value: startIndex, size: 32 });
   return prepareResult(`0x${indexHex}${unprefixedValue}`, encodingOptions);
 }
+function decodeAllowedCalldataTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexBytesMinLength(
+    hexTerms,
+    32,
+    "Invalid AllowedCalldata terms: must be at least 32 bytes"
+  );
+  const startIndex = extractNumber(hexTerms, 0, 32);
+  const valueHex = extractRemainingHex(hexTerms, 32);
+  const value = prepareResult(valueHex, encodingOptions);
+  return { startIndex, value };
+}
 
 // src/caveats/allowedMethods.ts
 
@@ -621,6 +927,22 @@ function createAllowedMethodsTerms(terms, encodingOptions = defaultOptions) {
   const hexValue = concatHex(normalizedSelectors);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeAllowedMethodsTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  const selectorSize = 4;
+  assertHexByteLengthAtLeastOneMultipleOf(
+    hexTerms,
+    selectorSize,
+    "Invalid selectors: must be a multiple of 4"
+  );
+  const selectorCount = getByteLength(hexTerms) / selectorSize;
+  const selectors = [];
+  for (let i = 0; i < selectorCount; i++) {
+    const selector = extractHex(hexTerms, i * selectorSize, selectorSize);
+    selectors.push(prepareResult(selector, encodingOptions));
+  }
+  return { selectors };
+}
 
 // src/caveats/allowedTargets.ts
 function createAllowedTargetsTerms(terms, encodingOptions = defaultOptions) {
@@ -636,6 +958,22 @@ function createAllowedTargetsTerms(terms, encodingOptions = defaultOptions) {
   const hexValue = concatHex(normalizedTargets);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeAllowedTargetsTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  const addressSize = 20;
+  assertHexByteLengthAtLeastOneMultipleOf(
+    hexTerms,
+    addressSize,
+    "Invalid targets: must be a multiple of 20"
+  );
+  const addressCount = getByteLength(hexTerms) / addressSize;
+  const targets = [];
+  for (let i = 0; i < addressCount; i++) {
+    const target = extractAddress(hexTerms, i * addressSize);
+    targets.push(prepareResult(target, encodingOptions));
+  }
+  return { targets };
+}
 
 // src/caveats/argsEqualityCheck.ts
 function createArgsEqualityCheckTerms(terms, encodingOptions = defaultOptions) {
@@ -649,6 +987,11 @@ function createArgsEqualityCheckTerms(terms, encodingOptions = defaultOptions) {
   );
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeArgsEqualityCheckTerms(terms, encodingOptions = defaultOptions) {
+  const argsHex = bytesLikeToHex(terms);
+  const args = prepareResult(argsHex, encodingOptions);
+  return { args };
+}
 
 // src/caveats/blockNumber.ts
 function createBlockNumberTerms(terms, encodingOptions = defaultOptions) {
@@ -671,6 +1014,17 @@ function createBlockNumberTerms(terms, encodingOptions = defaultOptions) {
   const hexValue = `0x${afterThresholdHex}${beforeThresholdHex}`;
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeBlockNumberTerms(terms) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    32,
+    "Invalid BlockNumber terms: must be exactly 32 bytes"
+  );
+  const afterThreshold = extractBigInt(hexTerms, 0, 16);
+  const beforeThreshold = extractBigInt(hexTerms, 16, 16);
+  return { afterThreshold, beforeThreshold };
+}
 
 // src/caveats/deployed.ts
 
@@ -696,6 +1050,22 @@ function createDeployedTerms(terms, encodingOptions = defaultOptions) {
   const hexValue = concatHex([contractAddressHex, paddedSalt, bytecodeHex]);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeDeployedTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexBytesMinLength(
+    hexTerms,
+    52,
+    "Invalid Deployed terms: must be at least 52 bytes"
+  );
+  const contractAddressHex = extractAddress(hexTerms, 0);
+  const saltHex = extractHex(hexTerms, 20, 32);
+  const bytecodeHex = extractRemainingHex(hexTerms, 52);
+  return {
+    contractAddress: prepareResult(contractAddressHex, encodingOptions),
+    salt: prepareResult(saltHex, encodingOptions),
+    bytecode: prepareResult(bytecodeHex, encodingOptions)
+  };
+}
 
 // src/caveats/id.ts
 var MAX_UINT256 = BigInt(`0x${"f".repeat(64)}`);
@@ -721,6 +1091,16 @@ function createIdTerms(terms, encodingOptions = defaultOptions) {
   const hexValue = `0x${toHexString({ value: idBigInt, size: 32 })}`;
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeIdTerms(terms) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    32,
+    "Invalid Id terms: must be exactly 32 bytes"
+  );
+  const id = extractBigInt(hexTerms, 0, 32);
+  return { id };
+}
 
 // src/caveats/limitedCalls.ts
 function createLimitedCallsTerms(terms, encodingOptions = defaultOptions) {
@@ -734,6 +1114,16 @@ function createLimitedCallsTerms(terms, encodingOptions = defaultOptions) {
   const hexValue = `0x${toHexString({ value: limit, size: 32 })}`;
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeLimitedCallsTerms(terms) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    32,
+    "Invalid LimitedCalls terms: must be exactly 32 bytes"
+  );
+  const limit = extractNumber(hexTerms, 0, 32);
+  return { limit };
+}
 
 // src/caveats/multiTokenPeriod.ts
 function createMultiTokenPeriodTerms(terms, encodingOptions = defaultOptions) {
@@ -768,6 +1158,31 @@ function createMultiTokenPeriodTerms(terms, encodingOptions = defaultOptions) {
   const hexValue = concatHex(hexParts);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeMultiTokenPeriodTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  const configSize = 116;
+  assertHexByteLengthAtLeastOneMultipleOf(
+    hexTerms,
+    configSize,
+    "Invalid MultiTokenPeriod terms: must be a multiple of 116 bytes"
+  );
+  const configCount = getByteLength(hexTerms) / configSize;
+  const tokenConfigs = [];
+  for (let i = 0; i < configCount; i++) {
+    const offset = i * configSize;
+    const tokenHex = extractAddress(hexTerms, offset);
+    const periodAmount = extractBigInt(hexTerms, offset + 20, 32);
+    const periodDuration = extractNumber(hexTerms, offset + 52, 32);
+    const startDate = extractNumber(hexTerms, offset + 84, 32);
+    tokenConfigs.push({
+      token: prepareResult(tokenHex, encodingOptions),
+      periodAmount,
+      periodDuration,
+      startDate
+    });
+  }
+  return { tokenConfigs };
+}
 
 // src/caveats/ownershipTransfer.ts
 function createOwnershipTransferTerms(terms, encodingOptions = defaultOptions) {
@@ -778,6 +1193,18 @@ function createOwnershipTransferTerms(terms, encodingOptions = defaultOptions) {
   );
   return prepareResult(contractAddressHex, encodingOptions);
 }
+function decodeOwnershipTransferTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexByteExactLength(
+    hexTerms,
+    20,
+    "Invalid OwnershipTransfer terms: must be exactly 20 bytes"
+  );
+  const contractAddressHex = extractAddress(hexTerms, 0);
+  return {
+    contractAddress: prepareResult(contractAddressHex, encodingOptions)
+  };
+}
 
 // src/caveats/redeemer.ts
 function createRedeemerTerms(terms, encodingOptions = defaultOptions) {
@@ -793,6 +1220,22 @@ function createRedeemerTerms(terms, encodingOptions = defaultOptions) {
   const hexValue = concatHex(normalizedRedeemers);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeRedeemerTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  const addressSize = 20;
+  assertHexByteLengthAtLeastOneMultipleOf(
+    hexTerms,
+    addressSize,
+    "Invalid redeemers: must be a multiple of 20"
+  );
+  const addressCount = getByteLength(hexTerms) / addressSize;
+  const redeemers = [];
+  for (let i = 0; i < addressCount; i++) {
+    const redeemer = extractAddress(hexTerms, i * addressSize);
+    redeemers.push(prepareResult(redeemer, encodingOptions));
+  }
+  return { redeemers };
+}
 
 // src/caveats/specificActionERC20TransferBatch.ts
 
@@ -834,6 +1277,105 @@ function createSpecificActionERC20TransferBatchTerms(terms, encodingOptions = de
   ]);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeSpecificActionERC20TransferBatchTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  assertHexBytesMinLength(
+    hexTerms,
+    92,
+    "Invalid SpecificActionERC20TransferBatch terms: must be at least 92 bytes"
+  );
+  const tokenAddressHex = extractAddress(hexTerms, 0);
+  const recipientHex = extractAddress(hexTerms, 20);
+  const amount = extractBigInt(hexTerms, 40, 32);
+  const targetHex = extractAddress(hexTerms, 72);
+  const calldataHex = extractRemainingHex(hexTerms, 92);
+  return {
+    tokenAddress: prepareResult(tokenAddressHex, encodingOptions),
+    recipient: prepareResult(recipientHex, encodingOptions),
+    amount,
+    target: prepareResult(targetHex, encodingOptions),
+    calldata: prepareResult(calldataHex, encodingOptions)
+  };
+}
+
+// src/caveats/logicalOrWrapper.ts
+
+
+var CAVEAT_GROUPS_ABI = "((address,bytes,bytes)[])[]";
+var SELECTED_GROUP_ABI = "(uint256,bytes[])";
+function assertValidCaveatGroups(groups) {
+  if (!_optionalChain([groups, 'optionalAccess', _ => _.length])) {
+    throw new Error(
+      "Invalid caveatGroups: must provide at least one caveat group"
+    );
+  }
+  for (let i = 0; i < groups.length; i++) {
+    const group = groups[i];
+    if (!_optionalChain([group, 'optionalAccess', _2 => _2.length])) {
+      throw new Error(
+        `Invalid caveatGroups: group at index ${i} must contain at least one caveat`
+      );
+    }
+  }
+}
+function normalizeCaveatTuple(caveat) {
+  return [
+    normalizeAddress(
+      caveat.enforcer,
+      "Invalid enforcer: must be a valid address"
+    ),
+    normalizeHex(caveat.terms, "Invalid terms: must be a valid hex string"),
+    normalizeHex(caveat.args, "Invalid args: must be a valid hex string")
+  ];
+}
+function encodeCaveatGroupTuple(group) {
+  return [group.map(normalizeCaveatTuple)];
+}
+function createLogicalOrWrapperTerms(terms, encodingOptions = defaultOptions) {
+  assertValidCaveatGroups(terms.caveatGroups);
+  const encodableGroups = terms.caveatGroups.map(encodeCaveatGroupTuple);
+  const hexValue = _abiutils.encodeSingle.call(void 0, CAVEAT_GROUPS_ABI, encodableGroups);
+  return prepareResult(hexValue, encodingOptions);
+}
+function decodeLogicalOrWrapperTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  const decoded = _abiutils.decodeSingle.call(void 0, 
+    CAVEAT_GROUPS_ABI,
+    hexTerms
+  );
+  const caveatGroups = decoded.map(
+    ([caveats]) => caveats.map(([enforcer, caveatTerms, args]) => ({
+      enforcer: prepareResult(enforcer, encodingOptions),
+      terms: prepareResult(_utils.bytesToHex.call(void 0, caveatTerms), encodingOptions),
+      args: prepareResult(_utils.bytesToHex.call(void 0, args), encodingOptions)
+    }))
+  );
+  return { caveatGroups };
+}
+function createLogicalOrWrapperArgs(args, encodingOptions = defaultOptions) {
+  if (args.groupIndex < 0n) {
+    throw new Error("Invalid groupIndex: must be a non-negative number");
+  }
+  const caveatArgsHex = args.caveatArgs.map(
+    (arg) => normalizeHex(arg, "Invalid caveatArgs: must be valid hex strings")
+  );
+  const hexValue = _abiutils.encodeSingle.call(void 0, SELECTED_GROUP_ABI, [
+    args.groupIndex,
+    caveatArgsHex
+  ]);
+  return prepareResult(hexValue, encodingOptions);
+}
+function decodeLogicalOrWrapperArgs(args, encodingOptions = defaultOptions) {
+  const hexArgs = bytesLikeToHex(args);
+  const [groupIndex, caveatArgsRaw] = _abiutils.decodeSingle.call(void 0, 
+    SELECTED_GROUP_ABI,
+    hexArgs
+  );
+  const caveatArgs = caveatArgsRaw.map(
+    (arg) => prepareResult(_utils.bytesToHex.call(void 0, arg), encodingOptions)
+  );
+  return { groupIndex, caveatArgs };
+}
 
 // src/delegation.ts
 
@@ -1003,5 +1545,41 @@ function getCaveatHash(caveat) {
 
 
 
-exports.ANY_BENEFICIARY = ANY_BENEFICIARY; exports.CAVEAT_TYPEHASH = CAVEAT_TYPEHASH; exports.DELEGATION_TYPEHASH = DELEGATION_TYPEHASH; exports.ROOT_AUTHORITY = ROOT_AUTHORITY; exports.createAllowedCalldataTerms = createAllowedCalldataTerms; exports.createAllowedMethodsTerms = createAllowedMethodsTerms; exports.createAllowedTargetsTerms = createAllowedTargetsTerms; exports.createArgsEqualityCheckTerms = createArgsEqualityCheckTerms; exports.createBlockNumberTerms = createBlockNumberTerms; exports.createDeployedTerms = createDeployedTerms; exports.createERC1155BalanceChangeTerms = createERC1155BalanceChangeTerms; exports.createERC20BalanceChangeTerms = createERC20BalanceChangeTerms; exports.createERC20StreamingTerms = createERC20StreamingTerms; exports.createERC20TokenPeriodTransferTerms = createERC20TokenPeriodTransferTerms; exports.createERC20TransferAmountTerms = createERC20TransferAmountTerms; exports.createERC721BalanceChangeTerms = createERC721BalanceChangeTerms; exports.createERC721TransferTerms = createERC721TransferTerms; exports.createExactCalldataBatchTerms = createExactCalldataBatchTerms; exports.createExactCalldataTerms = createExactCalldataTerms; exports.createExactExecutionBatchTerms = createExactExecutionBatchTerms; exports.createExactExecutionTerms = createExactExecutionTerms; exports.createIdTerms = createIdTerms; exports.createLimitedCallsTerms = createLimitedCallsTerms; exports.createMultiTokenPeriodTerms = createMultiTokenPeriodTerms; exports.createNativeBalanceChangeTerms = createNativeBalanceChangeTerms; exports.createNativeTokenPaymentTerms = createNativeTokenPaymentTerms; exports.createNativeTokenPeriodTransferTerms = createNativeTokenPeriodTransferTerms; exports.createNativeTokenStreamingTerms = createNativeTokenStreamingTerms; exports.createNativeTokenTransferAmountTerms = createNativeTokenTransferAmountTerms; exports.createNonceTerms = createNonceTerms; exports.createOwnershipTransferTerms = createOwnershipTransferTerms; exports.createRedeemerTerms = createRedeemerTerms; exports.createSpecificActionERC20TransferBatchTerms = createSpecificActionERC20TransferBatchTerms; exports.createTimestampTerms = createTimestampTerms; exports.createValueLteTerms = createValueLteTerms; exports.decodeDelegation = decodeDelegation; exports.decodeDelegations = decodeDelegations; exports.encodeDelegation = encodeDelegation; exports.encodeDelegations = encodeDelegations; exports.hashDelegation = hashDelegation;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ANY_BENEFICIARY = ANY_BENEFICIARY; exports.BalanceChangeType = BalanceChangeType; exports.CAVEAT_TYPEHASH = CAVEAT_TYPEHASH; exports.DELEGATION_TYPEHASH = DELEGATION_TYPEHASH; exports.ROOT_AUTHORITY = ROOT_AUTHORITY; exports.createAllowedCalldataTerms = createAllowedCalldataTerms; exports.createAllowedMethodsTerms = createAllowedMethodsTerms; exports.createAllowedTargetsTerms = createAllowedTargetsTerms; exports.createArgsEqualityCheckTerms = createArgsEqualityCheckTerms; exports.createBlockNumberTerms = createBlockNumberTerms; exports.createDeployedTerms = createDeployedTerms; exports.createERC1155BalanceChangeTerms = createERC1155BalanceChangeTerms; exports.createERC20BalanceChangeTerms = createERC20BalanceChangeTerms; exports.createERC20StreamingTerms = createERC20StreamingTerms; exports.createERC20TokenPeriodTransferTerms = createERC20TokenPeriodTransferTerms; exports.createERC20TransferAmountTerms = createERC20TransferAmountTerms; exports.createERC721BalanceChangeTerms = createERC721BalanceChangeTerms; exports.createERC721TransferTerms = createERC721TransferTerms; exports.createExactCalldataBatchTerms = createExactCalldataBatchTerms; exports.createExactCalldataTerms = createExactCalldataTerms; exports.createExactExecutionBatchTerms = createExactExecutionBatchTerms; exports.createExactExecutionTerms = createExactExecutionTerms; exports.createIdTerms = createIdTerms; exports.createLimitedCallsTerms = createLimitedCallsTerms; exports.createLogicalOrWrapperArgs = createLogicalOrWrapperArgs; exports.createLogicalOrWrapperTerms = createLogicalOrWrapperTerms; exports.createMultiTokenPeriodTerms = createMultiTokenPeriodTerms; exports.createNativeBalanceChangeTerms = createNativeBalanceChangeTerms; exports.createNativeTokenPaymentTerms = createNativeTokenPaymentTerms; exports.createNativeTokenPeriodTransferTerms = createNativeTokenPeriodTransferTerms; exports.createNativeTokenStreamingTerms = createNativeTokenStreamingTerms; exports.createNativeTokenTransferAmountTerms = createNativeTokenTransferAmountTerms; exports.createNonceTerms = createNonceTerms; exports.createOwnershipTransferTerms = createOwnershipTransferTerms; exports.createRedeemerTerms = createRedeemerTerms; exports.createSpecificActionERC20TransferBatchTerms = createSpecificActionERC20TransferBatchTerms; exports.createTimestampTerms = createTimestampTerms; exports.createValueLteTerms = createValueLteTerms; exports.decodeAllowedCalldataTerms = decodeAllowedCalldataTerms; exports.decodeAllowedMethodsTerms = decodeAllowedMethodsTerms; exports.decodeAllowedTargetsTerms = decodeAllowedTargetsTerms; exports.decodeArgsEqualityCheckTerms = decodeArgsEqualityCheckTerms; exports.decodeBlockNumberTerms = decodeBlockNumberTerms; exports.decodeDelegation = decodeDelegation; exports.decodeDelegations = decodeDelegations; exports.decodeDeployedTerms = decodeDeployedTerms; exports.decodeERC1155BalanceChangeTerms = decodeERC1155BalanceChangeTerms; exports.decodeERC20BalanceChangeTerms = decodeERC20BalanceChangeTerms; exports.decodeERC20StreamingTerms = decodeERC20StreamingTerms; exports.decodeERC20TokenPeriodTransferTerms = decodeERC20TokenPeriodTransferTerms; exports.decodeERC20TransferAmountTerms = decodeERC20TransferAmountTerms; exports.decodeERC721BalanceChangeTerms = decodeERC721BalanceChangeTerms; exports.decodeERC721TransferTerms = decodeERC721TransferTerms; exports.decodeExactCalldataBatchTerms = decodeExactCalldataBatchTerms; exports.decodeExactCalldataTerms = decodeExactCalldataTerms; exports.decodeExactExecutionBatchTerms = decodeExactExecutionBatchTerms; exports.decodeExactExecutionTerms = decodeExactExecutionTerms; exports.decodeIdTerms = decodeIdTerms; exports.decodeLimitedCallsTerms = decodeLimitedCallsTerms; exports.decodeLogicalOrWrapperArgs = decodeLogicalOrWrapperArgs; exports.decodeLogicalOrWrapperTerms = decodeLogicalOrWrapperTerms; exports.decodeMultiTokenPeriodTerms = decodeMultiTokenPeriodTerms; exports.decodeNativeBalanceChangeTerms = decodeNativeBalanceChangeTerms; exports.decodeNativeTokenPaymentTerms = decodeNativeTokenPaymentTerms; exports.decodeNativeTokenPeriodTransferTerms = decodeNativeTokenPeriodTransferTerms; exports.decodeNativeTokenStreamingTerms = decodeNativeTokenStreamingTerms; exports.decodeNativeTokenTransferAmountTerms = decodeNativeTokenTransferAmountTerms; exports.decodeNonceTerms = decodeNonceTerms; exports.decodeOwnershipTransferTerms = decodeOwnershipTransferTerms; exports.decodeRedeemerTerms = decodeRedeemerTerms; exports.decodeSpecificActionERC20TransferBatchTerms = decodeSpecificActionERC20TransferBatchTerms; exports.decodeTimestampTerms = decodeTimestampTerms; exports.decodeValueLteTerms = decodeValueLteTerms; exports.encodeDelegation = encodeDelegation; exports.encodeDelegations = encodeDelegations; exports.hashDelegation = hashDelegation;
 //# sourceMappingURL=index.cjs.map