@gvnrdao/dh-sdk 0.0.305 → 0.0.307

package/dist/index.mjs

@@ -577,45 +577,47 @@ var init_deployment_addresses = __esm({
     };
     LOCALHOST_DEPLOYMENT = {
       network: "localhost",
-      chainId: 31337,
-      timestamp: "2026-06-11T12:30:59.589Z",
+      chainId: 1337,
+      timestamp: "2026-07-20T19:45:58.514Z",
       deployer: "",
       contracts: {
-        MessageHashBuilder: "0x1613beB3B2C4f22Ee086B2b38C1476A3cE7f78E8",
-        UpgradeValidator: "0x610178dA211FEF7D417bC0e6FeD39F05609AD788",
+        MessageHashBuilder: "0xa82fF9aFd8f496c3d6ac40E2a0F282E47488CFc9",
+        LITActionValidator: "0xa513E6E4b8f2a923D98304ec87F64353C4D5C853",
+        UpgradeValidator: "0x8A791620dd6260079BF849Dc5567aDC3F2FdC318",
         UCDToken: "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
         UCDController: "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9",
-        PositionManagerCoreModule: "0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0",
-        TermManagerModule: "0x9A676e781A523b5d0C0e43731313A708CB607508",
-        LoanOperationsManagerModule: "0x3Aa5ebB10DC797CAC828524e59A333d0A371443c",
-        BTCSpendAuthorizer: "0x59b670e9fA9D0A427751Af201D676719a970857b",
-        CollateralManagerModule: "0xa85233C63b9Ee964Add6F2cffe00Fd84eb32338f",
-        LiquidationManagerModule: "0x7a2088a1bFc9d81c55368AE168C2C02570cB814F",
-        CircuitBreakerModule: "0x959922bE3CAee4b8Cd9a407cc3ac1C251C2007B1",
-        AdminModule: "0xc5a5C42992dECbae36851359345FE25997F5C42d",
-        PositionManagerViews: "0x9A9f2CCfdE556A7E9Ff0848998Aa4a0CFD8863AE",
-        PositionManager: "0xf5059a5D33d5853360D16C683c16e67980206f36",
-        OperationAuthorizationRegistry: "0xF8e31cb472bc70500f08Cd84917E5A1912Ec8397",
-        PKPValidation: "0xc0F115A19107322cFBf1cDBC7ea011C19EbDB4F8"
+        PositionManagerCoreModule: "0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e",
+        TermManagerModule: "0x0DCd1Bf9A1b36cE34237eEaFef220932846BCD82",
+        LoanOperationsManagerModule: "0x68B1D87F95878fE05B998F19b66F4baba5De1aed",
+        BTCSpendAuthorizer: "0xc6e7DF5E7b4f2A278906862b61205850344D4e7d",
+        CollateralManagerModule: "0x322813Fd9A801c5507c9de605d63CEA4f2CE6c44",
+        LiquidationManagerModule: "0x4A679253410272dd5232B3Ff7cF5dbB88f295319",
+        CircuitBreakerModule: "0x0B306BF915C4d645ff596e518fAf3F9669b97016",
+        AdminModule: "0x09635F643e140090A9A8Dcd712eD6285858ceBef",
+        PositionManagerViews: "0x959922bE3CAee4b8Cd9a407cc3ac1C251C2007B1",
+        PositionManager: "0x851356ae760d987E095750cCeb3bC6014560891C",
+        OperationAuthorizationRegistry: "0xc96304e3c037f81dA488ed9dEa1D8F2a48278a75",
+        PKPValidation: "0xD0141E899a65C95a556fE2B27e5982A6DE7fDD7A"
       }
     };
     LOCALHOST_CONTRACTS = {
-      MessageHashBuilder: "0x1613beB3B2C4f22Ee086B2b38C1476A3cE7f78E8",
-      UpgradeValidator: "0x610178dA211FEF7D417bC0e6FeD39F05609AD788",
+      MessageHashBuilder: "0xa82fF9aFd8f496c3d6ac40E2a0F282E47488CFc9",
+      LITActionValidator: "0xa513E6E4b8f2a923D98304ec87F64353C4D5C853",
+      UpgradeValidator: "0x8A791620dd6260079BF849Dc5567aDC3F2FdC318",
       UCDToken: "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
       UCDController: "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9",
-      PositionManagerCoreModule: "0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0",
-      TermManagerModule: "0x9A676e781A523b5d0C0e43731313A708CB607508",
-      LoanOperationsManagerModule: "0x3Aa5ebB10DC797CAC828524e59A333d0A371443c",
-      BTCSpendAuthorizer: "0x59b670e9fA9D0A427751Af201D676719a970857b",
-      CollateralManagerModule: "0xa85233C63b9Ee964Add6F2cffe00Fd84eb32338f",
-      LiquidationManagerModule: "0x7a2088a1bFc9d81c55368AE168C2C02570cB814F",
-      CircuitBreakerModule: "0x959922bE3CAee4b8Cd9a407cc3ac1C251C2007B1",
-      AdminModule: "0xc5a5C42992dECbae36851359345FE25997F5C42d",
-      PositionManagerViews: "0x9A9f2CCfdE556A7E9Ff0848998Aa4a0CFD8863AE",
-      PositionManager: "0xf5059a5D33d5853360D16C683c16e67980206f36",
-      OperationAuthorizationRegistry: "0xF8e31cb472bc70500f08Cd84917E5A1912Ec8397",
-      PKPValidation: "0xc0F115A19107322cFBf1cDBC7ea011C19EbDB4F8"
+      PositionManagerCoreModule: "0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e",
+      TermManagerModule: "0x0DCd1Bf9A1b36cE34237eEaFef220932846BCD82",
+      LoanOperationsManagerModule: "0x68B1D87F95878fE05B998F19b66F4baba5De1aed",
+      BTCSpendAuthorizer: "0xc6e7DF5E7b4f2A278906862b61205850344D4e7d",
+      CollateralManagerModule: "0x322813Fd9A801c5507c9de605d63CEA4f2CE6c44",
+      LiquidationManagerModule: "0x4A679253410272dd5232B3Ff7cF5dbB88f295319",
+      CircuitBreakerModule: "0x0B306BF915C4d645ff596e518fAf3F9669b97016",
+      AdminModule: "0x09635F643e140090A9A8Dcd712eD6285858ceBef",
+      PositionManagerViews: "0x959922bE3CAee4b8Cd9a407cc3ac1C251C2007B1",
+      PositionManager: "0x851356ae760d987E095750cCeb3bC6014560891C",
+      OperationAuthorizationRegistry: "0xc96304e3c037f81dA488ed9dEa1D8F2a48278a75",
+      PKPValidation: "0xD0141E899a65C95a556fE2B27e5982A6DE7fDD7A"
     };
     ALL_DEPLOYMENTS = {
       sepolia: SEPOLIA_DEPLOYMENT,
@@ -5534,7 +5536,12 @@ var init_network_configs = __esm({
     NETWORK_CONFIGS = {
       1: getMainnetConfig(),
       11155111: getSepoliaConfig(),
-      1337: getLocalhostConfig()
+      1337: getLocalhostConfig(),
+      // In-process hardhat default chainId — same localhost deployment as 1337
+      // (`npx hardhat node`), so consumers on either local chain resolve config.
+      // chainId overridden so the resolved config self-describes the chain that
+      // was actually looked up (downstream bind/log/validate reads it).
+      31337: { ...getLocalhostConfig(), chainId: 31337 }
     };
     DEFAULT_NETWORK_CONFIG = {
       /** Fallback when chain is unknown — production Chipotle. */
@@ -6874,12 +6881,20 @@ async function assertSafeQuantumSubmission(opts) {
     ...opts.sleep ? { sleep: opts.sleep } : {}
   };
   await awaitSafeSubmissionWindow(quantumTimestamp, gateOpts);
+  const SAME_BLOCK_INTERACTION_SELECTOR = "0x3b53d1db";
+  const laneGuardActive = opts.laneGuardActive === true;
   for (let sim = 1; ; sim++) {
     try {
       await provider.call({ to, from, data });
       break;
     } catch (simError) {
       const decoded = decodeQuantumRevert(simError);
+      if (laneGuardActive && decoded.selector === SAME_BLOCK_INTERACTION_SELECTOR) {
+        onDebug(
+          "\u21AA\uFE0F  [lane-only] Simulated SameBlockInteraction is a stale-latest-block artifact (the simulated block contains this flow's own previous tx) \u2014 proceeding to broadcast; the on-chain guard stays authoritative"
+        );
+        break;
+      }
       if (decoded.selector === DEAD_ZONE_VIOLATION_SELECTOR && sim <= maxResimulations) {
         const sigQuantum = Math.floor(quantumTimestamp / QUANTUM_WINDOW_SECONDS) * QUANTUM_WINDOW_SECONDS;
         const realCurrentQuantum = Math.floor(now() / QUANTUM_WINDOW_SECONDS) * QUANTUM_WINDOW_SECONDS;
@@ -6915,6 +6930,144 @@ async function assertSafeQuantumSubmission(opts) {
   await awaitSafeSubmissionWindow(quantumTimestamp, gateOpts);
 }
 
+// src/utils/lane-guard.utils.ts
+var HARDHAT_CHAIN_IDS = /* @__PURE__ */ new Set([1337, 31337]);
+function laneGuardEnvEnabled() {
+  return typeof process !== "undefined" && process.env?.LIT_LANE_GUARD === "1";
+}
+async function isLaneGuardActiveOnProvider(provider) {
+  if (!laneGuardEnvEnabled())
+    return false;
+  if (!provider || typeof provider.send !== "function")
+    return false;
+  try {
+    const [chainIdHex, clientVersion] = await Promise.all([
+      provider.send("eth_chainId", []),
+      provider.send("web3_clientVersion", [])
+    ]);
+    const chainId = Number(chainIdHex);
+    return HARDHAT_CHAIN_IDS.has(chainId) && typeof clientVersion === "string" && clientVersion.toLowerCase().includes("hardhat");
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/withdrawal-reconciliation.utils.ts
+var defaultHttpGetJson = async (url) => {
+  const res = await fetch(url, { headers: { accept: "application/json" } });
+  let body = null;
+  try {
+    body = await res.json();
+  } catch {
+    body = null;
+  }
+  return { status: res.status, body };
+};
+async function reconcileAuthorizedSpend(spend, esploraBaseUrl, httpGetJson = defaultHttpGetJson) {
+  const base = esploraBaseUrl.replace(/\/+$/, "");
+  const fundingRes = await httpGetJson(`${base}/tx/${spend.txid}`);
+  if (fundingRes.status === 404) {
+    return {
+      spend,
+      status: "UNFUNDED",
+      reason: `Funding tx ${spend.txid} not found on the network`
+    };
+  }
+  if (fundingRes.status !== 200) {
+    throw new Error(
+      `Withdrawal reconciliation: esplora /tx/${spend.txid} returned HTTP ${fundingRes.status}`
+    );
+  }
+  const funding = fundingRes.body;
+  if (!funding?.status?.confirmed) {
+    return {
+      spend,
+      status: "UNFUNDED",
+      reason: `Funding tx ${spend.txid} is not confirmed yet`
+    };
+  }
+  const output = funding.vout?.[spend.vout];
+  if (!output || typeof output.value !== "number") {
+    return {
+      spend,
+      status: "CORRUPT",
+      reason: `Authorized vout ${spend.vout} does not exist on tx ${spend.txid} (${funding.vout?.length ?? 0} outputs)`
+    };
+  }
+  const onChainOutputValue = output.value;
+  if (onChainOutputValue !== spend.satoshis) {
+    return {
+      spend,
+      status: "CORRUPT",
+      onChainOutputValue,
+      reason: `Authorization declares ${spend.satoshis} sats for ${spend.txid}:${spend.vout} but the on-chain output is ${onChainOutputValue} sats`
+    };
+  }
+  if (spend.targetAmount > onChainOutputValue) {
+    return {
+      spend,
+      status: "CORRUPT",
+      onChainOutputValue,
+      reason: `Authorized targetAmount ${spend.targetAmount} sats exceeds the ${onChainOutputValue}-sat output it is authorized against`
+    };
+  }
+  const outspendRes = await httpGetJson(
+    `${base}/tx/${spend.txid}/outspend/${spend.vout}`
+  );
+  if (outspendRes.status !== 200) {
+    throw new Error(
+      `Withdrawal reconciliation: esplora outspend for ${spend.txid}:${spend.vout} returned HTTP ${outspendRes.status}`
+    );
+  }
+  const outspend = outspendRes.body;
+  if (outspend?.spent) {
+    const spendingTxid = typeof outspend.txid === "string" && outspend.txid ? outspend.txid : null;
+    if (spendingTxid) {
+      const spendingRes = await httpGetJson(`${base}/tx/${spendingTxid}`);
+      if (spendingRes.status === 200) {
+        const spendingTx = spendingRes.body;
+        const includesOutpoint = (spendingTx.vin ?? []).some(
+          (v) => v.txid === spend.txid && Number(v.vout) === spend.vout
+        );
+        if (includesOutpoint) {
+          const paidToTargetSats = (spendingTx.vout ?? []).filter(
+            (o) => (o.scriptpubkey_address ?? "").toLowerCase() === spend.targetAddress.toLowerCase()
+          ).reduce((sum, o) => sum + (o.value ?? 0), 0);
+          if (paidToTargetSats > 0) {
+            return {
+              spend,
+              status: "EXECUTED",
+              spendingTxid,
+              paidToTargetSats,
+              onChainOutputValue,
+              reason: `Outpoint spent by ${spendingTxid}, paying ${paidToTargetSats} sats to the authorized target \u2014 withdrawal complete`
+            };
+          }
+          return {
+            spend,
+            status: "SPENT_MISMATCH",
+            spendingTxid,
+            onChainOutputValue,
+            reason: `Outpoint spent by ${spendingTxid} which pays the authorized target nothing \u2014 authorization is unexecutable`
+          };
+        }
+      }
+    }
+    return {
+      spend,
+      status: "EXECUTABLE",
+      onChainOutputValue,
+      reason: "Esplora claims the outpoint is spent but no spending tx provably includes it (known regtest-faucet artifact) \u2014 treated as unspent"
+    };
+  }
+  return {
+    spend,
+    status: "EXECUTABLE",
+    onChainOutputValue,
+    reason: "Outpoint confirmed, unspent, and coherent with the authorization"
+  };
+}
+
 // src/utils/btc-withdrawal-message.ts
 import { keccak256 as keccak2563, toUtf8Bytes as toUtf8Bytes3, solidityPackedKeccak256 as solidityPackedKeccak2563, getBytes as getBytes3, zeroPadValue } from "ethers";
 var QUANTUM_SECONDS = 60;
@@ -15776,7 +15929,7 @@ function createMockTokenManager(config) {
 
 // src/modules/diamond-hands-sdk.ts
 var import_dh_lit_actions2 = __toESM(require_pkg_src());
-import { LitOps } from "@gvnrdao/dh-lit-ops";
+import { LitOps, broadcastSignedBitcoinTransaction } from "@gvnrdao/dh-lit-ops";
 
 // src/utils/telegram-messaging.utils.ts
 var TelegramBot = null;
@@ -16261,6 +16414,10 @@ var DiamondHandsSDK = class _DiamondHandsSDK {
     this.litOps = new LitOps({
       mode: config.mode || "standalone",
       network: config.litNetwork || DEFAULT_LIT_NETWORK,
+      // Completes the module's chainId resolution chain (jsParams shapes →
+      // config.chainId) — e.g. the lane validator-override chain binding
+      // reads it when a jsParams shape lacks chainId.
+      chainId: config.chainId,
       signer: config.mode === "standalone" ? config.litOpsSigner : void 0,
       serviceEndpoint: isServiceModeConfig(config) ? config.serviceEndpoint : void 0,
       // Hand lit-ops a session-aware auth getter so every request it makes
@@ -16938,6 +17095,19 @@ var DiamondHandsSDK = class _DiamondHandsSDK {
       }
       const MAX_FULL_RETRIES = 3;
       for (let fullRetry = 1; fullRetry <= MAX_FULL_RETRIES; fullRetry++) {
+        if (await this.isLocalLaneGuardActive()) {
+          const phase = Math.floor(Date.now() / 1e3) % 60;
+          if (phase > 30) {
+            const waitMs = (60 - phase + 1) * 1e3;
+            if (this.config.debug) {
+              log.info(
+                `\u23F3 Quantum-phase alignment (lane-only): ${phase}s into the quantum \u2014 waiting ${Math.ceil(waitMs / 1e3)}s for the next boundary before authorization`,
+                {}
+              );
+            }
+            await new Promise((resolve) => setTimeout(resolve, waitMs));
+          }
+        }
         if (fullRetry > 1 && this.config.debug) {
           log.info(
             `\u{1F504} Full mint retry ${fullRetry}/${MAX_FULL_RETRIES} due to timestamp staleness...`,
@@ -17686,6 +17856,7 @@ var DiamondHandsSDK = class _DiamondHandsSDK {
           from: fromAddress,
           data: mintCalldata,
           quantumTimestamp: Number(validationResponse.timestamp),
+          laneGuardActive: await this.isLocalLaneGuardActive(),
           onDebug: this.config.debug ? (msg) => log.info(msg, {}) : void 0
         });
       } catch (simError) {
@@ -18981,6 +19152,7 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
         from: await extendSigner.getAddress(),
         data: extendCalldata,
         quantumTimestamp: Number(quantumTimestamp),
+        laneGuardActive: await this.isLocalLaneGuardActive(),
         onDebug: this.config.debug ? (msg) => log.info(msg, {}) : void 0
       });
     } catch (simError) {
@@ -19881,6 +20053,7 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
           from: paymentFrom,
           data: paymentCalldata,
           quantumTimestamp: Number(quantumTimestamp),
+          laneGuardActive: await this.isLocalLaneGuardActive(),
           onDebug: this.config.debug ? (msg) => log.info(msg, {}) : void 0
         });
       } catch (simError) {
@@ -20620,6 +20793,7 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
           from: await withdrawSigner.getAddress(),
           data: withdrawCalldata,
           quantumTimestamp: Number(withdrawalParams.quantumTimestamp),
+          laneGuardActive: await this.isLocalLaneGuardActive(),
           onDebug: this.config.debug ? (msg) => log.info(msg, {}) : void 0
         });
         tx = await sendEip1559Transaction({
@@ -20774,15 +20948,180 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
    * @param request - Execution request with positionId, utxoIdentifier, and networkFee
    * @returns Execution result with Bitcoin txid
    */
-  async executeBTCWithdrawal(request) {
-    this.ensureInitialized();
-    if (this.config.mode !== "service") {
+  /**
+   * STANDALONE Phase 2: sign + broadcast the withdrawal Bitcoin transaction
+   * in-process — the same orchestration lit-ops-server performs, composed
+   * from the same primitives (`litOps.signBTCTransaction`, which has always
+   * had a standalone path, and `broadcastSignedBitcoinTransaction`).
+   * Both modes must support withdrawal execution (Master mandate 2026-07-21).
+   *
+   * The service path's post-broadcast CRIT-2 re-verification exists to catch
+   * a LYING SERVER; here the broadcast happens locally from the signatures we
+   * just obtained, so the esplora-returned txid is already first-hand.
+   */
+  async executeBTCWithdrawalStandalonePhase2(request, envelope, txid, vout, chainId) {
+    const positionDetails = await this.getPositionDetailsView(
+      request.positionId
+    );
+    if (!positionDetails) {
+      return { success: false, error: `Position ${request.positionId} not found` };
+    }
+    const pkpId = positionDetails.pkpId;
+    const vaultAddress = positionDetails.vaultAddress;
+    if (!pkpId || pkpId === ZeroHash) {
+      return { success: false, error: "Position has no PKP" };
+    }
+    if (!vaultAddress) {
+      return { success: false, error: "Position has no vault address" };
+    }
+    const pkpCache = this.cacheManager.getCache("pkp-data", {
+      maxSize: 500,
+      ttlMs: 24 * 60 * 60 * 1e3
+    });
+    let publicKey = pkpCache.get(request.positionId)?.publicKey;
+    if (!publicKey) {
+      const derived = await this.litOps.deriveDiamondHandsLoanPkpPublicKey({
+        pkpId
+      });
+      publicKey = derived.publicKey;
+    }
+    if (!publicKey) {
+      return { success: false, error: "Failed to resolve PKP public key" };
+    }
+    const chipotlePkpAddress = computeAddress(publicKey);
+    const STANDALONE_CHAIN_NAMES = {
+      1: "ethereum",
+      11155111: "sepolia",
+      1337: "hardhat",
+      31337: "hardhat"
+    };
+    const chainName = STANDALONE_CHAIN_NAMES[chainId];
+    if (!chainName) {
       return {
         success: false,
-        error: "BTC withdrawal Phase 2 requires service mode. Set sdkConfig.mode = 'service' and serviceEndpoint to a lit-ops-server."
+        error: `Unsupported chainId ${chainId} for standalone BTC withdrawal (supported: 1, 11155111, 1337, 31337)`
       };
     }
-    if (!this.config.serviceEndpoint) {
+    const bitcoinNetworkName = chainId === 1 ? "mainnet" : "regtest";
+    const bitcoin = await import("bitcoinjs-lib");
+    const bitcoinNetwork = chainId === 1 ? bitcoin.networks.bitcoin : chainId === 1337 || chainId === 31337 ? bitcoin.networks.regtest : bitcoin.networks.testnet;
+    let scriptPubKeyBuffer;
+    if (vaultAddress.startsWith("bcrt1q")) {
+      const bech322 = await import("bech32");
+      const decoded = bech322.bech32.decode(vaultAddress);
+      const witnessProgram = Buffer.from(
+        bech322.bech32.fromWords(decoded.words.slice(1))
+      );
+      if (witnessProgram.length !== 20) {
+        return {
+          success: false,
+          error: `Vault address ${vaultAddress} decodes to a ${witnessProgram.length}-byte witness program \u2014 expected 20-byte P2WPKH`
+        };
+      }
+      scriptPubKeyBuffer = Buffer.concat([
+        Buffer.from([0, witnessProgram.length]),
+        witnessProgram
+      ]);
+    } else {
+      scriptPubKeyBuffer = bitcoin.address.toOutputScript(
+        vaultAddress,
+        bitcoinNetwork
+      );
+    }
+    const scriptPubKey = scriptPubKeyBuffer.toString("hex");
+    const executionUtxos = (envelope.utxos && envelope.utxos.length ? envelope.utxos : [{ txid, vout, value: request.utxoSatoshis }]).map((u) => ({ ...u, scriptPubKey }));
+    const dc = this.config.contractAddresses || {};
+    const signerContractAddresses = {
+      LoanOperationsManagerModule: dc.loanOperationsManager ?? "",
+      PositionManager: dc.positionManager ?? "",
+      BTCSpendAuthorizer: dc.btcSpendAuthorizer ?? "",
+      PositionDelegateRegistry: dc.positionDelegateRegistry ?? "",
+      OperationAuthorizationRegistry: dc.operationAuthorizationRegistry ?? "",
+      ...dc.bitcoinProviderRegistry ? { BitcoinProviderRegistry: dc.bitcoinProviderRegistry } : {}
+    };
+    const signResult = await this.litOps.signBTCTransaction({
+      auth: {
+        positionId: envelope.positionId,
+        utxo: { txid, vout, value: request.utxoSatoshis, scriptPubKey },
+        utxos: executionUtxos,
+        networkFee: envelope.networkFee,
+        targetAddress: envelope.targetAddress,
+        targetAmount: envelope.targetAmount,
+        timestamp: envelope.timestamp,
+        signature: envelope.userSignature,
+        chainId
+      },
+      publicKey,
+      pkpId: chipotlePkpAddress,
+      chain: chainName,
+      bitcoinNetwork: bitcoinNetworkName,
+      rpcUrl: this.config.ethRpcUrl,
+      contractAddresses: signerContractAddresses
+    });
+    if (!signResult.success) {
+      return {
+        success: false,
+        error: signResult.error ?? "BTC transaction signing failed"
+      };
+    }
+    if (!signResult.unsignedTxHex || !signResult.signatures?.length) {
+      return {
+        success: false,
+        error: "BTC signing returned incomplete data (missing unsignedTxHex/signatures)"
+      };
+    }
+    if (!signResult.userReceivesAmount) {
+      return { success: false, error: "BTC signing did not return userReceivesAmount" };
+    }
+    const broadcastUrl = this.config.bitcoinProviders?.[0]?.url;
+    if (!broadcastUrl) {
+      return {
+        success: false,
+        error: "Standalone Phase 2 broadcast requires config.bitcoinProviders[0].url (esplora base)"
+      };
+    }
+    try {
+      const { txid: btcTxid } = await broadcastSignedBitcoinTransaction({
+        signatures: signResult.signatures,
+        utxos: executionUtxos,
+        pkpPublicKey: signResult.pkpPublicKey ?? publicKey,
+        destination: envelope.targetAddress,
+        userReceivesAmount: signResult.userReceivesAmount,
+        changeAmount: signResult.changeAmount,
+        pkpBtcAddress: signResult.pkpBtcAddress,
+        bitcoinNetwork: bitcoinNetworkName,
+        bitcoinRpcUrl: broadcastUrl,
+        ...this.config.debug ? {
+          debug: (level, msg, data) => {
+            if (level === "warn")
+              log.warn(msg, { data });
+            else if (level === "error")
+              log.error(msg, { data });
+            else
+              log.info(msg, { data });
+          }
+        } : {}
+      });
+      if (this.config.debug) {
+        log.info("\u2705 Standalone Phase 2 broadcast successful", { txid: btcTxid });
+      }
+      return {
+        success: true,
+        txid: btcTxid,
+        amountSent: signResult.userReceivesAmount,
+        networkFee: signResult.networkFee,
+        destination: envelope.targetAddress
+      };
+    } catch (broadcastError) {
+      return {
+        success: false,
+        error: `BTC broadcast failed: ${broadcastError instanceof Error ? broadcastError.message : String(broadcastError)}`
+      };
+    }
+  }
+  async executeBTCWithdrawal(request) {
+    this.ensureInitialized();
+    if (this.config.mode === "service" && !this.config.serviceEndpoint) {
       return { success: false, error: "serviceEndpoint required for BTC withdrawal" };
     }
     if (!request.positionId) {
@@ -20837,6 +21176,15 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
         signer,
         ...request.utxos ? { utxos: request.utxos } : {}
       });
+      if (this.config.mode !== "service") {
+        return await this.executeBTCWithdrawalStandalonePhase2(
+          request,
+          envelope,
+          txid,
+          vout,
+          chainId
+        );
+      }
       const headers = {
         "Content-Type": "application/json",
         ...await this.getAuthHeader()
@@ -21096,6 +21444,41 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
       )
     }));
   }
+  /**
+   * Reconcile every pending withdrawal against BITCOIN truth (incident
+   * 2026-07-22): `getPendingWithdrawals` only reflects on-chain
+   * authorizations, and the contract can never know whether the Phase-2 BTC
+   * broadcast happened. Callers MUST use the returned `status` to decide what
+   * to offer:
+   * - EXECUTABLE      → offer Execute (the only status that may).
+   * - EXECUTED        → auto-clear; `spendingTxid` is the completion proof.
+   * - SPENT_MISMATCH  → unexecutable; offer cancelPendingWithdrawal.
+   * - CORRUPT         → authorization contradicts the chain (e.g. declared
+   *                     satoshis ≠ real output value); offer Cancel &
+   *                     re-request — Execute can only die at the signer guard.
+   * - UNFUNDED        → funding tx unknown/unconfirmed; wait.
+   *
+   * @param opts.esploraBaseUrl Esplora API base (e.g. the api proxy
+   *   `/v1/proxy/esplora/<network>`). Falls back to
+   *   `config.bitcoinProviders[0].url`; throws when neither is configured.
+   */
+  async reconcilePendingWithdrawals(positionId, opts) {
+    this.ensureInitialized();
+    const esploraBaseUrl = opts?.esploraBaseUrl ?? this.config.bitcoinProviders?.[0]?.url;
+    if (!esploraBaseUrl) {
+      throw new SDKError({
+        code: "SDK_ESPLORA_NOT_CONFIGURED",
+        message: "reconcilePendingWithdrawals requires opts.esploraBaseUrl or config.bitcoinProviders[0].url",
+        category: "CONFIGURATION" /* CONFIGURATION */,
+        severity: "HIGH" /* HIGH */,
+        originalError: new Error("esplora base URL not configured")
+      });
+    }
+    const spends = await this.getPendingWithdrawals(positionId);
+    return Promise.all(
+      spends.map((spend) => reconcileAuthorizedSpend(spend, esploraBaseUrl))
+    );
+  }
   /**
    * Cancel a pending BTC withdrawal
    *
@@ -22154,6 +22537,25 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
     const chain = this.config.chain?.toLowerCase() || "";
     return chain.includes("mainnet");
   }
+  /**
+   * Local-lane activation, verified against the LIVE node at call time (not
+   * the chainId cached at init — a provider that switched networks after
+   * init fails the fresh probe). Zero RPC cost outside a lane process tree:
+   * without LIT_LANE_GUARD=1 this short-circuits to false before any probe.
+   */
+  async isLocalLaneGuardActive() {
+    if (!laneGuardEnvEnabled())
+      return false;
+    let provider;
+    try {
+      provider = this.config.provider ?? this.getProviderOrThrow();
+    } catch {
+      return false;
+    }
+    return isLaneGuardActiveOnProvider(
+      provider
+    );
+  }
   /**
    * Get Bitcoin network based on chain.
    *
@@ -22975,6 +23377,7 @@ export {
   createPKPManager,
   createWithdrawalAddressModule,
   DiamondHandsSDK as default,
+  defaultHttpGetJson,
   failure,
   fetchProtocolPauseStatus,
   firstSuccess,
@@ -22998,6 +23401,7 @@ export {
   mapError,
   match,
   numericToPositionStatus,
+  reconcileAuthorizedSpend,
   setPositionDelegate,
   success,
   toPromise,

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

@@ -89,6 +89,18 @@ interface BaseSDKConfig {
     litActionCid?: string;
     litNodeConnectTimeoutMs?: number;
     subgraphUrl?: string;
+    /**
+     * Standalone/local-lane Bitcoin providers (esplora bases). LIT Actions pull
+     * every registered provider from the on-chain BitcoinProviderRegistry and
+     * the server's executePendingWithdrawal handles service-mode broadcast —
+     * this field never feeds those paths. It drives standalone-mode flows only:
+     * the standalone Phase 2 withdrawal broadcast, hardhat-lane per-call
+     * overrides, and `network` as a bitcoinNetwork inference fallback.
+     */
+    bitcoinProviders?: Array<{
+        url: string;
+        network?: "mainnet" | "testnet" | "regtest";
+    }>;
     priceProviders?: PriceProviderConfig[];
     /** PKP Ethereum address for signed price oracle (Lit jsParams pkpId); optional */
     priceOraclePkpId?: string;