@gvnrdao/dh-sdk 0.0.308 → 0.0.311

package/dist/index.js

@@ -6507,7 +6507,7 @@ async function generateExtendAuthorization(positionId, newTerm, chainId, signerO
 var import_ethers4 = require("ethers");
 function buildLoginDomain(chainId) {
   return {
-    name: "Diamond Hands lit-ops-server",
+    name: "Diamond Hands",
     version: "1",
     chainId
   };
@@ -6527,12 +6527,12 @@ var LOGIN_TYPES_WITH_AUDIENCE = {
     { name: "audience", type: "string" }
   ]
 };
-async function buildSignedLoginPayload(signer, chainId, audience) {
+async function buildSignedLoginPayload(signer, chainId, audience, reuse) {
   const address = await signer.getAddress();
   const message = {
     address,
-    issuedAt: Math.floor(Date.now() / 1e3),
-    nonce: (0, import_ethers4.hexlify)((0, import_ethers4.randomBytes)(32)),
+    issuedAt: reuse?.issuedAt ?? Math.floor(Date.now() / 1e3),
+    nonce: reuse?.nonce ?? (0, import_ethers4.hexlify)((0, import_ethers4.randomBytes)(32)),
     ...audience ? { audience } : {}
   };
   const signature = await signer.signTypedData(
@@ -6550,6 +6550,13 @@ var STORE_PREFIX = "dh-server-session:";
 function sessionStoreKey(address, chainId, endpoint) {
   return STORE_PREFIX + `${address.trim().toLowerCase()}:${chainId}:${endpoint.replace(/\/+$/, "")}`;
 }
+var PENDING_ENVELOPE_TTL_SECONDS = 8 * 60;
+function pendingEnvelopeKey(sessionKey) {
+  return sessionKey + ":pending";
+}
+function isPendingEnvelopeShape(value) {
+  return !!value && typeof value === "object" && typeof value.issuedAt === "number" && typeof value.nonce === "string";
+}
 function isPayloadShape(value) {
   return !!value && typeof value === "object" && typeof value.chainId === "number" && typeof value.signature === "string" && !!value.message && typeof value.message.address === "string" && typeof value.message.issuedAt === "number" && typeof value.message.nonce === "string";
 }
@@ -6591,9 +6598,48 @@ var LocalStorageSessionStore = class {
     } catch {
     }
   }
+  loadPending(key) {
+    let raw;
+    try {
+      raw = window.localStorage.getItem(pendingEnvelopeKey(key));
+    } catch {
+      return null;
+    }
+    if (!raw)
+      return null;
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      this.clearPending(key);
+      return null;
+    }
+    const nowSec = Math.floor(Date.now() / 1e3);
+    if (!isPendingEnvelopeShape(parsed) || nowSec >= parsed.issuedAt + PENDING_ENVELOPE_TTL_SECONDS) {
+      this.clearPending(key);
+      return null;
+    }
+    return parsed;
+  }
+  savePending(key, envelope) {
+    try {
+      window.localStorage.setItem(
+        pendingEnvelopeKey(key),
+        JSON.stringify(envelope)
+      );
+    } catch {
+    }
+  }
+  clearPending(key) {
+    try {
+      window.localStorage.removeItem(pendingEnvelopeKey(key));
+    } catch {
+    }
+  }
 };
 var MemorySessionStore = class {
   entries = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
   load(key) {
     return this.entries.get(key) ?? null;
   }
@@ -6603,6 +6649,23 @@ var MemorySessionStore = class {
   clear(key) {
     this.entries.delete(key);
   }
+  loadPending(key) {
+    const envelope = this.pending.get(key);
+    if (!envelope)
+      return null;
+    const nowSec = Math.floor(Date.now() / 1e3);
+    if (nowSec >= envelope.issuedAt + PENDING_ENVELOPE_TTL_SECONDS) {
+      this.pending.delete(key);
+      return null;
+    }
+    return envelope;
+  }
+  savePending(key, envelope) {
+    this.pending.set(key, envelope);
+  }
+  clearPending(key) {
+    this.pending.delete(key);
+  }
 };
 function localStorageUsable() {
   try {
@@ -6622,6 +6685,8 @@ function createDefaultSessionStore() {
 
 // src/utils/server-session.ts
 var REFRESH_LEEWAY_SECONDS = 30;
+var LOGIN_RETRY_BASE_MS = 3e4;
+var LOGIN_RETRY_MAX_MS = 5 * 6e4;
 var ServerLoginError = class extends Error {
   constructor(message, status) {
     super(message);
@@ -6638,10 +6703,16 @@ var ServerSession = class {
   chainId;
   store;
   onSignaturePrompt;
+  onSignatureResolved;
   now;
   fetchImpl;
   cached = null;
   inFlight = null;
+  /**
+   * Set when a prompted login failed; suppresses further prompts until `until`.
+   * `error` is replayed to callers so they still see the real failure reason.
+   */
+  promptBackoff = null;
   /**
    * Bumped by `clearPersisted()` (logout / disconnect). An in-flight
    * `getOrRefresh()` captures this at start and refuses to write its freshly
@@ -6662,6 +6733,7 @@ var ServerSession = class {
     this.chainId = opts.chainId;
     this.store = opts.persistSession === false ? null : opts.sessionStore ?? createDefaultSessionStore();
     this.onSignaturePrompt = opts.onSignaturePrompt;
+    this.onSignatureResolved = opts.onSignatureResolved;
     this.now = opts.now ?? (() => Math.floor(Date.now() / 1e3));
     this.fetchImpl = opts.fetchImpl ?? ((...a) => fetch(...a));
   }
@@ -6716,6 +6788,7 @@ var ServerSession = class {
     this.generation += 1;
     this.cached = null;
     this.inFlight = null;
+    this.promptBackoff = null;
     if (!this.store)
       return;
     try {
@@ -6812,19 +6885,53 @@ var ServerSession = class {
     this.inFlight = (async () => {
       try {
         const existing = await this.tryResolveSilently(gen);
-        if (existing)
+        if (existing) {
+          this.promptBackoff = null;
           return existing;
+        }
+        if (this.promptBackoff && this.now() * 1e3 < this.promptBackoff.until) {
+          throw this.promptBackoff.error;
+        }
         this.onSignaturePrompt?.();
-        const payload = await buildSignedLoginPayload(
-          this.signer,
-          this.chainId,
-          this.serviceEndpoint
-        );
-        const session = await this.login(payload);
-        if (notCleared()) {
-          this.persist(payload, session);
-          this.cached = session;
+        let session;
+        try {
+          const store = this.store;
+          const storeKey = store ? this.lastStoreKey : null;
+          const reuse = storeKey ? store.loadPending?.(storeKey) ?? void 0 : void 0;
+          const payload = await buildSignedLoginPayload(
+            this.signer,
+            this.chainId,
+            this.serviceEndpoint,
+            reuse
+          );
+          if (storeKey && !reuse) {
+            store.savePending?.(storeKey, {
+              issuedAt: payload.message.issuedAt,
+              nonce: payload.message.nonce
+            });
+          }
+          session = await this.login(payload);
+          if (notCleared()) {
+            this.persist(payload, session);
+            this.cached = session;
+          }
+          if (storeKey)
+            store.clearPending?.(storeKey);
+          this.onSignatureResolved?.(true);
+        } catch (error) {
+          this.onSignatureResolved?.(false);
+          const failures = (this.promptBackoff?.failures ?? 0) + 1;
+          this.promptBackoff = {
+            failures,
+            error,
+            until: this.now() * 1e3 + Math.min(
+              LOGIN_RETRY_BASE_MS * 2 ** (failures - 1),
+              LOGIN_RETRY_MAX_MS
+            )
+          };
+          throw error;
         }
+        this.promptBackoff = null;
         return session;
       } finally {
         if (notCleared())
@@ -16552,7 +16659,8 @@ var DiamondHandsSDK = class _DiamondHandsSDK {
         chainId: config.chainId,
         persistSession: config.sessionPersistence?.enabled,
         sessionStore: config.sessionPersistence?.store,
-        onSignaturePrompt: config.onSessionSignaturePrompt
+        onSignaturePrompt: config.onSessionSignaturePrompt,
+        onSignatureResolved: config.onSessionSignatureResolved
       });
     }
     const contractManagerResult = createContractManager({

package/dist/index.mjs

@@ -6426,7 +6426,7 @@ async function generateExtendAuthorization(positionId, newTerm, chainId, signerO
 import { hexlify, randomBytes } from "ethers";
 function buildLoginDomain(chainId) {
   return {
-    name: "Diamond Hands lit-ops-server",
+    name: "Diamond Hands",
     version: "1",
     chainId
   };
@@ -6446,12 +6446,12 @@ var LOGIN_TYPES_WITH_AUDIENCE = {
     { name: "audience", type: "string" }
   ]
 };
-async function buildSignedLoginPayload(signer, chainId, audience) {
+async function buildSignedLoginPayload(signer, chainId, audience, reuse) {
   const address = await signer.getAddress();
   const message = {
     address,
-    issuedAt: Math.floor(Date.now() / 1e3),
-    nonce: hexlify(randomBytes(32)),
+    issuedAt: reuse?.issuedAt ?? Math.floor(Date.now() / 1e3),
+    nonce: reuse?.nonce ?? hexlify(randomBytes(32)),
     ...audience ? { audience } : {}
   };
   const signature = await signer.signTypedData(
@@ -6469,6 +6469,13 @@ var STORE_PREFIX = "dh-server-session:";
 function sessionStoreKey(address, chainId, endpoint) {
   return STORE_PREFIX + `${address.trim().toLowerCase()}:${chainId}:${endpoint.replace(/\/+$/, "")}`;
 }
+var PENDING_ENVELOPE_TTL_SECONDS = 8 * 60;
+function pendingEnvelopeKey(sessionKey) {
+  return sessionKey + ":pending";
+}
+function isPendingEnvelopeShape(value) {
+  return !!value && typeof value === "object" && typeof value.issuedAt === "number" && typeof value.nonce === "string";
+}
 function isPayloadShape(value) {
   return !!value && typeof value === "object" && typeof value.chainId === "number" && typeof value.signature === "string" && !!value.message && typeof value.message.address === "string" && typeof value.message.issuedAt === "number" && typeof value.message.nonce === "string";
 }
@@ -6510,9 +6517,48 @@ var LocalStorageSessionStore = class {
     } catch {
     }
   }
+  loadPending(key) {
+    let raw;
+    try {
+      raw = window.localStorage.getItem(pendingEnvelopeKey(key));
+    } catch {
+      return null;
+    }
+    if (!raw)
+      return null;
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      this.clearPending(key);
+      return null;
+    }
+    const nowSec = Math.floor(Date.now() / 1e3);
+    if (!isPendingEnvelopeShape(parsed) || nowSec >= parsed.issuedAt + PENDING_ENVELOPE_TTL_SECONDS) {
+      this.clearPending(key);
+      return null;
+    }
+    return parsed;
+  }
+  savePending(key, envelope) {
+    try {
+      window.localStorage.setItem(
+        pendingEnvelopeKey(key),
+        JSON.stringify(envelope)
+      );
+    } catch {
+    }
+  }
+  clearPending(key) {
+    try {
+      window.localStorage.removeItem(pendingEnvelopeKey(key));
+    } catch {
+    }
+  }
 };
 var MemorySessionStore = class {
   entries = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
   load(key) {
     return this.entries.get(key) ?? null;
   }
@@ -6522,6 +6568,23 @@ var MemorySessionStore = class {
   clear(key) {
     this.entries.delete(key);
   }
+  loadPending(key) {
+    const envelope = this.pending.get(key);
+    if (!envelope)
+      return null;
+    const nowSec = Math.floor(Date.now() / 1e3);
+    if (nowSec >= envelope.issuedAt + PENDING_ENVELOPE_TTL_SECONDS) {
+      this.pending.delete(key);
+      return null;
+    }
+    return envelope;
+  }
+  savePending(key, envelope) {
+    this.pending.set(key, envelope);
+  }
+  clearPending(key) {
+    this.pending.delete(key);
+  }
 };
 function localStorageUsable() {
   try {
@@ -6541,6 +6604,8 @@ function createDefaultSessionStore() {
 
 // src/utils/server-session.ts
 var REFRESH_LEEWAY_SECONDS = 30;
+var LOGIN_RETRY_BASE_MS = 3e4;
+var LOGIN_RETRY_MAX_MS = 5 * 6e4;
 var ServerLoginError = class extends Error {
   constructor(message, status) {
     super(message);
@@ -6557,10 +6622,16 @@ var ServerSession = class {
   chainId;
   store;
   onSignaturePrompt;
+  onSignatureResolved;
   now;
   fetchImpl;
   cached = null;
   inFlight = null;
+  /**
+   * Set when a prompted login failed; suppresses further prompts until `until`.
+   * `error` is replayed to callers so they still see the real failure reason.
+   */
+  promptBackoff = null;
   /**
    * Bumped by `clearPersisted()` (logout / disconnect). An in-flight
    * `getOrRefresh()` captures this at start and refuses to write its freshly
@@ -6581,6 +6652,7 @@ var ServerSession = class {
     this.chainId = opts.chainId;
     this.store = opts.persistSession === false ? null : opts.sessionStore ?? createDefaultSessionStore();
     this.onSignaturePrompt = opts.onSignaturePrompt;
+    this.onSignatureResolved = opts.onSignatureResolved;
     this.now = opts.now ?? (() => Math.floor(Date.now() / 1e3));
     this.fetchImpl = opts.fetchImpl ?? ((...a) => fetch(...a));
   }
@@ -6635,6 +6707,7 @@ var ServerSession = class {
     this.generation += 1;
     this.cached = null;
     this.inFlight = null;
+    this.promptBackoff = null;
     if (!this.store)
       return;
     try {
@@ -6731,19 +6804,53 @@ var ServerSession = class {
     this.inFlight = (async () => {
       try {
         const existing = await this.tryResolveSilently(gen);
-        if (existing)
+        if (existing) {
+          this.promptBackoff = null;
           return existing;
+        }
+        if (this.promptBackoff && this.now() * 1e3 < this.promptBackoff.until) {
+          throw this.promptBackoff.error;
+        }
         this.onSignaturePrompt?.();
-        const payload = await buildSignedLoginPayload(
-          this.signer,
-          this.chainId,
-          this.serviceEndpoint
-        );
-        const session = await this.login(payload);
-        if (notCleared()) {
-          this.persist(payload, session);
-          this.cached = session;
+        let session;
+        try {
+          const store = this.store;
+          const storeKey = store ? this.lastStoreKey : null;
+          const reuse = storeKey ? store.loadPending?.(storeKey) ?? void 0 : void 0;
+          const payload = await buildSignedLoginPayload(
+            this.signer,
+            this.chainId,
+            this.serviceEndpoint,
+            reuse
+          );
+          if (storeKey && !reuse) {
+            store.savePending?.(storeKey, {
+              issuedAt: payload.message.issuedAt,
+              nonce: payload.message.nonce
+            });
+          }
+          session = await this.login(payload);
+          if (notCleared()) {
+            this.persist(payload, session);
+            this.cached = session;
+          }
+          if (storeKey)
+            store.clearPending?.(storeKey);
+          this.onSignatureResolved?.(true);
+        } catch (error) {
+          this.onSignatureResolved?.(false);
+          const failures = (this.promptBackoff?.failures ?? 0) + 1;
+          this.promptBackoff = {
+            failures,
+            error,
+            until: this.now() * 1e3 + Math.min(
+              LOGIN_RETRY_BASE_MS * 2 ** (failures - 1),
+              LOGIN_RETRY_MAX_MS
+            )
+          };
+          throw error;
         }
+        this.promptBackoff = null;
         return session;
       } finally {
         if (notCleared())
@@ -16481,7 +16588,8 @@ var DiamondHandsSDK = class _DiamondHandsSDK {
         chainId: config.chainId,
         persistSession: config.sessionPersistence?.enabled,
         sessionStore: config.sessionPersistence?.store,
-        onSignaturePrompt: config.onSessionSignaturePrompt
+        onSignaturePrompt: config.onSessionSignaturePrompt,
+        onSignatureResolved: config.onSessionSignatureResolved
       });
     }
     const contractManagerResult = createContractManager({

package/dist/interfaces/chunks/config.i.d.ts

@@ -77,6 +77,14 @@ interface BaseSDKConfig {
      * "check your wallet" prompt.
      */
     onSessionSignaturePrompt?: () => void;
+    /**
+     * Fires once that signature request has concluded — `true` when a session was
+     * established, `false` when it failed or was rejected. Pairs with
+     * `onSessionSignaturePrompt`, which otherwise has no ending: a UI that shows
+     * "check your wallet" on the prompt has no way to stop showing it, and a
+     * contract wallet can leave that request open for minutes.
+     */
+    onSessionSignatureResolved?: (ok: boolean) => void;
     ethRpcUrl?: string;
     chainId?: number;
     networkOverride?: {

package/dist/utils/eip712-login.d.ts

@@ -31,4 +31,16 @@ export declare const LOGIN_TYPES_WITH_AUDIENCE: Record<string, TypedDataField[]>
  * Audit M-8: pass `audience` (the service endpoint URL being logged into) to bind the login to
  * one service. Omit it for legacy compatibility during the migration window.
  */
-export declare function buildSignedLoginPayload(signer: Signer, chainId: number, audience?: string): Promise<DhServerLoginPayload>;
+export declare function buildSignedLoginPayload(signer: Signer, chainId: number, audience?: string, 
+/**
+ * Reuse the envelope of a login already collecting signatures instead of
+ * minting a fresh one. Every field is hashed into the EIP-712 message, so a
+ * new nonce produces a new hash — which a multi-owner Safe shows as a new
+ * message needing its FIRST signature, discarding the ones already collected.
+ * Passing the pending envelope back reproduces the same hash, so the next
+ * owner adds to it. See `server-session-store.ts`.
+ */
+reuse?: {
+    issuedAt: number;
+    nonce: string;
+}): Promise<DhServerLoginPayload>;

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

@@ -39,18 +39,62 @@ export interface ServerSessionStore {
     load(key: string): PersistedServerSession | null;
     save(key: string, session: PersistedServerSession): void;
     clear(key: string): void;
+    /**
+     * Optional pending-envelope persistence (see `PendingLoginEnvelope`). Optional
+     * 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.
+     */
+    loadPending?(key: string): PendingLoginEnvelope | null;
+    savePending?(key: string, envelope: PendingLoginEnvelope): void;
+    clearPending?(key: string): void;
 }
 export declare function sessionStoreKey(address: string, chainId: number, endpoint: string): string;
+/**
+ * The UNSIGNED envelope of a login already collecting signatures.
+ *
+ * A multi-owner Safe signs across sessions — owner 1 now, owner 2 later — and
+ * identifies the pending message solely by its EIP-712 hash. Every field is
+ * hashed, so minting a fresh `nonce`/`issuedAt` for the next attempt yields a
+ * DIFFERENT hash, which Safe presents as a new message needing its FIRST
+ * signature. Whatever owner 1 signed is orphaned, and a 2-of-N Safe can never
+ * reach threshold: every retry resets the count to zero.
+ *
+ * Reusing the envelope makes the re-request hash identically, so Safe shows the
+ * same pending message and the next owner ADDS to it. Invisible for an EOA,
+ * which signs immediately and spends the envelope.
+ */
+export interface PendingLoginEnvelope {
+    issuedAt: number;
+    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.
+ */
+export declare const PENDING_ENVELOPE_TTL_SECONDS: number;
+/** 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;
 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;
+    savePending(key: string, envelope: PendingLoginEnvelope): void;
+    clearPending(key: string): void;
 }
 export declare class MemorySessionStore implements ServerSessionStore {
     private readonly entries;
+    private readonly pending;
     load(key: string): PersistedServerSession | null;
     save(key: string, session: PersistedServerSession): void;
     clear(key: string): void;
+    loadPending(key: string): PendingLoginEnvelope | null;
+    savePending(key: string, envelope: PendingLoginEnvelope): void;
+    clearPending(key: string): void;
 }
 /** `localStorage` when usable (browser, not blocked), else per-instance memory. */
 export declare function createDefaultSessionStore(): ServerSessionStore;

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

@@ -40,6 +40,12 @@ export interface ServerSessionOptions {
      * never on the silent paths. Lets UIs show a "check your wallet" prompt.
      */
     onSignaturePrompt?: () => void;
+    /**
+     * Fires once the prompted signature has concluded, with whether a session was
+     * established. Without it `onSignaturePrompt` has no ending, so a UI showing
+     * "check your wallet" can never take it down.
+     */
+    onSignatureResolved?: (ok: boolean) => void;
     /** Override for tests. */
     now?: () => number;
     /** Override for tests. */
@@ -56,10 +62,16 @@ export declare class ServerSession {
     private readonly chainId;
     private readonly store;
     private readonly onSignaturePrompt?;
+    private readonly onSignatureResolved?;
     private readonly now;
     private readonly fetchImpl;
     private cached;
     private inFlight;
+    /**
+     * Set when a prompted login failed; suppresses further prompts until `until`.
+     * `error` is replayed to callers so they still see the real failure reason.
+     */
+    private promptBackoff;
     /**
      * Bumped by `clearPersisted()` (logout / disconnect). An in-flight
      * `getOrRefresh()` captures this at start and refuses to write its freshly

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gvnrdao/dh-sdk",
-  "version": "0.0.308",
+  "version": "0.0.311",
   "description": "TypeScript SDK for Diamond Hands Protocol - Bitcoin-backed lending with LIT Protocol PKPs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",