@gvnrdao/dh-sdk 0.0.314 → 0.0.315

package/dist/index.js

@@ -9178,6 +9178,23 @@ function createPKPManager(config) {
 // src/modules/loan/loan-creator.module.ts
 var import_ethers11 = require("ethers");
 var import_dh_lit_actions = __toESM(require_pkg_src());
+
+// src/utils/contract-wallet.utils.ts
+var contractWalletCache = /* @__PURE__ */ new Map();
+async function isContractWallet(provider, address) {
+  const { chainId } = await provider.getNetwork();
+  const cacheKey = `${chainId}:${address.toLowerCase()}`;
+  const cached = contractWalletCache.get(cacheKey);
+  if (cached !== void 0)
+    return cached;
+  const code = await provider.getCode(address);
+  const isContract = code !== "0x";
+  contractWalletCache.set(cacheKey, isContract);
+  return isContract;
+}
+
+// src/modules/loan/loan-creator.module.ts
+var CONTRACT_WALLET_POLL_INTERVAL_MS = 4e3;
 var LoanCreator = class {
   config;
   transactionTimeoutMs;
@@ -9401,6 +9418,11 @@ var LoanCreator = class {
         validatorSignature: validatorSignature.substring(0, 20) + "..."
       });
     }
+    this.config.onPkpCreated?.({
+      tokenId: pkpData.tokenId,
+      ethAddress: pkpData.ethAddress,
+      publicKey: pkpData.publicKey
+    });
     const addressesResult = await this.deriveBitcoinAddresses(
       pkpData.publicKey
     );
@@ -9573,6 +9595,12 @@ var LoanCreator = class {
           error: encErr instanceof Error ? encErr.message : String(encErr)
         });
       }
