@gvnrdao/dh-sdk 0.0.332 → 0.0.334

package/dist/index.js

@@ -1105,6 +1105,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,
@@ -1117,6 +1120,8 @@ var require_pkg_src = __commonJS({
       PerformanceTracker: () => PerformanceTracker,
       RetryStrategy: () => RetryStrategy,
       analyzeError: () => analyzeError,
+      borrowerAuthorizationTypes: () => borrowerAuthorizationTypes,
+      buildBorrowerAuthorizationDomain: () => buildBorrowerAuthorizationDomain,
       calculateDelay: () => calculateDelay,
       cidToHex: () => cidToHex,
       classifyError: () => classifyError,
@@ -1363,30 +1368,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",
@@ -1394,17 +1399,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",
@@ -1412,17 +1417,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",
@@ -1430,17 +1435,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",
@@ -1552,30 +1557,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",
@@ -1583,17 +1588,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) {
@@ -2354,6 +2359,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";
@@ -4164,11 +4264,11 @@ ${auth.clientId}`;
         );
         const prices = await Promise.race([fetchAll, timeoutPromise]);
         const sorted = [...prices].sort((a, b) => a - b);
-        let median;
+        let median2;
         if (this.devSingleProvider) {
-          median = sorted[0];
+          median2 = sorted[0];
         } else {
-          median = sorted[1];
+          median2 = sorted[1];
           const spread = (sorted[2] - sorted[0]) / sorted[0];
           if (spread > PRICE_ORACLE_TOLERANCE) {
             const names = this.sources.map((s) => s.name).join(", ");
@@ -4178,10 +4278,10 @@ ${auth.clientId}`;
             );
           }
         }
-        const priceCents = Math.round(median * 100);
+        const priceCents = Math.round(median2 * 100);
         const priceWith8Decimals = BigInt(priceCents) * 1000000n;
         const totalElapsed = Date.now() - startTime;
-        console.log(`[Price Oracle] Median price: $${median.toLocaleString()} \u2014 total time: ${totalElapsed}ms`);
+        console.log(`[Price Oracle] Median price: $${median2.toLocaleString()} \u2014 total time: ${totalElapsed}ms`);
         console.log(`[Price Oracle] Price with 8 decimals: ${priceWith8Decimals}`);
         return priceWith8Decimals;
       }
@@ -6133,26 +6233,83 @@ var MAKE_PAYMENT_GAS_CEILING = BigInt(1e6);
 var EXTEND_POSITION_GAS_CEILING = BigInt(1e6);
 var LIQUIDATION_COMMIT_GAS_CEILING = BigInt(1e6);
 var LIQUIDATION_REVEAL_GAS_CEILING = BigInt(2e6);
