@t402/extensions 2.4.0 → 2.6.0

package/dist/cjs/index.js

@@ -30,27 +30,57 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  APPROVE_FUNCTION_SELECTOR: () => APPROVE_FUNCTION_SELECTOR,
   BAZAAR: () => BAZAAR,
+  EIP2612_GAS_SPONSOR_EXTENSION_KEY: () => EIP2612_GAS_SPONSOR_EXTENSION_KEY,
+  EIP2612_GAS_SPONSOR_HEADER_NAME: () => EIP2612_GAS_SPONSOR_HEADER_NAME,
+  ERC20_APPROVAL_GAS_SPONSOR_EXTENSION_KEY: () => ERC20_APPROVAL_GAS_SPONSOR_EXTENSION_KEY,
+  ERC20_APPROVAL_GAS_SPONSOR_HEADER_NAME: () => ERC20_APPROVAL_GAS_SPONSOR_HEADER_NAME,
+  PAYMENT_ID_EXTENSION_KEY: () => PAYMENT_ID_EXTENSION_KEY,
   SIWX_EXTENSION_KEY: () => SIWX_EXTENSION_KEY,
   SIWX_HEADER_NAME: () => SIWX_HEADER_NAME,
   bazaarResourceServerExtension: () => bazaarResourceServerExtension,
+  buildPermitCallData: () => buildPermitCallData,
   constructMessage: () => constructMessage,
+  createERC20ApprovalGasSponsorPayload: () => createERC20ApprovalGasSponsorPayload,
+  createEip2612GasSponsorPayload: () => createEip2612GasSponsorPayload,
+  createPaymentIdPayload: () => createPaymentIdPayload,
+  createPermitSignature: () => createPermitSignature,
   createSIWxMessage: () => createSIWxMessage,
   createSIWxPayload: () => createSIWxPayload,
   createSIWxTypedData: () => createSIWxTypedData,
   declareDiscoveryExtension: () => declareDiscoveryExtension,
+  declareERC20ApprovalGasSponsorExtension: () => declareERC20ApprovalGasSponsorExtension,
+  declareEip2612GasSponsorExtension: () => declareEip2612GasSponsorExtension,
+  declarePaymentIdExtension: () => declarePaymentIdExtension,
   declareSIWxExtension: () => declareSIWxExtension,
+  decodeApproveCalldata: () => decodeApproveCalldata,
+  encodeApproveCalldata: () => encodeApproveCalldata,
+  encodeERC20ApprovalGasSponsorHeader: () => encodeERC20ApprovalGasSponsorHeader,
+  encodeEip2612GasSponsorHeader: () => encodeEip2612GasSponsorHeader,
+  encodePaymentIdHeader: () => encodePaymentIdHeader,
   encodeSIWxHeader: () => encodeSIWxHeader,
   extractDiscoveryInfo: () => extractDiscoveryInfo,
   extractDiscoveryInfoFromExtension: () => extractDiscoveryInfoFromExtension,
   extractDiscoveryInfoV1: () => extractDiscoveryInfoV1,
+  extractERC20ApprovalGasSponsorPayload: () => extractERC20ApprovalGasSponsorPayload,
+  extractEip2612GasSponsorPayload: () => extractEip2612GasSponsorPayload,
   extractResourceMetadataV1: () => extractResourceMetadataV1,
   hashMessage: () => hashMessage,
   isDiscoverableV1: () => isDiscoverableV1,
+  parseERC20ApprovalGasSponsorHeader: () => parseERC20ApprovalGasSponsorHeader,
+  parseEip2612GasSponsorHeader: () => parseEip2612GasSponsorHeader,
+  parsePaymentIdPayload: () => parsePaymentIdPayload,
   parseSIWxHeader: () => parseSIWxHeader,
+  processERC20ApprovalPayload: () => processERC20ApprovalPayload,
   signSIWxMessage: () => signSIWxMessage,
   validateAndExtract: () => validateAndExtract,
+  validateAndExtractApproval: () => validateAndExtractApproval,
+  validateAndExtractPermit: () => validateAndExtractPermit,
   validateDiscoveryExtension: () => validateDiscoveryExtension,