+      const provider = this.config.contractManager.getProvider();
+      const senderIsContractWallet = await isContractWallet(
+        provider,
+        await signerResult.value.getAddress()
+      );
+      const searchFromBlock = senderIsContractWallet ? await provider.getBlockNumber() : 0;
       const tx = await positionManager.createPosition(
         pkpIdBytes32,
         validatorSignature,
@@ -9594,19 +9622,20 @@ var LoanCreator = class {
       }
       if (this.config.debug) {
         log.info("\u23F3 Waiting for transaction confirmation", {
-          hash: tx.hash
+          // For a contract wallet this is the wallet's own id, not an L1 hash — which is
+          // exactly why the confirmation below does not wait on it.
+          hash: tx.hash,
+          senderIsContractWallet,
+          searchFromBlock: senderIsContractWallet ? searchFromBlock : void 0
         });
       }
       const confirmations = await this.createPositionConfirmations();
-      const receipt = await Promise.race([
-        tx.wait(confirmations),
-        new Promise(
-          (_, reject) => setTimeout(
-            () => reject(new Error("Transaction confirmation timeout")),
-            this.transactionTimeoutMs
-          )
-        )
-      ]);
+      const receipt = senderIsContractWallet ? await this.awaitPositionCreatedByPkpId(
+        positionManager,
+        pkpIdBytes32,
+        searchFromBlock,
+        confirmations
+      ) : await this.awaitReceiptByHash(tx, confirmations);
       if (!receipt)
         throw new Error("Transaction was not mined (receipt is null)");
       if (this.config.debug && receipt.logs) {
@@ -9740,6 +9769,81 @@ var LoanCreator = class {
     }
     return 3;
   }
+  /**
+   * EOA path: the returned hash is the L1 hash, so `tx.wait` is exact.
+   *
+   * The timer is cleared on settle — an uncleared one keeps the process alive for the
+   * full timeout after a fast confirmation, which in Node holds the event loop open.
+   */
+  async awaitReceiptByHash(tx, confirmations) {
+    let timer;
+    try {
+      return await Promise.race([
+        tx.wait(confirmations),
+        new Promise((_, reject) => {
+          timer = setTimeout(
+            () => reject(new Error("Transaction confirmation timeout")),
+            this.transactionTimeoutMs
+          );
+        })
+      ]);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  }
+  /**
+   * Contract-wallet path: find this position by its `PositionCreated` log.
+   *
+   * `pkpId` is minted fresh per attempt and is the event's second indexed argument, so a
+   * topic filter on it identifies exactly this position without reference to any transaction
+   * hash. The filter deliberately leaves topic0 unconstrained: two `PositionCreated` ABIs are
+   * in circulation (see `extractPositionId`) and matching on the freshly-minted pkpId alone,
+   * scoped to this contract and to blocks at or after the send, is already unambiguous.
+   *
+   * The same confirmation depth as the EOA path is applied to the log's block, for the reason
+   * given at the call site: `positionId` does not survive a reorg unchanged.
+   */
+  async awaitPositionCreatedByPkpId(positionManager, pkpIdBytes32, fromBlock, confirmations) {
+    const provider = this.config.contractManager.getProvider();
+    const contractAddress = await positionManager.getAddress();
+    const deadline = Date.now() + this.transactionTimeoutMs;
+    while (Date.now() < deadline) {
+      const logs = await provider.getLogs({
+        address: contractAddress,
+        topics: [null, null, pkpIdBytes32],
+        fromBlock,
+        toBlock: "latest"
+      });
+      if (logs.length > 1) {
+        throw new Error(
+          `Expected at most one PositionCreated log for pkpId ${pkpIdBytes32}, found ${logs.length}`
+        );
+      }
+      const positionLog = logs[0];
+      if (positionLog) {
+        const head = await provider.getBlockNumber();
+        const depth = head - positionLog.blockNumber + 1;
+        if (depth >= confirmations) {
+          const receipt = await provider.getTransactionReceipt(
+            positionLog.transactionHash
+          );
+          if (!receipt) {
+            throw new Error(
+              `PositionCreated log for pkpId ${pkpIdBytes32} has no receipt at ${positionLog.transactionHash} \u2014 the block was reorged out mid-confirmation.`
+            );
+          }
+          return receipt;
+        }
+      }
+      await new Promise(
+        (resolve) => setTimeout(resolve, CONTRACT_WALLET_POLL_INTERVAL_MS)
+      );
+    }
+    throw new Error(
+      `Timed out after ${this.transactionTimeoutMs}ms waiting for the PositionCreated log for pkpId ${pkpIdBytes32}. The wallet may not have executed the transaction yet; the position must be rediscovered by pkpId before it is used.`
+    );
+  }
   /**
    * Re-read the receipt after confirmations and re-derive `positionId`, so a reorg
    * cannot leave the caller holding an id that never survived to the canonical chain.
@@ -18772,7 +18876,8 @@ var DiamondHandsSDK = class _DiamondHandsSDK {
       litNetwork: config.litNetwork,
       loanCreationValidatorVersion: config.validators?.loanCreation ?? 1,
       ethRpcUrl: config.ethRpcUrl,
-      temperSignaturesTest: config.temperSignaturesTest
+      temperSignaturesTest: config.temperSignaturesTest,
+      onPkpCreated: config.onPkpCreated
     });
     if (!loanCreatorResult.success) {
       throw new Error(

package/dist/index.mjs

@@ -9099,6 +9099,23 @@ function createPKPManager(config) {
 // src/modules/loan/loan-creator.module.ts
 import { Contract as Contract3, Interface as Interface2, zeroPadValue as zeroPadValue4, toBeHex, SigningKey } from "ethers";
 var import_dh_lit_actions = __toESM(require_pkg_src());
+
+// src/utils/contract-wallet.utils.ts
+var contractWalletCache = /* @__PURE__ */ new Map();
+async function isContractWallet(provider, address) {
+  const { chainId } = await provider.getNetwork();
+  const cacheKey = `${chainId}:${address.toLowerCase()}`;
+  const cached = contractWalletCache.get(cacheKey);
+  if (cached !== void 0)
+    return cached;
+  const code = await provider.getCode(address);
+  const isContract = code !== "0x";
+  contractWalletCache.set(cacheKey, isContract);
+  return isContract;
+}
+
+// src/modules/loan/loan-creator.module.ts
+var CONTRACT_WALLET_POLL_INTERVAL_MS = 4e3;
 var LoanCreator = class {
   config;
   transactionTimeoutMs;
@@ -9322,6 +9339,11 @@ var LoanCreator = class {
         validatorSignature: validatorSignature.substring(0, 20) + "..."
       });
     }
+    this.config.onPkpCreated?.({
+      tokenId: pkpData.tokenId,
+      ethAddress: pkpData.ethAddress,
+      publicKey: pkpData.publicKey
+    });
     const addressesResult = await this.deriveBitcoinAddresses(
       pkpData.publicKey
     );
@@ -9494,6 +9516,12 @@ var LoanCreator = class {
           error: encErr instanceof Error ? encErr.message : String(encErr)
         });
       }
