@metamask/delegation-core 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -1,5 +1,55 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/returns.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/internalUtils.ts
+
+
+
+
+
 var _utils = require('@metamask/utils');
+var toHexString = ({
+  value,
+  size
+}) => {
+  return value.toString(16).padStart(size * 2, "0");
+};
+var normalizeHex = (value, errorMessage) => {
+  if (typeof value === "string") {
+    if (!_utils.isHexString.call(void 0, value)) {
+      throw new Error(errorMessage);
+    }
+    return value;
+  }
+  return _utils.bytesToHex.call(void 0, value);
+};
+var normalizeAddress = (value, errorMessage) => {
+  if (typeof value === "string") {
+    if (!_utils.isHexString.call(void 0, value) || value.length !== 42) {
+      throw new Error(errorMessage);
+    }
+    return value;
+  }
+  if (value.length !== 20) {
+    throw new Error(errorMessage);
+  }
+  return _utils.bytesToHex.call(void 0, value);
+};
+var normalizeAddressLowercase = (value, errorMessage) => {
+  if (typeof value === "string") {
+    if (!_utils.isHexString.call(void 0, value) || value.length !== 42) {
+      throw new Error(errorMessage);
+    }
+    return _utils.bytesToHex.call(void 0, _utils.hexToBytes.call(void 0, value));
+  }
+  if (value.length !== 20) {
+    throw new Error(errorMessage);
+  }
+  return _utils.bytesToHex.call(void 0, value);
+};
+var concatHex = (parts) => {
+  return `0x${parts.map(_utils.remove0x).join("")}`;
+};
+
+// src/returns.ts
+
 var defaultOptions = { out: "hex" };
 function prepareResult(result, options) {
   if (options.out === "hex") {
@@ -22,14 +72,6 @@ var bytesLikeToBytes = (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
+var _abiutils = require('@metamask/abi-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 = _utils.bytesToHex.call(void 0, execution.callData);
+    }
+    return [targetHex, execution.value, callDataHex];
+  });
+  const hexValue = _abiutils.encodeSingle.call(void 0, EXECUTION_ARRAY_ABI, encodableExecutions);
+  return prepareResult(hexValue, encodingOptions);
+}
+
+// src/caveats/exactExecution.ts
+
+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 = _utils.bytesToHex.call(void 0, 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
+
+
+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 = _utils.bytesToHex.call(void 0, execution.callData);
+    }
+    return [targetHex, execution.value, callDataHex];
+  });
+  const hexValue = _abiutils.encodeSingle.call(void 0, EXECUTION_ARRAY_ABI2, encodableExecutions);
+  return prepareResult(hexValue, encodingOptions);
+}
+
 // src/caveats/nativeTokenStreaming.ts
 var TIMESTAMP_UPPER_BOUND_SECONDS2 = 253402300799;
 function createNativeTokenStreamingTerms(terms, encodingOptions = defaultOptions) {
@@ -141,6 +281,51 @@ 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
 
 var TIMESTAMP_UPPER_BOUND_SECONDS3 = 253402300799;
@@ -224,6 +409,144 @@ 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
 
 var MAX_NONCE_STRING_LENGTH = 66;
@@ -251,8 +574,269 @@ function createNonceTerms(terms, encodingOptions = defaultOptions) {
   return prepareResult(hexValue, encodingOptions);
 }
 
+// src/caveats/allowedCalldata.ts
+
+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 = _utils.remove0x.call(void 0, value);
+  } else {
+    unprefixedValue = _utils.remove0x.call(void 0, _utils.bytesToHex.call(void 0, value));
+  }
+  const indexHex = toHexString({ value: startIndex, size: 32 });
+  return prepareResult(`0x${indexHex}${unprefixedValue}`, encodingOptions);
+}
+
+// src/caveats/allowedMethods.ts
+
+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 (_utils.isHexString.call(void 0, 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 _utils.bytesToHex.call(void 0, 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
+
+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 = _utils.remove0x.call(void 0, 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
+
+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 = _utils.bytesToHex.call(void 0, 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
-var _abiutils = require('@metamask/abi-utils');
+
 
 var _sha3 = require('@noble/hashes/sha3');
 var ANY_BENEFICIARY = "0x0000000000000000000000000000000000000a11";
@@ -260,6 +844,7 @@ var ROOT_AUTHORITY = "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff
 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) {
@@ -282,6 +867,22 @@ function encodeDelegations(delegations, options = defaultOptions) {
   }
   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 = _abiutils.encodeSingle.call(void 0, 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 = _abiutils.decodeSingle.call(void 0, 
+    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 = _abiutils.encode.call(void 0, 
     ["bytes32", "address", "address", "bytes32", "bytes32", "uint256"],
@@ -366,5 +978,30 @@ function getCaveatHash(caveat) {
 
 
 
-exports.ANY_BENEFICIARY = ANY_BENEFICIARY; exports.CAVEAT_TYPEHASH = CAVEAT_TYPEHASH; exports.DELEGATION_TYPEHASH = DELEGATION_TYPEHASH; exports.ROOT_AUTHORITY = ROOT_AUTHORITY; exports.createERC20StreamingTerms = createERC20StreamingTerms; exports.createERC20TokenPeriodTransferTerms = createERC20TokenPeriodTransferTerms; exports.createExactCalldataTerms = createExactCalldataTerms; exports.createNativeTokenPeriodTransferTerms = createNativeTokenPeriodTransferTerms; exports.createNativeTokenStreamingTerms = createNativeTokenStreamingTerms; exports.createNonceTerms = createNonceTerms; exports.createTimestampTerms = createTimestampTerms; exports.createValueLteTerms = createValueLteTerms; exports.decodeDelegations = decodeDelegations; exports.encodeDelegations = encodeDelegations; exports.hashDelegation = hashDelegation;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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;
 //# sourceMappingURL=index.cjs.map