@gvnrdao/dh-sdk 0.0.317 → 0.0.319

package/dist/interfaces/chunks/contract-types.i.d.ts

@@ -96,18 +96,6 @@ export interface IUCDController extends BaseContract {
     ucdToken(): Promise<string>;
     adminModule(): Promise<string>;
 }
-/**
- * Price Feed Consumer Contract Interface
- */
-export interface IPriceFeedConsumer extends BaseContract {
-    updatePrice(): Promise<ContractTransactionResponse>;
-    getCurrentPrice(): Promise<bigint>;
-    getPriceAge(): Promise<bigint>;
-    isPriceStale(): Promise<boolean>;
-    validatePriceFeed(): Promise<boolean>;
-    getLatestBTCPrice(): Promise<bigint>;
-    decimals(): Promise<number>;
-}
 /**
  * Term Manager Contract Interface
  * Based on contracts/src/interfaces/ITermManager.sol

package/dist/modules/contract/contract-manager.module.d.ts

@@ -15,7 +15,7 @@ import type { ContractAddresses } from "../../interfaces/chunks/config.i";
 import { type DeploymentContracts } from "../../constants/chunks/deployment-addresses";
 import { Result } from "../../types/result";
 import { SDKError } from "../../utils/error-handler";
-import type { PositionManager, ILoanOperationsManager, IUCDController, IPriceFeedConsumer, ITermManager, CircuitBreakerModule, ILiquidationManager } from "../../interfaces/chunks/contract-types.i";
+import type { PositionManager, ILoanOperationsManager, IUCDController, ITermManager, CircuitBreakerModule, ILiquidationManager } from "../../interfaces/chunks/contract-types.i";
 /**
  * Type alias for ethers v6 provider (used throughout SDK)
  */