+      const provider = this.config.contractManager.getProvider();
+      const senderIsContractWallet = await isContractWallet(
+        provider,
+        await signerResult.value.getAddress()
+      );
+      const searchFromBlock = senderIsContractWallet ? await provider.getBlockNumber() : 0;
       const tx = await positionManager.createPosition(
         pkpIdBytes32,
         validatorSignature,
@@ -9515,19 +9543,20 @@ var LoanCreator = class {
       }
       if (this.config.debug) {
         log.info("\u23F3 Waiting for transaction confirmation", {
-          hash: tx.hash
+          // For a contract wallet this is the wallet's own id, not an L1 hash — which is
+          // exactly why the confirmation below does not wait on it.
+          hash: tx.hash,
+          senderIsContractWallet,
+          searchFromBlock: senderIsContractWallet ? searchFromBlock : void 0
         });
       }
       const confirmations = await this.createPositionConfirmations();
-      const receipt = await Promise.race([
-        tx.wait(confirmations),
-        new Promise(
-          (_, reject) => setTimeout(
-            () => reject(new Error("Transaction confirmation timeout")),
-            this.transactionTimeoutMs
-          )
-        )
-      ]);
+      const receipt = senderIsContractWallet ? await this.awaitPositionCreatedByPkpId(
+        positionManager,
+        pkpIdBytes32,
+        searchFromBlock,
+        confirmations
+      ) : await this.awaitReceiptByHash(tx, confirmations);
       if (!receipt)
         throw new Error("Transaction was not mined (receipt is null)");
       if (this.config.debug && receipt.logs) {
@@ -9661,6 +9690,81 @@ var LoanCreator = class {
     }
     return 3;
   }
+  /**
+   * EOA path: the returned hash is the L1 hash, so `tx.wait` is exact.
+   *
+   * The timer is cleared on settle — an uncleared one keeps the process alive for the
+   * full timeout after a fast confirmation, which in Node holds the event loop open.
+   */
+  async awaitReceiptByHash(tx, confirmations) {
+    let timer;
+    try {
+      return await Promise.race([
+        tx.wait(confirmations),
+        new Promise((_, reject) => {
+          timer = setTimeout(
+            () => reject(new Error("Transaction confirmation timeout")),
+            this.transactionTimeoutMs
+          );
+        })
+      ]);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  }
+  /**
+   * Contract-wallet path: find this position by its `PositionCreated` log.
+   *
+   * `pkpId` is minted fresh per attempt and is the event's second indexed argument, so a
+   * topic filter on it identifies exactly this position without reference to any transaction
+   * hash. The filter deliberately leaves topic0 unconstrained: two `PositionCreated` ABIs are
+   * in circulation (see `extractPositionId`) and matching on the freshly-minted pkpId alone,
+   * scoped to this contract and to blocks at or after the send, is already unambiguous.
+   *
+   * The same confirmation depth as the EOA path is applied to the log's block, for the reason
+   * given at the call site: `positionId` does not survive a reorg unchanged.
+   */
+  async awaitPositionCreatedByPkpId(positionManager, pkpIdBytes32, fromBlock, confirmations) {
+    const provider = this.config.contractManager.getProvider();
+    const contractAddress = await positionManager.getAddress();
+    const deadline = Date.now() + this.transactionTimeoutMs;
+    while (Date.now() < deadline) {
+      const logs = await provider.getLogs({
+        address: contractAddress,
+        topics: [null, null, pkpIdBytes32],
+        fromBlock,
+        toBlock: "latest"
+      });
+      if (logs.length > 1) {
+        throw new Error(
+          `Expected at most one PositionCreated log for pkpId ${pkpIdBytes32}, found ${logs.length}`
+        );
+      }
+      const positionLog = logs[0];
+      if (positionLog) {
+        const head = await provider.getBlockNumber();
+        const depth = head - positionLog.blockNumber + 1;
+        if (depth >= confirmations) {
+          const receipt = await provider.getTransactionReceipt(
+            positionLog.transactionHash
+          );
+          if (!receipt) {
+            throw new Error(
+              `PositionCreated log for pkpId ${pkpIdBytes32} has no receipt at ${positionLog.transactionHash} \u2014 the block was reorged out mid-confirmation.`
+            );
+          }
+          return receipt;
+        }
+      }
+      await new Promise(
+        (resolve) => setTimeout(resolve, CONTRACT_WALLET_POLL_INTERVAL_MS)
+      );
+    }
+    throw new Error(
+      `Timed out after ${this.transactionTimeoutMs}ms waiting for the PositionCreated log for pkpId ${pkpIdBytes32}. The wallet may not have executed the transaction yet; the position must be rediscovered by pkpId before it is used.`
+    );
+  }
   /**
    * Re-read the receipt after confirmations and re-derive `positionId`, so a reorg
    * cannot leave the caller holding an id that never survived to the canonical chain.
@@ -18701,7 +18805,8 @@ var DiamondHandsSDK = class _DiamondHandsSDK {
       litNetwork: config.litNetwork,
       loanCreationValidatorVersion: config.validators?.loanCreation ?? 1,
       ethRpcUrl: config.ethRpcUrl,
-      temperSignaturesTest: config.temperSignaturesTest
+      temperSignaturesTest: config.temperSignaturesTest,
+      onPkpCreated: config.onPkpCreated
     });
     if (!loanCreatorResult.success) {
       throw new Error(

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

@@ -102,6 +102,24 @@ interface BaseSDKConfig {
      * contract wallet can leave that request open for minutes.
      */
     onSessionSignatureResolved?: (ok: boolean) => void;
+    /**
+     * Fires during loan creation the moment the PKP has been minted and validated,
+     * before the `createPosition` transaction is submitted.
+     *
+     * The PKP is minted fresh per attempt, so `tokenId` is a unique, send-independent
+     * handle on the position that transaction is about to create — it is the only
+     * identifier a caller can hold *before* a hash exists. UIs use it to recognise
+     * their own position in an indexed feed without depending on the transaction
+     * hash, which a contract wallet does not return in a usable form.
+     *
+     * Note `tokenId` is a decimal string; the on-chain and subgraph `pkpId` is the
+     * same value as 32-byte hex. Normalise before comparing.
+     */
+    onPkpCreated?: (pkp: {
+        tokenId: string;
+        ethAddress: string;
+        publicKey: string;
+    }) => void;
     ethRpcUrl?: string;
     chainId?: number;
     networkOverride?: {

package/dist/modules/loan/loan-creator.module.d.ts

@@ -61,6 +61,15 @@ export interface LoanCreatorConfig {
     ethRpcUrl?: string;
     /** Security testing: Temper signatures to test contract validation */
     temperSignaturesTest?: boolean;
+    /**
+     * Fires once the PKP is minted and validated, before `createPosition` is submitted.
+     * See `SDKConfig.onPkpCreated` for why this exists and for the tokenId encoding caveat.
+     */
+    onPkpCreated?: (pkp: {
+        tokenId: string;
+        ethAddress: string;
+        publicKey: string;
+    }) => void;
 }
 /**
  * Loan creation audit trail
@@ -133,6 +142,26 @@ export declare class LoanCreator {
      * Override with `createPositionConfirmations` when a chain needs more.
      */
     private createPositionConfirmations;
+    /**
+     * EOA path: the returned hash is the L1 hash, so `tx.wait` is exact.
+     *
+     * The timer is cleared on settle — an uncleared one keeps the process alive for the
+     * full timeout after a fast confirmation, which in Node holds the event loop open.
+     */
+    private awaitReceiptByHash;
+    /**
+     * Contract-wallet path: find this position by its `PositionCreated` log.
+     *
+     * `pkpId` is minted fresh per attempt and is the event's second indexed argument, so a
+     * topic filter on it identifies exactly this position without reference to any transaction
+     * hash. The filter deliberately leaves topic0 unconstrained: two `PositionCreated` ABIs are
+     * in circulation (see `extractPositionId`) and matching on the freshly-minted pkpId alone,
+     * scoped to this contract and to blocks at or after the send, is already unambiguous.
+     *
+     * The same confirmation depth as the EOA path is applied to the log's block, for the reason
+     * given at the call site: `positionId` does not survive a reorg unchanged.
+     */
+    private awaitPositionCreatedByPkpId;
     /**
      * Re-read the receipt after confirmations and re-derive `positionId`, so a reorg
      * cannot leave the caller holding an id that never survived to the canonical chain.

package/dist/utils/contract-wallet.utils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Contract-wallet detection.
+ *
+ * A Safe (or any smart-account) returns its OWN transaction identifier from
+ * `eth_sendTransaction` — the safeTxHash — not an L1 transaction hash. Anything that
+ * waits on that identifier waits forever, because it never lands on chain. Callers
+ * that need to confirm a transaction must therefore know which kind of sender they
+ * are dealing with and confirm by some other means.
+ *
+ * Contract-ness is settled by asking the chain for code at the address, which is the
+ * same test the servers use for the EIP-1271 path — not the wallet name, which is
+ * whatever the connector chose to call itself.
+ */
+import type { Provider } from "ethers";
+/**
+ * True when `address` has code on the chain behind `provider`.
+ *
+ * Deliberately propagates provider errors rather than assuming EOA: a failed `getCode`
+ * means the provider is unreachable, and guessing "EOA" there would send the caller
+ * back into a wait that cannot complete.
+ */
+export declare function isContractWallet(provider: Provider, address: string): Promise<boolean>;
+/** Test seam — clears memoised detections. */
+export declare function resetContractWalletCache(): void;

package/package.json

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