@gvnrdao/dh-sdk 0.0.331 → 0.0.333

package/dist/index.mjs

@@ -1111,6 +1111,9 @@ var require_pkg_src = __commonJS({
     });
     var index_exports = {};
     __export2(index_exports, {
+      BORROWER_AUTHORIZATION_ENCODE_TYPES: () => BORROWER_AUTHORIZATION_ENCODE_TYPES,
+      BORROWER_AUTHORIZATION_FIELDS: () => BORROWER_AUTHORIZATION_FIELDS,
+      BORROWER_AUTHORIZATION_PRIMARY_TYPES: () => BORROWER_AUTHORIZATION_PRIMARY_TYPES,
       CHIPOTLE_DEPLOYMENTS: () => CHIPOTLE_DEPLOYMENTS,
       DEFAULT_CACHE_CONFIG: () => DEFAULT_CACHE_CONFIG,
       DEFAULT_DEBUG_CONFIG: () => DEFAULT_DEBUG_CONFIG,
@@ -1123,6 +1126,8 @@ var require_pkg_src = __commonJS({
       PerformanceTracker: () => PerformanceTracker,
       RetryStrategy: () => RetryStrategy,
       analyzeError: () => analyzeError,
+      borrowerAuthorizationTypes: () => borrowerAuthorizationTypes,
+      buildBorrowerAuthorizationDomain: () => buildBorrowerAuthorizationDomain,
       calculateDelay: () => calculateDelay,
       cidToHex: () => cidToHex,
       classifyError: () => classifyError,
@@ -1369,30 +1374,30 @@ var require_pkg_src = __commonJS({
         }
       },
       btcTransactionSigner: {
-        cid: "QmakWzTce8NH1Jkgv1xwg83Bg9WmF2UG1Mq76pDYDSwwUp",
+        cid: "QmVi1BYdxvCX3QUhXwPtP6FjWMzqSPtXzrS54YsXjTgjYf",
         authorizedCidHex: cidToHex(
-          "QmakWzTce8NH1Jkgv1xwg83Bg9WmF2UG1Mq76pDYDSwwUp"
+          "QmVi1BYdxvCX3QUhXwPtP6FjWMzqSPtXzrS54YsXjTgjYf"
         ),
         name: "Btc Transaction Signer",
         description: "Production Btc Transaction Signer",
         version: "1.1.1",
         deployed: true,
-        deployedAt: 1786465606156,
-        size: 67999,
-        hash: "83f3644c68819215e05ba8db3225571354a009458fc1437f606df6cb9142d3f9"
+        deployedAt: 1787923905597,
+        size: 70646,
+        hash: "37c3bb72a660c8275d92e1b73f9482742d86b64789480b9246304c0ca1bab47a"
       },
       ucdMintValidator: {
-        cid: "Qmd8jgKRceLvf5aoTtwdXG2JqMoBK5cRJwrvEtQkgvbFbx",
+        cid: "QmUWR5fLiyimLT9TPXpYx3HgwNwkvR6MxjZ7hdeYCFodbc",
         authorizedCidHex: cidToHex(
-          "Qmd8jgKRceLvf5aoTtwdXG2JqMoBK5cRJwrvEtQkgvbFbx"
+          "QmUWR5fLiyimLT9TPXpYx3HgwNwkvR6MxjZ7hdeYCFodbc"
         ),
         name: "Ucd Mint Validator",
         description: "Production Ucd Mint Validator",
         version: "1.2.1",
         deployed: true,
-        deployedAt: 1786465627201,
-        size: 82739,
-        hash: "2bdd9aebdaad58a43a4731d5b7284f2531b7a9caaf8caf5719d891c4ed33cb2e",
+        deployedAt: 1787923919527,
+        size: 86197,
+        hash: "c2d80939746cc37f65ef2f63c6a3215b929214a63f10c78144e1f5c98320dabf",
         validatorWalletAddress: "0x82DB9F515957aA380B596C6eA2Bd30CEF181f236",
         pkp: {
           publicKey: "0x041ab17cd91fc5c0b761eea6092d032807561b621b82c488826776e04a9158d61ba64d809a4729f0501289d980732cb06d8dfd06999dd9c8efd2f495dad78b31bb",
@@ -1400,17 +1405,17 @@ var require_pkg_src = __commonJS({
         }
       },
       processPaymentValidator: {
-        cid: "QmNXVdysXDhCaQ1uNE2Vgjbuzy6yUEnnVgHzmDfNKXMU6z",
+        cid: "QmXmXuMRAjMLdgKGyTf9KQdGwYrDp8DxkiF44TvSXDf7wF",
         authorizedCidHex: cidToHex(
-          "QmNXVdysXDhCaQ1uNE2Vgjbuzy6yUEnnVgHzmDfNKXMU6z"
+          "QmXmXuMRAjMLdgKGyTf9KQdGwYrDp8DxkiF44TvSXDf7wF"
         ),
         name: "Process Payment Validator",
         description: "Production Process Payment Validator",
         version: "1.2.1",
         deployed: true,
-        deployedAt: 1786465654796,
-        size: 78736,
-        hash: "17191ecc9c009e0fa5ab52c876330beb2a9a75d30cccb92e7c0c04f169df088b",
+        deployedAt: 1787923987153,
+        size: 82217,
+        hash: "13defa19614215ab3b1fe88955d69e530d13a09475396af932fe0e213637da2f",
         validatorWalletAddress: "0x82DB9F515957aA380B596C6eA2Bd30CEF181f236",
         pkp: {
           publicKey: "0x04cfccb9b6c7addc79469c0e9fafebef4c70801302c62cdb26b610723a9b8527d23f98a40158c7340d83fd0e62d02b5ec74c12f7a86d98e8c6973b4811110f19ad",
@@ -1418,17 +1423,17 @@ var require_pkg_src = __commonJS({
         }
       },
       extendPositionValidator: {
-        cid: "QmYwBsyrhGfHWyRKx549G4tKHxsBLAuRUHcecigeUCkFav",
+        cid: "QmU8h99EEVEsQkxroXiYqLsKZw9gNjE6N5CcTpE9aUc12m",
         authorizedCidHex: cidToHex(
-          "QmYwBsyrhGfHWyRKx549G4tKHxsBLAuRUHcecigeUCkFav"
+          "QmU8h99EEVEsQkxroXiYqLsKZw9gNjE6N5CcTpE9aUc12m"
         ),
         name: "Extend Position Validator",
         description: "Production Extend Position Validator",
         version: "1.2.1",
         deployed: true,
-        deployedAt: 1786465681874,
-        size: 76515,
-        hash: "1d4e085335af80f194a663a577876902c83015177e95906a0b461fa93bd5da08",
+        deployedAt: 1787923999294,
+        size: 79975,
+        hash: "31c1aaf883ef22f37681ddb0a4a949be5c05304b6aef178989475a2da935ef9a",
         validatorWalletAddress: "0x82DB9F515957aA380B596C6eA2Bd30CEF181f236",
         pkp: {
           publicKey: "0x04e52338f6a0c3362800f1a94c4c8f08be5030dde0fa217388c53d1c1a4790f4443c9f2886b2d2d8f4b75a9a156e9b028011b1a1cf7648da0e556aa980ec692836",
@@ -1436,17 +1441,17 @@ var require_pkg_src = __commonJS({
         }
       },
       btcWithdrawal: {
-        cid: "QmRYVoTTDxk2McvBqxSm9M7YcaBGdTqjnZGPX4Y191DaZh",
+        cid: "QmZQWET9pzrVD4gwQuSzYZmqa24JrUNtnnGFDd513sxMCY",
         authorizedCidHex: cidToHex(
-          "QmRYVoTTDxk2McvBqxSm9M7YcaBGdTqjnZGPX4Y191DaZh"
+          "QmZQWET9pzrVD4gwQuSzYZmqa24JrUNtnnGFDd513sxMCY"
         ),
         name: "Btc Withdrawal",
         description: "Production Btc Withdrawal",
         version: "1.2.7",
         deployed: true,
-        deployedAt: 1786446046614,
-        size: 97456,
-        hash: "3cae8250861832f91ee3c573abeb50ff27b9acd34148176071cbfbabb359fc91",
+        deployedAt: 1787924017769,
+        size: 100069,
+        hash: "4f8e27414e4da235e63d6ae1325c63f3d2fb956464515a21aa007a99935f0f13",
         validatorWalletAddress: "0x82DB9F515957aA380B596C6eA2Bd30CEF181f236",
         pkp: {
           publicKey: "0x043616787c5432415c24378c4ef48de2bcd6bb7b575b837e3cff09171802662da7105d79586c7659677a0ecbaddac4cce06cb2a11f69a16fa0c4d7002ac7d51a4d",
@@ -1558,30 +1563,30 @@ var require_pkg_src = __commonJS({
         hash: "03ee5be239c91c735d2c95db89a0d1b77e602cfc18af8eb64b3281fddcd90a72"
       },
       agentModuleExecutor: {
-        cid: "QmdhC18wF7PFGMQ8aThdPsEVSpuDewA27dFvbA3bG6kVDQ",
+        cid: "QmcD65vuremot5fsHVgp9JBAmei6gAaEtm5mdtLP7Yt9Kf",
         authorizedCidHex: cidToHex(
-          "QmdhC18wF7PFGMQ8aThdPsEVSpuDewA27dFvbA3bG6kVDQ"
+          "QmcD65vuremot5fsHVgp9JBAmei6gAaEtm5mdtLP7Yt9Kf"
         ),
         name: "Agent Module Executor",
         description: "Production Agent Module Executor",
         version: "1.1.1",
         deployed: true,
-        deployedAt: 1786446108348,
-        size: 11655,
-        hash: "d4e2149f843d6c2699fc61114d54b268ba4ed2c46ebdaee1145e0f101ec2a1ec"
+        deployedAt: 1787924032013,
+        size: 13878,
+        hash: "a7f0204700912e26e5a354bee13a1242a2baa218643b3bb22d28481f67f9baf4"
       },
       staleSpendRecoveryValidator: {
-        cid: "QmXQWT8V4wjuvH8BbC7xrkYxsVu5AKfvfWcS7jnYfrexYm",
+        cid: "QmNuwo4PT4AikAmhMdZgPWCb2mJDwWa9TnUqrqvofjbrT8",
         authorizedCidHex: cidToHex(
-          "QmXQWT8V4wjuvH8BbC7xrkYxsVu5AKfvfWcS7jnYfrexYm"
+          "QmNuwo4PT4AikAmhMdZgPWCb2mJDwWa9TnUqrqvofjbrT8"
         ),
         name: "Stale Spend Recovery Validator",
         description: "Production Stale Spend Recovery Validator",
         version: "1.1.2",
         deployed: true,
-        deployedAt: 1785173285829,
-        size: 37108,
-        hash: "04de5fc5b6f5131dc1544e3d3d187a1f9ef9616ffd12483d119f9102b3671791",
+        deployedAt: 1787924048772,
+        size: 41424,
+        hash: "3c5f028d2bef4344768462993616d45e30d9d44ef126e04d6eb579821d57d99c",
         validatorWalletAddress: "0x82DB9F515957aA380B596C6eA2Bd30CEF181f236",
         pkp: {
           publicKey: "0x046da0ad6da7dd4a0063cbeac6f2bdb6a9889c2178b23470833356a8ee5630f7f0eee0db348d9d9aaaadd23eccf0063c8f68ee5e446abe30b882bf1de4c932bc21",
@@ -1589,17 +1594,17 @@ var require_pkg_src = __commonJS({
         }
       },
       btcUtxoInvalidator: {
-        cid: "Qmf4Ze8yhnQhHbnX5RPgJrC7Jw1aA3gbpfpd52kFg7fd1m",
+        cid: "QmaNGeWut7EiGwW4zUc2sFSt7RY5NWFgxYboyG333TwrJf",
         authorizedCidHex: cidToHex(
-          "Qmf4Ze8yhnQhHbnX5RPgJrC7Jw1aA3gbpfpd52kFg7fd1m"
+          "QmaNGeWut7EiGwW4zUc2sFSt7RY5NWFgxYboyG333TwrJf"
         ),
         name: "Btc Utxo Invalidator",
         description: "Production Btc Utxo Invalidator",
         version: "1.0.0",
         deployed: true,
-        deployedAt: 1786465704240,
-        size: 62553,
-        hash: "1dcea2b49e545c423195be22e072dc5e3039ed1c95a8490b23505956029f5b33"
+        deployedAt: 1787924133241,
+        size: 66026,
+        hash: "603bc50920d7f1dee77086f2c518d9e2922ab3858a419d3fbea8221ea3a6d9e9"
       }
     };
     function getDeploymentsForNetwork(network) {
@@ -2360,6 +2365,101 @@ ${errorReport}`);
     var SECONDS_PER_DAY = 86400;
     var DAYS_PER_MONTH = 30;
     var LIT_ACTION_ETH_RPC_TIMEOUT_MS = 8e3;
+    var PINNED_CONTRACT_ADDRESSES = {
+      1: {
+        PositionManager: "0x12A1836e56139ccaD8722B89519d84233efc224B",
+        LoanOperationsManagerModule: "0x2561974A40F1AEed1251d0A090A83cF8536FB9E9",
+        BTCSpendAuthorizer: "0xfBbF108486fa07F1B06a811C5b66ed68DD9c508a",
+        BitcoinProviderRegistry: "0x4ab3Fb96e02893Ed6FAa61bad1918390c8DbbFFC",
+        LITActionValidator: "0xD2c5d59c2CC5c409AC65ce0A817236aeC6869512",
+        PositionDelegateRegistry: "0xf0aa2678aD4F60f49e8F7725089B5E86B7F8FE4C"
+      },
+      11155111: {
+        PositionManager: "0x68e0507D982AEBF1D1C1Af8FBbd842327e2deeFF",
+        LoanOperationsManagerModule: "0x3e05e760a87715207b7F4e8fD35EF7559BcA72C0",
+        BTCSpendAuthorizer: "0xd7E9Eb5eE53f1d9ee55Dc162bBC7486bE437B6bD",
+        BitcoinProviderRegistry: "0xbfA0c48B070D0a9A9CD27469AeacFD2d4261cEE2",
+        LITActionValidator: "0x54eECd7C90F8A8fac27749Ba30BbE8AFBAccc856",
+        PositionDelegateRegistry: "0x482369De283622E7b05731875ec137d4E3D208F9"
+      }
+    };
+    function getPinnedContractAddresses(chainId) {
+      return PINNED_CONTRACT_ADDRESSES[chainId] ?? null;
+    }
+    var PROTOCOL_EIP712_DOMAIN_NAME = "DiamondHands.Protocol";
+    var PROTOCOL_EIP712_DOMAIN_VERSION = "1";
+    var BORROWER_AUTHORIZATION_PRIMARY_TYPES = {
+      MINT: "MintRequest",
+      REPAY: "RepayRequest",
+      RENEW: "RenewRequest",
+      WITHDRAW: "WithdrawRequest"
+    };
+    var BORROWER_AUTHORIZATION_FIELDS = {
+      MintRequest: [
+        { name: "positionId", type: "bytes32" },
+        { name: "mintAmount", type: "uint256" },
+        { name: "quantumTimestamp", type: "uint256" }
+      ],
+      RepayRequest: [
+        { name: "positionId", type: "bytes32" },
+        { name: "paymentAmount", type: "uint256" },
+        { name: "quantumTimestamp", type: "uint256" }
+      ],
+      RenewRequest: [
+        { name: "positionId", type: "bytes32" },
+        { name: "selectedTerm", type: "uint256" },
+        { name: "quantumTimestamp", type: "uint256" }
+      ],
+      WithdrawRequest: [
+        { name: "positionId", type: "bytes32" },
+        { name: "totalDeduction", type: "uint256" },
+        { name: "withdrawalAddress", type: "string" },
+        { name: "quantumTimestamp", type: "uint256" }
+      ]
+    };
+    var BORROWER_AUTHORIZATION_ENCODE_TYPES = {
+      MintRequest: "MintRequest(bytes32 positionId,uint256 mintAmount,uint256 quantumTimestamp)",
+      RepayRequest: "RepayRequest(bytes32 positionId,uint256 paymentAmount,uint256 quantumTimestamp)",
+      RenewRequest: "RenewRequest(bytes32 positionId,uint256 selectedTerm,uint256 quantumTimestamp)",
+      WithdrawRequest: "WithdrawRequest(bytes32 positionId,uint256 totalDeduction,string withdrawalAddress,uint256 quantumTimestamp)"
+    };
+    function borrowerAuthorizationTypes(primaryType) {
+      const fields = BORROWER_AUTHORIZATION_FIELDS[primaryType];
+      if (!fields) {
+        throw new Error(
+          `Unknown borrower authorization primary type "${primaryType}"; expected one of ${Object.keys(BORROWER_AUTHORIZATION_FIELDS).join(", ")}`
+        );
+      }
+      return { [primaryType]: fields.map((field) => ({ ...field })) };
+    }
+    function buildBorrowerAuthorizationDomain(chainId, verifyingContractOverride) {
+      if (!Number.isInteger(chainId) || chainId <= 0) {
+        throw new Error(
+          `Borrower authorization domain requires a positive integer chainId, got ${String(chainId)}`
+        );
+      }
+      const pinned = getPinnedContractAddresses(chainId);
+      const pinnedLom = pinned?.LoanOperationsManagerModule;
+      if (pinnedLom && verifyingContractOverride) {
+        if (pinnedLom.toLowerCase() !== verifyingContractOverride.toLowerCase()) {
+          throw new Error(
+            `Refusing a caller-supplied verifyingContract that contradicts the pin for chainId ${chainId}: caller ${verifyingContractOverride}, pinned ${pinnedLom}`
+          );
+        }
+      }
+      const verifyingContract = pinnedLom ?? verifyingContractOverride;
+      if (!verifyingContract) {
+        throw new Error(
+          `No pinned LoanOperationsManagerModule for chainId ${chainId} and no verifyingContract supplied; refusing to build a borrower authorization domain without one`
+        );
+      }
+      return {
+        name: PROTOCOL_EIP712_DOMAIN_NAME,
+        version: PROTOCOL_EIP712_DOMAIN_VERSION,
+        chainId,
+        verifyingContract
+      };
+    }
     var EVMChain = /* @__PURE__ */ ((EVMChain3) => {
       EVMChain3["SEPOLIA"] = "sepolia";
       EVMChain3["ETHEREUM"] = "ethereum";
@@ -5654,7 +5754,7 @@ var init_network_configs = __esm({
 });
 
 // src/modules/diamond-hands-sdk.ts
-import { Contract as Contract9, Interface as Interface5, JsonRpcProvider, AbiCoder as AbiCoder2, keccak256 as keccak2566, solidityPackedKeccak256 as solidityPackedKeccak2565, toUtf8Bytes as toUtf8Bytes6, getBytes as getBytes5, zeroPadValue as zeroPadValue5, toBeHex as toBeHex2, parseEther, formatEther, formatUnits, computeAddress, Signature, ZeroHash, ZeroAddress as ZeroAddress3, MaxUint256 } from "ethers";
+import { Contract as Contract9, Interface as Interface5, JsonRpcProvider, AbiCoder as AbiCoder2, keccak256 as keccak2565, solidityPackedKeccak256 as solidityPackedKeccak2564, toUtf8Bytes as toUtf8Bytes5, getBytes as getBytes4, zeroPadValue as zeroPadValue5, toBeHex as toBeHex2, parseEther, formatEther, formatUnits, computeAddress, Signature, ZeroHash, ZeroAddress as ZeroAddress3, MaxUint256 } from "ethers";
 
 // src/types/result.ts
 function success(value) {
@@ -6265,6 +6365,80 @@ async function awaitSafeSubmissionWindowOnChain(signatureQuantum, chainNow, slee
   return { waited: waitedSeconds > 0, waitedSeconds };
 }
 
+// src/utils/borrower-authorization-712.ts
+init_deployment_addresses();
+import { TypedDataEncoder } from "ethers";
+var BORROWER_AUTHORIZATION_712_DOMAIN_NAME = "DiamondHands.Protocol";
+var BORROWER_AUTHORIZATION_712_DOMAIN_VERSION = "1";
+var BORROWER_AUTHORIZATION_712_FIELDS = {
+  MintRequest: [
+    { name: "positionId", type: "bytes32" },
+    { name: "mintAmount", type: "uint256" },
+    { name: "quantumTimestamp", type: "uint256" }
+  ],
+  RepayRequest: [
+    { name: "positionId", type: "bytes32" },
+    { name: "paymentAmount", type: "uint256" },
+    { name: "quantumTimestamp", type: "uint256" }
+  ],
+  RenewRequest: [
+    { name: "positionId", type: "bytes32" },
+    { name: "selectedTerm", type: "uint256" },
+    { name: "quantumTimestamp", type: "uint256" }
+  ],
+  WithdrawRequest: [
+    { name: "positionId", type: "bytes32" },
+    { name: "totalDeduction", type: "uint256" },
+    { name: "withdrawalAddress", type: "string" },
+    { name: "quantumTimestamp", type: "uint256" }
+  ]
+};
+function borrowerAuthorization712Types(primaryType) {
+  const fields = BORROWER_AUTHORIZATION_712_FIELDS[primaryType];
+  if (!fields) {
+    throw new Error(
+      `Unknown borrower authorization primary type "${primaryType}"; expected one of ` + Object.keys(BORROWER_AUTHORIZATION_712_FIELDS).join(", ")
+    );
+  }
+  return { [primaryType]: fields.map((field) => ({ ...field })) };
+}
+function buildBorrowerAuthorization712Domain(chainId) {
+  if (!Number.isInteger(chainId) || chainId <= 0) {
+    throw new Error(
+      `Borrower authorization domain requires a positive integer chainId, got ${String(chainId)}`
+    );
+  }
+  const deployment = Object.values(ALL_DEPLOYMENTS).find(
+    (d) => d.chainId === chainId
+  );
+  const verifyingContract = deployment?.contracts?.LoanOperationsManagerModule;
+  if (!verifyingContract) {
+    throw new Error(
+      `No LoanOperationsManagerModule deployment known for chainId ${chainId}; refusing to build a borrower authorization domain without one`
+    );
+  }
+  return {
+    name: BORROWER_AUTHORIZATION_712_DOMAIN_NAME,
+    version: BORROWER_AUTHORIZATION_712_DOMAIN_VERSION,
+    chainId,
+    verifyingContract
+  };
+}
+async function signBorrowerAuthorization712(signer, primaryType, chainId, message) {
+  const signTypedData = signer.signTypedData;
+  if (typeof signTypedData !== "function") {
+    throw new Error(
+      `Signer has no signTypedData \u2014 cannot produce an EIP-712 ${primaryType}. Wallets without typed-data support must supply the signature via an authorizationProvider instead of a connected signer.`
+    );
+  }
+  return signTypedData.call(
+    signer,
+    buildBorrowerAuthorization712Domain(chainId),
+    borrowerAuthorization712Types(primaryType),
+    message
+  );
+}
+
 // src/utils/mint-authorization.utils.ts
 var PKP_NFT_ABI = [
   "function getPubkey(uint256 tokenId) external view returns (bytes memory)"
@@ -6278,29 +6452,11 @@ async function generateMintAuthorization(positionId, amount, chainId, signerOrPr
   const signer = signerOrPrecomputed;
   const timestamp = calculateNextQuantumTimestamp();
   const action = "mint-ucd";
-  const actionHash = keccak256(toUtf8Bytes(action));
-  const types = [
-    "bytes32",
-    // positionId
-    "uint256",
-    // timestamp
-    "uint256",
-    // chainId
-    "uint256",
-    // amount
-    "bytes32"
-    // actionHash
-  ];
-  const values = [
+  const signature = await signBorrowerAuthorization712(signer, "MintRequest", chainId, {
     positionId,
-    timestamp,
-    chainId,
-    amount.toString(),
-    actionHash
-  ];
-  const messageHash = solidityPackedKeccak256(types, values);
-  const messageHashBytes = getBytes(messageHash);
-  const signature = await signer.signMessage(messageHashBytes);
+    mintAmount: amount.toString(),
+    quantumTimestamp: timestamp
+  });
   return {
     positionId,
     timestamp,
@@ -6337,44 +6493,17 @@ async function generatePaymentAuthorization(positionId, amount, chainId, signerO
     throw new Error(`timestamp must be a number, got ${typeof timestamp}`);
   }
   const action = "make-payment";
-  const actionHash = keccak256(toUtf8Bytes(action));
-  if (typeof actionHash !== "string") {
-    throw new Error(`actionHash must be a string, got ${typeof actionHash}`);
-  }
-  const types = [
-    "bytes32",
-    // positionId
-    "uint256",
-    // timestamp
-    "uint256",
-    // chainId
-    "uint256",
-    // amount
-    "bytes32"
-    // actionHash
-  ];
   const amountStr = amount.toString();
-  if (typeof amountStr !== "string") {
-    throw new Error(
-      `amount.toString() must return a string, got ${typeof amountStr}`
-    );
-  }
-  const values = [positionId, timestamp, chainId, amountStr, actionHash];
-  for (let i = 0; i < values.length; i++) {
-    if (typeof values[i] === "object" && values[i] !== null) {
-      throw new Error(
-        `Value at index ${i} is an object: ${JSON.stringify(values[i])}`
-      );
-    }
-  }
-  const messageHash = solidityPackedKeccak256(types, values);
-  const messageHashBytes = getBytes(messageHash);
-  const signature = await signer.signMessage(messageHashBytes);
+  const signature = await signBorrowerAuthorization712(signer, "RepayRequest", chainId, {
+    positionId,
+    paymentAmount: amountStr,
+    quantumTimestamp: timestamp
+  });
   return {
     positionId,
     timestamp,
     chainId,
-    amount: amount.toString(),
+    amount: amountStr,
     action,
     signature
   };
@@ -6461,32 +6590,12 @@ async function generateWithdrawAuthorization(positionId, amount, chainId, signer
   const signer = signerOrPrecomputed;
   const timestamp = calculateNextQuantumTimestamp();
   const action = "withdraw-btc";
-  const actionHash = keccak256(toUtf8Bytes(action));
-  const types = [
-    "bytes32",
-    // positionId
-    "uint256",
-    // timestamp
-    "uint256",
-    // chainId
-    "uint256",
-    // amount (in satoshis)
-    "string",
-    // destinationAddress (Bitcoin address)
-    "bytes32"
-    // actionHash
-  ];
-  const values = [
+  const signature = await signBorrowerAuthorization712(signer, "WithdrawRequest", chainId, {
     positionId,
-    timestamp,
-    chainId,
-    amount.toString(),
-    destinationAddress,
-    actionHash
-  ];
-  const messageHash = solidityPackedKeccak256(types, values);
-  const messageHashBytes = getBytes(messageHash);
-  const signature = await signer.signMessage(messageHashBytes);
+    totalDeduction: amount.toString(),
+    withdrawalAddress: destinationAddress,
+    quantumTimestamp: timestamp
+  });
   return {
     positionId,
     timestamp,
@@ -6528,7 +6637,6 @@ async function generateBalanceConfirmationAuthorization(positionId, chainId, sig
 }
 
 // src/utils/extend-authorization.utils.ts
-import { keccak256 as keccak2562, toUtf8Bytes as toUtf8Bytes2, solidityPackedKeccak256 as solidityPackedKeccak2562, getBytes as getBytes2 } from "ethers";
 async function generateExtendAuthorization(positionId, newTerm, chainId, signerOrPrecomputed) {
   if (typeof signerOrPrecomputed === "object" && "signature" in signerOrPrecomputed && !("signMessage" in signerOrPrecomputed)) {
     const { timestamp: timestamp2, signature: signature2 } = signerOrPrecomputed;
@@ -6538,29 +6646,11 @@ async function generateExtendAuthorization(positionId, newTerm, chainId, signerO
   const signer = signerOrPrecomputed;
   const timestamp = calculateNextQuantumTimestamp();
   const action = "extend-position";
-  const actionHash = keccak2562(toUtf8Bytes2(action));
-  const types = [
-    "bytes32",
-    // positionId
-    "uint256",
-    // timestamp
-    "uint256",
-    // chainId
-    "uint256",
-    // newTerm (extension term in months)
-    "bytes32"
-    // actionHash
-  ];
-  const values = [
+  const signature = await signBorrowerAuthorization712(signer, "RenewRequest", chainId, {
     positionId,
-    timestamp,
-    chainId,
-    newTerm,
-    actionHash
-  ];
-  const messageHash = solidityPackedKeccak2562(types, values);
-  const messageHashBytes = getBytes2(messageHash);
-  const signature = await signer.signMessage(messageHashBytes);
+    selectedTerm: newTerm,
+    quantumTimestamp: timestamp
+  });
   return {
     positionId,
     timestamp,
@@ -7501,10 +7591,10 @@ async function reconcileAuthorizedSpend(spend, esploraBaseUrl, httpGetJson = def
 
 // src/utils/stale-spend-invalidate-message.ts
 import {
-  keccak256 as keccak2563,
-  toUtf8Bytes as toUtf8Bytes3,
-  solidityPackedKeccak256 as solidityPackedKeccak2563,
-  getBytes as getBytes3,
+  keccak256 as keccak2562,
+  toUtf8Bytes as toUtf8Bytes2,
+  solidityPackedKeccak256 as solidityPackedKeccak2562,
+  getBytes as getBytes2,
   zeroPadValue
 } from "ethers";
 var RECOVERY_INVALIDATE_ACTION = "btc-utxo-invalidator";
@@ -7515,8 +7605,8 @@ function buildInvalidateMessageHash(params) {
     params.positionId.startsWith("0x") ? params.positionId : `0x${params.positionId}`,
     32
   );
-  const actionHash = keccak2563(toUtf8Bytes3(RECOVERY_INVALIDATE_ACTION));
-  return solidityPackedKeccak2563(
+  const actionHash = keccak2562(toUtf8Bytes2(RECOVERY_INVALIDATE_ACTION));
+  return solidityPackedKeccak2562(
     [
       "bytes32",
       // positionId
@@ -7562,7 +7652,7 @@ async function buildInvalidateStaleSpendEnvelope(params) {
     utxoTxid,
     utxoVout
   });
-  const signature = await signer.signMessage(getBytes3(messageHash));
+  const signature = await signer.signMessage(getBytes2(messageHash));
   const borrowerAddress = await signer.getAddress();
   return {
     positionId,
@@ -7577,7 +7667,7 @@ async function buildInvalidateStaleSpendEnvelope(params) {
 }
 
 // src/utils/btc-withdrawal-message.ts
-import { keccak256 as keccak2564, toUtf8Bytes as toUtf8Bytes4, solidityPackedKeccak256 as solidityPackedKeccak2564, getBytes as getBytes4, zeroPadValue as zeroPadValue2 } from "ethers";
+import { keccak256 as keccak2563, toUtf8Bytes as toUtf8Bytes3, solidityPackedKeccak256 as solidityPackedKeccak2563, getBytes as getBytes3, zeroPadValue as zeroPadValue2 } from "ethers";
 var QUANTUM_SECONDS2 = 60;
 var QUANTUM_SAFE_THRESHOLD2 = 40;
 function hashBtcInputSet(utxos) {
@@ -7608,7 +7698,7 @@ function hashBtcInputSet(utxos) {
     seen.add(key);
   }
   const canonical = normalized.sort((a, b) => a.txid < b.txid ? -1 : a.txid > b.txid ? 1 : a.vout - b.vout).map((u) => `${u.txid}:${u.vout}:${u.value}`).join("|");
-  return keccak2564(toUtf8Bytes4(canonical));
+  return keccak2563(toUtf8Bytes3(canonical));
 }
 async function buildBtcExecuteEnvelope(params) {
   const {
@@ -7653,15 +7743,15 @@ async function buildBtcExecuteEnvelope(params) {
   } else {
     timestamp = currentQuantumStart;
   }
-  const actionHash = keccak2564(
-    toUtf8Bytes4("execute-btc-withdrawal")
+  const actionHash = keccak2563(
+    toUtf8Bytes3("execute-btc-withdrawal")
   );
   const utxoIdentifier = `${txid}:${vout}`;
   const positionIdBytes32 = zeroPadValue2(
     positionId.startsWith("0x") ? positionId : `0x${positionId}`,
     32
   );
-  const messageHash = solidityPackedKeccak2564(
+  const messageHash = solidityPackedKeccak2563(
     [
       "bytes32",
       // positionId
@@ -7694,7 +7784,7 @@ async function buildBtcExecuteEnvelope(params) {
       actionHash
     ]
   );
-  const userSignature = await signer.signMessage(getBytes4(messageHash));
+  const userSignature = await signer.signMessage(getBytes3(messageHash));
   const borrowerAddress = await signer.getAddress();
   return {
     positionId,
@@ -10181,6 +10271,10 @@ function normalizePkpId(pkpId) {
   }
   return pkpId;
 }
+function isNormalizedChipotlePkpId(pkpId) {
+  const rawId = pkpId.startsWith("0x") ? pkpId.slice(2) : pkpId;
+  return rawId.length === 40;
+}
 function padPkpIdForSubgraph(pkpId) {
   const raw = pkpId.startsWith("0x") ? pkpId.slice(2) : pkpId;
   if (raw.length === 40) {
@@ -10465,7 +10559,7 @@ var LoanQuery = class {
         batch.map(async (loan) => {
           try {
             const rawId = loan.pkpId?.startsWith("0x") ? loan.pkpId.slice(2) : loan.pkpId;
-            const isChipotlePkpId2 = typeof rawId === "string" && rawId.length === 40 && !rawId.toLowerCase().startsWith("04");
+            const isChipotlePkpId2 = typeof rawId === "string" && isNormalizedChipotlePkpId(rawId);
             if (isChipotlePkpId2) {
               if (this.config.positionManagerCoreAddress && this.config.provider) {
                 const pmContract = new Contract4(
@@ -10791,7 +10885,8 @@ function createLoanQuery(config) {
 }
 
 // src/modules/withdrawal-address/withdrawal-address.module.ts
-import { keccak256 as keccak2565, toUtf8Bytes as toUtf8Bytes5, ZeroAddress as ZeroAddress2 } from "ethers";
+import { keccak256 as keccak2564, toUtf8Bytes as toUtf8Bytes4, ZeroAddress as ZeroAddress2 } from "ethers";
+var STATIC_CALL_DIAGNOSTIC_TIMEOUT_MS = 5e3;
 var WithdrawalAddressModule = class {
   config;
   graphClient;
@@ -10826,7 +10921,7 @@ var WithdrawalAddressModule = class {
   }
   /** keccak256 of the canonicalized address — matches the on-chain key. */
   static addressHash(btcAddress) {
-    return keccak2565(toUtf8Bytes5(normalizeBitcoinAddress(btcAddress)));
+    return keccak2564(toUtf8Bytes4(normalizeBitcoinAddress(btcAddress)));
   }
   /**
    * Add a Bitcoin address to the caller's allowlist. It becomes usable only
@@ -10836,13 +10931,17 @@ var WithdrawalAddressModule = class {
     const reg = this.getRegistry();
     if (!reg.success)
       return reg;
+    const normalized = normalizeBitcoinAddress(btcAddress);
     try {
-      const tx = await reg.value.addAddress(
-        normalizeBitcoinAddress(btcAddress)
-      );
+      const tx = await reg.value.addAddress(normalized);
       return success(tx);
     } catch (error) {
-      return this.txFailure("addAddress", error, btcAddress);
+      return this.txFailure(
+        "addAddress",
+        error,
+        btcAddress,
+        await this.staticCallDiagnostic(reg.value, "addAddress", normalized)
+      );
     }
   }
   /** Remove a Bitcoin address from the caller's allowlist (effective immediately). */
@@ -10850,13 +10949,17 @@ var WithdrawalAddressModule = class {
     const reg = this.getRegistry();
     if (!reg.success)
       return reg;
+    const normalized = normalizeBitcoinAddress(btcAddress);
     try {
-      const tx = await reg.value.removeAddress(
-        normalizeBitcoinAddress(btcAddress)
-      );
+      const tx = await reg.value.removeAddress(normalized);
       return success(tx);
     } catch (error) {
-      return this.txFailure("removeAddress", error, btcAddress);
+      return this.txFailure(
+        "removeAddress",
+        error,
+        btcAddress,
+        await this.staticCallDiagnostic(reg.value, "removeAddress", normalized)
+      );
     }
   }
   /**
@@ -10952,16 +11055,59 @@ var WithdrawalAddressModule = class {
     }
     return success(void 0);
   }
-  txFailure(op, error, context) {
+  /**
+   * Ask the node for the reason a failed write did not carry.
+   *
+   * A failing `eth_estimateGas` frequently answers with NOTHING to decode — ethers renders that
+   * as `missing revert data ... data=null, reason=null, revert=null`, which names no cause and
+   * cannot distinguish "the contract rejected this" from "the RPC hiccuped". An `eth_call` of the
+   * same calldata usually does carry the revert reason or custom-error selector, so this runs one
+   * and folds the answer into the reported error.
+   *
+   * Three deliberate properties:
+   *
+   * 1. It runs ONLY after the write has already failed. Gating the write on a static call would
+   *    let a flaky endpoint — precisely the condition this exists to diagnose — block an add that
+   *    would otherwise have succeeded.
+   * 2. It costs NO extra signature. `staticCall` is `eth_call`: a node read, never a wallet prompt.
+   * 3. It can never throw. A diagnostic that escapes would replace the real cause with itself.
+   *    (The `try/catch` here is the authorized exception to CLAUDE.md's forbidden-patterns rule;
+   *    it swallows nothing — every branch returns text that is reported alongside the original.)
+   *
+   * A static call that SUCCEEDS is itself a finding: the contract accepts this call, so the
+   * failure lay outside contract logic (RPC, gas, or nonce).
+   */
+  async staticCallDiagnostic(registry, op, normalizedAddress) {
+    try {
+      await Promise.race([
+        registry[op].staticCall(normalizedAddress),
+        // The failure being diagnosed is often an unresponsive endpoint, so the diagnostic must
+        // not inherit that hang — the user is waiting on this error message.
+        new Promise(
+          (_, reject) => setTimeout(
+            () => reject(new Error("static call timed out after 5s")),
+            STATIC_CALL_DIAGNOSTIC_TIMEOUT_MS
+          )
+        )
+      ]);
+      return "static call SUCCEEDED \u2014 the contract accepts this call, so the failure was not contract logic (RPC, gas, or nonce)";
+    } catch (diagnostic) {
+      const code = typeof diagnostic === "object" && diagnostic !== null ? diagnostic.code : void 0;
+      const msg = diagnostic instanceof Error ? diagnostic.message : String(diagnostic);
+      return typeof code === "string" ? `static call reverted [${code}]: ${msg}` : `static call failed: ${msg}`;
+    }
+  }
+  txFailure(op, error, context, diagnostic) {
     const msg = error instanceof Error ? error.message : String(error);
+    const detail = diagnostic ? `${msg} \u2014 ${diagnostic}` : msg;
     return failure(
       new SDKError({
         code: `SDK_WITHDRAWAL_REGISTRY_${op.toUpperCase()}_FAILED`,
-        message: `WithdrawalAddressRegistry.${op} failed: ${msg}`,
+        message: `WithdrawalAddressRegistry.${op} failed: ${detail}`,
         category: "CONTRACT" /* CONTRACT */,
         severity: "MEDIUM" /* MEDIUM */,
         originalError: error instanceof Error ? error : new Error(String(error)),
-        context: { op, context }
+        context: { op, context, diagnostic }
       })
     );
   }
@@ -12052,6 +12198,47 @@ function normalizePkpId2(pkpId) {
   }
   return pkpId;
 }
+function applyLoanEventsFilter(events, opts) {
+  const { wantsEvent, fromTimestamp, toTimestamp, fromBlock, toBlock, limit } = opts;
+  const inBounds = (e) => {
+    const ts = e?.timestamp;
+    const bn = e?.blockNumber;
+    try {
+      if (fromTimestamp !== void 0 && ts !== void 0 && BigInt(ts) < BigInt(fromTimestamp))
+        return false;
+      if (toTimestamp !== void 0 && ts !== void 0 && BigInt(ts) > BigInt(toTimestamp))
+        return false;
+      if (fromBlock !== void 0 && bn !== void 0 && BigInt(bn) < BigInt(fromBlock))
+        return false;
+      if (toBlock !== void 0 && bn !== void 0 && BigInt(bn) > BigInt(toBlock))
+        return false;
+    } catch {
+      return true;
+    }
+    return true;
+  };
+  const narrow = (list, kind) => wantsEvent(kind) ? (list ?? []).filter(inBounds).slice(0, limit) : [];
+  const single = (value, kind) => value && wantsEvent(kind) && inBounds(value) ? value : void 0;
+  const filtered = {
+    ...events,
+    positionCreated: single(events.positionCreated, "positionCreated"),
+    payments: narrow(events.payments, "payment"),
+    statusUpdates: narrow(events.statusUpdates, "status"),
+    liquidation: single(events.liquidation, "liquidation"),
+    mints: narrow(events.mints, "mint"),
+    withdrawals: narrow(events.withdrawals, "withdrawal"),
+    renewals: narrow(events.renewals, "renewal"),
+    operationFailures: narrow(events.operationFailures, "operationFailure"),
+    mintRequests: narrow(events.mintRequests, "mintRequest"),
+    burnRequests: narrow(events.burnRequests, "burnRequest"),
+    collateralEvents: narrow(events.collateralEvents, "collateralEvent"),
+    mintingFees: narrow(events.mintingFees, "mintingFee"),
+    renewalFees: narrow(events.renewalFees, "renewalFee"),
+    totalEvents: 0
+  };
+  filtered.totalEvents = (filtered.positionCreated ? 1 : 0) + (filtered.liquidation ? 1 : 0) + filtered.payments.length + filtered.statusUpdates.length + filtered.mints.length + filtered.withdrawals.length + filtered.renewals.length + filtered.operationFailures.length + filtered.mintRequests.length + filtered.burnRequests.length + filtered.collateralEvents.length + filtered.mintingFees.length + filtered.renewalFees.length;
+  return filtered;
+}
 function hasLoanEventsFilter(filter) {
   if (!filter)
     return false;
@@ -13208,32 +13395,24 @@ var DiamondHandsGraph = class {
       limit = 1e3,
       orderDirection = "desc"
     } = filter || {};
+    const wantsEvent = (kind) => !eventTypes || eventTypes.includes(kind);
+    const hasBounds = fromTimestamp !== void 0 || toTimestamp !== void 0 || fromBlock !== void 0 || toBlock !== void 0;
+    const pageSize = hasBounds ? THE_GRAPH_MAX_BATCH_SIZE : limit;
+    const buildPositionWhereClause = () => `where: { position: "${positionId.toLowerCase()}" }`;
     const shouldQuery = {
-      positionCreated: !eventTypes || eventTypes.includes("positionCreated"),
-      payment: !eventTypes || eventTypes.includes("payment"),
-      status: !eventTypes || eventTypes.includes("status"),
-      liquidation: !eventTypes || eventTypes.includes("liquidation"),
-      mint: !eventTypes || eventTypes.includes("mint"),
-      withdrawal: !eventTypes || eventTypes.includes("withdrawal"),
-      renewal: !eventTypes || eventTypes.includes("renewal"),
-      operationFailure: !eventTypes || eventTypes.includes("operationFailure"),
-      mintRequest: !eventTypes || eventTypes.includes("mintRequest"),
-      burnRequest: !eventTypes || eventTypes.includes("burnRequest"),
-      collateralEvent: !eventTypes || eventTypes.includes("collateralEvent"),
-      mintingFee: !eventTypes || eventTypes.includes("mintingFee"),
-      renewalFee: !eventTypes || eventTypes.includes("renewalFee")
-    };
-    const buildPositionWhereClause = () => {
-      const conditions = [`position: "${positionId.toLowerCase()}"`];
-      if (fromTimestamp)
-        conditions.push(`timestamp_gte: "${fromTimestamp}"`);
-      if (toTimestamp)
-        conditions.push(`timestamp_lte: "${toTimestamp}"`);
-      if (fromBlock)
-        conditions.push(`blockNumber_gte: "${fromBlock}"`);
-      if (toBlock)
-        conditions.push(`blockNumber_lte: "${toBlock}"`);
-      return `where: { ${conditions.join(", ")} }`;
+      positionCreated: true,
+      payment: true,
+      status: true,
+      liquidation: true,
+      mint: true,
+      withdrawal: true,
+      renewal: true,
+      operationFailure: true,
+      mintRequest: true,
+      burnRequest: true,
+      collateralEvent: true,
+      mintingFee: true,
+      renewalFee: true
     };
     const query = `
       query GetLoanEvents($positionId: Bytes!, $limit: Int!, $orderDirection: OrderDirection!) {
@@ -13469,11 +13648,41 @@ var DiamondHandsGraph = class {
     `;
     const variables = {
       positionId: positionId.toLowerCase(),
-      limit,
+      limit: pageSize,
       orderDirection
     };
     const result = await this.client.execute(query, variables);
-    return this.assembleLoanEvents(positionId, result);
+    if (hasBounds) {
+      const collections = [
+        ["payments", result.position?.payments],
+        ["statusUpdates", result.position?.statusUpdates],
+        ["withdrawals", result.position?.withdrawals],
+        ["renewals", result.position?.renewals],
+        ["operationFailures", result.position?.operationFailures],
+        ["mintRequests", result.position?.mintRequests],
+        ["burnRequests", result.position?.burnRequests],
+        ["mintingFees", result.position?.mintingFees],
+        ["renewalFees", result.position?.renewalFees],
+        ["mints", result.ucdmintEvents],
+        ["collateralEvents", result.collateralEvents]
+      ];
+      const saturated = collections.filter(([, list]) => (list?.length ?? 0) >= pageSize).map(([name]) => name);
+      if (saturated.length > 0) {
+        log.warn(
+          "[DiamondHandsGraph] bounded getLoanEvents page saturated \u2014 the filtered history may be incomplete",
+          { positionId, pageSize, saturated }
+        );
+      }
+    }
+    const assembled = this.assembleLoanEvents(positionId, result);
+    return applyLoanEventsFilter(assembled, {
+      wantsEvent,
+      fromTimestamp,
+      toTimestamp,
+      fromBlock,
+      toBlock,
+      limit
+    });
   }
   /**
    * Map one position's raw event payload into `LoanEvents`.
@@ -20556,8 +20765,8 @@ var DiamondHandsSDK = class _DiamondHandsSDK {
         throw new Error(`Position not found: ${request.positionId}`);
       }
       const currentDebt = position.ucdDebt.toString();
-      const ucdDebtHash = keccak2566(AbiCoder2.defaultAbiCoder().encode(["uint256"], [currentDebt]));
-      const contractHash = keccak2566(AbiCoder2.defaultAbiCoder().encode(
+      const ucdDebtHash = keccak2565(AbiCoder2.defaultAbiCoder().encode(["uint256"], [currentDebt]));
+      const contractHash = keccak2565(AbiCoder2.defaultAbiCoder().encode(
         ["address", "address", "address", "address"],
         [
           positionManagerAddress,
@@ -20634,7 +20843,7 @@ var DiamondHandsSDK = class _DiamondHandsSDK {
         const currentPosition = await positionCore["getPositionDetails"](
           positionIdBytes32
         );
-        const currentDebtHash = keccak2566(
+        const currentDebtHash = keccak2565(
           AbiCoder2.defaultAbiCoder().encode(
             ["uint256"],
             [currentPosition.ucdDebt]
@@ -24546,7 +24755,7 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
       targetAddress: spend.targetAddress,
       targetAmount: Number(spend.targetAmount),
       authorizedAt: Number(spend.authorizedAt),
-      utxoKey: solidityPackedKeccak2565(
+      utxoKey: solidityPackedKeccak2564(
         ["string", "uint32"],
         [spend.txid, Number(spend.vout)]
       )
@@ -25554,9 +25763,9 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
       to: registryAddress,
       data: iface.encodeFunctionData("getLoanGrant", [pid])
     });
-    if (getBytes5(data).length < 96) {
+    if (getBytes4(data).length < 96) {
       throw new SDKError({
-        message: `AgentDelegationRegistry at ${registryAddress} returned ${getBytes5(data).length} bytes for getLoanGrant(bytes32) \u2014 expected at least 96. Wrong address, or a registry version this SDK does not support.`,
+        message: `AgentDelegationRegistry at ${registryAddress} returned ${getBytes4(data).length} bytes for getLoanGrant(bytes32) \u2014 expected at least 96. Wrong address, or a registry version this SDK does not support.`,
         category: "CONTRACT" /* CONTRACT */,
         severity: "HIGH" /* HIGH */
       });
@@ -25565,7 +25774,7 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
       "getLoanGrant",
       data
     );
-    const raw = getBytes5(data);
+    const raw = getBytes4(data);
     const withdrawScopeSupported = raw.length >= 128;
     const minWithdrawRatioBps = withdrawScopeSupported ? Number(
       AbiCoder2.defaultAbiCoder().decode(["uint32"], raw.slice(96, 128))[0]
@@ -26754,8 +26963,8 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
     const MIN_REVEAL_DELAY = 60;
     const MAX_RANDOM_DELAY = 240;
     const entropyInput = positionId + quantumTimestamp.toString();
-    const hash = keccak2566(
-      toUtf8Bytes6(entropyInput)
+    const hash = keccak2565(
+      toUtf8Bytes5(entropyInput)
     );
     const randomValue = BigInt(hash);
     const randomDelay = Number(randomValue % BigInt(MAX_RANDOM_DELAY));
@@ -26780,12 +26989,12 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
     const rawPositionId = /^0x/i.test(params.positionId.trim()) ? params.positionId.trim().slice(2) : params.positionId.trim();
     const canonicalPositionId = "0x" + rawPositionId.padStart(64, "0").toLowerCase();
     const intentTimestamp = Math.floor(Date.now() / 1e3);
-    const intentActionHash = keccak2566(toUtf8Bytes6("liquidate-position"));
-    const intentHash = solidityPackedKeccak2565(
+    const intentActionHash = keccak2565(toUtf8Bytes5("liquidate-position"));
+    const intentHash = solidityPackedKeccak2564(
       ["bytes32", "uint256", "uint256", "address", "bytes32"],
       [canonicalPositionId, intentTimestamp, chainId, intentSigner, intentActionHash]
     );
-    const intentSignature = await signer.signMessage(getBytes5(intentHash));
+    const intentSignature = await signer.signMessage(getBytes4(intentHash));
     const response = await fetch(endpoint, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -26837,7 +27046,7 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
         const vrfSeedRaw = await lmResult.value["vrfSeeds"](positionId);
         const vrfSeed = BigInt(vrfSeedRaw.toString());
         if (vrfSeed !== 0n) {
-          const finalEntropy = solidityPackedKeccak2565(
+          const finalEntropy = solidityPackedKeccak2564(
             ["uint256", "uint256", "bytes32"],
             [vrfSeed, BigInt(quantumTimestamp.toString()), positionId]
           );