@@ -52,7 +52,6 @@ export interface ManagedContracts {
     positionManager: PositionManager;
     loanOperationsManager: ILoanOperationsManager;
     ucdController: IUCDController;
-    priceFeed: IPriceFeedConsumer;
     termManager: ITermManager;
     circuitBreaker: CircuitBreakerModule;
     liquidationManager: ILiquidationManager;
@@ -94,10 +93,6 @@ export declare class ContractManager {
      * Get UCD Controller contract
      */
     getUCDController(): Result<IUCDController, SDKError>;
-    /**
-     * Get Price Feed contract
-     */
-    getPriceFeed(): Result<IPriceFeedConsumer, SDKError>;
     /**
      * Get Term Manager contract
      */

package/dist/modules/diamond-hands-sdk.d.ts

@@ -887,8 +887,22 @@ export declare class DiamondHandsSDK {
      * @param options - Override timeout/interval for this call
      * @throws if timeout is reached before subgraph catches up
      */
-    /** Guard: the AgentDelegationRegistry MVP is deployed on Sepolia only. */
-    private assertAgentDelegationSepolia;
+    /**
+     * Guard: resolve the AgentDelegationRegistry for the configured network.
+     *
+     * Deployment presence IS the availability test — there is deliberately no chainId
+     * allow-list here. The registry is deployed per network (Sepolia 2026-07, mainnet
+     * 2026-08 agent-stack release) and `getNetworkConfig` populates the address from the
+     * generated deployment table, so a chain without a deployment resolves to `""` and
+     * fails closed below. Adding a chain therefore needs no SDK code change — which is
+     * exactly how the previous hardcoded `chainId !== 11155111` gate went stale and kept
+     * the mainnet toggle dark after the registry shipped.
+     *
+     * Callers that need the availability answer WITHOUT throwing (e.g. to decide whether to
+     * render a toggle at all) should ask the deployment table directly rather than calling this
+     * and catching — `ALL_DEPLOYMENTS` is published on the `@gvnrdao/dh-sdk/deployments` subpath.
+     */
+    private agentDelegationRegistryOrThrow;
     /**
      * Read a position's auto-renew delegation state (used to drive the Enable/Disable toggle).
      * Pure view — no signer required.

package/dist/utils/position-delegate.utils.d.ts

@@ -12,12 +12,27 @@
  * and cannot carry the additional storage + setter without going over.
  */
 import { type Signer, type Provider, type TransactionResponse } from "ethers";
-/** Registry v2.0.0 `delegateStatus` deny reasons. */
+/**
+ * Registry v2.0.0 `delegateStatus` deny reasons.
+ *
+ * Mirrors `PositionDelegateRegistry.DenyReason` exactly, by ordinal — `getDelegateStatus` casts the
+ * raw uint8 straight to this enum, so a missing member surfaces as an unmapped value rather than an
+ * error. Keep the two in lockstep, and only ever APPEND: the contract appends too, so that the
+ * existing ABI values never shift.
+ */
 export declare enum DelegateDenyReason {
     NONE = 0,
     PAUSED = 1,
     NO_DELEGATE = 2,
-    NOT_DELEGATE = 3
+    NOT_DELEGATE = 3,
+    /**
+     * The delegate address was permanently burned protocol-wide by `revokeDelegate`
+     * (REGISTRAR_ROLE). Checked ahead of the per-position match, so a burned key reports BURNED on
+     * every position rather than NOT_DELEGATE on the one it was revoked from. The burn is global and
+     * irreversible — recovery is rotating to a fresh address, which AgentDelegationRegistry's AR-1
+     * non-reuse rule forces anyway.
+     */
+    BURNED = 4
 }
 /**
  * Register (or revoke) the off-chain authorization delegate for a position.

package/dist/utils/server-session-store.d.ts

@@ -44,8 +44,12 @@ export interface ServerSessionStore {
      * so a custom store written before this existed still satisfies the interface;
      * without it the session simply mints a fresh envelope each attempt, which is
      * the pre-existing behavior and only costs a multi-owner Safe a restart.
+     *
+     * `maxAgeSeconds` is supplied by the caller, which knows the signer kind and
+     * therefore which of the server's two first-use windows applies. A store that
+     * ignores it keeps the old single-TTL behavior.
      */
-    loadPending?(key: string): PendingLoginEnvelope | null;
+    loadPending?(key: string, maxAgeSeconds?: number): PendingLoginEnvelope | null;
     savePending?(key: string, envelope: PendingLoginEnvelope): void;
     clearPending?(key: string): void;
 }
@@ -69,12 +73,26 @@ export interface PendingLoginEnvelope {
     nonce: string;
 }
 /**
- * How long an unsigned envelope stays reusable. Must stay UNDER the server's
- * contract-wallet first-use skew (`CONTRACT_ISSUED_AT_SKEW_SECONDS`, 10 min):
- * beyond it the first use is rejected as stale, so reuse would guarantee failure
- * instead of preventing a re-sign.
+ * How long an unsigned envelope stays reusable FOR A CONTRACT WALLET. Must stay
+ * UNDER the server's contract-wallet first-use skew
+ * (`CONTRACT_ISSUED_AT_SKEW_SECONDS`, 10 min): beyond it the first use is
+ * rejected as stale, so reuse would guarantee failure instead of preventing a
+ * re-sign.
  */
 export declare const PENDING_ENVELOPE_TTL_SECONDS: number;
+/**
+ * The same, for an EOA — which the server gives only `ISSUED_AT_SKEW_SECONDS`
+ * (120s) to make its FIRST use.
+ *
+ * Between 120s and 8 minutes a reused EOA envelope is still "live" locally and
+ * certain to be refused by the server, so the contract-wallet TTL is not a safe
+ * over-estimate for a key-holding wallet — it is a window in which every retry
+ * re-signs a message that cannot be accepted. 60s leaves a full minute of the
+ * server's window for the prompt and the round trip, and an EOA gives up
+ * nothing by re-minting: it signs in one click, so it has no equivalent of the
+ * cross-session ceremony this reuse exists for.
+ */
+export declare const EOA_PENDING_ENVELOPE_TTL_SECONDS = 60;
 /** Storage key for the pending envelope matching a session key. */
 export declare function pendingEnvelopeKey(sessionKey: string): string;
 export declare function isPendingEnvelopeShape(value: any): value is PendingLoginEnvelope;
@@ -82,7 +100,7 @@ export declare class LocalStorageSessionStore implements ServerSessionStore {
     load(key: string): PersistedServerSession | null;
     save(key: string, session: PersistedServerSession): void;
     clear(key: string): void;
-    loadPending(key: string): PendingLoginEnvelope | null;
+    loadPending(key: string, maxAgeSeconds?: number): PendingLoginEnvelope | null;
     savePending(key: string, envelope: PendingLoginEnvelope): void;
     clearPending(key: string): void;
 }
@@ -92,7 +110,7 @@ export declare class MemorySessionStore implements ServerSessionStore {
     load(key: string): PersistedServerSession | null;
     save(key: string, session: PersistedServerSession): void;
     clear(key: string): void;
-    loadPending(key: string): PendingLoginEnvelope | null;
+    loadPending(key: string, maxAgeSeconds?: number): PendingLoginEnvelope | null;
     savePending(key: string, envelope: PendingLoginEnvelope): void;
     clearPending(key: string): void;
 }

package/dist/utils/server-session.d.ts

@@ -62,10 +62,15 @@ export interface ServerSessionOptions {
     /** Override for tests. */
     fetchImpl?: typeof fetch;
 }
-/** Login failure carrying the HTTP status so callers can tell rejection from outage. */
+/**
+ * Login failure carrying the HTTP status — and the server's machine-readable
+ * `reason` where it sent one — so callers can tell rejection from outage, and
+ * one kind of rejection from another.
+ */
 export declare class ServerLoginError extends Error {
     readonly status: number;
-    constructor(message: string, status: number);
+    readonly reason?: string | undefined;
+    constructor(message: string, status: number, reason?: string | undefined);
 }
 export declare class ServerSession {
     private readonly signer;
@@ -97,6 +102,12 @@ export declare class ServerSession {
      * `clear()` can drop the persisted token without an async address lookup.
      */
     private lastStoreKey;
+    /**
+     * Whether the signer is a smart-contract wallet, memoized after the first
+     * `eth_getCode`. Decides which of the server's two first-use windows bounds
+     * envelope reuse; a signer cannot change kind for the life of the session.
+     */
+    private contractSigner;
     constructor(opts: ServerSessionOptions);
     /**
      * Returns a JWT good for at least `REFRESH_LEEWAY_SECONDS` more seconds.
@@ -160,6 +171,20 @@ export declare class ServerSession {
      * and the store are skipped if a `clearPersisted()` landed meanwhile.
      */
     private tryResolveSilently;
+    /**
+     * How long a pending envelope for THIS signer may be reused, in seconds.
+     *
+     * The server grants an EOA 120s to make an envelope's first use and a contract
+     * wallet 600s, so one local TTL is necessarily wrong for one of them. Deployed
+     * code has bytecode; an EOA does not — one `eth_getCode`, memoized, settles it.
+     *
+     * Reports the CONTRACT window when it cannot tell, which is the behavior that
+     * shipped before the split. The asymmetry is intended: guessing "EOA" for a
+     * Safe hands it a new message and orphans the owner signatures already
+     * collected, while guessing "contract" for an EOA now costs one rejected
+     * attempt, because a rejection clears the envelope.
+     */
+    private pendingEnvelopeTtl;
     private getOrRefresh;
     private login;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gvnrdao/dh-sdk",
-  "version": "0.0.317",
+  "version": "0.0.319",
   "description": "TypeScript SDK for Diamond Hands Protocol - Bitcoin-backed lending with LIT Protocol PKPs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -82,8 +82,8 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@gvnrdao/dh-lit-actions": "^0.0.318",
-    "@gvnrdao/dh-lit-ops": "^0.0.309",
+    "@gvnrdao/dh-lit-actions": "^0.0.319",
+    "@gvnrdao/dh-lit-ops": "^0.0.310",
     "@noble/hashes": "^1.5.0",
     "axios": "^1.17.0",
     "bech32": "^2.0.0",