@metamask/delegation-core 1.0.0 → 2.0.0

package/dist/index.mjs

@@ -1,3 +1,10 @@
+// src/caveats/types.ts
+var BalanceChangeType = /* @__PURE__ */ ((BalanceChangeType2) => {
+  BalanceChangeType2[BalanceChangeType2["Increase"] = 0] = "Increase";
+  BalanceChangeType2[BalanceChangeType2["Decrease"] = 1] = "Decrease";
+  return BalanceChangeType2;
+})(BalanceChangeType || {});
+
 // src/internalUtils.ts
 import {
   bytesToHex,
@@ -47,6 +54,52 @@ var normalizeAddressLowercase = (value, errorMessage) => {
 var concatHex = (parts) => {
   return `0x${parts.map(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
 import { bytesToHex as bytesToHex2, hexToBytes as hexToBytes2 } from "@metamask/utils";
@@ -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,9 +235,14 @@ 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
-import { encodeSingle } from "@metamask/abi-utils";
+import { decodeSingle, encodeSingle } from "@metamask/abi-utils";
 import { bytesToHex as bytesToHex3 } from "@metamask/utils";
 var EXECUTION_ARRAY_ABI = "(address,uint256,bytes)[]";
 function createExactCalldataBatchTerms(terms, encodingOptions = defaultOptions) {
@@ -187,6 +274,18 @@ function createExactCalldataBatchTerms(terms, encodingOptions = defaultOptions)
   const hexValue = encodeSingle(EXECUTION_ARRAY_ABI, encodableExecutions);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeExactCalldataBatchTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  const decoded = decodeSingle(EXECUTION_ARRAY_ABI, hexTerms);
+  const executions = decoded.map(
+    ([target, value, callData]) => ({
+      target: prepareResult(target, encodingOptions),
+      value,
+      callData: prepareResult(bytesToHex3(callData), encodingOptions)
+    })
+  );
+  return { executions };
+}
 
 // src/caveats/exactExecution.ts
 import { bytesToHex as bytesToHex4 } from "@metamask/utils";
@@ -214,9 +313,27 @@ 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
-import { encodeSingle as encodeSingle2 } from "@metamask/abi-utils";
+import { decodeSingle as decodeSingle2, encodeSingle as encodeSingle2 } from "@metamask/abi-utils";
 import { bytesToHex as bytesToHex5 } from "@metamask/utils";
 var EXECUTION_ARRAY_ABI2 = "(address,uint256,bytes)[]";
 function createExactExecutionBatchTerms(terms, encodingOptions = defaultOptions) {
@@ -248,6 +365,18 @@ function createExactExecutionBatchTerms(terms, encodingOptions = defaultOptions)
   const hexValue = encodeSingle2(EXECUTION_ARRAY_ABI2, encodableExecutions);
   return prepareResult(hexValue, encodingOptions);
 }
+function decodeExactExecutionBatchTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  const decoded = decodeSingle2(EXECUTION_ARRAY_ABI2, hexTerms);
+  const executions = decoded.map(
+    ([target, value, callData]) => ({
+      target: prepareResult(target, encodingOptions),
+      value,
+      callData: prepareResult(bytesToHex5(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
 import { bytesToHex as bytesToHex6, isHexString as isHexString2 } from "@metamask/utils";
@@ -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
 import { isHexString as isHexString3, bytesToHex as bytesToHex7 } from "@metamask/utils";
@@ -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
 import { isHexString as isHexString4 } from "@metamask/utils";
@@ -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
 import { bytesToHex as bytesToHex8, remove0x as remove0x2 } from "@metamask/utils";
@@ -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
 import { bytesToHex as bytesToHex9, isHexString as isHexString5 } from "@metamask/utils";
@@ -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
 import { remove0x as remove0x3 } from "@metamask/utils";
@@ -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
 import { bytesToHex as bytesToHex10 } from "@metamask/utils";
@@ -834,9 +1277,108 @@ 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
+import { decodeSingle as decodeSingle3, encodeSingle as encodeSingle3 } from "@metamask/abi-utils";
+import { bytesToHex as bytesToHex11 } from "@metamask/utils";
+var CAVEAT_GROUPS_ABI = "((address,bytes,bytes)[])[]";
+var SELECTED_GROUP_ABI = "(uint256,bytes[])";
+function assertValidCaveatGroups(groups) {
+  if (!groups?.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 (!group?.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 = encodeSingle3(CAVEAT_GROUPS_ABI, encodableGroups);
+  return prepareResult(hexValue, encodingOptions);
+}
+function decodeLogicalOrWrapperTerms(terms, encodingOptions = defaultOptions) {
+  const hexTerms = bytesLikeToHex(terms);
+  const decoded = decodeSingle3(
+    CAVEAT_GROUPS_ABI,
+    hexTerms
+  );
+  const caveatGroups = decoded.map(
+    ([caveats]) => caveats.map(([enforcer, caveatTerms, args]) => ({
+      enforcer: prepareResult(enforcer, encodingOptions),
+      terms: prepareResult(bytesToHex11(caveatTerms), encodingOptions),
+      args: prepareResult(bytesToHex11(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 = encodeSingle3(SELECTED_GROUP_ABI, [
+    args.groupIndex,
+    caveatArgsHex
+  ]);
+  return prepareResult(hexValue, encodingOptions);
+}
+function decodeLogicalOrWrapperArgs(args, encodingOptions = defaultOptions) {
+  const hexArgs = bytesLikeToHex(args);
+  const [groupIndex, caveatArgsRaw] = decodeSingle3(
+    SELECTED_GROUP_ABI,
+    hexArgs
+  );
+  const caveatArgs = caveatArgsRaw.map(
+    (arg) => prepareResult(bytesToHex11(arg), encodingOptions)
+  );
+  return { groupIndex, caveatArgs };
+}
 
 // src/delegation.ts
-import { encode, encodeSingle as encodeSingle3, decodeSingle } from "@metamask/abi-utils";
+import { encode, encodeSingle as encodeSingle4, decodeSingle as decodeSingle4 } from "@metamask/abi-utils";
 import { hexToBytes as hexToBytes3 } from "@metamask/utils";
 import { keccak_256 as keccak256 } from "@noble/hashes/sha3";
 var ANY_BENEFICIARY = "0x0000000000000000000000000000000000000a11";
@@ -863,7 +1405,7 @@ function encodeDelegations(delegations, options = defaultOptions) {
       struct.salt,
       struct.signature
     ]);
-    result = encodeSingle3(DELEGATION_ARRAY_ABI_TYPES, encodableStructs);
+    result = encodeSingle4(DELEGATION_ARRAY_ABI_TYPES, encodableStructs);
   }
   return prepareResult(result, options);
 }
@@ -880,7 +1422,7 @@ function encodeDelegation(delegation, options = defaultOptions) {
     delegation.salt,
     delegation.signature
   ];
-  const result = encodeSingle3(DELEGATION_ABI_TYPE, encodableStruct);
+  const result = encodeSingle4(DELEGATION_ABI_TYPE, encodableStruct);
   return prepareResult(result, options);
 }
 var delegationFromDecodedDelegation = (decodedDelegation, convertFn) => {
@@ -899,7 +1441,7 @@ var delegationFromDecodedDelegation = (decodedDelegation, convertFn) => {
   };
 };
 function decodeDelegations(encoded, options = defaultOptions) {
-  const decodedStructs = decodeSingle(
+  const decodedStructs = decodeSingle4(
     DELEGATION_ARRAY_ABI_TYPES,
     encoded
     // return types cannot be inferred from complex ABI types, so we must assert the type
@@ -914,7 +1456,7 @@ function decodeDelegations(encoded, options = defaultOptions) {
   );
 }
 function decodeDelegation(encoded, options = defaultOptions) {
-  const decodedStruct = decodeSingle(
+  const decodedStruct = decodeSingle4(
     DELEGATION_ABI_TYPE,
     encoded
     // return types cannot be inferred from complex ABI types, so we must assert the type
@@ -964,6 +1506,7 @@ function getCaveatHash(caveat) {
 }
 export {
   ANY_BENEFICIARY,
+  BalanceChangeType,
   CAVEAT_TYPEHASH,
   DELEGATION_TYPEHASH,
   ROOT_AUTHORITY,
@@ -986,6 +1529,8 @@ export {
   createExactExecutionTerms,
   createIdTerms,
   createLimitedCallsTerms,
+  createLogicalOrWrapperArgs,
+  createLogicalOrWrapperTerms,
   createMultiTokenPeriodTerms,
   createNativeBalanceChangeTerms,
   createNativeTokenPaymentTerms,
@@ -998,8 +1543,41 @@ export {
   createSpecificActionERC20TransferBatchTerms,
   createTimestampTerms,
   createValueLteTerms,
+  decodeAllowedCalldataTerms,
+  decodeAllowedMethodsTerms,
+  decodeAllowedTargetsTerms,
+  decodeArgsEqualityCheckTerms,
+  decodeBlockNumberTerms,
   decodeDelegation,
   decodeDelegations,
+  decodeDeployedTerms,
+  decodeERC1155BalanceChangeTerms,
+  decodeERC20BalanceChangeTerms,
+  decodeERC20StreamingTerms,
+  decodeERC20TokenPeriodTransferTerms,
+  decodeERC20TransferAmountTerms,
+  decodeERC721BalanceChangeTerms,
+  decodeERC721TransferTerms,
+  decodeExactCalldataBatchTerms,
+  decodeExactCalldataTerms,
+  decodeExactExecutionBatchTerms,
+  decodeExactExecutionTerms,
+  decodeIdTerms,
+  decodeLimitedCallsTerms,
+  decodeLogicalOrWrapperArgs,
+  decodeLogicalOrWrapperTerms,
+  decodeMultiTokenPeriodTerms,
+  decodeNativeBalanceChangeTerms,
+  decodeNativeTokenPaymentTerms,
+  decodeNativeTokenPeriodTransferTerms,
+  decodeNativeTokenStreamingTerms,
+  decodeNativeTokenTransferAmountTerms,
+  decodeNonceTerms,
+  decodeOwnershipTransferTerms,
+  decodeRedeemerTerms,
+  decodeSpecificActionERC20TransferBatchTerms,
+  decodeTimestampTerms,
+  decodeValueLteTerms,
   encodeDelegation,
   encodeDelegations,
   hashDelegation