@metamask/delegation-core 0.2.0 → 0.4.0

package/dist/index.mjs

@@ -1,35 +1,77 @@
+// src/internalUtils.ts
+import {
+  bytesToHex,
+  hexToBytes,
+  isHexString,
+  remove0x
+} from "@metamask/utils";
+var toHexString = ({
+  value,
+  size
+}) => {
+  return value.toString(16).padStart(size * 2, "0");
+};
+var normalizeHex = (value, errorMessage) => {
+  if (typeof value === "string") {
+    if (!isHexString(value)) {
+      throw new Error(errorMessage);
+    }
+    return value;
+  }
+  return bytesToHex(value);
+};
+var normalizeAddress = (value, errorMessage) => {
+  if (typeof value === "string") {
+    if (!isHexString(value) || value.length !== 42) {
+      throw new Error(errorMessage);
+    }
+    return value;
+  }
+  if (value.length !== 20) {
+    throw new Error(errorMessage);
+  }
+  return bytesToHex(value);
+};
+var normalizeAddressLowercase = (value, errorMessage) => {
+  if (typeof value === "string") {
+    if (!isHexString(value) || value.length !== 42) {
+      throw new Error(errorMessage);
+    }
+    return bytesToHex(hexToBytes(value));
+  }
+  if (value.length !== 20) {
+    throw new Error(errorMessage);
+  }
+  return bytesToHex(value);
+};
+var concatHex = (parts) => {
+  return `0x${parts.map(remove0x).join("")}`;
+};
+
 // src/returns.ts
-import { bytesToHex, hexToBytes } from "@metamask/utils";
+import { bytesToHex as bytesToHex2, hexToBytes as hexToBytes2 } from "@metamask/utils";
 var defaultOptions = { out: "hex" };
 function prepareResult(result, options) {
   if (options.out === "hex") {
-    const hexValue = typeof result === "string" ? result : bytesToHex(result);
+    const hexValue = typeof result === "string" ? result : bytesToHex2(result);
     return hexValue.startsWith("0x") ? hexValue : `0x${hexValue}`;
   }
-  const bytesValue = result instanceof Uint8Array ? result : hexToBytes(result);
+  const bytesValue = result instanceof Uint8Array ? result : hexToBytes2(result);
   return bytesValue;
 }
 var bytesLikeToHex = (bytesLike) => {
   if (typeof bytesLike === "string") {
     return bytesLike;
   }
-  return bytesToHex(bytesLike);
+  return bytesToHex2(bytesLike);
 };
 var bytesLikeToBytes = (bytesLike) => {
   if (typeof bytesLike === "string") {
-    return hexToBytes(bytesLike);
+    return hexToBytes2(bytesLike);
   }
   return bytesLike;
 };
 