+  validateERC20ApprovalGasSponsorPayload: () => validateERC20ApprovalGasSponsorPayload,
+  validateEip2612GasSponsorPayload: () => validateEip2612GasSponsorPayload,
+  validatePaymentId: () => validatePaymentId,
   validateSIWxMessage: () => validateSIWxMessage,
   verifyEIP6492Signature: () => verifyEIP6492Signature,
   verifySIWxSignature: () => verifySIWxSignature,
@@ -492,6 +522,7 @@ function withBazaar(client) {
 // src/sign-in-with-x/server.ts
 var import_crypto = require("crypto");
 var import_sha3 = require("@noble/hashes/sha3");
+var import_sha2 = require("@noble/hashes/sha2");
 var import_secp256k1 = require("@noble/curves/secp256k1");
 var import_ed25519 = require("@noble/curves/ed25519");
 var import_utils = require("@noble/hashes/utils");
@@ -622,7 +653,10 @@ function detectSignatureScheme(chainId) {
   switch (namespace) {
     case "solana":
     case "stellar":
+    case "ton":
       return "ed25519";
+    case "tron":
+      return "tron";
     case "eip155":
     default:
       return "evm";
@@ -685,6 +719,44 @@ function decodeBase58(str) {
   }
   return new Uint8Array(bytes.reverse());
 }
+function encodeBase58(bytes) {
+  const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  if (bytes.length === 0) return "";
+  let leadingZeros = 0;
+  for (const b of bytes) {
+    if (b !== 0) break;
+    leadingZeros++;
+  }
+  const digits = [0];
+  for (const b of bytes) {
+    let carry = b;
+    for (let j = 0; j < digits.length; j++) {
+      carry += digits[j] * 256;
+      digits[j] = carry % 58;
+      carry = Math.floor(carry / 58);
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = Math.floor(carry / 58);
+    }
+  }
+  let result = ALPHABET[0].repeat(leadingZeros);
+  for (let i = digits.length - 1; i >= 0; i--) {
+    result += ALPHABET[digits[i]];
+  }
+  return result;
+}
+function evmAddressToTron(evmAddress) {
+  const addr = evmAddress.toLowerCase().replace("0x", "");
+  const addressBytes = (0, import_utils.hexToBytes)("41" + addr);
+  const hash1 = (0, import_sha2.sha256)(addressBytes);
+  const hash2 = (0, import_sha2.sha256)(hash1);
+  const checksum = hash2.slice(0, 4);
+  const fullAddress = new Uint8Array(addressBytes.length + 4);
+  fullAddress.set(addressBytes, 0);
+  fullAddress.set(checksum, addressBytes.length);
+  return encodeBase58(fullAddress);
+}
 async function verifySIWxSignature(message, signature, options = {}) {
   const { checkSmartWallet = false } = options;
   try {
@@ -700,6 +772,19 @@ async function verifySIWxSignature(message, signature, options = {}) {
         error: "Ed25519 signature verification failed"
       };
     }
+    if (scheme === "tron") {
+      const messageHash2 = hashMessage(messageText);
+      const recoveredEvmAddress = recoverAddress(messageHash2, signature);
+      const recoveredTronAddress = evmAddressToTron(recoveredEvmAddress);
+      if (recoveredTronAddress === message.address) {
+        return { valid: true, address: message.address };
+      }
+      return {
+        valid: false,
+        address: recoveredTronAddress,
+        error: `Signature mismatch: expected ${message.address}, recovered ${recoveredTronAddress}`
+      };
+    }
     const messageHash = hashMessage(messageText);
     const recoveredAddress = recoverAddress(messageHash, signature);
     if (recoveredAddress.toLowerCase() !== message.address.toLowerCase()) {
@@ -967,29 +1052,594 @@ async function createSIWxPayload(serverExtension, signer) {
 }
 var SIWX_EXTENSION_KEY = "siwx";
 var SIWX_HEADER_NAME = "X-T402-SIWx";
+
+// src/payment-id/types.ts
+var PAYMENT_ID_EXTENSION_KEY = "paymentId";
+
+// src/payment-id/server.ts
+var import_crypto2 = require("crypto");
+var PAYMENT_ID_SCHEMA = {
+  type: "object",
+  required: ["id"],
+  properties: {
+    id: { type: "string", format: "uuid" },
+    clientId: { type: "string" }
+  }
+};
+function declarePaymentIdExtension(options = {}) {
+  const info = {
+    id: options.id || (0, import_crypto2.randomUUID)(),
+    idempotencyKey: options.idempotencyKey,
+    groupId: options.groupId,
+    metadata: options.metadata
+  };
+  return {
+    info,
+    schema: PAYMENT_ID_SCHEMA
+  };
+}
+function parsePaymentIdPayload(extensions) {
+  if (!extensions || !(PAYMENT_ID_EXTENSION_KEY in extensions)) {
+    return null;
+  }
+  const raw = extensions[PAYMENT_ID_EXTENSION_KEY];
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error("Invalid paymentId extension: expected object");
+  }
+  const obj = raw;
+  if (typeof obj.id !== "string" || obj.id.length === 0) {
+    throw new Error("Invalid paymentId extension: missing or empty id");
+  }
+  return {
+    id: obj.id,
+    clientId: typeof obj.clientId === "string" ? obj.clientId : void 0
+  };
+}
+function validatePaymentId(payload, expected) {
+  return payload.id === expected.id;
+}
+
+// src/payment-id/client.ts
+function createPaymentIdPayload(extension, clientId) {
+  return {
+    id: extension.info.id,
+    clientId
+  };
+}
+function encodePaymentIdHeader(payload) {
+  const json = JSON.stringify(payload);
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(json, "utf-8").toString("base64");
+  }
+  return btoa(json);
+}
+
+// src/eip2612-gas-sponsoring/server.ts
+var EIP2612_GAS_SPONSOR_SCHEMA = {
+  type: "object",
+  required: ["network", "permitSignature", "owner", "spender", "value", "deadline", "v", "r", "s"],
+  properties: {
+    network: { type: "string" },
+    permitSignature: { type: "string" },
+    owner: { type: "string" },
+    spender: { type: "string" },
+    value: { type: "string" },
+    deadline: { type: "number" },
+    v: { type: "number" },
+    r: { type: "string" },
+    s: { type: "string" }
+  }
+};
+function declareEip2612GasSponsorExtension(options) {
+  const info = {
+    sponsoredNetworks: options.sponsoredNetworks,
+    maxAmount: options.maxAmount,
+    permitDeadline: options.permitDeadline ?? 300,
+    sponsorAddress: options.sponsorAddress
+  };
+  return {
+    info,
+    schema: EIP2612_GAS_SPONSOR_SCHEMA
+  };
+}
+function parseEip2612GasSponsorHeader(header) {
+  if (!header) {
+    throw new Error("Missing EIP-2612 gas sponsor header");
+  }
+  try {
+    const decoded = Buffer.from(header, "base64").toString("utf-8");
+    const payload = JSON.parse(decoded);
+    const required = [
+      "network",
+      "permitSignature",
+      "owner",
+      "spender",
+      "value",
+      "deadline",
+      "v",
+      "r",
+      "s"
+    ];
+    for (const field of required) {
+      if (!(field in payload)) {
+        throw new Error(`Missing required field: ${field}`);
+      }
+    }
+    return payload;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error("Invalid EIP-2612 gas sponsor header: malformed JSON");
+    }
+    throw error;
+  }
+}
+function validateEip2612GasSponsorPayload(payload, extensionInfo, options = {}) {
+  const now = options.now ? options.now() : Date.now();
+  const nowSeconds = Math.floor(now / 1e3);
+  if (!extensionInfo.sponsoredNetworks.includes(payload.network)) {
+    return {
+      valid: false,
+      error: `Network ${payload.network} is not in sponsored networks: ${extensionInfo.sponsoredNetworks.join(", ")}`
+    };
+  }
+  const payloadValue = BigInt(payload.value);
+  const maxAmount = BigInt(extensionInfo.maxAmount);
+  if (payloadValue > maxAmount) {
+    return {
+      valid: false,
+      error: `Value ${payload.value} exceeds maximum amount ${extensionInfo.maxAmount}`
+    };
+  }
+  if (payload.deadline <= nowSeconds) {
+    return {
+      valid: false,
+      error: "Permit deadline has expired"
+    };
+  }
+  const maxDeadline = nowSeconds + extensionInfo.permitDeadline;
+  if (payload.deadline > maxDeadline) {
+    return {
+      valid: false,
+      error: `Permit deadline ${payload.deadline} exceeds maximum allowed deadline ${maxDeadline}`
+    };
+  }
+  if (payload.spender.toLowerCase() !== extensionInfo.sponsorAddress.toLowerCase()) {
+    return {
+      valid: false,
+      error: `Spender ${payload.spender} does not match sponsor address ${extensionInfo.sponsorAddress}`
+    };
+  }
+  const sigHex = payload.permitSignature.startsWith("0x") ? payload.permitSignature.slice(2) : payload.permitSignature;
+  if (sigHex.length !== 130) {
+    return {
+      valid: false,
+      error: `Invalid permit signature length: expected 130 hex chars, got ${sigHex.length}`
+    };
+  }
+  if (payload.v !== 27 && payload.v !== 28) {
+    return {
+      valid: false,
+      error: `Invalid v value: expected 27 or 28, got ${payload.v}`
+    };
+  }
+  const rHex = payload.r.startsWith("0x") ? payload.r.slice(2) : payload.r;
+  if (rHex.length !== 64) {
+    return {
+      valid: false,
+      error: `Invalid r length: expected 64 hex chars, got ${rHex.length}`
+    };
+  }
+  const sHex = payload.s.startsWith("0x") ? payload.s.slice(2) : payload.s;
+  if (sHex.length !== 64) {
+    return {
+      valid: false,
+      error: `Invalid s length: expected 64 hex chars, got ${sHex.length}`
+    };
+  }
+  return { valid: true };
+}
+
+// src/eip2612-gas-sponsoring/client.ts
+var EIP2612_GAS_SPONSOR_EXTENSION_KEY = "eip2612GasSponsoring";
+var EIP2612_GAS_SPONSOR_HEADER_NAME = "X-T402-EIP2612-Gas-Sponsoring";
+async function createPermitSignature(params) {
+  const { signer, tokenAddress, tokenName, chainId, spender, value, deadline, nonce = 0 } = params;
+  const domain = {
+    name: tokenName,
+    version: "1",
+    chainId,
+    verifyingContract: tokenAddress
+  };
+  const types = {
+    Permit: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "nonce", type: "uint256" },
+      { name: "deadline", type: "uint256" }
+    ]
+  };
+  const message = {
+    owner: signer.address,
+    spender,
+    value,
+    nonce,
+    deadline
+  };
+  const signature = await signer.signTypedData({
+    domain,
+    types,
+    primaryType: "Permit",
+    message
+  });
+  const sigHex = signature.startsWith("0x") ? signature.slice(2) : signature;
+  if (sigHex.length !== 130) {
+    throw new Error(`Invalid signature length: expected 130 hex chars, got ${sigHex.length}`);
+  }
+  const r = "0x" + sigHex.slice(0, 64);
+  const s = "0x" + sigHex.slice(64, 128);
+  let v = parseInt(sigHex.slice(128, 130), 16);
+  if (v < 27) {
+    v += 27;
+  }
+  return {
+    owner: signer.address,
+    spender,
+    value,
+    deadline,
+    v,
+    r,
+    s,
+    permitSignature: signature.startsWith("0x") ? signature : "0x" + signature
+  };
+}
+function createEip2612GasSponsorPayload(permit, network) {
+  return {
+    network,
+    permitSignature: permit.permitSignature,
+    owner: permit.owner,
+    spender: permit.spender,
+    value: permit.value,
+    deadline: permit.deadline,
+    v: permit.v,
+    r: permit.r,
+    s: permit.s
+  };
+}
+function encodeEip2612GasSponsorHeader(payload) {
+  const json = JSON.stringify(payload);
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(json, "utf-8").toString("base64");
+  }
+  return btoa(json);
+}
+
+// src/eip2612-gas-sponsoring/facilitator.ts
+function extractEip2612GasSponsorPayload(extensions) {
+  if (!extensions) {
+    return null;
+  }
+  const raw = extensions[EIP2612_GAS_SPONSOR_EXTENSION_KEY];
+  if (!raw || typeof raw !== "object") {
+    return null;
+  }
+  const payload = raw;
+  const required = [
+    "network",
+    "permitSignature",
+    "owner",
+    "spender",
+    "value",
+    "deadline",
+    "v",
+    "r",
+    "s"
+  ];
+  for (const field of required) {
+    if (!(field in payload)) {
+      return null;
+    }
+  }
+  return {
+    network: payload.network,
+    permitSignature: payload.permitSignature,
+    owner: payload.owner,
+    spender: payload.spender,
+    value: payload.value,
+    deadline: payload.deadline,
+    v: payload.v,
+    r: payload.r,
+    s: payload.s
+  };
+}
+function validateAndExtractPermit(extensions, extensionInfo) {
+  const payload = extractEip2612GasSponsorPayload(extensions);
+  if (!payload) {
+    return {
+      valid: false,
+      error: `Missing or invalid ${EIP2612_GAS_SPONSOR_EXTENSION_KEY} extension in payment`
+    };
+  }
+  const result = validateEip2612GasSponsorPayload(payload, extensionInfo);
+  if (!result.valid) {
+    return result;
+  }
+  return { valid: true, payload };
+}
+function buildPermitCallData(payload) {
+  return {
+    owner: payload.owner,
+    spender: payload.spender,
+    value: payload.value,
+    deadline: payload.deadline,
+    v: payload.v,
+    r: payload.r,
+    s: payload.s
+  };
+}
+
+// src/erc20-approval-gas-sponsoring/server.ts
+var ERC20_APPROVAL_GAS_SPONSOR_SCHEMA = {
+  type: "object",
+  required: ["network", "from", "asset", "amount", "signedApprovalTx", "chainId"],
+  properties: {
+    network: { type: "string" },
+    from: { type: "string" },
+    asset: { type: "string" },
+    amount: { type: "string" },
+    signedApprovalTx: { type: "string" },
+    chainId: { type: "number" },
+    nonce: { type: "number" }
+  }
+};
+function declareERC20ApprovalGasSponsorExtension(options) {
+  const info = {
+    sponsoredNetworks: options.sponsoredNetworks,
+    maxAmount: options.maxAmount,
+    sponsorAddress: options.sponsorAddress,
+    requiresAtomicBatch: options.requiresAtomicBatch ?? false
+  };
+  if (options.permit2Address) {
+    info.permit2Address = options.permit2Address;
+  }
+  return {
+    info,
+    schema: ERC20_APPROVAL_GAS_SPONSOR_SCHEMA
+  };
+}
+function parseERC20ApprovalGasSponsorHeader(header) {
+  if (!header) {
+    throw new Error("Missing ERC-20 approval gas sponsor header");
+  }
+  try {
+    const decoded = Buffer.from(header, "base64").toString("utf-8");
+    const payload = JSON.parse(decoded);
+    const required = ["network", "from", "asset", "amount", "signedApprovalTx", "chainId"];
+    for (const field of required) {
+      if (!(field in payload)) {
+        throw new Error(`Missing required field: ${field}`);
+      }
+    }
+    return payload;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error("Invalid ERC-20 approval gas sponsor header: malformed JSON");
+    }
+    throw error;
+  }
+}
+function validateERC20ApprovalGasSponsorPayload(payload, extensionInfo, options = {}) {
+  if (!extensionInfo.sponsoredNetworks.includes(payload.network)) {
+    return {
+      valid: false,
+      error: `Network ${payload.network} is not in sponsored networks: ${extensionInfo.sponsoredNetworks.join(", ")}`
+    };
+  }
+  const payloadAmount = BigInt(payload.amount);
+  const maxAmount = BigInt(extensionInfo.maxAmount);
+  if (payloadAmount > maxAmount) {
+    return {
+      valid: false,
+      error: `Amount ${payload.amount} exceeds maximum amount ${extensionInfo.maxAmount}`
+    };
+  }
+  if (options.expectedChainIds) {
+    const expectedChainId = options.expectedChainIds[payload.network];
+    if (expectedChainId !== void 0 && payload.chainId !== expectedChainId) {
+      return {
+        valid: false,
+        error: `Chain ID ${payload.chainId} does not match expected chain ID ${expectedChainId} for network ${payload.network}`
+      };
+    }
+  }
+  const txHex = payload.signedApprovalTx.startsWith("0x") ? payload.signedApprovalTx.slice(2) : payload.signedApprovalTx;
+  if (txHex.length === 0) {
+    return {
+      valid: false,
+      error: "Signed approval transaction is empty"
+    };
+  }
+  if (!/^[0-9a-fA-F]+$/.test(txHex)) {
+    return {
+      valid: false,
+      error: "Signed approval transaction is not valid hex"
+    };
+  }
+  const fromHex = payload.from.startsWith("0x") ? payload.from.slice(2) : payload.from;
+  if (fromHex.length !== 40 || !/^[0-9a-fA-F]+$/.test(fromHex)) {
+    return {
+      valid: false,
+      error: `Invalid from address: ${payload.from}`
+    };
+  }
+  const assetHex = payload.asset.startsWith("0x") ? payload.asset.slice(2) : payload.asset;
+  if (assetHex.length !== 40 || !/^[0-9a-fA-F]+$/.test(assetHex)) {
+    return {
+      valid: false,
+      error: `Invalid asset address: ${payload.asset}`
+    };
+  }
+  return { valid: true };
+}
+
+// src/erc20-approval-gas-sponsoring/client.ts
+var ERC20_APPROVAL_GAS_SPONSOR_EXTENSION_KEY = "erc20ApprovalGasSponsoring";
+var ERC20_APPROVAL_GAS_SPONSOR_HEADER_NAME = "X-T402-ERC20-Approval-Gas-Sponsoring";
+var APPROVE_FUNCTION_SELECTOR = "0x095ea7b3";
+function encodeApproveCalldata(spender, amount) {
+  const spenderHex = spender.startsWith("0x") ? spender.slice(2) : spender;
+  const paddedSpender = spenderHex.toLowerCase().padStart(64, "0");
+  const amountBigInt = BigInt(amount);
+  const amountHex = amountBigInt.toString(16).padStart(64, "0");
+  return APPROVE_FUNCTION_SELECTOR + paddedSpender + amountHex;
+}
+function createERC20ApprovalGasSponsorPayload(_info, params) {
+  const payload = {
+    network: params.network,
+    from: params.from,
+    asset: params.asset,
+    amount: params.amount,
+    signedApprovalTx: params.signedApprovalTx.startsWith("0x") ? params.signedApprovalTx : "0x" + params.signedApprovalTx,
+    chainId: params.chainId
+  };
+  if (params.nonce !== void 0) {
+    payload.nonce = params.nonce;
+  }
+  return payload;
+}
+function encodeERC20ApprovalGasSponsorHeader(payload) {
+  const json = JSON.stringify(payload);
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(json, "utf-8").toString("base64");
+  }
+  return btoa(json);
+}
+
+// src/erc20-approval-gas-sponsoring/facilitator.ts
+function extractERC20ApprovalGasSponsorPayload(extensions) {
+  if (!extensions) {
+    return null;
+  }
+  const raw = extensions[ERC20_APPROVAL_GAS_SPONSOR_EXTENSION_KEY];
+  if (!raw || typeof raw !== "object") {
+    return null;
+  }
+  const payload = raw;
+  const required = ["network", "from", "asset", "amount", "signedApprovalTx", "chainId"];
+  for (const field of required) {
+    if (!(field in payload)) {
+      return null;
+    }
+  }
+  const result = {
+    network: payload.network,
+    from: payload.from,
+    asset: payload.asset,
+    amount: payload.amount,
+    signedApprovalTx: payload.signedApprovalTx,
+    chainId: payload.chainId
+  };
+  if ("nonce" in payload && payload.nonce !== void 0) {
+    result.nonce = payload.nonce;
+  }
+  return result;
+}
+function processERC20ApprovalPayload(payload, extensionInfo) {
+  const validationResult = validateERC20ApprovalGasSponsorPayload(payload, extensionInfo);
+  if (!validationResult.valid) {
+    return validationResult;
+  }
+  const txHex = payload.signedApprovalTx.startsWith("0x") ? payload.signedApprovalTx.slice(2) : payload.signedApprovalTx;
+  if (txHex.length < 8) {
+    return {
+      valid: false,
+      error: "Signed approval transaction is too short to contain function selector"
+    };
+  }
+  return { valid: true };
+}
+function validateAndExtractApproval(extensions, extensionInfo) {
+  const payload = extractERC20ApprovalGasSponsorPayload(extensions);
+  if (!payload) {
+    return {
+      valid: false,
+      error: `Missing or invalid ${ERC20_APPROVAL_GAS_SPONSOR_EXTENSION_KEY} extension in payment`
+    };
+  }
+  const result = processERC20ApprovalPayload(payload, extensionInfo);
+  if (!result.valid) {
+    return result;
+  }
+  return { valid: true, payload };
+}
+function decodeApproveCalldata(calldata) {
+  const hex = calldata.startsWith("0x") ? calldata.slice(2) : calldata;
+  if (hex.length < 136) {
+    return null;
+  }
+  const selector = "0x" + hex.slice(0, 8);
+  if (selector !== APPROVE_FUNCTION_SELECTOR) {
+    return null;
+  }
+  const spenderWord = hex.slice(8, 72);
+  const spender = "0x" + spenderWord.slice(24);
+  const amountHex = hex.slice(72, 136);
+  const amount = BigInt("0x" + amountHex).toString(10);
+  return { spender, amount };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  APPROVE_FUNCTION_SELECTOR,
   BAZAAR,
+  EIP2612_GAS_SPONSOR_EXTENSION_KEY,
+  EIP2612_GAS_SPONSOR_HEADER_NAME,
+  ERC20_APPROVAL_GAS_SPONSOR_EXTENSION_KEY,
+  ERC20_APPROVAL_GAS_SPONSOR_HEADER_NAME,
+  PAYMENT_ID_EXTENSION_KEY,
   SIWX_EXTENSION_KEY,
   SIWX_HEADER_NAME,
   bazaarResourceServerExtension,
+  buildPermitCallData,
   constructMessage,
+  createERC20ApprovalGasSponsorPayload,
+  createEip2612GasSponsorPayload,
+  createPaymentIdPayload,
+  createPermitSignature,
   createSIWxMessage,
   createSIWxPayload,
   createSIWxTypedData,
   declareDiscoveryExtension,
+  declareERC20ApprovalGasSponsorExtension,
+  declareEip2612GasSponsorExtension,
+  declarePaymentIdExtension,
   declareSIWxExtension,
+  decodeApproveCalldata,
+  encodeApproveCalldata,
+  encodeERC20ApprovalGasSponsorHeader,
+  encodeEip2612GasSponsorHeader,
+  encodePaymentIdHeader,
   encodeSIWxHeader,
   extractDiscoveryInfo,
   extractDiscoveryInfoFromExtension,
   extractDiscoveryInfoV1,
+  extractERC20ApprovalGasSponsorPayload,
+  extractEip2612GasSponsorPayload,
   extractResourceMetadataV1,
   hashMessage,
   isDiscoverableV1,
+  parseERC20ApprovalGasSponsorHeader,
+  parseEip2612GasSponsorHeader,
+  parsePaymentIdPayload,
   parseSIWxHeader,
+  processERC20ApprovalPayload,
   signSIWxMessage,
   validateAndExtract,
+  validateAndExtractApproval,
+  validateAndExtractPermit,
   validateDiscoveryExtension,
+  validateERC20ApprovalGasSponsorPayload,
+  validateEip2612GasSponsorPayload,
+  validatePaymentId,
   validateSIWxMessage,
   verifyEIP6492Signature,
   verifySIWxSignature,