-async function resolveEip1559FeeFields(provider) {
-  const feeData = await provider.getFeeData();
-  let maxFeePerGas = feeData.maxFeePerGas ?? void 0;
-  let maxPriorityFeePerGas = feeData.maxPriorityFeePerGas ?? void 0;
-  if (!maxFeePerGas || !maxPriorityFeePerGas) {
-    const gasPrice = (await provider.getFeeData()).gasPrice ?? (0, import_ethers.parseUnits)("1", "gwei");
-    maxFeePerGas = maxFeePerGas || gasPrice * 2n;
-    maxPriorityFeePerGas = maxPriorityFeePerGas || (0, import_ethers.parseUnits)("1.5", "gwei");
-  }
-  if (maxFeePerGas < maxPriorityFeePerGas) {
-    maxFeePerGas = maxPriorityFeePerGas;
+var PRIORITY_FEE_FLOOR_WEI = (0, import_ethers.parseUnits)("0.1", "gwei");
+var PRIORITY_FEE_CAP_WEI = (0, import_ethers.parseUnits)("3", "gwei");
+var FEE_HISTORY_BLOCK_COUNT = 20;
+var FEE_HISTORY_REWARD_PERCENTILE = 75;
+function isJsonRpcSendable(provider) {
+  return typeof provider.send === "function";
+}
+function parseFeeHistory(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error(`eth_feeHistory returned a non-object result: ${JSON.stringify(raw)}`);
   }
+  const { baseFeePerGas, reward } = raw;
+  if (!Array.isArray(baseFeePerGas) || baseFeePerGas.length === 0) {
+    throw new Error(
+      `eth_feeHistory returned no baseFeePerGas \u2014 the RPC does not support EIP-1559 fee history: ${JSON.stringify(raw)}`
+    );
+  }
+  if (!Array.isArray(reward) || reward.length === 0) {
+    throw new Error(
+      `eth_feeHistory returned no reward percentiles \u2014 the RPC ignored the rewardPercentiles argument: ${JSON.stringify(raw)}`
+    );
+  }
+  const nextBaseFee = (0, import_ethers.getBigInt)(baseFeePerGas[baseFeePerGas.length - 1], "baseFeePerGas");
+  const tips = reward.map((perBlock, i) => {
+    if (!Array.isArray(perBlock) || perBlock.length === 0) {
+      throw new Error(`eth_feeHistory reward row ${i} is empty: ${JSON.stringify(raw)}`);
+    }
+    return (0, import_ethers.getBigInt)(perBlock[0], `reward[${i}]`);
+  });
+  return { nextBaseFee, tips };
+}
+function median(values) {
+  const sorted = [...values].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const mid = sorted.length >> 1;
+  const hi = sorted[mid];
+  if (hi === void 0) {
+    throw new Error("median: no values");
+  }
+  if (sorted.length % 2 === 1)
+    return hi;
+  const lo = sorted[mid - 1];
+  if (lo === void 0) {
+    throw new Error("median: no values");
+  }
+  return (lo + hi) / 2n;
+}
+function clamp(value, floor, cap) {
+  if (value < floor)
+    return floor;
+  if (value > cap)
+    return cap;
+  return value;
+}
+async function resolveEip1559FeeFields(feeProvider) {
+  if (!isJsonRpcSendable(feeProvider)) {
+    throw new Error(
+      "resolveEip1559FeeFields: feeProvider must be a JSON-RPC provider exposing send() (the SDK read provider), not a wallet BrowserProvider \u2014 eth_feeHistory is required"
+    );
+  }
+  const history = parseFeeHistory(
+    await feeProvider.send("eth_feeHistory", [
+      (0, import_ethers.toQuantity)(FEE_HISTORY_BLOCK_COUNT),
+      "latest",
+      [FEE_HISTORY_REWARD_PERCENTILE]
+    ])
+  );
+  const marketTip = median(history.tips);
+  const maxPriorityFeePerGas = clamp(marketTip, PRIORITY_FEE_FLOOR_WEI, PRIORITY_FEE_CAP_WEI);
+  const maxFeePerGas = history.nextBaseFee * 2n + maxPriorityFeePerGas;
   return { maxFeePerGas, maxPriorityFeePerGas };
 }
 async function sendEip1559Transaction(params) {
-  const { signer, to, data, gasLimit } = params;
+  const { signer, feeProvider, to, data, gasLimit } = params;
   if (!signer.provider) {
     throw new Error("Signer must have a provider attached");
   }
-  const fees = await resolveEip1559FeeFields(signer.provider);
+  const fees = await resolveEip1559FeeFields(feeProvider);
   return signer.sendTransaction({
     to,
     data,
@@ -6247,7 +6404,7 @@ function validateSDKConfig(config) {
 }
 
 // src/utils/mint-authorization.utils.ts
-var import_ethers2 = require("ethers");
+var import_ethers3 = require("ethers");
 
 // src/utils/quantum-timing.ts
 var QUANTUM_WINDOW_SECONDS = 60;
@@ -6354,6 +6511,80 @@ async function awaitSafeSubmissionWindowOnChain(signatureQuantum, chainNow, slee
   return { waited: waitedSeconds > 0, waitedSeconds };
 }
 
+// src/utils/borrower-authorization-712.ts
+var import_ethers2 = require("ethers");
+init_deployment_addresses();
+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)"
@@ -6367,29 +6598,11 @@ async function generateMintAuthorization(positionId, amount, chainId, signerOrPr
   const signer = signerOrPrecomputed;
   const timestamp = calculateNextQuantumTimestamp();
   const action = "mint-ucd";
-  const actionHash = (0, import_ethers2.keccak256)((0, import_ethers2.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 = (0, import_ethers2.solidityPackedKeccak256)(types, values);
-  const messageHashBytes = (0, import_ethers2.getBytes)(messageHash);
-  const signature = await signer.signMessage(messageHashBytes);
+    mintAmount: amount.toString(),
+    quantumTimestamp: timestamp
+  });
   return {
     positionId,
     timestamp,
@@ -6426,44 +6639,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 = (0, import_ethers2.keccak256)((0, import_ethers2.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 = (0, import_ethers2.solidityPackedKeccak256)(types, values);
-  const messageHashBytes = (0, import_ethers2.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
   };
@@ -6532,7 +6718,7 @@ async function getPKPPublicKeyFromTokenId(pkpTokenId, provider, pkpNftContractAd
       `pkpNftContractAddress is required for getPKPPublicKeyFromTokenId`
     );
   }
-  const pkpNft = new import_ethers2.Contract(
+  const pkpNft = new import_ethers3.Contract(
     pkpNftContractAddress,
     PKP_NFT_ABI,
     provider
@@ -6550,32 +6736,12 @@ async function generateWithdrawAuthorization(positionId, amount, chainId, signer
   const signer = signerOrPrecomputed;
   const timestamp = calculateNextQuantumTimestamp();
   const action = "withdraw-btc";
-  const actionHash = (0, import_ethers2.keccak256)((0, import_ethers2.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 = (0, import_ethers2.solidityPackedKeccak256)(types, values);
-  const messageHashBytes = (0, import_ethers2.getBytes)(messageHash);
-  const signature = await signer.signMessage(messageHashBytes);
+    totalDeduction: amount.toString(),
+    withdrawalAddress: destinationAddress,
+    quantumTimestamp: timestamp
+  });
   return {
     positionId,
     timestamp,
@@ -6589,7 +6755,7 @@ async function generateBalanceConfirmationAuthorization(positionId, chainId, sig
   const timestamp = calculateNextQuantumTimestamp();
   const caller = await signer.getAddress();
   const action = "confirm-balance";
-  const actionHash = (0, import_ethers2.keccak256)((0, import_ethers2.toUtf8Bytes)(action));
+  const actionHash = (0, import_ethers3.keccak256)((0, import_ethers3.toUtf8Bytes)(action));
   const types = [
     "bytes32",
     // positionId
@@ -6603,8 +6769,8 @@ async function generateBalanceConfirmationAuthorization(positionId, chainId, sig
     // actionHash
   ];
   const values = [positionId, timestamp, chainId, caller, actionHash];
-  const messageHash = (0, import_ethers2.solidityPackedKeccak256)(types, values);
-  const messageHashBytes = (0, import_ethers2.getBytes)(messageHash);
+  const messageHash = (0, import_ethers3.solidityPackedKeccak256)(types, values);
+  const messageHashBytes = (0, import_ethers3.getBytes)(messageHash);
   const signature = await signer.signMessage(messageHashBytes);
   return {
     positionId,
@@ -6617,7 +6783,6 @@ async function generateBalanceConfirmationAuthorization(positionId, chainId, sig
 }
 
 // src/utils/extend-authorization.utils.ts
-var import_ethers3 = require("ethers");
 async function generateExtendAuthorization(positionId, newTerm, chainId, signerOrPrecomputed) {
   if (typeof signerOrPrecomputed === "object" && "signature" in signerOrPrecomputed && !("signMessage" in signerOrPrecomputed)) {
     const { timestamp: timestamp2, signature: signature2 } = signerOrPrecomputed;
@@ -6627,29 +6792,11 @@ async function generateExtendAuthorization(positionId, newTerm, chainId, signerO
   const signer = signerOrPrecomputed;
   const timestamp = calculateNextQuantumTimestamp();
   const action = "extend-position";
-  const actionHash = (0, import_ethers3.keccak256)((0, import_ethers3.toUtf8Bytes)(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 = (0, import_ethers3.solidityPackedKeccak256)(types, values);
-  const messageHashBytes = (0, import_ethers3.getBytes)(messageHash);
-  const signature = await signer.signMessage(messageHashBytes);
+    selectedTerm: newTerm,
+    quantumTimestamp: timestamp
+  });
   return {
     positionId,
     timestamp,
@@ -10879,6 +11026,7 @@ function createLoanQuery(config) {
 
 // src/modules/withdrawal-address/withdrawal-address.module.ts
 var import_ethers13 = require("ethers");
+var STATIC_CALL_DIAGNOSTIC_TIMEOUT_MS = 5e3;
 var WithdrawalAddressModule = class {
   config;
   graphClient;
@@ -10923,13 +11071,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). */
@@ -10937,13 +11089,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)
+      );
     }
   }
   /**
@@ -11039,16 +11195,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 }
       })
     );
   }
@@ -12139,6 +12338,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;
@@ -13295,32 +13535,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!) {
@@ -13556,11 +13788,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`.
@@ -21004,6 +21266,7 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
       }
       const tx = await sendEip1559Transaction({
         signer,
+        feeProvider: this.getProviderOrThrow(),
         to: positionManagerAddress,
         data: mintCalldata,
         gasLimit: MINT_UCD_GAS_CEILING
@@ -22225,6 +22488,7 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
     }
     const tx = await sendEip1559Transaction({
       signer: extendSigner,
+      feeProvider: this.getProviderOrThrow(),
       to: extendTo,
       data: extendCalldata,
       gasLimit: EXTEND_POSITION_GAS_CEILING
@@ -23153,6 +23417,7 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
       }
       const tx = await sendEip1559Transaction({
         signer: paymentSigner,
+        feeProvider: this.getProviderOrThrow(),
         to: paymentContractAddress,
         data: paymentCalldata,
         gasLimit: MAKE_PAYMENT_GAS_CEILING
@@ -23918,6 +24183,7 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
         });
         tx = await sendEip1559Transaction({
           signer: withdrawSigner,
+          feeProvider: this.getProviderOrThrow(),
           to: positionManagerAddress,
           data: withdrawCalldata,
           gasLimit: WITHDRAW_BTC_GAS_CEILING