@gvnrdao/dh-sdk 0.0.328 → 0.0.330

package/dist/deployments.js

@@ -521,6 +521,14 @@ var MAINNET_DEPLOYMENT = {
       reason: "2026-08 agent-stack release. The mainnet PositionManagerViews at 0x9225647a was deployed as a BARE implementation (EIP-1967 slot 0x00), so upgradeToAndCall reverts UUPSUnauthorizedCallContext \u2014 it could never be upgraded. PositionManager.setViews (added in the same Execute B batch) removed the repoint blocker, so Views was replaced behind a new proxy rather than upgraded. This makes the Pashov F3 renewal debt-ceiling check REACHABLE for the first time: ExceedsMaxLoan (0x499e7985) is present in 0xE68DC096 and absent from 0x9225647a. Views holds no protocol state (8 wiring slots + roles + pause), which is what made replacement safe. The old contract is ABANDONED, not decommissioned \u2014 it stays live and callable as the rollback target for setViews. NOTE: VERSION reads 1.1.1 on both sides; verify by address.",
       executeTx: "0xf1f8d5fc13f45d7a3f932bf1a2d6e29381fdd41cd31298ad785bf7688df07fe6",
       block: 25673200
+    },
+    AgentDelegationRegistry: {
+      newImplementation: "0xa9fF405Edd4329fc3159a64F56B37EBD253e4928",
+      upgradedAt: "2026-07-31T22:03:35.000Z",
+      upgradedBy: "AdminModule/Safe audit-batch upgradeToAndCall; executed by 0xEba7BfAeB35ee18408b424Ee0BB45AdDf776589f in tx 0x8fed0ab7eee3aaaa3792a35b40b0ef74bd09cfb1a175934afd846bee546048d4 (block 25655710)",
+      reason: "Reconciled from chain \u2014 mainnet audit rollout batch (cross-ref onchain-auth/.safe-batches/mainnet-audit-execute.json)",
+      executeTx: "0x8fed0ab7eee3aaaa3792a35b40b0ef74bd09cfb1a175934afd846bee546048d4",
+      block: 25655710
     }
   },
   latestEnv: {

package/dist/deployments.mjs

@@ -488,6 +488,14 @@ var MAINNET_DEPLOYMENT = {
       reason: "2026-08 agent-stack release. The mainnet PositionManagerViews at 0x9225647a was deployed as a BARE implementation (EIP-1967 slot 0x00), so upgradeToAndCall reverts UUPSUnauthorizedCallContext \u2014 it could never be upgraded. PositionManager.setViews (added in the same Execute B batch) removed the repoint blocker, so Views was replaced behind a new proxy rather than upgraded. This makes the Pashov F3 renewal debt-ceiling check REACHABLE for the first time: ExceedsMaxLoan (0x499e7985) is present in 0xE68DC096 and absent from 0x9225647a. Views holds no protocol state (8 wiring slots + roles + pause), which is what made replacement safe. The old contract is ABANDONED, not decommissioned \u2014 it stays live and callable as the rollback target for setViews. NOTE: VERSION reads 1.1.1 on both sides; verify by address.",
       executeTx: "0xf1f8d5fc13f45d7a3f932bf1a2d6e29381fdd41cd31298ad785bf7688df07fe6",
       block: 25673200
+    },
+    AgentDelegationRegistry: {
+      newImplementation: "0xa9fF405Edd4329fc3159a64F56B37EBD253e4928",
+      upgradedAt: "2026-07-31T22:03:35.000Z",
+      upgradedBy: "AdminModule/Safe audit-batch upgradeToAndCall; executed by 0xEba7BfAeB35ee18408b424Ee0BB45AdDf776589f in tx 0x8fed0ab7eee3aaaa3792a35b40b0ef74bd09cfb1a175934afd846bee546048d4 (block 25655710)",
+      reason: "Reconciled from chain \u2014 mainnet audit rollout batch (cross-ref onchain-auth/.safe-batches/mainnet-audit-execute.json)",
+      executeTx: "0x8fed0ab7eee3aaaa3792a35b40b0ef74bd09cfb1a175934afd846bee546048d4",
+      block: 25655710
     }
   },
   latestEnv: {

package/dist/graphs/diamond-hands.d.ts

@@ -86,6 +86,174 @@ export interface UserRateLimitData {
     nextResetBlock: string;
     lastUpdated: string;
 }
+export interface LoanEventsQueryResponse {
+    position: {
+        id: string;
+        payments?: Array<{
+            id: string;
+            payer: {
+                id: string;
+            };
+            amount: string;
+            type: string;
+            transactionHash: string;
+            timestamp: string;
+            blockNumber: string;
+            logIndex: string;
+            newDebt: string;
+            newCollateralRatio: string;
+        }>;
+        statusUpdates?: Array<{
+            id: string;
+            oldStatus: string;
+            newStatus: string;
+            reason?: string;
+            timestamp: string;
+            blockNumber: string;
+            transactionHash: string;
+        }>;
+        liquidation?: {
+            id: string;
+            liquidator: string;
+            liquidatedAmount: string;
+            collateralSeized: string;
+            transactionHash: string;
+            timestamp: string;
+            blockNumber: string;
+            commitHash?: string;
+            commitTimestamp?: string;
+            revealDelay?: string;
+        };
+        withdrawals?: Array<{
+            id: string;
+            withdrawalAmount: string;
+            withdrawalAddress: string;
+            networkFee?: string;
+            timestamp: string;
+            blockNumber: string;
+            transactionHash: string;
+            logIndex: string;
+        }>;
+        renewals?: Array<{
+            id: string;
+            extensionTerm: string;
+            extensionFee: string;
+            newExpiryDate: string;
+            timestamp: string;
+            blockNumber: string;
+            transactionHash: string;
+            logIndex: string;
+        }>;
+        operationFailures?: Array<{
+            id: string;
+            operationType: string;
+            reason: string;
+            errorCode?: string;
+            amount?: string;
+            timestamp: string;
+            blockNumber: string;
+            transactionHash: string;
+            logIndex: string;
+        }>;
+        mintRequests?: Array<{
+            id: string;
+            pkpId: string;
+            borrower: {
+                id: string;
+            };
+            mintAmount: string;
+            originationFee: string;
+            newDebt: string;
+            newCollateralRatio: string;
+            btcPrice: string;
+            quantumTimestamp: string;
+            opId: string;
+            timestamp: string;
+            blockNumber: string;
+            transactionHash: string;
+            logIndex: string;
+        }>;
+        burnRequests?: Array<{
+            id: string;
+            pkpId: string;
+            borrower: {
+                id: string;
+            };
+            burnAmount: string;
+            remainingDebt: string;
+            newCollateralRatio: string;
+            opId: string;
+            timestamp: string;
+            blockNumber: string;
+            transactionHash: string;
+            logIndex: string;
+        }>;
+        mintingFees?: Array<{
+            id: string;
+            borrower: {
+                id: string;
+            };
+            feeAmount: string;
+            mintAmount: string;
+            newDebt: string;
+            btcPrice: string;
+            quantumTimestamp: string;
+            timestamp: string;
+            blockNumber: string;
+            transactionHash: string;
+            logIndex: string;
+        }>;
+        renewalFees?: Array<{
+            id: string;
+            borrower: {
+                id: string;
+            };
+            feeAmount: string;
+            extensionTerm: string;
+            newExpiryDate: string;
+            timestamp: string;
+            blockNumber: string;
+            transactionHash: string;
+            logIndex: string;
+        }>;
+    };
+    positionCreatedEvents?: Array<{
+        id: string;
+        pkpId: string;
+        borrower: {
+            id: string;
+        };
+        requestedCollateralRatio: string;
+        selectedTerm: string;
+        expiryAt: string;
+        timestamp: string;
+        blockNumber: string;
+        transactionHash: string;
+    }>;
+    ucdmintEvents?: Array<{
+        id: string;
+        amount: string;
+        proof: string;
+        minter: {
+            id: string;
+        };
+        isCommunityMint: boolean;
+        timestamp: string;
+        blockNumber: string;
+        transactionHash: string;
+    }>;
+    collateralEvents?: Array<{
+        id: string;
+        eventType: string;
+        networkFee?: string;
+        remainingCollateral?: string;
+        collateralRatio?: string;
+        timestamp: string;
+        blockNumber: string;
+        transactionHash: string;
+        logIndex: string;
+    }>;
+}
 export declare class DiamondHandsGraph {
     private client;
     private defaultPageSize;
@@ -115,6 +283,15 @@ export declare class DiamondHandsGraph {
     /**
      * Get user positions from subgraph
      */
+    private getUserPositionsOnly;
+    /**
+     * Get user positions, plus an accurate total count.
+     *
+     * The count is a SECOND round trip (`getTotalCountPaginated`, which pages to handle
+     * >1000 items). Callers that only need the rows should use `getUserPositionsOnly` and
+     * skip it — the event paths did not, and paid for a count they immediately discarded on
+     * every activity refresh.
+     */
     getUserPositions(userAddress: string, first?: number, skip?: number, orderBy?: string, orderDirection?: string): Promise<{
         positions: LoanData[];
         total: number;
@@ -262,6 +439,14 @@ export declare class DiamondHandsGraph {
      * @returns Complete event history for the position
      */
     getLoanEvents(positionId: string, filter?: LoanEventsFilter): Promise<LoanEvents>;
+    /**
+     * Map one position's raw event payload into `LoanEvents`.
+     *
+     * Extracted verbatim from getLoanEvents so the wallet-collapsed path produces
+     * byte-identical objects by construction rather than by a second implementation
+     * that has to be kept in step by hand.
+     */
+    private assembleLoanEvents;
     /**
      * Get the full loan-event history for every position owned by a wallet.
      *
@@ -280,6 +465,31 @@ export declare class DiamondHandsGraph {
      * @returns One LoanEvents object per position; empty array if the wallet has none.
      */
     getWalletLoanEvents(userAddress: string, filter?: LoanEventsFilter): Promise<LoanEvents[]>;
+    /**
+     * The per-position path: enumerate the wallet's positions, then one `GetLoanEvents` each.
+     *
+     * Used for filtered calls, and as the completeness fallback when the collapsed document
+     * hits a page limit. Costs `1 + N` requests, which is exactly why it is not the default.
+     */
+    private getWalletLoanEventsFanout;
+    /**
+     * The whole wallet's event history in ONE request.
+     *
+     * Replaces `1 + N` round trips (one position enumeration plus one per position) with a
+     * single document. Measured on Sepolia: a wallet holding 44 positions cost 46 requests
+     * per activity refresh against a per-wallet budget of 30/min — this makes it 1.
+     *
+     * Three subgraph facts make it possible, all verified against the deployed schema rather
+     * than assumed:
+     *   - ten event collections are `@derivedFrom` on Position, so they nest under a
+     *     borrower-filtered `positions(...)`;
+     *   - `positionCreatedEvents` is ALSO derived on Position — `getLoanEvents` queries it
+     *     top-level, which it never needed to;
+     *   - `ucdmintEvents` / `collateralEvents` are not derived and carry no `borrower`
+     *     field, but graph-node's nested `position_: { borrower }` filter reaches them.
+     *     Without that last one this would be two requests, not one.
+     */
+    private getWalletLoanEventsCollapsed;
     /**
      * Retrieve events across the full protocol, optionally narrowed to a position.
      * Returns a merged, sorted discriminated-union timeline suitable for explorers.

package/dist/index.js

@@ -546,6 +546,14 @@ var init_deployment_addresses = __esm({
           reason: "2026-08 agent-stack release. The mainnet PositionManagerViews at 0x9225647a was deployed as a BARE implementation (EIP-1967 slot 0x00), so upgradeToAndCall reverts UUPSUnauthorizedCallContext \u2014 it could never be upgraded. PositionManager.setViews (added in the same Execute B batch) removed the repoint blocker, so Views was replaced behind a new proxy rather than upgraded. This makes the Pashov F3 renewal debt-ceiling check REACHABLE for the first time: ExceedsMaxLoan (0x499e7985) is present in 0xE68DC096 and absent from 0x9225647a. Views holds no protocol state (8 wiring slots + roles + pause), which is what made replacement safe. The old contract is ABANDONED, not decommissioned \u2014 it stays live and callable as the rollback target for setViews. NOTE: VERSION reads 1.1.1 on both sides; verify by address.",
           executeTx: "0xf1f8d5fc13f45d7a3f932bf1a2d6e29381fdd41cd31298ad785bf7688df07fe6",
           block: 25673200
+        },
+        AgentDelegationRegistry: {
+          newImplementation: "0xa9fF405Edd4329fc3159a64F56B37EBD253e4928",
+          upgradedAt: "2026-07-31T22:03:35.000Z",
+          upgradedBy: "AdminModule/Safe audit-batch upgradeToAndCall; executed by 0xEba7BfAeB35ee18408b424Ee0BB45AdDf776589f in tx 0x8fed0ab7eee3aaaa3792a35b40b0ef74bd09cfb1a175934afd846bee546048d4 (block 25655710)",
+          reason: "Reconciled from chain \u2014 mainnet audit rollout batch (cross-ref onchain-auth/.safe-batches/mainnet-audit-execute.json)",
+          executeTx: "0x8fed0ab7eee3aaaa3792a35b40b0ef74bd09cfb1a175934afd846bee546048d4",
+          block: 25655710
         }
       },
       latestEnv: {
@@ -12120,6 +12128,169 @@ function normalizePkpId2(pkpId) {
   }
   return pkpId;
 }
+function hasLoanEventsFilter(filter) {
+  if (!filter)
+    return false;
+  return filter.eventTypes !== void 0 || filter.fromTimestamp !== void 0 || filter.toTimestamp !== void 0 || filter.fromBlock !== void 0 || filter.toBlock !== void 0 || filter.limit !== void 0 || filter.orderDirection !== void 0;
+}
+var WALLET_LOAN_EVENTS_QUERY = `
+      query GetWalletLoanEvents($borrower: Bytes!, $first: Int!, $limit: Int!, $orderDirection: OrderDirection!) {
+        positions(where: { borrower: $borrower }, first: $first, orderBy: id) {
+          id
+          payments(first: $limit, orderBy: timestamp, orderDirection: $orderDirection) {
+            id
+            payer { id }
+            amount
+            type
+            transactionHash
+            timestamp
+            blockNumber
+            logIndex
+            newDebt
+            newCollateralRatio
+          }
+          statusUpdates(first: $limit, orderBy: timestamp, orderDirection: $orderDirection) {
+            id
+            oldStatus
+            newStatus
+            reason
+            timestamp
+            blockNumber
+            transactionHash
+          }
+          liquidation {
+            id
+            liquidator
+            liquidatedAmount
+            collateralSeized
+            transactionHash
+            timestamp
+            blockNumber
+            commitHash
+            commitTimestamp
+            revealDelay
+          }
+          withdrawals(first: $limit, orderBy: timestamp, orderDirection: $orderDirection) {
+            id
+            withdrawalAmount
+            withdrawalAddress
+            networkFee
+            timestamp
+            blockNumber
+            transactionHash
+            logIndex
+          }
+          renewals(first: $limit, orderBy: timestamp, orderDirection: $orderDirection) {
+            id
+            extensionTerm
+            extensionFee
+            newExpiryDate
+            timestamp
+            blockNumber
+            transactionHash
+            logIndex
+          }
+          operationFailures(first: $limit, orderBy: timestamp, orderDirection: $orderDirection) {
+            id
+            operationType
+            reason
+            errorCode
+            amount
+            timestamp
+            blockNumber
+            transactionHash
+            logIndex
+          }
+          mintRequests(first: $limit, orderBy: timestamp, orderDirection: $orderDirection) {
+            id
+            pkpId
+            borrower { id }
+            mintAmount
+            originationFee
+            newDebt
+            newCollateralRatio
+            btcPrice
+            quantumTimestamp
+            opId
+            timestamp
+            blockNumber
+            transactionHash
+            logIndex
+          }
+          burnRequests(first: $limit, orderBy: timestamp, orderDirection: $orderDirection) {
+            id
+            pkpId
+            borrower { id }
+            burnAmount
+            remainingDebt
+            newCollateralRatio
+            opId
+            timestamp
+            blockNumber
+            transactionHash
+            logIndex
+          }
+          mintingFees(first: $limit, orderBy: timestamp, orderDirection: $orderDirection) {
+            id
+            borrower { id }
+            feeAmount
+            mintAmount
+            newDebt
+            btcPrice
+            quantumTimestamp
+            timestamp
+            blockNumber
+            transactionHash
+            logIndex
+          }
+          renewalFees(first: $limit, orderBy: timestamp, orderDirection: $orderDirection) {
+            id
+            borrower { id }
+            feeAmount
+            extensionTerm
+            newExpiryDate
+            timestamp
+            blockNumber
+            transactionHash
+            logIndex
+          }
+          positionCreatedEvents(first: 1, orderBy: timestamp, orderDirection: asc) {
+            id
+            pkpId
+            borrower { id }
+            requestedCollateralRatio
+            selectedTerm
+            expiryAt
+            timestamp
+            blockNumber
+            transactionHash
+          }
+        }
+        ucdmintEvents(where: { position_: { borrower: $borrower } }, first: $limit, orderBy: timestamp, orderDirection: $orderDirection) {
+          id
+          position { id }
+          amount
+          proof
+          minter { id }
+          isCommunityMint
+          timestamp
+          blockNumber
+          transactionHash
+        }
+        collateralEvents(where: { position_: { borrower: $borrower } }, first: $limit, orderBy: timestamp, orderDirection: $orderDirection) {
+          id
+          position { id }
+          eventType
+          networkFee
+          remainingCollateral
+          collateralRatio
+          timestamp
+          blockNumber
+          transactionHash
+          logIndex
+        }
+      }
+    `;
 var DiamondHandsGraph = class {
   client;
   defaultPageSize;
@@ -12225,7 +12396,7 @@ var DiamondHandsGraph = class {
   /**
    * Get user positions from subgraph
    */
-  async getUserPositions(userAddress, first, skip, orderBy, orderDirection) {
+  async getUserPositionsOnly(userAddress, first, skip, orderBy, orderDirection) {
     const query = `
       query GetUserPositions($borrower: Bytes!, $first: Int, $skip: Int, $orderBy: Position_orderBy, $orderDirection: OrderDirection) {
         user(id: $borrower) {
@@ -12266,17 +12437,28 @@ var DiamondHandsGraph = class {
       query,
       variables
     );
-    const total = await this.getTotalCountPaginated("{ borrower: $borrower }", {
-      borrower: userAddress.toLowerCase()
-    });
     let positions = [];
     if (result && result.user && Array.isArray(result.user.positions)) {
       positions = result.user.positions.filter((p) => p != null).map((p) => this.transformGraphPositionToLoanData(p));
     }
-    return {
-      positions,
-      total
-    };
+    return positions;
+  }
+  /**
+   * Get user positions, plus an accurate total count.
+   *
+   * The count is a SECOND round trip (`getTotalCountPaginated`, which pages to handle
+   * >1000 items). Callers that only need the rows should use `getUserPositionsOnly` and
+   * skip it — the event paths did not, and paid for a count they immediately discarded on
+   * every activity refresh.
+   */
+  async getUserPositions(userAddress, first, skip, orderBy, orderDirection) {
+    const [positions, total] = await Promise.all([
+      this.getUserPositionsOnly(userAddress, first, skip, orderBy, orderDirection),
+      this.getTotalCountPaginated("{ borrower: $borrower }", {
+        borrower: userAddress.toLowerCase()
+      })
+    ]);
+    return { positions, total };
   }
   /**
    * Get user positions with enriched Bitcoin balance data
@@ -13367,6 +13549,16 @@ var DiamondHandsGraph = class {
       orderDirection
     };
     const result = await this.client.execute(query, variables);
+    return this.assembleLoanEvents(positionId, result);
+  }
+  /**
+   * Map one position's raw event payload into `LoanEvents`.
+   *
+   * Extracted verbatim from getLoanEvents so the wallet-collapsed path produces
+   * byte-identical objects by construction rather than by a second implementation
+   * that has to be kept in step by hand.
+   */
+  assembleLoanEvents(positionId, result) {
     const rawCreated = result.positionCreatedEvents?.[0];
     const positionCreated = rawCreated ? {
       id: rawCreated.id,
@@ -13571,7 +13763,22 @@ var DiamondHandsGraph = class {
    * @returns One LoanEvents object per position; empty array if the wallet has none.
    */
   async getWalletLoanEvents(userAddress, filter) {
-    const { positions } = await this.getUserPositions(userAddress);
+    if (!hasLoanEventsFilter(filter)) {
+      return this.getWalletLoanEventsCollapsed(userAddress);
+    }
+    return this.getWalletLoanEventsFanout(userAddress, filter);
+  }
+  /**
+   * The per-position path: enumerate the wallet's positions, then one `GetLoanEvents` each.
+   *
+   * Used for filtered calls, and as the completeness fallback when the collapsed document
+   * hits a page limit. Costs `1 + N` requests, which is exactly why it is not the default.
+   */
+  async getWalletLoanEventsFanout(userAddress, filter) {
+    const positions = await this.getUserPositionsOnly(
+      userAddress,
+      THE_GRAPH_MAX_BATCH_SIZE
+    );
     const positionIds = positions.map((p) => p?.id != null ? String(p.id) : "").filter((id) => id.length > 0);
     if (positionIds.length === 0)
       return [];
@@ -13586,6 +13793,81 @@ var DiamondHandsGraph = class {
     }
     return results;
   }
+  /**
+   * The whole wallet's event history in ONE request.
+   *
+   * Replaces `1 + N` round trips (one position enumeration plus one per position) with a
+   * single document. Measured on Sepolia: a wallet holding 44 positions cost 46 requests
+   * per activity refresh against a per-wallet budget of 30/min — this makes it 1.
+   *
+   * Three subgraph facts make it possible, all verified against the deployed schema rather
+   * than assumed:
+   *   - ten event collections are `@derivedFrom` on Position, so they nest under a
+   *     borrower-filtered `positions(...)`;
+   *   - `positionCreatedEvents` is ALSO derived on Position — `getLoanEvents` queries it
+   *     top-level, which it never needed to;
+   *   - `ucdmintEvents` / `collateralEvents` are not derived and carry no `borrower`
+   *     field, but graph-node's nested `position_: { borrower }` filter reaches them.
+   *     Without that last one this would be two requests, not one.
+   */
+  async getWalletLoanEventsCollapsed(userAddress) {
+    const borrower = userAddress.toLowerCase();
+    const pageSize = THE_GRAPH_MAX_BATCH_SIZE;
+    const result = await this.client.execute(
+      WALLET_LOAN_EVENTS_QUERY,
+      {
+        borrower,
+        first: pageSize,
+        limit: pageSize,
+        orderDirection: "desc"
+      }
+    );
+    const positions = result.positions || [];
+    const ucdmintEvents = result.ucdmintEvents || [];
+    const collateralEvents = result.collateralEvents || [];
+    const truncated = positions.length >= pageSize || ucdmintEvents.length >= pageSize || collateralEvents.length >= pageSize;
+    if (truncated) {
+      log.warn(
+        "[DiamondHandsGraph] wallet event page limit reached \u2014 falling back to the per-position path to avoid returning a partial history",
+        {
+          borrower,
+          pageSize,
+          positions: positions.length,
+          ucdmintEvents: ucdmintEvents.length,
+          collateralEvents: collateralEvents.length
+        }
+      );
+      return this.getWalletLoanEventsFanout(userAddress);
+    }
+    if (positions.length === 0)
+      return [];
+    const mintsByPosition = /* @__PURE__ */ new Map();
+    for (const m of result.ucdmintEvents || []) {
+      const key = m.position?.id;
+      if (!key)
+        continue;
+      const bucket = mintsByPosition.get(key) || [];
+      bucket.push(m);
+      mintsByPosition.set(key, bucket);
+    }
+    const collateralByPosition = /* @__PURE__ */ new Map();
+    for (const c of result.collateralEvents || []) {
+      const key = c.position?.id;
+      if (!key)
+        continue;
+      const bucket = collateralByPosition.get(key) || [];
+      bucket.push(c);
+      collateralByPosition.set(key, bucket);
+    }
+    return positions.map(
+      (p) => this.assembleLoanEvents(p.id, {
+        position: p,
+        positionCreatedEvents: p.positionCreatedEvents || [],
+        ucdmintEvents: mintsByPosition.get(p.id) || [],
+        collateralEvents: collateralByPosition.get(p.id) || []
+      })
+    );
+  }
   // ============================================================================
   // Protocol-wide Events
   // ============================================================================
@@ -18496,16 +18778,6 @@ var import_dh_lit_ops = require("@gvnrdao/dh-lit-ops");
 var import_dh_lit_actions2 = __toESM(require_pkg_src());
 
 // src/utils/telegram-messaging.utils.ts
-var TelegramBot = null;
-try {
-  if (typeof window === "undefined" && typeof global !== "undefined") {
-    TelegramBot = require("node-telegram-bot-api");
-  }
-} catch (error) {
-  log.warn("Telegram bot API not available", {
-    error: error instanceof Error ? error.message : String(error)
-  });
-}
 function formatMintMessage(mintAmount, loanId, txHash) {
   return `\u2705 DH SDK: ${mintAmount} UCD was minted for loan id: ${loanId} Tx: https://sepolia.etherscan.io/tx/${txHash}`;
 }