@gvnrdao/dh-sdk 0.0.340 → 0.0.342

package/dist/index.mjs

@@ -2357,7 +2357,7 @@ ${errorReport}`);
     }
     init_debug_logger();
     init_session_signature_cache();
-    var import_ethers23 = __require("ethers");
+    var import_ethers24 = __require("ethers");
     var EXPIRED_LOAN_MIN_LIQUIDATION_THRESHOLD_BPS = 11e3;
     var GRACE_PERIOD_DAYS = 30;
     var SATOSHIS_PER_BITCOIN = 100000000n;
@@ -5285,12 +5285,12 @@ ${auth.clientId}`;
     }
     async function executeVaultSnapshot(params) {
       global.ethers = {
-        ...import_ethers23.ethers,
+        ...import_ethers24.ethers,
         providers: {
-          StaticJsonRpcProvider: import_ethers23.ethers.JsonRpcProvider
+          StaticJsonRpcProvider: import_ethers24.ethers.JsonRpcProvider
         },
-        Contract: import_ethers23.ethers.Contract,
-        utils: import_ethers23.ethers
+        Contract: import_ethers24.ethers.Contract,
+        utils: import_ethers24.ethers
         // v6 moved utils to top level
       };
       global.Lit = {
@@ -5774,7 +5774,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 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 } from "ethers";
+import { Contract as Contract9, Interface as Interface6, 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 } from "ethers";
 
 // src/types/result.ts
 function success(value) {
@@ -6159,17 +6159,56 @@ var SDKError = class _SDKError extends Error {
 // src/utils/chunks/eip1559-broadcast.utils.ts
 import {
   getBigInt,
-  parseUnits,
   toQuantity
 } from "ethers";
+
+// src/utils/sign-guard/fee-ceiling.ts
+import { ethers as ethers2 } from "ethers";
+var MAX_GAS_LIMIT = 5000000n;
+var MAX_FEE_PER_GAS_WEI = 2000000000000n;
+var DEFAULT_MAX_TX_FEE_WEI = 250000000000000000n;
+var PRIORITY_FEE_FLOOR_WEI = 100000000n;
+var PRIORITY_FEE_CAP_WEI = 3000000000n;
+var DEFAULT_FEE_CEILING = {
+  maxGasLimit: MAX_GAS_LIMIT,
+  maxFeePerGasWei: MAX_FEE_PER_GAS_WEI,
+  maxTxFeeWei: DEFAULT_MAX_TX_FEE_WEI
+};
+function fmtEth(wei) {
+  return `${ethers2.formatEther(wei)} ETH`;
+}
+function fmtGwei(wei) {
+  return `${ethers2.formatUnits(wei, "gwei")} gwei`;
+}
+function worstCaseFeeWei(gasLimit, maxFeePerGas) {
+  if (gasLimit == null || maxFeePerGas == null)
+    return null;
+  return gasLimit * maxFeePerGas;
+}
+function assertFeeCeiling(gasLimit, maxFeePerGas, raise, ceiling = DEFAULT_FEE_CEILING) {
+  if (gasLimit != null && gasLimit > ceiling.maxGasLimit) {
+    raise(`gasLimit ${gasLimit} exceeds the signing ceiling of ${ceiling.maxGasLimit}`);
+  }
+  if (maxFeePerGas != null && maxFeePerGas > ceiling.maxFeePerGasWei) {
+    raise(
+      `maxFeePerGas ${fmtGwei(maxFeePerGas)} exceeds the signing ceiling of ${fmtGwei(ceiling.maxFeePerGasWei)}`
+    );
+  }
+  const worst = worstCaseFeeWei(gasLimit, maxFeePerGas);
+  if (worst != null && worst > ceiling.maxTxFeeWei) {
+    raise(
+      `worst-case transaction fee ${fmtEth(worst)} (gasLimit ${gasLimit} \xD7 ${fmtGwei(maxFeePerGas)}) exceeds the signing ceiling of ${fmtEth(ceiling.maxTxFeeWei)}.${ceiling.raiseHint ? ` ${ceiling.raiseHint}` : ""}`
+    );
+  }
+}
+
+// src/utils/chunks/eip1559-broadcast.utils.ts
 var MINT_UCD_GAS_CEILING = BigInt(13e5);
 var WITHDRAW_BTC_GAS_CEILING = BigInt(3e6);
 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);
-var PRIORITY_FEE_FLOOR_WEI = parseUnits("0.1", "gwei");
-var PRIORITY_FEE_CAP_WEI = parseUnits("3", "gwei");
 var FEE_HISTORY_BLOCK_COUNT = 20;
 var FEE_HISTORY_REWARD_PERCENTILE = 75;
 function isJsonRpcSendable(provider) {
@@ -7467,16 +7506,13 @@ var ERROR_STRING_SELECTOR = "0x08c379a0";
 var PANIC_SELECTOR = "0x4e487b71";
 var QUANTUM_REVERT_NAMES = {
   "0xbe4b82c1": "DeadZoneViolation()",
-  "0x137f3b70": "InDeadZone()",
-  "0x131d9a21": "QuantumExpired()",
   "0x52ce5d58": "QuantumAlreadyUsed()",
   "0x3e76a3c9": "QuantumOutsideWindow()",
-  "0x8baa579f": "InvalidSignature()",
   "0x62278171": "InvalidValidatorSignature()",
-  "0x3ee5aeb5": "OperationNotAuthorized()",
-  "0x48f5c3ed": "Unauthorized()",
-  "0x70f4b32a": "UnauthorizedSigner()",
-  "0xd92e233d": "ValidationFailed()",
+  "0x82b42900": "Unauthorized()",
+  "0x3ee5aeb5": "ReentrancyGuardReentrantCall()",
+  "0x0a0b0d79": "ValidationFailed()",
+  "0xd92e233d": "ZeroAddress()",
   "0x36bfdeea": "StateHashMismatch()",
   "0xb9d419a7": "DebtUpdateVerificationFailed()",
   "0xc7e20553": "DebtUpdateVerificationFailedDetailed(bytes32,uint256,uint256,uint256,uint256,uint256)",
@@ -19161,7 +19197,7 @@ var TxValidationError = class extends Error {
 };
 
 // src/utils/sign-guard/signable-functions.ts
-import { ethers as ethers2 } from "ethers";
+import { ethers as ethers3 } from "ethers";
 var SIGNABLE_FUNCTIONS = [
   "function mintUCD(bytes32 positionId, uint256 mintAmount, uint256 mintFee, uint256 newDebt, uint256 newCollateral, uint256 btcPrice, bytes32 authorizedSpendsHash, bytes32 ucdDebtHash, bytes32 contractHash, uint256 quantumTimestamp, bytes calldata mintValidatorSignature) external returns (bool)",
   // `makePayment` is the ONLY repayment entry point. A `repayPosition` entry
@@ -19198,7 +19234,7 @@ var SIGNABLE_FUNCTIONS = [
   // this too is client-only and never module-whitelisted.
   "function addAddress(string btcAddress) external"
 ];
-var IFACE = new ethers2.Interface(SIGNABLE_FUNCTIONS);
+var IFACE = new ethers3.Interface(SIGNABLE_FUNCTIONS);
 function encodeSignable(fn, args) {
   return IFACE.encodeFunctionData(fn, args);
 }
@@ -19222,46 +19258,6 @@ function decodeSignable(data) {
 
 // src/utils/sign-guard/tx-validator.ts
 import { ethers as ethers4 } from "ethers";
-
-// src/utils/sign-guard/fee-ceiling.ts
-import { ethers as ethers3 } from "ethers";
-var MAX_GAS_LIMIT = 5000000n;
-var MAX_FEE_PER_GAS_WEI = 2000000000000n;
-var DEFAULT_MAX_TX_FEE_WEI = 250000000000000000n;
-var DEFAULT_FEE_CEILING = {
-  maxGasLimit: MAX_GAS_LIMIT,
-  maxFeePerGasWei: MAX_FEE_PER_GAS_WEI,
-  maxTxFeeWei: DEFAULT_MAX_TX_FEE_WEI
-};
-function fmtEth(wei) {
-  return `${ethers3.formatEther(wei)} ETH`;
-}
-function fmtGwei(wei) {
-  return `${ethers3.formatUnits(wei, "gwei")} gwei`;
-}
-function worstCaseFeeWei(gasLimit, maxFeePerGas) {
-  if (gasLimit == null || maxFeePerGas == null)
-    return null;
-  return gasLimit * maxFeePerGas;
-}
-function assertFeeCeiling(gasLimit, maxFeePerGas, raise, ceiling = DEFAULT_FEE_CEILING) {
-  if (gasLimit != null && gasLimit > ceiling.maxGasLimit) {
-    raise(`gasLimit ${gasLimit} exceeds the signing ceiling of ${ceiling.maxGasLimit}`);
-  }
-  if (maxFeePerGas != null && maxFeePerGas > ceiling.maxFeePerGasWei) {
-    raise(
-      `maxFeePerGas ${fmtGwei(maxFeePerGas)} exceeds the signing ceiling of ${fmtGwei(ceiling.maxFeePerGasWei)}`
-    );
-  }
-  const worst = worstCaseFeeWei(gasLimit, maxFeePerGas);
-  if (worst != null && worst > ceiling.maxTxFeeWei) {
-    raise(
-      `worst-case transaction fee ${fmtEth(worst)} (gasLimit ${gasLimit} \xD7 ${fmtGwei(maxFeePerGas)}) exceeds the signing ceiling of ${fmtEth(ceiling.maxTxFeeWei)}.${ceiling.raiseHint ? ` ${ceiling.raiseHint}` : ""}`
-    );
-  }
-}
-
-// src/utils/sign-guard/tx-validator.ts
 function eqAddr(a, b) {
   if (!a || !b)
     return false;
@@ -19964,6 +19960,391 @@ function formatLiquidationFailureMessage(loanId, errorMessage, btcVault, btcVaul
   return `\u274C DH SDK: Loan Id ${loanId} liquidation FAILED: ${errorMessage}; BTC vault ${btcVault} balance is ${formattedBalance}, UCD Debt of ${ucdDebt} and BTC Price of ${formattedPrice}`;
 }
 
+// src/utils/contract-error-decoder.ts
+import { Interface as Interface5 } from "ethers";
+
+// src/constants/chunks/contract-errors.generated.ts
+var CONTRACT_ERROR_FRAGMENTS = [
+  { fragment: "error AboveMaxRedeem(uint256 amount, uint256 maximum)", contracts: ["SimplePSMV2"] },
+  { fragment: "error AboveMaxSwap(uint256 amount, uint256 maximum)", contracts: ["SimplePSMV2"] },
+  { fragment: "error AccessControlBadConfirmation()", contracts: ["PositionManager", "LoanOperationsManagerModule", "CollateralManagerModule", "BTCSpendAuthorizer", "UCDController", "SimplePSMV2"] },
+  { fragment: "error AccessControlUnauthorizedAccount(address account, bytes32 neededRole)", contracts: ["PositionManager", "LoanOperationsManagerModule", "CollateralManagerModule", "BTCSpendAuthorizer", "UCDController", "SimplePSMV2"] },
+  { fragment: "error AddressEmptyCode(address target)", contracts: ["PositionManager", "LoanOperationsManagerModule", "OperationAuthorizationRegistry", "CollateralManagerModule", "BTCSpendAuthorizer", "UCDController", "SimplePSMV2"] },
+  { fragment: "error AlreadyActive()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error AlreadySigned()", contracts: ["PositionManagerErrors", "OperationAuthorizationRegistry"] },
+  { fragment: "error AmountMustBePositive()", contracts: ["LoanOperationsManagerModule", "SimplePSMV2"] },
+  { fragment: "error ArrayLengthMismatch()", contracts: ["BTCSpendAuthorizer", "SimplePSMV2"] },
+  { fragment: "error BTCSpendAuthorizerNotSet()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error BalanceMismatch()", contracts: ["UCDController"] },
+  { fragment: "error BatchSizeTooLarge()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error BelowMinRedeem(uint256 amount, uint256 minimum)", contracts: ["SimplePSMV2"] },
+  { fragment: "error BelowMinSwap(uint256 amount, uint256 minimum)", contracts: ["SimplePSMV2"] },
+  { fragment: "error BorrowerBTCSpendMutationDisabled()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error BtcAmountTooLarge()", contracts: ["PositionManager", "LoanOperationsManagerModule", "CollateralManagerModule"] },
+  { fragment: "error BtcPriceBoundOutOfRange()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error BtcPriceDeviationExceeded(uint256 signedPrice, uint256 chainlinkPrice, uint16 deviationBps)", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error BtcPriceFeedStale(uint256 updatedAt, uint256 maxAge)", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error BtcPriceTooHigh()", contracts: ["PositionManager", "LoanOperationsManagerModule", "CollateralManagerModule"] },
+  { fragment: "error BurnCallFailed()", contracts: ["UCDController"] },
+  { fragment: "error BurnGuardFailed(uint8 code)", contracts: ["UCDController"] },
+  { fragment: "error BurnVerificationFailed()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error CannotRemoveLastTerm()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error CannotUpgradeToSelf()", contracts: ["PositionManagerErrors", "LoanOperationsManagerModule", "CollateralManagerModule", "BTCSpendAuthorizer"] },
+  { fragment: "error CircuitBreakerNotActive()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error CircuitBreakerTriggered()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error CollateralOverflow()", contracts: ["PositionManager", "LoanOperationsManagerModule", "CollateralManagerModule"] },
+  { fragment: "error CollateralRatioTooLargeForStorage()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error CollateralRatioTooLow()", contracts: ["PositionManager", "PositionManagerErrors", "LoanOperationsManagerModule"] },
+  { fragment: "error ContractNotDeployed(address addr)", contracts: ["PositionManager"] },
+  { fragment: "error DailyLimitExceeded()", contracts: ["UCDController"] },
+  { fragment: "error DeadZoneViolation()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error DebtCalculationMismatch()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error DebtNotZero()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error DebtOverflow()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error DebtUpdateVerificationFailed()", contracts: ["LoanOperationsValidation", "LoanOperationsManagerModule"] },
+  { fragment: "error DebtUpdateVerificationFailedDetailed(bytes32 positionId, uint256 currentDebt, uint256 newDebt, uint256 quantumTimestamp, uint256 supplyAfterMint, uint256 expectedIncrease)", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error DecimalsMismatch(uint8 provided, uint8 actual)", contracts: ["SimplePSMV2"] },
+  { fragment: "error DecimalsQueryFailed()", contracts: ["SimplePSMV2"] },
+  { fragment: "error DivisionByZero()", contracts: ["PositionManager", "CollateralManagerModule"] },
+  { fragment: "error ECDSAInvalidSignature()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error ECDSAInvalidSignatureLength(uint256 length)", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error ECDSAInvalidSignatureS(bytes32 s)", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error ERC1967InvalidImplementation(address implementation)", contracts: ["PositionManager", "LoanOperationsManagerModule", "OperationAuthorizationRegistry", "CollateralManagerModule", "BTCSpendAuthorizer", "UCDController", "SimplePSMV2"] },
+  { fragment: "error ERC1967NonPayable()", contracts: ["PositionManager", "LoanOperationsManagerModule", "OperationAuthorizationRegistry", "CollateralManagerModule", "BTCSpendAuthorizer", "UCDController", "SimplePSMV2"] },
+  { fragment: "error EnforcedPause()", contracts: ["PositionManager", "LoanOperationsManagerModule", "CollateralManagerModule", "BTCSpendAuthorizer", "UCDController", "SimplePSMV2"] },
+  { fragment: "error EntryFeeTooHigh(uint256 fee, uint256 max)", contracts: ["SimplePSMV2"] },
+  { fragment: "error ExceedsFeeBalance(uint256 requested, uint256 max)", contracts: ["SimplePSMV2"] },
+  { fragment: "error ExceedsMaxLoan()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error ExitFeeTooHigh(uint256 fee, uint256 max)", contracts: ["SimplePSMV2"] },
+  { fragment: "error ExpectedPause()", contracts: ["PositionManager", "LoanOperationsManagerModule", "CollateralManagerModule", "BTCSpendAuthorizer", "UCDController", "SimplePSMV2"] },
+  { fragment: "error ExtensionFeeMintingFailed()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error ExtensionNotAllowed()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error FailedCall()", contracts: ["PositionManager", "LoanOperationsManagerModule", "OperationAuthorizationRegistry", "CollateralManagerModule", "BTCSpendAuthorizer", "UCDController", "SimplePSMV2"] },
+  { fragment: "error FailedToGetStablecoinDecimals()", contracts: ["SimplePSMV2"] },
+  { fragment: "error FailedToGetUCDDecimals()", contracts: ["SimplePSMV2"] },
+  { fragment: "error FeeOnTransferNotSupported()", contracts: ["SimplePSMV2"] },
+  { fragment: "error FeeTooHigh(uint256 fee, uint256 max)", contracts: ["PositionManagerErrors"] },
+  { fragment: "error FeeTooLow(uint256 fee, uint256 min)", contracts: ["PositionManagerErrors"] },
+  { fragment: "error ImplNotDeployed()", contracts: ["LoanOperationsManagerModule", "BTCSpendAuthorizer"] },
+  { fragment: "error ImplementationNotDeployed()", contracts: ["UCDController"] },
+  { fragment: "error InitialBalanceTooLarge()", contracts: ["SimplePSMV2"] },
+  { fragment: "error InsufficientBalance()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error InsufficientCollateralForAmount()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error InsufficientCollateralRatio()", contracts: ["CollateralManagerModule"] },
+  { fragment: "error InsufficientFeeBal()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error InsufficientReserves(uint256 available, uint256 required)", contracts: ["SimplePSMV2"] },
+  { fragment: "error InsufficientSignatures()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error IntegrityCheckFailed()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error InvalidActionHash()", contracts: ["CollateralManagerModule"] },
+  { fragment: "error InvalidAddress()", contracts: ["PositionManager", "PositionManagerErrors", "OperationAuthorizationRegistry", "CollateralManagerModule", "SimplePSMV2"] },
+  { fragment: "error InvalidAdmin()", contracts: ["LoanOperationsManagerModule", "BTCSpendAuthorizer", "SimplePSMV2"] },
+  { fragment: "error InvalidAmount()", contracts: ["PositionManagerErrors", "SimplePSMV2"] },
+  { fragment: "error InvalidBTCPrice()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error InvalidBytes32()", contracts: ["PositionManager"] },
+  { fragment: "error InvalidCollateralAmount()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error InvalidController()", contracts: ["SimplePSMV2"] },
+  { fragment: "error InvalidDecimals(uint8 decimals)", contracts: ["SimplePSMV2"] },
+  { fragment: "error InvalidExchangeRate()", contracts: ["SimplePSMV2"] },
+  { fragment: "error InvalidImpl()", contracts: ["LoanOperationsManagerModule", "BTCSpendAuthorizer"] },
+  { fragment: "error InvalidImplementation()", contracts: ["UCDController"] },
+  { fragment: "error InvalidInitialization()", contracts: ["PositionManager", "LoanOperationsManagerModule", "OperationAuthorizationRegistry", "CollateralManagerModule", "BTCSpendAuthorizer", "UCDController", "SimplePSMV2"] },
+  { fragment: "error InvalidLitSignature()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error InvalidLoanOps()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error InvalidModuleAddress()", contracts: ["UCDController"] },
+  { fragment: "error InvalidNetwork()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error InvalidNetworkMode()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error InvalidOracleConfig()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error InvalidPKPId()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error InvalidParameter()", contracts: ["UCDController"] },
+  { fragment: "error InvalidPkpPublicKey()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error InvalidPosMgr()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error InvalidPositionId()", contracts: ["PositionManager", "PositionManagerErrors", "LoanOperationsValidation", "LoanOperationsManagerModule", "CollateralManagerModule"] },
+  { fragment: "error InvalidPositionState()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error InvalidPriceFeed()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error InvalidRecipient()", contracts: ["LoanOperationsManagerModule", "SimplePSMV2"] },
+  { fragment: "error InvalidRegistry()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error InvalidRequestedExpiryDate()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error InvalidSignature(string reason)", contracts: ["PositionManager"] },
+  { fragment: "error InvalidSignatureLength()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error InvalidStablecoinAddress()", contracts: ["SimplePSMV2"] },
+  { fragment: "error InvalidStaleSpendAttestation()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error InvalidString(string value)", contracts: ["PositionManager"] },
+  { fragment: "error InvalidTerm()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error InvalidTerm(uint256 term, uint256 min, uint256 max)", contracts: ["PositionManager"] },
+  { fragment: "error InvalidTermMgr()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error InvalidTermStartTime()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error InvalidToken()", contracts: ["SimplePSMV2"] },
+  { fragment: "error InvalidUCDCtrl()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error InvalidUCDDecimals(uint8 decimals)", contracts: ["SimplePSMV2"] },
+  { fragment: "error InvalidUCDToken()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error InvalidValidatorAddress()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error InvalidValidatorSignature()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error InvalidVaultAddress()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error InvalidVolumeCap(bool isRedeem)", contracts: ["SimplePSMV2"] },
+  { fragment: "error InvalidWithdrawalAddress()", contracts: ["CollateralManagerModule"] },
+  { fragment: "error InvalidWithdrawalLoanStatusType()", contracts: ["CollateralManagerModule"] },
+  { fragment: "error LiquidationsPaused()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error LoanAmountTooHigh()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error LoanAmountTooLow()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error MaxAuthorizedSpendsReached()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error MaxLoanOutOfBounds()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error MaxRedeemBelowMin(uint256 maximum, uint256 minimum)", contracts: ["SimplePSMV2"] },
+  { fragment: "error MaxRedeemCapDisabled()", contracts: ["SimplePSMV2"] },
+  { fragment: "error MaxSupplyExceeded()", contracts: ["UCDController"] },
+  { fragment: "error MaxSwapBelowMin(uint256 maximum, uint256 minimum)", contracts: ["SimplePSMV2"] },
+  { fragment: "error MaxSwapCapDisabled()", contracts: ["SimplePSMV2"] },
+  { fragment: "error MinLoanOutOfBounds()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error MintBorrowerMismatch()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error MintCallFailed()", contracts: ["UCDController"] },
+  { fragment: "error MintFailed()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error MintGuardFailed(uint8 code)", contracts: ["UCDController"] },
+  { fragment: "error MintVerificationFailed()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error MintVerificationMismatch(uint256 expectedSupply, uint256 currentSupply)", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error MissingVERSION()", contracts: ["LoanOperationsManagerModule", "BTCSpendAuthorizer", "UCDController"] },
+  { fragment: "error MissingVersion()", contracts: ["PositionManagerErrors", "CollateralManagerModule"] },
+  { fragment: "error ModuleCallFailed()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error NoFeesToTransfer()", contracts: ["SimplePSMV2"] },
+  { fragment: "error NoRegistry()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error NoVersion()", contracts: ["LoanOperationsManagerModule", "BTCSpendAuthorizer", "UCDController"] },
+  { fragment: "error NonZeroReserves(address stablecoin, uint256 reserves)", contracts: ["SimplePSMV2"] },
+  { fragment: "error NormalizationOverflow()", contracts: ["SimplePSMV2"] },
+  { fragment: "error NotAdminModule()", contracts: ["PositionManager", "PositionManagerErrors", "LoanOperationsManagerModule", "OperationAuthorizationRegistry", "CollateralManagerModule", "BTCSpendAuthorizer", "UCDController", "SimplePSMV2"] },
+  { fragment: "error NotAuthorized()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error NotAuthorizedConsumer()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error NotAuthorizedSigner()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error NotBorrower()", contracts: ["PositionManager", "PositionManagerErrors", "LoanOperationsManagerModule"] },
+  { fragment: "error NotContract()", contracts: ["PositionManagerErrors", "LoanOperationsManagerModule", "OperationAuthorizationRegistry", "CollateralManagerModule", "BTCSpendAuthorizer", "SimplePSMV2"] },
+  { fragment: "error NotInitializing()", contracts: ["PositionManager", "LoanOperationsManagerModule", "OperationAuthorizationRegistry", "CollateralManagerModule", "BTCSpendAuthorizer", "UCDController", "SimplePSMV2"] },
+  { fragment: "error NotLiquidationPkpOwner()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error NotLiquidator()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error NotOwner()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error NotPendingOwner()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error NotProductionAuthorizer()", contracts: ["PositionManagerErrors", "LoanOperationsManagerModule"] },
+  { fragment: "error NotProductionRegistry()", contracts: ["PositionManager", "PositionManagerErrors", "LoanOperationsManagerModule"] },
+  { fragment: "error OnlyCore()", contracts: ["CollateralManagerModule"] },
+  { fragment: "error OnlyLoanOps()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error OnlyPosMgr()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error OnlyPositionManager()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error OperationInProgress()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error OracleDecimalMismatch()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error PKPAlreadyUsed()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error PaymentAmountTooLarge()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error PaymentAmountZero()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error PaymentMustBeLessThanDebt()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error PaymentMustBePositive()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error PositionAlreadyExists()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error PositionDoesNotExist()", contracts: ["CollateralManagerModule"] },
+  { fragment: "error PositionLiquidatable()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error PositionManagerNotContract()", contracts: ["LoanOperationsValidation"] },
+  { fragment: "error PositionManagerNotSet()", contracts: ["LoanOperationsValidation"] },
+  { fragment: "error PositionNotActive()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error PositionNotEligible()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error PositionNotEligibleForOperation()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error PositionNotFound()", contracts: ["PositionManager", "PositionManagerErrors", "LoanOperationsManagerModule"] },
+  { fragment: "error PositionNotInCore()", contracts: ["LoanOperationsValidation"] },
+  { fragment: "error PositionStatusInvalid()", contracts: ["PositionManager", "PositionManagerErrors", "LoanOperationsManagerModule"] },
+  { fragment: "error PositionWouldBecomeLiquidatable()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error ProposalAlreadyExecuted()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error ProposalAlreadyExists()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error ProposalCancelled()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error ProposalNotFound()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error PsmBurnSupplyMismatch(uint256 expected, uint256 actual)", contracts: ["SimplePSMV2"] },
+  { fragment: "error PsmMintSupplyMismatch(uint256 expected, uint256 actual)", contracts: ["SimplePSMV2"] },
+  { fragment: "error QuantumAlreadyUsed()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error QuantumOutsideWindow()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error RateLimitExceeded()", contracts: ["SimplePSMV2"] },
+  { fragment: "error RatioOverflow()", contracts: ["PositionManager", "LoanOperationsManagerModule", "CollateralManagerModule"] },
+  { fragment: "error RecipientNotAllowed()", contracts: ["LoanOperationsManagerModule", "SimplePSMV2"] },
+  { fragment: "error RedeemVolumeExceededThisBlock(address stablecoin, uint256 attempted, uint256 cap)", contracts: ["SimplePSMV2"] },
+  { fragment: "error RedemptionsPaused()", contracts: ["SimplePSMV2"] },
+  { fragment: "error ReentrancyGuardReentrantCall()", contracts: ["PositionManager", "LoanOperationsManagerModule", "CollateralManagerModule", "BTCSpendAuthorizer", "UCDController", "SimplePSMV2"] },
+  { fragment: "error RegistryNotSet()", contracts: ["LoanOperationsManagerModule", "SimplePSMV2"] },
+  { fragment: "error ReserveOverflow()", contracts: ["SimplePSMV2"] },
+  { fragment: "error ReserveTooLarge()", contracts: ["SimplePSMV2"] },
+  { fragment: "error ReserveUnderflow()", contracts: ["SimplePSMV2"] },
+  { fragment: "error SafeERC20FailedOperation(address token)", contracts: ["PositionManager", "LoanOperationsManagerModule", "SimplePSMV2"] },
+  { fragment: "error SameBlockInteraction()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error SameImpl()", contracts: ["LoanOperationsManagerModule", "BTCSpendAuthorizer"] },
+  { fragment: "error SameImplementation()", contracts: ["PositionManagerErrors", "CollateralManagerModule"] },
+  { fragment: "error SignatureVerificationFailed(bytes4 selector, address recovered, address expected, bytes32 messageHash, uint8 errorCode)", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error SlippageExceeded(uint256 got, uint256 minimum)", contracts: ["SimplePSMV2"] },
+  { fragment: "error SlippageProtectionRequired()", contracts: ["SimplePSMV2"] },
+  { fragment: "error StablecoinAlreadySupported(address stablecoin)", contracts: ["SimplePSMV2"] },
+  { fragment: "error StablecoinNotContract(address stablecoin)", contracts: ["SimplePSMV2"] },
+  { fragment: "error StablecoinNotSupported(address stablecoin)", contracts: ["SimplePSMV2"] },
+  { fragment: "error StablecoinNotSupportedInV1(address stablecoin)", contracts: ["SimplePSMV2"] },
+  { fragment: "error StaleAttestationMismatch()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error StaleAttestationTooOld()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error StaleSpendValidatorNotSet()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error StateHashMismatch()", contracts: ["LoanOperationsValidation", "LoanOperationsManagerModule", "CollateralManagerModule"] },
+  { fragment: "error SwapVolumeExceededThisBlock(address stablecoin, uint256 attempted, uint256 cap)", contracts: ["SimplePSMV2"] },
+  { fragment: "error SyncDriftTooLarge()", contracts: ["SimplePSMV2"] },
+  { fragment: "error TargetAddrRequired()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error TargetExceedsInputValue()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error TargetMustBePositive()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error TermAlreadyExists()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error TermExceedsMaximum()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error TermNotFound()", contracts: ["PositionManagerErrors"] },
+  { fragment: "error ThresholdTooHigh()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error TimelockNotMet()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error TimelockRequiredOnThisChain()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error TimestampOverflow()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error TooManySigners()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error UTXOAlreadyAuthorized()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error UTXONotAuthorized()", contracts: ["BTCSpendAuthorizer"] },
+  { fragment: "error UUPSUnauthorizedCallContext()", contracts: ["PositionManager", "LoanOperationsManagerModule", "OperationAuthorizationRegistry", "CollateralManagerModule", "BTCSpendAuthorizer", "UCDController", "SimplePSMV2"] },
+  { fragment: "error UUPSUnsupportedProxiableUUID(bytes32 slot)", contracts: ["PositionManager", "LoanOperationsManagerModule", "OperationAuthorizationRegistry", "CollateralManagerModule", "BTCSpendAuthorizer", "UCDController", "SimplePSMV2"] },
+  { fragment: "error UcdAmountTooLarge()", contracts: ["PositionManager", "LoanOperationsManagerModule", "CollateralManagerModule"] },
+  { fragment: "error Unauthorized()", contracts: ["UCDController"] },
+  { fragment: "error UnexpectedRoleGrantFailure()", contracts: ["PositionManager", "PositionManagerErrors", "LoanOperationsManagerModule", "CollateralManagerModule", "BTCSpendAuthorizer", "UCDController", "SimplePSMV2"] },
+  { fragment: "error UnsupportedFeeToken(address token)", contracts: ["SimplePSMV2"] },
+  { fragment: "error UserDailyMintLimitExceeded()", contracts: ["LoanOperationsManagerModule"] },
+  { fragment: "error V2AlreadyInitialized()", contracts: ["SimplePSMV2"] },
+  { fragment: "error ValidationFailed()", contracts: ["PositionManager", "PositionManagerErrors"] },
+  { fragment: "error ValidatorNotActive()", contracts: ["OperationAuthorizationRegistry"] },
+  { fragment: "error WithdrawalAddressNotApproved()", contracts: ["CollateralManagerModule"] },
+  { fragment: "error WithdrawalExceedsReserves(uint256 amount, uint256 reserves)", contracts: ["SimplePSMV2"] },
+  { fragment: "error ZeroAddress()", contracts: ["PositionManager", "UCDController"] },
+  { fragment: "error ZeroAmount()", contracts: ["UCDController"] }
+];
+
+// src/utils/contract-error-decoder.ts
+var TABLE = null;
+function contractErrorTable() {
+  if (TABLE)
+    return TABLE;
+  const table = /* @__PURE__ */ new Map();
+  const iface = new Interface5(CONTRACT_ERROR_FRAGMENTS.map((e) => e.fragment));
+  const contractsByName = new Map(
+    CONTRACT_ERROR_FRAGMENTS.map((e) => [e.fragment.slice("error ".length, e.fragment.indexOf("(")), e.contracts])
+  );
+  iface.forEachError((fragment) => {
+    const existing = table.get(fragment.selector);
+    const contracts = contractsByName.get(fragment.name) ?? [];
+    if (existing) {
+      for (const c of contracts)
+        if (!existing.contracts.includes(c))
+          existing.contracts.push(c);
+      return;
+    }
+    table.set(fragment.selector, {
+      signature: fragment.format("sighash"),
+      fragment,
+      contracts: [...contracts]
+    });
+  });
+  TABLE = table;
+  return table;
+}
+function lookupContractError(selector) {
+  return contractErrorTable().get(selector.toLowerCase()) ?? null;
+}
+function extractErrorData(error) {
+  const viaQuantum = decodeQuantumRevert(error).data;
+  if (viaQuantum && viaQuantum.length >= 10)
+    return viaQuantum;
+  const candidates = [
+    error?.error?.error?.error?.data,
+    error?.error?.error?.data,
+    error?.data?.data,
+    error?.transaction?.data
+  ];
+  for (const data of candidates) {
+    if (typeof data === "string" && data.startsWith("0x") && data.length >= 10)
+      return data;
+  }
+  const body = typeof error?.body === "string" ? error.body : null;
+  if (body) {
+    try {
+      const parsed = JSON.parse(body);
+      const data = parsed?.error?.data;
+      if (typeof data === "string" && data.startsWith("0x") && data.length >= 10)
+        return data;
+    } catch {
+    }
+  }
+  return null;
+}
+function extractRevertString(error) {
+  if (typeof error?.reason === "string" && error.reason.length > 0)
+    return error.reason;
+  const message = typeof error?.message === "string" ? error.message : null;
+  if (!message)
+    return null;
+  const withReasonString = message.match(/reverted with reason string ['"](.+?)['"]/);
+  if (withReasonString)
+    return withReasonString[1];
+  const withReason = message.match(/reason: ['"](.+?)['"]/);
+  return withReason ? withReason[1] : null;
+}
+function renderArgs(args) {
+  return args.map((arg) => typeof arg === "object" && arg !== null ? JSON.stringify(arg) : String(arg)).join(", ");
+}
+function decodeContractError(error) {
+  const errorData = extractErrorData(error);
+  if (!errorData) {
+    const revertString2 = extractRevertString(error);
+    if (revertString2 && !revertString2.includes("cannot estimate gas")) {
+      return {
+        name: "RevertString",
+        selector: "0x00000000",
+        args: [revertString2],
+        contract: "Unknown",
+        message: `Revert: ${revertString2}`
+      };
+    }
+    return null;
+  }
+  const selector = errorData.slice(0, 10).toLowerCase();
+  if (selector === ERROR_STRING_SELECTOR || selector === PANIC_SELECTOR) {
+    const { name } = decodeQuantumRevert(error);
+    if (name) {
+      return { name, selector, args: [], contract: "Solidity", message: name };
+    }
+  }
+  const entry = lookupContractError(selector);
+  if (entry) {
+    const contract = entry.contracts.join(" | ");
+    let args = [];
+    try {
+      const decoded = new Interface5([entry.fragment]).decodeErrorResult(entry.fragment, errorData);
+      args = Array.from(decoded);
+    } catch {
+      args = [];
+    }
+    return {
+      name: entry.fragment.name,
+      selector,
+      args,
+      contract,
+      message: `${contract}.${entry.fragment.name}(${renderArgs(args)})`
+    };
+  }
+  const revertString = extractRevertString(error);
+  if (revertString && !revertString.includes("cannot estimate gas")) {
+    return {
+      name: "RevertString",
+      selector,
+      args: [revertString],
+      contract: "Unknown",
+      message: `Revert: ${revertString}`
+    };
+  }
+  return {
+    name: "UnknownError",
+    selector,
+    args: [],
+    contract: "Unknown",
+    message: `Unknown error (selector: ${selector})`
+  };
+}
+function formatDecodedError(decoded) {
+  if (decoded.args && decoded.args.length > 0) {
+    return `${decoded.contract}.${decoded.name}(${renderArgs(decoded.args)})`;
+  }
+  return `${decoded.contract}.${decoded.name}()`;
+}
+
 // src/utils/ethers-interop.utils.ts
 function normalizeBigNumberish(value) {
   if (value === null || value === void 0) {
@@ -22031,7 +22412,7 @@ var DiamondHandsSDK = class _DiamondHandsSDK {
         });
       }
       const signatureHexMint = finalSignature.startsWith("0x") ? finalSignature : "0x" + finalSignature;
-      const mintIface = new Interface5(positionManagerAbi);
+      const mintIface = new Interface6(positionManagerAbi);
       const mintCalldata = mintIface.encodeFunctionData("mintUCD", [
         positionIdBytes32,
         validationResponse.mintAmount,
@@ -22144,7 +22525,6 @@ Mint/debt diagnostics (LoanOperationsManager mint path \u2192 increaseDebtFromMi
         let quantumContext = "";
         if (selector === "0x131d9a21" || // QuantumExpired()
         selector === "0x52ce5d58" || // QuantumAlreadyUsed()
-        selector === "0x137f3b70" || // InDeadZone()
         selector === "0xbe4b82c1" || // DeadZoneViolation()
         selector === "0x3e76a3c9") {
           const nowSecs = Math.floor(Date.now() / 1e3);
@@ -22197,7 +22577,7 @@ Message: ${causeMessage}${quantumContext}${loanCapDiagnostics}${mintDebtDiagnost
         if (receipt.logs && receipt.logs.length > 0) {
           for (const receiptLog of receipt.logs) {
             if (receiptLog.topics && receiptLog.topics[0] === "0x08c379a0") {
-              const iface = new Interface5([
+              const iface = new Interface6([
                 "error Error(string)"
               ]);
               const decoded = iface.decodeErrorResult("Error", receiptLog.data);
@@ -22214,7 +22594,7 @@ Message: ${causeMessage}${quantumContext}${loanCapDiagnostics}${mintDebtDiagnost
         const minimalAbi = [
           "event UCDMintedWithAuthorization(bytes32 indexed positionId, address indexed borrower, uint256 mintAmount, uint256 mintFee, uint256 newDebt, uint256 newCollateral, uint256 btcPrice, uint256 quantumTimestamp, bytes32 authorizedSpendsHash)"
         ];
-        const iface = new Interface5(minimalAbi);
+        const iface = new Interface6(minimalAbi);
         for (const receiptLog of receipt.logs) {
           const parsed = (() => {
             const logIface = iface;
@@ -22267,33 +22647,14 @@ Message: ${causeMessage}${quantumContext}${loanCapDiagnostics}${mintDebtDiagnost
       return result;
     } catch (error) {
       let customErrorDetails = "";
-      const errorData = error?.data || error?.error?.data?.data || error?.error?.data;
-      if (errorData && typeof errorData === "string" && errorData.startsWith("0x") && errorData.length > 10) {
-        const selector = errorData.slice(0, 10);
-        const knownErrors = {
-          "0x8baa579f": "InvalidSignature()",
-          "0xd92e233d": "ValidationFailed()",
-          "0x3ee5aeb5": "OperationNotAuthorized()",
-          "0x70f4b32a": "UnauthorizedSigner()",
-          "0x48f5c3ed": "Unauthorized()",
-          "0x36bfdeea": "StateHashMismatch()",
-          "0xb9d419a7": "DebtUpdateVerificationFailed()",
-          "0xc7e20553": "DebtUpdateVerificationFailedDetailed(bytes32,uint256,uint256,uint256,uint256,uint256)",
-          "0x0cfd2a97": "MintVerificationMismatch(uint256,uint256)",
-          "0x07637bd8": "MintFailed()",
-          "0x131d9a21": "QuantumExpired() - Signature quantum window has closed",
-          "0x52ce5d58": "QuantumAlreadyUsed() - This quantum was already used for this position",
-          "0x137f3b70": "InDeadZone() - Timestamp in dead zone (near quantum boundary)",
-          "0xbe4b82c1": "DeadZoneViolation() - Non-current-quantum signature mined in the last 8s of the current quantum",
-          "0x3e76a3c9": "QuantumOutsideWindow() - Timestamp not in past/current/next quantum window"
-        };
-        const errorName = knownErrors[selector] || `Unknown error ${selector}`;
-        customErrorDetails = ` [${errorName}]`;
+      const decoded = decodeContractError(error);
+      if (decoded) {
+        customErrorDetails = ` [${formatDecodedError(decoded)}]`;
         if (this.config.debug) {
           log.error("Custom error decoded from transaction receipt", {
-            selector,
-            errorName,
-            errorData
+            selector: decoded.selector,
+            errorName: decoded.name,
+            contract: decoded.contract
           });
         }
       }
@@ -23365,7 +23726,7 @@ Message: ${causeMessage}${quantumContext}${loanCapDiagnostics}${mintDebtDiagnost
     if (!signatureBytes.startsWith("0x")) {
       signatureBytes = "0x" + signatureBytes;
     }
-    const extendIface = new Interface5([
+    const extendIface = new Interface6([
       "function extendPosition(bytes32 positionId, uint256 selectedTerm, uint256 quantumTimestamp, uint256 btcPrice, uint256 availableBTCBalance, uint256 proRataRenewalFee, bytes calldata extensionValidatorSignature) external returns (bool)"
     ]);
     const extendCalldata = extendIface.encodeFunctionData("extendPosition", [
@@ -24290,7 +24651,7 @@ Message: ${causeMessage}${quantumContext}${loanCapDiagnostics}${mintDebtDiagnost
       const paymentSigner = this.getSignerOrThrow();
       const paymentFrom = await paymentSigner.getAddress();
       const paymentProvider = contractManager.getProvider();
-      const paymentIface = new Interface5([
+      const paymentIface = new Interface6([
         "function makePayment(bytes32 positionId, uint256 paymentAmount, uint256 quantumTimestamp, uint256 btcPrice, bytes calldata paymentValidatorSignature) external returns (bool)"
       ]);
       const paymentCalldata = paymentIface.encodeFunctionData("makePayment", [
@@ -25072,7 +25433,7 @@ Message: ${causeMessage}${quantumContext}${loanCapDiagnostics}${mintDebtDiagnost
           utxoVout: withdrawalParams.utxoVout
         });
       }
-      const withdrawIface = new Interface5([
+      const withdrawIface = new Interface6([
         "function withdrawBTC((bytes32 positionId, bytes32 actionHash, bytes32 authorizedSpendsHash, bytes32 ucdDebtHash, bytes32 contractBundleHash, string withdrawalAddress, uint256 totalDeduction, uint256 newCollateral, uint256 quantumTimestamp, uint256 btcPrice, string utxoTxid, uint32 utxoVout) params, bytes withdrawalValidatorSignature, bytes btcSpendAuthSignature) external returns (bool)"
       ]);
       const withdrawCalldata = withdrawIface.encodeFunctionData("withdrawBTC", [
@@ -26815,7 +27176,7 @@ Message: ${causeMessage}${quantumContext}${loanCapDiagnostics}${mintDebtDiagnost
    *
    * Deliberately omits `minWithdrawRatioBps` — see {@link readLoanGrant}.
    */
-  static LOAN_GRANT_PREFIX_IFACE = new Interface5([
+  static LOAN_GRANT_PREFIX_IFACE = new Interface6([
     "function getLoanGrant(bytes32 positionId) view returns (address borrower, uint32 scopeBits, uint32 minCollateralRatioBps)"
   ]);
   /**
@@ -28429,7 +28790,7 @@ var EventHelpers = {
 
 // src/utils/safe-agent-delegation.utils.ts
 init_deployment_addresses();
-import { Contract as Contract10, Interface as Interface6 } from "ethers";
+import { Contract as Contract10, Interface as Interface7 } from "ethers";
 var SAFE_ABI = [
   "function getModulesPaginated(address start, uint256 pageSize) view returns (address[] modules, address next)"
 ];