@gvnrdao/dh-sdk 0.0.304 → 0.0.306

package/dist/index.mjs

@@ -444,9 +444,13 @@ var init_deployment_addresses = __esm({
           reason: "Validator gas fix (#420): BitcoinAddressValidator packed-table lookups; VERSION 1.0.0 -> 1.0.1"
         },
         UCDController: {
+          previousImplementation: "0x16f94AcC78cE87bEeBCfF90552091B3EfC071E48",
           newImplementation: "0x28B8cAB89D89B3F83581FD2290de2Ce84535bd0A",
-          upgradedBy: "Reconciled from chain \u2014 Upgraded event log unavailable; provenance omitted (never fabricated)",
-          reason: "Reconciled from chain \u2014 mainnet audit rollout batch (cross-ref onchain-auth/.safe-batches/mainnet-audit-execute.json)"
+          upgradedAt: "2026-07-06T10:41:59.000Z",
+          upgradedBy: "AdminModule/Safe audit-batch upgradeToAndCall; executed by 0xEba7BfAeB35ee18408b424Ee0BB45AdDf776589f in tx 0xf6609d3fa43b460d953c85d8d7265b59bf177723042db79a6a700571bad777b7 (block 25472962)",
+          reason: "Reconciled from chain \u2014 mainnet audit rollout batch (cross-ref onchain-auth/.safe-batches/mainnet-audit-execute.json)",
+          executeTx: "0xf6609d3fa43b460d953c85d8d7265b59bf177723042db79a6a700571bad777b7",
+          block: 25472962
         },
         PositionManagerCoreModule: {
           previousImplementation: "0x6C8b0FB93F8d0239254aefaC24d4264cA2F8AAeB",
@@ -573,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,
@@ -1293,7 +1299,7 @@ var require_pkg_src = __commonJS({
         description: "Production Pkp Validator",
         version: "1.0.0",
         deployed: true,
-        deployedAt: 1783106284785,
+        deployedAt: 1784569687492,
         size: 4140,
         hash: "4c0d65bf1f33cdac22a78fd8c4764319cc3fe00650e0fe7fa8a6090d9a318a7b",
         validatorWalletAddress: "0x82db9f515957aa380b596c6ea2bd30cef181f236",
@@ -1370,17 +1376,17 @@ var require_pkg_src = __commonJS({
         }
       },
       btcWithdrawal: {
-        cid: "QmYG1o9qMBZsEMDE9DNsJMzQmvxfj6jTu9V37WwuJZAtC2",
+        cid: "QmexvpfHPacjsVcqNHHLyJhSnnAPLgbWmWd9N3NDLDvYds",
         authorizedCidHex: cidToHex(
-          "QmYG1o9qMBZsEMDE9DNsJMzQmvxfj6jTu9V37WwuJZAtC2"
+          "QmexvpfHPacjsVcqNHHLyJhSnnAPLgbWmWd9N3NDLDvYds"
         ),
         name: "Btc Withdrawal",
         description: "Production Btc Withdrawal",
-        version: "1.2.1",
+        version: "1.2.3",
         deployed: true,
-        deployedAt: 1784316549409,
-        size: 90692,
-        hash: "ca7276763142fe1fc812b70f6319973000faf338a91c531f898f8f6406035c64",
+        deployedAt: 1784585746901,
+        size: 92027,
+        hash: "7b4f4eab1f0c08b8b5b1c9cdb1064dd403ec13f57765919f62dec67fb8ba3c69",
         validatorWalletAddress: "0x82DB9F515957aA380B596C6eA2Bd30CEF181f236",
         pkp: {
           publicKey: "0x043616787c5432415c24378c4ef48de2bcd6bb7b575b837e3cff09171802662da7105d79586c7659677a0ecbaddac4cce06cb2a11f69a16fa0c4d7002ac7d51a4d",
@@ -3752,12 +3758,23 @@ ${auth.clientId}`;
           if (!data.vout || !Array.isArray(data.vout)) {
             return null;
           }
-          return data.vout.map((output, index) => ({
-            index,
-            scriptpubkey: output.scriptpubkey,
-            scriptpubkey_address: output.scriptpubkey_address,
-            value: output.value ?? 0
-          }));
+          return data.vout.map((output, index) => {
+            if (output.value === void 0) {
+              throw new Error(
+                `getTransactionOutputs(${txid}): output ${index} is missing its value \u2014 malformed provider response, refusing to return outputs that cannot be value-verified`
+              );
+            }
+            assertSaneSatoshis(
+              output.value,
+              `getTransactionOutputs(${txid}) output ${index}`
+            );
+            return {
+              index,
+              scriptpubkey: output.scriptpubkey,
+              scriptpubkey_address: output.scriptpubkey_address,
+              value: output.value
+            };
+          });
         } catch (error) {
           clearTimeout(timeoutId);
           if (isAbortError(error)) {
@@ -5519,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. */
@@ -6859,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;
@@ -6900,6 +6930,28 @@ 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/btc-withdrawal-message.ts
 import { keccak256 as keccak2563, toUtf8Bytes as toUtf8Bytes3, solidityPackedKeccak256 as solidityPackedKeccak2563, getBytes as getBytes3, zeroPadValue } from "ethers";
 var QUANTUM_SECONDS = 60;
@@ -15761,7 +15813,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;
@@ -16246,6 +16298,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
@@ -16923,6 +16979,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...`,
@@ -17671,6 +17740,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) {
@@ -18966,6 +19036,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) {
@@ -19866,6 +19937,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) {
@@ -20605,6 +20677,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({
@@ -20682,7 +20755,9 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
         gasUsed: receipt.gasUsed?.toString() || "unknown",
         utxoTxid: validationResponse.utxoTxid,
         utxoVout: validationResponse.utxoVout,
-        utxoSatoshis: validationResponse.utxoSatoshis
+        utxoSatoshis: validationResponse.utxoSatoshis,
+        // Phase B: full consensus-validated spend set (absent on older actions).
+        confirmedUtxos: validationResponse.confirmedUtxos
       };
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
@@ -20757,15 +20832,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) {
@@ -20820,6 +21060,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()
@@ -21365,7 +21614,12 @@ Message: ${causeMessage}${quantumContext}${mintDebtDiagnostics}`
         log.info("\u{1F50D} Found vault UTXO for execution", { utxoIdentifier });
       }
       let executionUtxos;
-      const gatheredUtxos = await this.fetchConfirmedVaultUtxos(positionId);
+      const gatheredUtxos = authResult.confirmedUtxos && authResult.confirmedUtxos.length > 0 ? authResult.confirmedUtxos.map((u) => ({
+        txid: u.txid,
+        vout: Number(u.vout),
+        value: Number(u.value),
+        confirmations: 0
+      })) : await this.fetchConfirmedVaultUtxos(positionId);
       if (gatheredUtxos.length > 0) {
         const normTxid = (t) => String(t).toLowerCase().replace(/^0x/, "");
         const byOutpoint = /* @__PURE__ */ new Map();
@@ -22132,6 +22386,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.
    *

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;

package/dist/interfaces/chunks/loan-operations.i.d.ts

@@ -233,6 +233,16 @@ export interface BTCWithdrawalResult {
     utxoVout?: number;
     /** Full satoshi value of the authorized UTXO; needed by Phase 2 broadcast. */
     utxoSatoshis?: string;
+    /**
+     * Phase B: the FULL consensus-validated confirmed UTXO set the Lit Action
+     * spends, so a multi-UTXO consolidation withdrawal can sign the whole set
+     * without the temporary /vault-utxos endpoint. Absent on older Lit Actions.
+     */
+    confirmedUtxos?: Array<{
+        txid: string;
+        vout: number;
+        value: string;
+    }>;
     error?: string;
 }
 /**

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

@@ -475,6 +475,18 @@ export declare class DiamondHandsSDK {
      * @param request - Execution request with positionId, utxoIdentifier, and networkFee
      * @returns Execution result with Bitcoin txid
      */
+    /**
+     * 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.
+     */
+    private executeBTCWithdrawalStandalonePhase2;
     executeBTCWithdrawal(request: {
         positionId: string;
         utxoIdentifier: string;
@@ -944,6 +956,13 @@ export declare class DiamondHandsSDK {
      * Check if running on production network
      */
     private isProductionNetwork;
+    /**
+     * 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.
+     */
+    private isLocalLaneGuardActive;
     /**
      * Get Bitcoin network based on chain.
      *

package/dist/utils/lane-guard.utils.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Local-verification-lane guard — the ONLY file in the SDK allowed to read
+ * the `LIT_LANE_*` environment (enforced by
+ * `contracts/tests/unit/lane-guard-env-allowlist.unit.test.ts`).
+ *
+ * The lane hooks (quantum-phase alignment before mint authorization, the
+ * simulated-SameBlockInteraction tolerance) exist solely to absorb local
+ * hardhat artifacts: tunnel latency and automine's stale-latest-block
+ * simulation. They are never correct on a live network, so activation is
+ * TRIPLY bound, verified against the live node at the moment of use:
+ *
+ *   1. `LIT_LANE_GUARD=1` — exported only by `scripts/lane-env-guard.sh`
+ *      for the detached local lane's process tree, AND
+ *   2. a fresh `eth_chainId` probe (NOT ethers' init-time network cache, so a
+ *      provider that switched networks after init cannot keep the hooks
+ *      alive) returns a hardhat chainId (1337 `npx hardhat node`, 31337
+ *      in-process default), AND
+ *   3. the node self-identifies as Hardhat via `web3_clientVersion` — a
+ *      live/private network that merely reuses chainId 1337/31337 does not.
+ *
+ * Any probe failure, missing `send` capability, or unexpected answer is
+ * treated as NOT the lane — fail closed. The on-chain guards remain fully
+ * authoritative in every mode regardless.
+ */
+/** Minimal raw-RPC seam — satisfied by ethers v6 JsonRpcApiProvider. */
+export interface RawRpcSender {
+    send?(method: string, params: unknown[]): Promise<unknown>;
+}
+/** The env half of the guard: is the lane environment exported at all? */
+export declare function laneGuardEnvEnabled(): boolean;
+/**
+ * Full lane-guard check against the LIVE node. Cheap short-circuit (no RPC)
+ * when the lane env is not exported — the two probes only ever run inside a
+ * lane process tree.
+ */
+export declare function isLaneGuardActiveOnProvider(provider: RawRpcSender | undefined | null): Promise<boolean>;

package/dist/utils/quantum-submission.utils.d.ts

@@ -61,6 +61,14 @@ export interface SafeQuantumSubmissionOpts {
     sleep?: (ms: number) => Promise<void>;
     /** Debug sink; called with human-readable progress lines. */
     onDebug?: (msg: string) => void;
+    /**
+     * Local-lane activation, computed by the caller at submission time via
+     * `isLaneGuardActiveOnProvider` (lane env exported + live node probes as a
+     * hardhat chain/client). Only consulted by the local-lane
+     * SameBlockInteraction tolerance; omitted or false keeps the fail-fast
+     * behavior on every decodable revert.
+     */
+    laneGuardActive?: boolean;
 }
 /**
  * Gate + pre-send simulation loop. Resolves when it is safe to broadcast;