-// src/utils.ts
-var toHexString = ({
-  value,
-  size
-}) => {
-  return value.toString(16).padStart(size * 2, "0");
-};
-
 // src/caveats/valueLte.ts
 function createValueLteTerms(terms, options = defaultOptions) {
   const { maxValue } = terms;
@@ -103,12 +145,110 @@ function createNativeTokenPeriodTransferTerms(terms, encodingOptions = defaultOp
 // src/caveats/exactCalldata.ts
 function createExactCalldataTerms(terms, encodingOptions = defaultOptions) {
   const { calldata } = terms;
+  if (calldata === void 0 || calldata === null) {
+    throw new Error("Invalid calldata: calldata is required");
+  }
   if (typeof calldata === "string" && !calldata.startsWith("0x")) {
     throw new Error("Invalid calldata: must be a hex string starting with 0x");
   }
   return prepareResult(calldata, encodingOptions);
 }
 
+// src/caveats/exactCalldataBatch.ts
+import { encodeSingle } from "@metamask/abi-utils";
+import { bytesToHex as bytesToHex3 } from "@metamask/utils";
+var EXECUTION_ARRAY_ABI = "(address,uint256,bytes)[]";
+function createExactCalldataBatchTerms(terms, encodingOptions = defaultOptions) {
+  const { executions } = terms;
+  if (executions.length === 0) {
+    throw new Error("Invalid executions: array cannot be empty");
+  }
+  const encodableExecutions = executions.map((execution) => {
+    const targetHex = normalizeAddress(
+      execution.target,
+      "Invalid target: must be a valid address"
+    );
+    if (execution.value < 0n) {
+      throw new Error("Invalid value: must be a non-negative number");
+    }
+    let callDataHex;
+    if (typeof execution.callData === "string") {
+      if (!execution.callData.startsWith("0x")) {
+        throw new Error(
+          "Invalid calldata: must be a hex string starting with 0x"
+        );
+      }
+      callDataHex = execution.callData;
+    } else {
+      callDataHex = bytesToHex3(execution.callData);
+    }
+    return [targetHex, execution.value, callDataHex];
+  });
+  const hexValue = encodeSingle(EXECUTION_ARRAY_ABI, encodableExecutions);
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/exactExecution.ts
+import { bytesToHex as bytesToHex4 } from "@metamask/utils";
+function createExactExecutionTerms(terms, encodingOptions = defaultOptions) {
+  const { execution } = terms;
+  const targetHex = normalizeAddress(
+    execution.target,
+    "Invalid target: must be a valid address"
+  );
+  if (execution.value < 0n) {
+    throw new Error("Invalid value: must be a non-negative number");
+  }
+  let callDataHex;
+  if (typeof execution.callData === "string") {
+    if (!execution.callData.startsWith("0x")) {
+      throw new Error(
+        "Invalid calldata: must be a hex string starting with 0x"
+      );
+    }
+    callDataHex = execution.callData;
+  } else {
+    callDataHex = bytesToHex4(execution.callData);
+  }
+  const valueHex = `0x${toHexString({ value: execution.value, size: 32 })}`;
+  const hexValue = concatHex([targetHex, valueHex, callDataHex]);
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/exactExecutionBatch.ts
+import { 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) {
+  const { executions } = terms;
+  if (executions.length === 0) {
+    throw new Error("Invalid executions: array cannot be empty");
+  }
+  const encodableExecutions = executions.map((execution) => {
+    const targetHex = normalizeAddress(
+      execution.target,
+      "Invalid target: must be a valid address"
+    );
+    if (execution.value < 0n) {
+      throw new Error("Invalid value: must be a non-negative number");
+    }
+    let callDataHex;
+    if (typeof execution.callData === "string") {
+      if (!execution.callData.startsWith("0x")) {
+        throw new Error(
+          "Invalid calldata: must be a hex string starting with 0x"
+        );
+      }
+      callDataHex = execution.callData;
+    } else {
+      callDataHex = bytesToHex5(execution.callData);
+    }
+    return [targetHex, execution.value, callDataHex];
+  });
+  const hexValue = encodeSingle2(EXECUTION_ARRAY_ABI2, encodableExecutions);
+  return prepareResult(hexValue, encodingOptions);
+}
+
 // src/caveats/nativeTokenStreaming.ts
 var TIMESTAMP_UPPER_BOUND_SECONDS2 = 253402300799;
 function createNativeTokenStreamingTerms(terms, encodingOptions = defaultOptions) {
@@ -141,8 +281,53 @@ function createNativeTokenStreamingTerms(terms, encodingOptions = defaultOptions
   return prepareResult(hexValue, encodingOptions);
 }
 
+// src/caveats/nativeTokenTransferAmount.ts
+function createNativeTokenTransferAmountTerms(terms, encodingOptions = defaultOptions) {
+  const { maxAmount } = terms;
+  if (maxAmount < 0n) {
+    throw new Error("Invalid maxAmount: must be zero or positive");
+  }
+  const hexValue = `0x${toHexString({ value: maxAmount, size: 32 })}`;
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/nativeTokenPayment.ts
+function createNativeTokenPaymentTerms(terms, encodingOptions = defaultOptions) {
+  const { recipient, amount } = terms;
+  const recipientHex = normalizeAddressLowercase(
+    recipient,
+    "Invalid recipient: must be a valid address"
+  );
+  if (amount <= 0n) {
+    throw new Error("Invalid amount: must be positive");
+  }
+  const amountHex = `0x${toHexString({ value: amount, size: 32 })}`;
+  const hexValue = concatHex([recipientHex, amountHex]);
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/nativeBalanceChange.ts
+function createNativeBalanceChangeTerms(terms, encodingOptions = defaultOptions) {
+  const { recipient, balance, changeType: changeTypeNumber } = terms;
+  const recipientHex = normalizeAddressLowercase(
+    recipient,
+    "Invalid recipient: must be a valid Address"
+  );
+  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");
+  }
+  const changeTypeHex = `0x${toHexString({ value: changeType, size: 1 })}`;
+  const balanceHex = `0x${toHexString({ value: balance, size: 32 })}`;
+  const hexValue = concatHex([changeTypeHex, recipientHex, balanceHex]);
+  return prepareResult(hexValue, encodingOptions);
+}
+
 // src/caveats/erc20Streaming.ts
-import { bytesToHex as bytesToHex2, isHexString } from "@metamask/utils";
+import { bytesToHex as bytesToHex6, isHexString as isHexString2 } from "@metamask/utils";
 var TIMESTAMP_UPPER_BOUND_SECONDS3 = 253402300799;
 function createERC20StreamingTerms(terms, encodingOptions = defaultOptions) {
   const { tokenAddress, initialAmount, maxAmount, amountPerSecond, startTime } = terms;
@@ -151,7 +336,7 @@ function createERC20StreamingTerms(terms, encodingOptions = defaultOptions) {
   }
   let prefixedTokenAddressHex;
   if (typeof tokenAddress === "string") {
-    if (!isHexString(tokenAddress) || tokenAddress.length !== 42) {
+    if (!isHexString2(tokenAddress) || tokenAddress.length !== 42) {
       throw new Error("Invalid tokenAddress: must be a valid address");
     }
     prefixedTokenAddressHex = tokenAddress;
@@ -159,7 +344,7 @@ function createERC20StreamingTerms(terms, encodingOptions = defaultOptions) {
     if (tokenAddress.length !== 20) {
       throw new Error("Invalid tokenAddress: must be a valid address");
     }
-    prefixedTokenAddressHex = bytesToHex2(tokenAddress);
+    prefixedTokenAddressHex = bytesToHex6(tokenAddress);
   }
   if (initialAmount < 0n) {
     throw new Error("Invalid initialAmount: must be greater than zero");
@@ -190,7 +375,7 @@ function createERC20StreamingTerms(terms, encodingOptions = defaultOptions) {
 }
 
 // src/caveats/erc20TokenPeriodTransfer.ts
-import { isHexString as isHexString2, bytesToHex as bytesToHex3 } from "@metamask/utils";
+import { isHexString as isHexString3, bytesToHex as bytesToHex7 } from "@metamask/utils";
 function createERC20TokenPeriodTransferTerms(terms, encodingOptions = defaultOptions) {
   const { tokenAddress, periodAmount, periodDuration, startDate } = terms;
   if (!tokenAddress) {
@@ -198,7 +383,7 @@ function createERC20TokenPeriodTransferTerms(terms, encodingOptions = defaultOpt
   }
   let prefixedTokenAddressHex;
   if (typeof tokenAddress === "string") {
-    if (!isHexString2(tokenAddress) || tokenAddress.length !== 42) {
+    if (!isHexString3(tokenAddress) || tokenAddress.length !== 42) {
       throw new Error("Invalid tokenAddress: must be a valid address");
     }
     prefixedTokenAddressHex = tokenAddress;
@@ -206,7 +391,7 @@ function createERC20TokenPeriodTransferTerms(terms, encodingOptions = defaultOpt
     if (tokenAddress.length !== 20) {
       throw new Error("Invalid tokenAddress: must be a valid address");
     }
-    prefixedTokenAddressHex = bytesToHex3(tokenAddress);
+    prefixedTokenAddressHex = bytesToHex7(tokenAddress);
   }
   if (periodAmount <= 0n) {
     throw new Error("Invalid periodAmount: must be a positive number");
@@ -224,8 +409,146 @@ function createERC20TokenPeriodTransferTerms(terms, encodingOptions = defaultOpt
   return prepareResult(hexValue, encodingOptions);
 }
 
+// src/caveats/erc20TransferAmount.ts
+function createERC20TransferAmountTerms(terms, encodingOptions = defaultOptions) {
+  const { tokenAddress, maxAmount } = terms;
+  const tokenAddressHex = normalizeAddress(
+    tokenAddress,
+    "Invalid tokenAddress: must be a valid address"
+  );
+  if (maxAmount <= 0n) {
+    throw new Error("Invalid maxAmount: must be a positive number");
+  }
+  const maxAmountHex = `0x${toHexString({ value: maxAmount, size: 32 })}`;
+  const hexValue = concatHex([tokenAddressHex, maxAmountHex]);
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/erc20BalanceChange.ts
+function createERC20BalanceChangeTerms(terms, encodingOptions = defaultOptions) {
+  const {
+    tokenAddress,
+    recipient,
+    balance,
+    changeType: changeTypeNumber
+  } = terms;
+  const tokenAddressHex = normalizeAddressLowercase(
+    tokenAddress,
+    "Invalid tokenAddress: must be a valid address"
+  );
+  const recipientHex = normalizeAddressLowercase(
+    recipient,
+    "Invalid recipient: must be a valid address"
+  );
+  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");
+  }
+  const changeTypeHex = `0x${toHexString({ value: changeType, size: 1 })}`;
+  const balanceHex = `0x${toHexString({ value: balance, size: 32 })}`;
+  const hexValue = concatHex([
+    changeTypeHex,
+    tokenAddressHex,
+    recipientHex,
+    balanceHex
+  ]);
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/erc721BalanceChange.ts
+function createERC721BalanceChangeTerms(terms, encodingOptions = defaultOptions) {
+  const {
+    tokenAddress,
+    recipient,
+    amount,
+    changeType: changeTypeNumber
+  } = terms;
+  const tokenAddressHex = normalizeAddressLowercase(
+    tokenAddress,
+    "Invalid tokenAddress: must be a valid address"
+  );
+  const recipientHex = normalizeAddressLowercase(
+    recipient,
+    "Invalid recipient: must be a valid address"
+  );
+  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");
+  }
+  const changeTypeHex = `0x${toHexString({ value: changeType, size: 1 })}`;
+  const amountHex = `0x${toHexString({ value: amount, size: 32 })}`;
+  const hexValue = concatHex([
+    changeTypeHex,
+    tokenAddressHex,
+    recipientHex,
+    amountHex
+  ]);
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/erc721Transfer.ts
+function createERC721TransferTerms(terms, encodingOptions = defaultOptions) {
+  const { tokenAddress, tokenId } = terms;
+  const tokenAddressHex = normalizeAddress(
+    tokenAddress,
+    "Invalid tokenAddress: must be a valid address"
+  );
+  if (tokenId < 0n) {
+    throw new Error("Invalid tokenId: must be a non-negative number");
+  }
+  const tokenIdHex = `0x${toHexString({ value: tokenId, size: 32 })}`;
+  const hexValue = concatHex([tokenAddressHex, tokenIdHex]);
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/erc1155BalanceChange.ts
+function createERC1155BalanceChangeTerms(terms, encodingOptions = defaultOptions) {
+  const {
+    tokenAddress,
+    recipient,
+    tokenId,
+    balance,
+    changeType: changeTypeNumber
+  } = terms;
+  const tokenAddressHex = normalizeAddressLowercase(
+    tokenAddress,
+    "Invalid tokenAddress: must be a valid address"
+  );
+  const recipientHex = normalizeAddressLowercase(
+    recipient,
+    "Invalid recipient: must be a valid address"
+  );
+  if (balance <= 0n) {
+    throw new Error("Invalid balance: must be a positive number");
+  }
+  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");
+  }
+  const changeTypeHex = `0x${toHexString({ value: changeType, size: 1 })}`;
+  const tokenIdHex = `0x${toHexString({ value: tokenId, size: 32 })}`;
+  const balanceHex = `0x${toHexString({ value: balance, size: 32 })}`;
+  const hexValue = concatHex([
+    changeTypeHex,
+    tokenAddressHex,
+    recipientHex,
+    tokenIdHex,
+    balanceHex
+  ]);
+  return prepareResult(hexValue, encodingOptions);
+}
+
 // src/caveats/nonce.ts
-import { isHexString as isHexString3 } from "@metamask/utils";
+import { isHexString as isHexString4 } from "@metamask/utils";
 var MAX_NONCE_STRING_LENGTH = 66;
 function createNonceTerms(terms, encodingOptions = defaultOptions) {
   const { nonce } = terms;
@@ -239,7 +562,7 @@ function createNonceTerms(terms, encodingOptions = defaultOptions) {
   if (hexNonce === "0x") {
     throw new Error("Invalid nonce: must not be empty");
   }
-  if (!isHexString3(hexNonce)) {
+  if (!isHexString4(hexNonce)) {
     throw new Error("Invalid nonce: must be a valid BytesLike value");
   }
   if (hexNonce.length > MAX_NONCE_STRING_LENGTH) {
@@ -251,15 +574,277 @@ function createNonceTerms(terms, encodingOptions = defaultOptions) {
   return prepareResult(hexValue, encodingOptions);
 }
 
+// src/caveats/allowedCalldata.ts
+import { bytesToHex as bytesToHex8, remove0x as remove0x2 } from "@metamask/utils";
+function createAllowedCalldataTerms(terms, encodingOptions = defaultOptions) {
+  const { startIndex, value } = terms;
+  if (startIndex < 0) {
+    throw new Error("Invalid startIndex: must be zero or positive");
+  }
+  if (!Number.isInteger(startIndex)) {
+    throw new Error("Invalid startIndex: must be a whole number");
+  }
+  let unprefixedValue;
+  if (typeof value === "string") {
+    if (!value.startsWith("0x")) {
+      throw new Error("Invalid value: must be a hex string starting with 0x");
+    }
+    unprefixedValue = remove0x2(value);
+  } else {
+    unprefixedValue = remove0x2(bytesToHex8(value));
+  }
+  const indexHex = toHexString({ value: startIndex, size: 32 });
+  return prepareResult(`0x${indexHex}${unprefixedValue}`, encodingOptions);
+}
+
+// src/caveats/allowedMethods.ts
+import { bytesToHex as bytesToHex9, isHexString as isHexString5 } from "@metamask/utils";
+var FUNCTION_SELECTOR_STRING_LENGTH = 10;
+var INVALID_SELECTOR_ERROR = "Invalid selector: must be a 4 byte hex string, abi function signature, or AbiFunction";
+function createAllowedMethodsTerms(terms, encodingOptions = defaultOptions) {
+  const { selectors } = terms;
+  if (!selectors || selectors.length === 0) {
+    throw new Error("Invalid selectors: must provide at least one selector");
+  }
+  const normalizedSelectors = selectors.map((selector) => {
+    if (typeof selector === "string") {
+      if (isHexString5(selector) && selector.length === FUNCTION_SELECTOR_STRING_LENGTH) {
+        return selector;
+      }
+      throw new Error(INVALID_SELECTOR_ERROR);
+    }
+    if (selector.length !== 4) {
+      throw new Error(INVALID_SELECTOR_ERROR);
+    }
+    return bytesToHex9(selector);
+  });
+  const hexValue = concatHex(normalizedSelectors);
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/allowedTargets.ts
+function createAllowedTargetsTerms(terms, encodingOptions = defaultOptions) {
+  const { targets } = terms;
+  if (!targets || targets.length === 0) {
+    throw new Error(
+      "Invalid targets: must provide at least one target address"
+    );
+  }
+  const normalizedTargets = targets.map(
+    (target) => normalizeAddress(target, "Invalid targets: must be valid addresses")
+  );
+  const hexValue = concatHex(normalizedTargets);
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/argsEqualityCheck.ts
+function createArgsEqualityCheckTerms(terms, encodingOptions = defaultOptions) {
+  const { args } = terms;
+  if (typeof args === "string" && args === "0x") {
+    return prepareResult(args, encodingOptions);
+  }
+  const hexValue = normalizeHex(
+    args,
+    "Invalid config: args must be a valid hex string"
+  );
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/blockNumber.ts
+function createBlockNumberTerms(terms, encodingOptions = defaultOptions) {
+  const { afterThreshold, beforeThreshold } = terms;
+  if (afterThreshold < 0n || beforeThreshold < 0n) {
+    throw new Error("Invalid thresholds: block numbers must be non-negative");
+  }
+  if (afterThreshold === 0n && beforeThreshold === 0n) {
+    throw new Error(
+      "Invalid thresholds: At least one of afterThreshold or beforeThreshold must be specified"
+    );
+  }
+  if (beforeThreshold !== 0n && afterThreshold >= beforeThreshold) {
+    throw new Error(
+      "Invalid thresholds: afterThreshold must be less than beforeThreshold if both are specified"
+    );
+  }
+  const afterThresholdHex = toHexString({ value: afterThreshold, size: 16 });
+  const beforeThresholdHex = toHexString({ value: beforeThreshold, size: 16 });
+  const hexValue = `0x${afterThresholdHex}${beforeThresholdHex}`;
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/deployed.ts
+import { remove0x as remove0x3 } from "@metamask/utils";
+function createDeployedTerms(terms, encodingOptions = defaultOptions) {
+  const { contractAddress, salt, bytecode } = terms;
+  const contractAddressHex = normalizeAddress(
+    contractAddress,
+    "Invalid contractAddress: must be a valid Ethereum address"
+  );
+  const saltHex = normalizeHex(
+    salt,
+    "Invalid salt: must be a valid hexadecimal string"
+  );
+  const bytecodeHex = normalizeHex(
+    bytecode,
+    "Invalid bytecode: must be a valid hexadecimal string"
+  );
+  const unprefixedSalt = remove0x3(saltHex);
+  if (unprefixedSalt.length > 64) {
+    throw new Error("Invalid salt: must be a valid hexadecimal string");
+  }
+  const paddedSalt = `0x${unprefixedSalt.padStart(64, "0")}`;
+  const hexValue = concatHex([contractAddressHex, paddedSalt, bytecodeHex]);
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/id.ts
+var MAX_UINT256 = BigInt(`0x${"f".repeat(64)}`);
+function createIdTerms(terms, encodingOptions = defaultOptions) {
+  const { id } = terms;
+  let idBigInt;
+  if (typeof id === "number") {
+    if (!Number.isInteger(id)) {
+      throw new Error("Invalid id: must be an integer");
+    }
+    idBigInt = BigInt(id);
+  } else if (typeof id === "bigint") {
+    idBigInt = id;
+  } else {
+    throw new Error("Invalid id: must be a bigint or number");
+  }
+  if (idBigInt < 0n) {
+    throw new Error("Invalid id: must be a non-negative number");
+  }
+  if (idBigInt > MAX_UINT256) {
+    throw new Error("Invalid id: must be less than 2^256");
+  }
+  const hexValue = `0x${toHexString({ value: idBigInt, size: 32 })}`;
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/limitedCalls.ts
+function createLimitedCallsTerms(terms, encodingOptions = defaultOptions) {
+  const { limit } = terms;
+  if (!Number.isInteger(limit)) {
+    throw new Error("Invalid limit: must be an integer");
+  }
+  if (limit <= 0) {
+    throw new Error("Invalid limit: must be a positive integer");
+  }
+  const hexValue = `0x${toHexString({ value: limit, size: 32 })}`;
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/multiTokenPeriod.ts
+function createMultiTokenPeriodTerms(terms, encodingOptions = defaultOptions) {
+  const { tokenConfigs } = terms;
+  if (!tokenConfigs || tokenConfigs.length === 0) {
+    throw new Error(
+      "MultiTokenPeriodBuilder: tokenConfigs array cannot be empty"
+    );
+  }
+  const hexParts = [];
+  for (const tokenConfig of tokenConfigs) {
+    const tokenHex = normalizeAddress(
+      tokenConfig.token,
+      `Invalid token address: ${String(tokenConfig.token)}`
+    );
+    if (tokenConfig.periodAmount <= 0n) {
+      throw new Error("Invalid period amount: must be greater than 0");
+    }
+    if (tokenConfig.periodDuration <= 0) {
+      throw new Error("Invalid period duration: must be greater than 0");
+    }
+    if (tokenConfig.startDate <= 0) {
+      throw new Error("Invalid start date: must be greater than 0");
+    }
+    hexParts.push(
+      tokenHex,
+      `0x${toHexString({ value: tokenConfig.periodAmount, size: 32 })}`,
+      `0x${toHexString({ value: tokenConfig.periodDuration, size: 32 })}`,
+      `0x${toHexString({ value: tokenConfig.startDate, size: 32 })}`
+    );
+  }
+  const hexValue = concatHex(hexParts);
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/ownershipTransfer.ts
+function createOwnershipTransferTerms(terms, encodingOptions = defaultOptions) {
+  const { contractAddress } = terms;
+  const contractAddressHex = normalizeAddress(
+    contractAddress,
+    "Invalid contractAddress: must be a valid address"
+  );
+  return prepareResult(contractAddressHex, encodingOptions);
+}
+
+// src/caveats/redeemer.ts
+function createRedeemerTerms(terms, encodingOptions = defaultOptions) {
+  const { redeemers } = terms;
+  if (!redeemers || redeemers.length === 0) {
+    throw new Error(
+      "Invalid redeemers: must specify at least one redeemer address"
+    );
+  }
+  const normalizedRedeemers = redeemers.map(
+    (redeemer) => normalizeAddress(redeemer, "Invalid redeemers: must be a valid address")
+  );
+  const hexValue = concatHex(normalizedRedeemers);
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/specificActionERC20TransferBatch.ts
+import { bytesToHex as bytesToHex10 } from "@metamask/utils";
+function createSpecificActionERC20TransferBatchTerms(terms, encodingOptions = defaultOptions) {
+  const { tokenAddress, recipient, amount, target, calldata } = terms;
+  const tokenAddressHex = normalizeAddress(
+    tokenAddress,
+    "Invalid tokenAddress: must be a valid address"
+  );
+  const recipientHex = normalizeAddress(
+    recipient,
+    "Invalid recipient: must be a valid address"
+  );
+  const targetHex = normalizeAddress(
+    target,
+    "Invalid target: must be a valid address"
+  );
+  let calldataHex;
+  if (typeof calldata === "string") {
+    if (!calldata.startsWith("0x")) {
+      throw new Error(
+        "Invalid calldata: must be a hex string starting with 0x"
+      );
+    }
+    calldataHex = calldata;
+  } else {
+    calldataHex = bytesToHex10(calldata);
+  }
+  if (amount <= 0n) {
+    throw new Error("Invalid amount: must be a positive number");
+  }
+  const amountHex = `0x${toHexString({ value: amount, size: 32 })}`;
+  const hexValue = concatHex([
+    tokenAddressHex,
+    recipientHex,
+    amountHex,
+    targetHex,
+    calldataHex
+  ]);
+  return prepareResult(hexValue, encodingOptions);
+}
+
 // src/delegation.ts
-import { encode, encodeSingle, decodeSingle } from "@metamask/abi-utils";
-import { hexToBytes as hexToBytes2 } from "@metamask/utils";
+import { encode, encodeSingle as encodeSingle3, decodeSingle } from "@metamask/abi-utils";
+import { hexToBytes as hexToBytes3 } from "@metamask/utils";
 import { keccak_256 as keccak256 } from "@noble/hashes/sha3";
 var ANY_BENEFICIARY = "0x0000000000000000000000000000000000000a11";
 var ROOT_AUTHORITY = "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
 var DELEGATION_TYPEHASH = "0x88c1d2ecf185adf710588203a5f263f0ff61be0d33da39792cde19ba9aa4331e";
 var CAVEAT_TYPEHASH = "0x80ad7e1b04ee6d994a125f4714ca0720908bd80ed16063ec8aee4b88e9253e2d";
 var DELEGATION_ARRAY_ABI_TYPES = "(address,address,bytes32,(address,bytes,bytes)[],uint256,bytes)[]";
+var DELEGATION_ABI_TYPE = "(address,address,bytes32,(address,bytes,bytes)[],uint256,bytes)";
 function encodeDelegations(delegations, options = defaultOptions) {
   let result;
   if (delegations.length === 0) {
@@ -278,10 +863,26 @@ function encodeDelegations(delegations, options = defaultOptions) {
       struct.salt,
       struct.signature
     ]);
-    result = encodeSingle(DELEGATION_ARRAY_ABI_TYPES, encodableStructs);
+    result = encodeSingle3(DELEGATION_ARRAY_ABI_TYPES, encodableStructs);
   }
   return prepareResult(result, options);
 }
+function encodeDelegation(delegation, options = defaultOptions) {
+  const encodableStruct = [
+    delegation.delegate,
+    delegation.delegator,
+    delegation.authority,
+    delegation.caveats.map((caveat) => [
+      caveat.enforcer,
+      caveat.terms,
+      caveat.args
+    ]),
+    delegation.salt,
+    delegation.signature
+  ];
+  const result = encodeSingle3(DELEGATION_ABI_TYPE, encodableStruct);
+  return prepareResult(result, options);
+}
 var delegationFromDecodedDelegation = (decodedDelegation, convertFn) => {
   const [delegate, delegator, authority, caveats, salt, signature] = decodedDelegation;
   return {
@@ -312,6 +913,17 @@ function decodeDelegations(encoded, options = defaultOptions) {
     (struct) => delegationFromDecodedDelegation(struct, bytesLikeToHex)
   );
 }
+function decodeDelegation(encoded, options = defaultOptions) {
+  const decodedStruct = decodeSingle(
+    DELEGATION_ABI_TYPE,
+    encoded
+    // return types cannot be inferred from complex ABI types, so we must assert the type
+  );
+  if (options.out === "bytes") {
+    return delegationFromDecodedDelegation(decodedStruct, bytesLikeToBytes);
+  }
+  return delegationFromDecodedDelegation(decodedStruct, bytesLikeToHex);
+}
 function hashDelegation(delegation, options = defaultOptions) {
   const encoded = encode(
     ["bytes32", "address", "address", "bytes32", "bytes32", "uint256"],
@@ -341,7 +953,7 @@ function getCaveatsArrayHash(caveats) {
   return keccak256(encoded);
 }
 function getCaveatHash(caveat) {
-  const termsBytes = typeof caveat.terms === "string" ? hexToBytes2(caveat.terms) : caveat.terms;
+  const termsBytes = typeof caveat.terms === "string" ? hexToBytes3(caveat.terms) : caveat.terms;
   const termsHash = keccak256(termsBytes);
   const encoded = encode(
     ["bytes32", "address", "bytes32"],
@@ -355,15 +967,40 @@ export {
   CAVEAT_TYPEHASH,
   DELEGATION_TYPEHASH,
   ROOT_AUTHORITY,
+  createAllowedCalldataTerms,
+  createAllowedMethodsTerms,
+  createAllowedTargetsTerms,
+  createArgsEqualityCheckTerms,
+  createBlockNumberTerms,
+  createDeployedTerms,
+  createERC1155BalanceChangeTerms,
+  createERC20BalanceChangeTerms,
   createERC20StreamingTerms,
   createERC20TokenPeriodTransferTerms,
+  createERC20TransferAmountTerms,
+  createERC721BalanceChangeTerms,
+  createERC721TransferTerms,
+  createExactCalldataBatchTerms,
   createExactCalldataTerms,
+  createExactExecutionBatchTerms,
+  createExactExecutionTerms,
+  createIdTerms,
+  createLimitedCallsTerms,
+  createMultiTokenPeriodTerms,
+  createNativeBalanceChangeTerms,
+  createNativeTokenPaymentTerms,
   createNativeTokenPeriodTransferTerms,
   createNativeTokenStreamingTerms,
+  createNativeTokenTransferAmountTerms,
   createNonceTerms,
+  createOwnershipTransferTerms,
+  createRedeemerTerms,
+  createSpecificActionERC20TransferBatchTerms,
   createTimestampTerms,
   createValueLteTerms,
+  decodeDelegation,
   decodeDelegations,
+  encodeDelegation,
   encodeDelegations,
   hashDelegation
 };