@paytaca/opencode-plugin 0.2.1 → 0.3.0

package/dist/bundled/proxy.js

@@ -110,6 +110,43 @@ async function getWalletBalance() {
   }
 }
 
+// LIFT token balance in base units (2 decimals); null when unavailable.
+const LIFT_TOKEN_ID = '5932b2fd4915d6a75d3ec53282cd49118149a2176ee67ed68b1111ff0786f7fc';
+async function getLiftBalance() {
+  try {
+    const output = await runCommand(PAYTACA_CMD, ['token', 'info', LIFT_TOKEN_ID]);
+    const match = output.match(/Balance:\\s*([\\d.]+)\\s*LIFT/i);
+    if (match) return Math.round(parseFloat(match[1]) * 100);
+    return null;
+  } catch (err) {
+    log('Failed to get LIFT balance: ' + err.message);
+    return null;
+  }
+}
+
+// LIFT payment discount percent advertised by the backend (/v1/config), cached
+// briefly (30s) so a server-side rate change is picked up quickly. Returns 0
+// when unset/unavailable so callers can fall back to no-discount messaging.
+let liftDiscountCache = { at: 0, percent: 0 };
+async function getLiftDiscountPercent() {
+  const now = Date.now();
+  if (liftDiscountCache.at && now - liftDiscountCache.at < 30000) {
+    return liftDiscountCache.percent;
+  }
+  let percent = 0;
+  try {
+    const configRes = await fetch(BACKEND_URL + '/v1/config');
+    if (configRes.ok) {
+      const data = await configRes.json();
+      percent = Number(data.lift_payment_discount_percent) || 0;
+    }
+  } catch (err) {
+    log('Failed to fetch LIFT discount config: ' + err.message);
+  }
+  liftDiscountCache = { at: now, percent };
+  return percent;
+}
+
 // Utility: get receiving address
 async function getReceivingAddress() {
   try {
@@ -236,16 +273,6 @@ async function streamTierSelectionBody(res, walletHash, modelName, tiers, includ
     choices: [{ index: 0, delta: { content: '💳 Select a plan for **' + (modelName || 'AI Model') + '**\\n\\n' }, finish_reason: null }],
   });
 
-  // If other models still have paid credits, tell the user they can switch
-  // instead of buying a new plan (only when there is something to suggest).
-  if (otherModels && otherModels.length > 0) {
-    sseLine(res, {
-      id: 'tier-9b',
-      object: 'chat.completion.chunk',
-      choices: [{ index: 0, delta: { content: otherModelsHint(otherModels) }, finish_reason: null }],
-    });
-  }
-
   // Build all tier lines into one string so backtick markdown renders
   // consistently (same as the 'plans' command).
   let tiersContent = '';
@@ -265,12 +292,32 @@ async function streamTierSelectionBody(res, walletHash, modelName, tiers, includ
     choices: [{ index: 0, delta: { content: tiersContent }, finish_reason: null }],
   });
 
+  // Advertise the LIFT discount when the backend advertises one.
+  const liftPercent = await getLiftDiscountPercent();
+  if (liftPercent > 0) {
+    sseLine(res, {
+      id: 'tier-10b',
+      object: 'chat.completion.chunk',
+      choices: [{ index: 0, delta: { content: '\\n💡 **' + liftPercent + '% off** when you pay with LIFT tokens — type \`LIFT\` to pay with LIFT and get the discount.\\n' }, finish_reason: null }],
+    });
+  }
+
   sseLine(res, {
     id: 'tier-11',
     object: 'chat.completion.chunk',
-    choices: [{ index: 0, delta: { content: '\\nEnter a number (1-' + tiers.length + '), e.g. type ' + tiers[0].minutes + ':' }, finish_reason: 'stop' }],
+    choices: [{ index: 0, delta: { content: '\\nEnter a number (1-' + tiers.length + ') to pay with BCH, or type \`LIFT\` to pay with LIFT tokens' + (liftPercent > 0 ? ' and get ' + liftPercent + '% off' : '') + ':\\n' }, finish_reason: 'stop' }],
   });
 
+  // If other models still have paid credits, tell the user they can switch
+  // instead of buying a new plan (only when there is something to suggest).
+  if (otherModels && otherModels.length > 0) {
+    sseLine(res, {
+      id: 'tier-9b',
+      object: 'chat.completion.chunk',
+      choices: [{ index: 0, delta: { content: otherModelsHint(otherModels) }, finish_reason: null }],
+    });
+  }
+
   sseLine(res, {
     id: 'tier-12',
     object: 'chat.completion.chunk',
@@ -731,7 +778,7 @@ async function streamPaymentFailureAndRetry(res, walletHash, pendingPayload, mes
 }
 
 // Run paytaca pay internally and return the response
-function runPaytacaPay(djangoUrl, body, walletHash, extraHeaders, callback) {
+function runPaytacaPay(djangoUrl, body, walletHash, extraHeaders, paymentMethod, callback) {
   const url = djangoUrl + '/chat/completions?wallet_hash=' + encodeURIComponent(walletHash || '');
   const payBody = forceNonStreaming(body);
 
@@ -753,6 +800,9 @@ function runPaytacaPay(djangoUrl, body, walletHash, extraHeaders, callback) {
     bodyFile,
     confirmed: true,
   };
+  if (paymentMethod === 'lift') {
+    config.paymentMethod = 'lift';
+  }
 
   try {
     fs.writeFileSync(configFile, JSON.stringify(config), 'utf8');
@@ -1167,20 +1217,43 @@ const server = http.createServer(async (req, res) => {
             await handlePricingCommand(res);
             return;
           }
+
+          // LIFT payment option: user typed "LIFT" (optionally followed by a
+          // tier number, e.g. "LIFT 2"). Defaults to the first tier.
+          let paymentMethod = 'bch';
+          if (timeCmd === 'lift' || (timeCmd && /^lift[\s]+\\d+$/.test(timeCmd))) {
+            paymentMethod = 'lift';
+          }
+          let liftTierIndex = -1;
+          if (timeCmd && /^lift[\s]+\\d+$/.test(timeCmd)) {
+            const liftNum = parseInt(timeCmd.split(/\\s+/)[1], 10);
+            if (!isNaN(liftNum) && liftNum >= 1 && liftNum <= pendingPayload.tiers.length) {
+              liftTierIndex = liftNum - 1;
+            }
+          }
+
           let selectedIndex = -1;
           
-          // Try to parse user input as a number (1-based)
-          const num = parseInt(userInput, 10);
-          if (!isNaN(num) && num >= 1 && num <= pendingPayload.tiers.length) {
-            selectedIndex = num - 1;
+          // "LIFT" alone selects the first (cheapest) tier paid with LIFT;
+          // "LIFT N" selects tier N.
+          if (paymentMethod === 'lift' && liftTierIndex >= 0) {
+            selectedIndex = liftTierIndex;
+          } else if (paymentMethod === 'lift') {
+            selectedIndex = 0;
           } else {
-            // Try to match by duration minutes
-            for (let i = 0; i < pendingPayload.tiers.length; i++) {
-              if (userInput === String(pendingPayload.tiers[i].minutes) ||
-                  userInput === pendingPayload.tiers[i].minutes + ' minutes' ||
-                  userInput === pendingPayload.tiers[i].minutes + ' min') {
-                selectedIndex = i;
-                break;
+            // Try to parse user input as a number (1-based)
+            const num = parseInt(userInput, 10);
+            if (!isNaN(num) && num >= 1 && num <= pendingPayload.tiers.length) {
+              selectedIndex = num - 1;
+            } else {
+              // Try to match by duration minutes
+              for (let i = 0; i < pendingPayload.tiers.length; i++) {
+                if (userInput === String(pendingPayload.tiers[i].minutes) ||
+                    userInput === pendingPayload.tiers[i].minutes + ' minutes' ||
+                    userInput === pendingPayload.tiers[i].minutes + ' min') {
+                  selectedIndex = i;
+                  break;
+                }
               }
             }
           }
@@ -1188,9 +1261,10 @@ const server = http.createServer(async (req, res) => {
           if (selectedIndex >= 0) {
             const selectedTier = pendingPayload.tiers[selectedIndex];
             pendingPayload.durationMinutes = selectedTier.minutes;
+            pendingPayload.paymentMethod = paymentMethod;
             pendingPayload.step = 'processing';
             
-            log('Tier selected: ' + selectedTier.minutes + ' min for wallet ' + walletHash?.substring(0, 16) + '...');
+            log('Tier selected: ' + selectedTier.minutes + ' min (' + paymentMethod + ') for wallet ' + walletHash?.substring(0, 16) + '...');
             
             // Build extra headers for payment wrapper
             const extraHeaders = {};
@@ -1198,28 +1272,56 @@ const server = http.createServer(async (req, res) => {
               extraHeaders['X-Model-Id'] = pendingPayload.modelId;
             }
             extraHeaders['X-Duration-Minutes'] = String(selectedTier.minutes);
+            if (paymentMethod === 'lift') {
+              extraHeaders['X-Payment-Method'] = 'lift';
+            }
             
-            // Check wallet balance before attempting payment
-            const currentBalanceSats = await getWalletBalance();
-            if (currentBalanceSats !== null && selectedTier.price_sats && currentBalanceSats < selectedTier.price_sats) {
-              log('Insufficient balance for wallet ' + walletHash?.substring(0, 16) + '...: ' + currentBalanceSats + ' sats < ' + selectedTier.price_sats + ' sats needed');
-              pendingPayments.delete(walletHash);
-              const addr = await getReceivingAddress();
-              const neededBch = (selectedTier.price_sats - currentBalanceSats) / 100000000;
-              const neededLine = addr ? '\\n\\n📥 **Fund your wallet:** \\\`' + addr + '\\\`\\nOr run: paytaca receive (in another terminal) for QR code' : '';
-              sseLine(res, {
-                id: 'balance-err',
-                object: 'chat.completion.chunk',
-                choices: [{ index: 0, delta: { content: PROXY_MARKER + '\\n\\n❌ **Insufficient balance** — You have **' + (currentBalanceSats / 100000000).toFixed(8) + ' BCH** but need **' + (selectedTier.price_sats / 100000000).toFixed(8) + ' BCH** for this plan. Top up at least **' + neededBch.toFixed(8) + ' BCH** more.' + neededLine + '\\n\\nType \\\`balance\\\` to re-check or try a different plan:' }, finish_reason: 'stop' }],
-              });
-              sseLine(res, {
-                id: 'balance-err-done',
-                object: 'chat.completion.chunk',
-                choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
-              });
-              sseDone(res);
-              res.end();
-              return;
+            // Check wallet balance before attempting payment — only for BCH.
+            // The LIFT path sells tokens, so no BCH balance is required.
+            if (paymentMethod !== 'lift') {
+              const currentBalanceSats = await getWalletBalance();
+              if (currentBalanceSats !== null && selectedTier.price_sats && currentBalanceSats < selectedTier.price_sats) {
+                log('Insufficient balance for wallet ' + walletHash?.substring(0, 16) + '...: ' + currentBalanceSats + ' sats < ' + selectedTier.price_sats + ' sats needed');
+                pendingPayments.delete(walletHash);
+                const addr = await getReceivingAddress();
+                const neededBch = (selectedTier.price_sats - currentBalanceSats) / 100000000;
+                const neededLine = addr ? '\\n\\n📥 **Fund your wallet:** \\\`' + addr + '\\\`\\nOr run: paytaca receive (in another terminal) for QR code' : '';
+                sseLine(res, {
+                  id: 'balance-err',
+                  object: 'chat.completion.chunk',
+                  choices: [{ index: 0, delta: { content: PROXY_MARKER + '\\n\\n❌ **Insufficient balance** — You have **' + (currentBalanceSats / 100000000).toFixed(8) + ' BCH** but need **' + (selectedTier.price_sats / 100000000).toFixed(8) + ' BCH** for this plan. Top up at least **' + neededBch.toFixed(8) + ' BCH** more.' + neededLine + '\\n\\nType \\\`balance\\\` to re-check or try a different plan:' }, finish_reason: 'stop' }],
+                });
+                sseLine(res, {
+                  id: 'balance-err-done',
+                  object: 'chat.completion.chunk',
+                  choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+                });
+                sseDone(res);
+                res.end();
+                return;
+              }
+            } else {
+              // LIFT path: fail fast if the wallet holds no LIFT tokens.
+              const liftBalanceUnits = await getLiftBalance();
+              if (liftBalanceUnits !== null && liftBalanceUnits <= 0) {
+                log('No LIFT tokens for wallet ' + walletHash?.substring(0, 16) + '...');
+                pendingPayments.delete(walletHash);
+                const addr = await getReceivingAddress();
+                const fundLine = addr ? '\\n\\n📥 **Add LIFT to your wallet:** \\\`' + addr + '\\\` (send LIFT tokens) or buy LIFT on the Cauldron DEX' : '';
+                sseLine(res, {
+                  id: 'lift-err',
+                  object: 'chat.completion.chunk',
+                  choices: [{ index: 0, delta: { content: PROXY_MARKER + '\\n\\n❌ **No LIFT tokens** — you need LIFT to pay with tokens. Add LIFT to your wallet, then type a plan number above or \\\`LIFT\\\` again.' + fundLine + '\\n\\nType \\\`balance\\\` to re-check:' }, finish_reason: 'stop' }],
+                });
+                sseLine(res, {
+                  id: 'lift-err-done',
+                  object: 'chat.completion.chunk',
+                  choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+                });
+                sseDone(res);
+                res.end();
+                return;
+              }
             }
             
             // Keepalive during payment processing
@@ -1236,7 +1338,7 @@ const server = http.createServer(async (req, res) => {
               res.write(': keepalive\\n\\n');
             }, 2000);
 
-            runPaytacaPay(BACKEND_URL + '/v1', pendingPayload.body, walletHash, extraHeaders, async (err, responseJson) => {
+            runPaytacaPay(BACKEND_URL + '/v1', pendingPayload.body, walletHash, extraHeaders, pendingPayload.paymentMethod || 'bch', async (err, responseJson) => {
               pendingPayments.delete(walletHash);
               clearInterval(keepalive);
 
@@ -1299,7 +1401,18 @@ const server = http.createServer(async (req, res) => {
 
               if (wasStreaming) {
                 try {
-                  jsonToSse(res, chatCompletion, { prependContent: '\\n💳 Payment successful — generating your response...\\n\\n' });
+                  let prepend = '\\n💳 Payment successful — generating your response...\\n\\n';
+                  if (pendingPayload.paymentMethod === 'lift') {
+                    const liftPercent = await getLiftDiscountPercent();
+                    const selectedTier = (pendingPayload.tiers || []).find((t) => t.minutes === pendingPayload.durationMinutes);
+                    if (liftPercent > 0 && selectedTier && selectedTier.price_sats) {
+                      const savedBch = (selectedTier.price_sats * (liftPercent / 100) / 100000000).toFixed(8);
+                      prepend = '\\n💳 Payment successful — paid with LIFT (**' + liftPercent + '% off**, saved **' + savedBch + ' BCH**). Generating your response...\\n\\n';
+                    } else {
+                      prepend = '\\n💳 Payment successful — paid with LIFT tokens. Generating your response...\\n\\n';
+                    }
+                  }
+                  jsonToSse(res, chatCompletion, { prependContent: prepend });
                 } catch (e) { log('jsonToSse threw: ' + e.message); }
               } else {
                 try {
@@ -1345,7 +1458,7 @@ const server = http.createServer(async (req, res) => {
             res.write(': keepalive\\n\\n');
           }, 2000);
 
-          runPaytacaPay(BACKEND_URL + '/v1', pendingPayload.body, walletHash, extraHeaders, (err, responseJson) => {
+          runPaytacaPay(BACKEND_URL + '/v1', pendingPayload.body, walletHash, extraHeaders, 'bch', (err, responseJson) => {
             clearInterval(keepalive);
             if (err) {
               log('paytaca pay failed: ' + err.message);

package/dist/bundled/proxy.js.map

@@ -1 +1 @@
-{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../src/bundled/proxy.ts"],"names":[],"mappings":";AAAA,0DAA0D;AAC1D,6DAA6D;;;AAEhD,QAAA,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAonDnC,CAAC"}
+{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../src/bundled/proxy.ts"],"names":[],"mappings":";AAAA,0DAA0D;AAC1D,6DAA6D;;;AAEhD,QAAA,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAquDnC,CAAC"}

package/dist/bundled/wrapper.d.ts

@@ -1,2 +1,2 @@
-export declare const WRAPPER_SCRIPT_CONTENT = "#!/usr/bin/env node\n/**\n * Paytaca Pay Wrapper \u2014 handles large request bodies by reading from a file.\n * Imports paytaca-cli modules directly (avoids CLI argument size limits).\n */\n\nimport { readFileSync } from 'fs';\nimport { execSync } from 'child_process';\nimport { fileURLToPath } from 'url';\nimport { dirname, join } from 'path';\n\n// How long to wait for the server to respond before treating the payment as timed out.\n// Default 240s so heavy non-streaming generations (large context / long output) can\n// complete; override with PAYTACA_PAY_TIMEOUT_MS.\nconst PAY_TIMEOUT_MS = Number(process.env.PAYTACA_PAY_TIMEOUT_MS || 240000);\n\n// Find paytaca-cli installation\nfunction findPaytacaCliPath() {\n  const possiblePaths = [];\n  \n  // Try to get global npm root\n  try {\n    const globalPath = execSync('npm root -g', { encoding: 'utf8' }).trim();\n    possiblePaths.push(\n      join(globalPath, 'paytaca-cli'),\n      join(globalPath, 'opencode-plugin', 'node_modules', 'paytaca-cli'),\n    );\n  } catch {}\n  \n  // Common global locations\n  possiblePaths.push(\n    '/usr/lib/node_modules/paytaca-cli',\n    '/usr/local/lib/node_modules/paytaca-cli',\n    '/opt/homebrew/lib/node_modules/paytaca-cli',\n  );\n  \n  // Try current file's node_modules (for bundled installs)\n  try {\n    const currentFile = fileURLToPath(import.meta.url);\n    const currentDir = dirname(currentFile);\n    possiblePaths.push(\n      join(currentDir, '..', 'node_modules', 'paytaca-cli'),\n      join(currentDir, '..', '..', 'node_modules', 'paytaca-cli'),\n    );\n  } catch {}\n  \n  // Find first valid path\n  for (const basePath of possiblePaths) {\n    try {\n      const walletPath = join(basePath, 'dist', 'wallet', 'index.js');\n      readFileSync(walletPath);\n      return basePath;\n    } catch {}\n  }\n  \n  throw new Error('paytaca-cli not found. Try reinstalling opencode-plugin: npm install @paytaca/opencode-plugin');\n}\n\n// Load paytaca-cli modules\nlet loadMnemonic, loadWallet, LibauthHDWallet, X402Payer, parsePaymentRequiredJson, selectBchPaymentRequirements, BCH_DERIVATION_PATH;\n\ntry {\n  const basePath = findPaytacaCliPath();\n  \n  ({ loadMnemonic, loadWallet } = await import(join(basePath, 'dist', 'wallet', 'index.js')));\n  ({ LibauthHDWallet } = await import(join(basePath, 'dist', 'wallet', 'keys.js')));\n  ({ X402Payer } = await import(join(basePath, 'dist', 'wallet', 'x402.js')));\n  ({ parsePaymentRequiredJson, selectBchPaymentRequirements } = await import(join(basePath, 'dist', 'utils', 'x402.js')));\n  ({ BCH_DERIVATION_PATH } = await import(join(basePath, 'dist', 'utils', 'network.js')));\n} catch (err) {\n  console.log(JSON.stringify({ success: false, error: 'Failed to load paytaca-cli: ' + err.message }));\n  process.exit(1);\n}\n\nasync function main() {\n  const configPath = process.argv[2];\n  if (!configPath) {\n    console.log(JSON.stringify({ success: false, error: 'Usage: node paytaca-pay-wrapper.mjs <config.json>' }));\n    process.exit(1);\n  }\n\n  const config = JSON.parse(readFileSync(configPath, 'utf8'));\n  const { url, method, headers, bodyFile, chipnet, confirmed } = config;\n\n  const body = readFileSync(bodyFile, 'utf8');\n\n  const data = loadMnemonic();\n  if (!data) {\n    console.log(JSON.stringify({ success: false, error: 'No wallet found. Run paytaca wallet create first.' }));\n    process.exit(1);\n  }\n\n  const wallet = loadWallet();\n  const isChipnet = Boolean(chipnet);\n  const bchWallet = wallet.forNetwork(isChipnet);\n  const hdWallet = new LibauthHDWallet(data.mnemonic, BCH_DERIVATION_PATH, isChipnet ? 'chipnet' : 'mainnet');\n  const x402Payer = new X402Payer({ hdWallet, addressIndex: 0 });\n\n  try {\n    const result = await executePay(url, method, headers, body, bchWallet, x402Payer, isChipnet, confirmed);\n    console.log(JSON.stringify(result, null, 2));\n  } catch (err) {\n    console.log(JSON.stringify({ success: false, error: err.message || String(err) }, null, 2));\n    process.exit(1);\n  }\n}\n\nasync function executePay(url, method, headers, body, bchWallet, x402Payer, isChipnet, confirmed) {\n  const response = await fetch(url, {\n    method,\n    headers,\n    body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,\n    signal: AbortSignal.timeout(PAY_TIMEOUT_MS),\n  });\n\n  const responseHeaders = {};\n  response.headers.forEach((value, key) => { responseHeaders[key] = value; });\n  const responseText = await response.text();\n  let responseData;\n  try { responseData = JSON.parse(responseText); } catch { responseData = responseText; }\n\n  if (response.status === 402) {\n    const paymentRequired = parsePaymentRequiredJson(responseData);\n    if (!paymentRequired) {\n      return { success: false, status: 402, error: 'Could not parse PaymentRequired from 402 response body' };\n    }\n    const requirements = selectBchPaymentRequirements(paymentRequired, isChipnet ? 'chipnet' : 'mainnet');\n    if (!requirements) {\n      return {\n        success: false, status: 402, error: 'Server does not accept BCH payment',\n        data: { acceptedSchemes: paymentRequired.accepts.map(a => ({ scheme: a.scheme, network: a.network })) },\n      };\n    }\n\n    const payerAddress = x402Payer.getPayerAddress();\n    const address = requirements.payTo;\n    const amountBch = Number(requirements.amount) / 1e8;\n    const changeAddressSet = bchWallet.getAddressSetAt(0);\n    const changeAddress = changeAddressSet.change;\n\n    if (!confirmed) {\n      return {\n        success: false, status: 402, error: 'Payment not confirmed.',\n        payment: { required: true, amount: requirements.amount, payTo: address },\n      };\n    }\n\n    const sendResult = await bchWallet.sendBch(amountBch, address, changeAddress);\n    if (!sendResult.success) {\n      return { success: false, status: 402, payment: { required: true, error: sendResult.error }, error: sendResult.error };\n    }\n\n    const txid = sendResult.txid;\n    const paymentPayload = await x402Payer.createPaymentPayload(requirements, paymentRequired.resource.url, txid, 0, requirements.amount);\n    headers['PAYMENT-SIGNATURE'] = JSON.stringify(paymentPayload);\n\n    let retryResponse;\n    try {\n      retryResponse = await fetch(url, {\n        method,\n        headers,\n        body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,\n        signal: AbortSignal.timeout(PAY_TIMEOUT_MS),\n      });\n    } catch (e) {\n      if (e.name === 'AbortError') {\n        return { success: false, timeout: true, error: 'Response timed out from server.' };\n      }\n      throw e;\n    }\n    const retryResponseHeaders = {};\n    retryResponse.headers.forEach((value, key) => { retryResponseHeaders[key] = value; });\n    const retryResponseText = await retryResponse.text();\n    let retryResponseData;\n    try { retryResponseData = JSON.parse(retryResponseText); } catch { retryResponseData = retryResponseText; }\n\n    return {\n      success: retryResponse.ok,\n      status: retryResponse.status,\n      statusText: retryResponse.statusText,\n      headers: retryResponseHeaders,\n      data: retryResponseData,\n      payment: { required: true, txid, recipientAddress: address },\n    };\n  }\n\n  return {\n    success: response.ok,\n    status: response.status,\n    statusText: response.statusText,\n    headers: responseHeaders,\n    data: responseData,\n    payment: { required: false },\n  };\n}\n\nmain();\n";
+export declare const WRAPPER_SCRIPT_CONTENT = "#!/usr/bin/env node\n/**\n * Paytaca Pay Wrapper \u2014 handles large request bodies by reading from a file.\n * Imports paytaca-cli modules directly (avoids CLI argument size limits).\n */\n\nimport { readFileSync } from 'fs';\nimport { execSync } from 'child_process';\nimport { fileURLToPath } from 'url';\nimport { dirname, join } from 'path';\n\n// How long to wait for the server to respond before treating the payment as timed out.\n// Default 240s so heavy non-streaming generations (large context / long output) can\n// complete; override with PAYTACA_PAY_TIMEOUT_MS.\nconst PAY_TIMEOUT_MS = Number(process.env.PAYTACA_PAY_TIMEOUT_MS || 240000);\n\n// Find paytaca-cli installation\nfunction findPaytacaCliPath() {\n  const possiblePaths = [];\n  \n  // Try to get global npm root\n  try {\n    const globalPath = execSync('npm root -g', { encoding: 'utf8' }).trim();\n    possiblePaths.push(\n      join(globalPath, 'paytaca-cli'),\n      join(globalPath, 'opencode-plugin', 'node_modules', 'paytaca-cli'),\n    );\n  } catch {}\n  \n  // Common global locations\n  possiblePaths.push(\n    '/usr/lib/node_modules/paytaca-cli',\n    '/usr/local/lib/node_modules/paytaca-cli',\n    '/opt/homebrew/lib/node_modules/paytaca-cli',\n  );\n  \n  // Try current file's node_modules (for bundled installs)\n  try {\n    const currentFile = fileURLToPath(import.meta.url);\n    const currentDir = dirname(currentFile);\n    possiblePaths.push(\n      join(currentDir, '..', 'node_modules', 'paytaca-cli'),\n      join(currentDir, '..', '..', 'node_modules', 'paytaca-cli'),\n    );\n  } catch {}\n  \n  // Find first valid path\n  for (const basePath of possiblePaths) {\n    try {\n      const walletPath = join(basePath, 'dist', 'wallet', 'index.js');\n      readFileSync(walletPath);\n      return basePath;\n    } catch {}\n  }\n  \n  throw new Error('paytaca-cli not found. Try reinstalling opencode-plugin: npm install @paytaca/opencode-plugin');\n}\n\n// Load paytaca-cli modules\nlet loadMnemonic, loadWallet, LibauthHDWallet, X402Payer, parsePaymentRequiredJson, selectBchPaymentRequirements, BCH_DERIVATION_PATH;\n\ntry {\n  const basePath = findPaytacaCliPath();\n  \n  ({ loadMnemonic, loadWallet } = await import(join(basePath, 'dist', 'wallet', 'index.js')));\n  ({ LibauthHDWallet } = await import(join(basePath, 'dist', 'wallet', 'keys.js')));\n  ({ X402Payer } = await import(join(basePath, 'dist', 'wallet', 'x402.js')));\n  ({ parsePaymentRequiredJson, selectBchPaymentRequirements } = await import(join(basePath, 'dist', 'utils', 'x402.js')));\n  ({ BCH_DERIVATION_PATH } = await import(join(basePath, 'dist', 'utils', 'network.js')));\n} catch (err) {\n  console.log(JSON.stringify({ success: false, error: 'Failed to load paytaca-cli: ' + err.message }));\n  process.exit(1);\n}\n\n// Cauldron payment support (opt-in via config.paymentMethod === 'lift').\n// The LIFT token is sold in a single swap transaction whose output pays the\n// x402 payTo address directly. Uses the same machinery as paytaca-cli's\n// \"paytaca swap\" command, imported via absolute paths because the wrapper runs\n// outside any node_modules tree.\nconst LIFT_TOKEN_ID = process.env.PAYTACA_PAYMENT_TOKEN_ID || '5932b2fd4915d6a75d3ec53282cd49118149a2176ee67ed68b1111ff0786f7fc';\nlet cauldronLoaded = false;\nlet fetchPoolsForToken, apiPoolToMicroPool, microPoolToPoolV0, attemptTrade, watchtowerUtxosToSpendableCoins, ExchangeLab, PayoutAmountRuleType, cashAddressToLockingBytecode, binToHex;\ntry {\n  const basePath = findPaytacaCliPath();\n  const cauldronDir = join(basePath, 'dist', 'wallet', 'cauldron');\n  const cashlabDir = join(basePath, 'node_modules', '@cashlab');\n  ({ fetchPoolsForToken } = await import(join(cauldronDir, 'api.js')));\n  ({ apiPoolToMicroPool, microPoolToPoolV0 } = await import(join(cauldronDir, 'pools.js')));\n  ({ attemptTrade, watchtowerUtxosToSpendableCoins } = await import(join(cauldronDir, 'transact.js')));\n  ({ default: ExchangeLab } = await import(join(cashlabDir, 'cauldron', 'out', 'exchange-lab.js')));\n  ({ PayoutAmountRuleType } = await import(join(cashlabDir, 'common', 'out', 'constants.js')));\n  ({ cashAddressToLockingBytecode, binToHex } = await import(join(cashlabDir, 'common', 'out', 'libauth.js')));\n  cauldronLoaded = true;\n} catch (err) {\n  // Cauldron modules are only needed for LIFT payments; BCH payments still work.\n  cauldronLoaded = false;\n}\n\nasync function main() {\n  const configPath = process.argv[2];\n  if (!configPath) {\n    console.log(JSON.stringify({ success: false, error: 'Usage: node paytaca-pay-wrapper.mjs <config.json>' }));\n    process.exit(1);\n  }\n\n  const config = JSON.parse(readFileSync(configPath, 'utf8'));\n  const { url, method, headers, bodyFile, chipnet, confirmed, paymentMethod } = config;\n\n  const body = readFileSync(bodyFile, 'utf8');\n\n  const data = loadMnemonic();\n  if (!data) {\n    console.log(JSON.stringify({ success: false, error: 'No wallet found. Run paytaca wallet create first.' }));\n    process.exit(1);\n  }\n\n  const wallet = loadWallet();\n  const isChipnet = Boolean(chipnet);\n  const bchWallet = wallet.forNetwork(isChipnet);\n  const hdWallet = new LibauthHDWallet(data.mnemonic, BCH_DERIVATION_PATH, isChipnet ? 'chipnet' : 'mainnet');\n  const x402Payer = new X402Payer({ hdWallet, addressIndex: 0 });\n\n  try {\n    const result = await executePay(url, method, headers, body, bchWallet, hdWallet, x402Payer, isChipnet, confirmed, paymentMethod);\n    console.log(JSON.stringify(result, null, 2));\n  } catch (err) {\n    console.log(JSON.stringify({ success: false, error: err.message || String(err) }, null, 2));\n    process.exit(1);\n  }\n}\n\n// Sell LIFT tokens via Cauldron in a single swap transaction that pays the\n// x402 payTo address directly. Returns { txid, vout } for the payment payload.\nasync function payWithLift(bchWallet, hdWallet, requirements, changeAddress) {\n  if (!cauldronLoaded) {\n    throw new Error('Cauldron payment modules unavailable. Update paytaca-cli to 0.5.0+ to pay with LIFT.');\n  }\n  const tokenId = LIFT_TOKEN_ID;\n  const amountSats = BigInt(requirements.amount);\n\n  const [apiPools, allUtxos, tokenUtxos] = await Promise.all([\n    fetchPoolsForToken(tokenId),\n    bchWallet.getUtxos(),\n    bchWallet.getUtxos({ category: tokenId }),\n  ]);\n  if (!apiPools || apiPools.length === 0) {\n    throw new Error('No active Cauldron pools for the payment token.');\n  }\n  const pools = apiPools.map(apiPoolToMicroPool).map(microPoolToPoolV0);\n\n  const tokenBalance = (tokenUtxos || []).reduce((sum, u) => sum + BigInt(u.amount || 0), 0n);\n  if (tokenBalance <= 0n) {\n    throw new Error('No LIFT tokens in the wallet. Add LIFT to pay this plan with tokens, or pay with BCH.');\n  }\n\n  const bchUtxos = allUtxos.filter((utxo) => !utxo.is_cashtoken);\n  const spendableCoins = watchtowerUtxosToSpendableCoins({\n    utxos: [...bchUtxos, ...(tokenUtxos || [])],\n    wallet: hdWallet,\n  });\n  if (spendableCoins.length === 0) {\n    throw new Error('No spendable UTXOs available.');\n  }\n\n  const payToDecoded = cashAddressToLockingBytecode(requirements.payTo);\n  if (!payToDecoded || typeof payToDecoded === 'string' || !payToDecoded.bytecode) {\n    throw new Error('Invalid payment address: ' + requirements.payTo);\n  }\n  const changeDecoded = cashAddressToLockingBytecode(changeAddress);\n  if (!changeDecoded || typeof changeDecoded === 'string' || !changeDecoded.bytecode) {\n    throw new Error('Invalid change address: ' + changeAddress);\n  }\n\n  const exlab = new ExchangeLab();\n  const payoutRules = [\n    { type: PayoutAmountRuleType.FIXED, locking_bytecode: payToDecoded.bytecode, amount: amountSats },\n    { type: PayoutAmountRuleType.CHANGE, locking_bytecode: changeDecoded.bytecode, allow_mixing_native_and_token: false, allow_mixing_native_and_token_when_bch_change_is_dust: false, add_change_to_txfee_when_bch_change_is_dust: true },\n  ];\n\n  // Back-compute the token supply for a demand target slightly above the plan\n  // cost so the received BCH covers the fixed payout plus fees (excess becomes\n  // change). Retry with a bigger buffer if the first target leaves no change.\n  let trade = null;\n  let tradeTx = null;\n  let lastError = null;\n  for (const buffer of [2000n, 20000n, 100000n]) {\n    try {\n      trade = attemptTrade({ pools, isBuyingToken: false, supply: undefined, demand: amountSats + buffer });\n      tradeTx = exlab.createTradeTx(trade.entries, spendableCoins, payoutRules, null, 1n);\n      exlab.verifyTradeTx(tradeTx);\n      break;\n    } catch (e) {\n      lastError = e;\n    }\n  }\n  if (!tradeTx) {\n    const supply = trade?.summary?.supply;\n    if (supply && tokenBalance < supply) {\n      throw new Error('Insufficient LIFT balance: this payment needs ' + supply + ' base units but the wallet has ' + tokenBalance + '.');\n    }\n    throw new Error('Could not fund the payment by selling LIFT: ' + (lastError?.message || 'unknown error'));\n  }\n\n  const tx = tradeTx.libauth_generated_transaction;\n  const payToHex = binToHex(payToDecoded.bytecode);\n  const vout = tx.outputs.findIndex((o) => binToHex(o.lockingBytecode) === payToHex);\n  if (vout === -1) {\n    throw new Error('Payment output missing from built transaction.');\n  }\n\n  const txHex = binToHex(tradeTx.txbin);\n  const broadcastResponse = await bchWallet.watchtower.BCH._api.post('broadcast/', { transaction: txHex });\n  const data = broadcastResponse.data;\n  if (data?.result) {\n    data[data.success ? 'txid' : 'error'] = data.result;\n    delete data.result;\n  }\n  if (!data?.success || !data?.txid) {\n    throw new Error(data?.error || 'Broadcast failed');\n  }\n  return { txid: data.txid, vout };\n}\n\nasync function executePay(url, method, headers, body, bchWallet, hdWallet, x402Payer, isChipnet, confirmed, paymentMethod) {\n  // Tell the backend the payment method so it can apply the LIFT discount and\n  // record how the plan was paid. Set once here \u2014 the same headers object is\n  // reused for the 402 fetch and the PAYMENT-SIGNATURE retry.\n  if (paymentMethod === 'lift') {\n    headers['X-Payment-Method'] = 'lift';\n  }\n\n  const response = await fetch(url, {\n    method,\n    headers,\n    body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,\n    signal: AbortSignal.timeout(PAY_TIMEOUT_MS),\n  });\n\n  const responseHeaders = {};\n  response.headers.forEach((value, key) => { responseHeaders[key] = value; });\n  const responseText = await response.text();\n  let responseData;\n  try { responseData = JSON.parse(responseText); } catch { responseData = responseText; }\n\n  if (response.status === 402) {\n    const paymentRequired = parsePaymentRequiredJson(responseData);\n    if (!paymentRequired) {\n      return { success: false, status: 402, error: 'Could not parse PaymentRequired from 402 response body' };\n    }\n    const requirements = selectBchPaymentRequirements(paymentRequired, isChipnet ? 'chipnet' : 'mainnet');\n    if (!requirements) {\n      return {\n        success: false, status: 402, error: 'Server does not accept BCH payment',\n        data: { acceptedSchemes: paymentRequired.accepts.map(a => ({ scheme: a.scheme, network: a.network })) },\n      };\n    }\n\n    const payerAddress = x402Payer.getPayerAddress();\n    const address = requirements.payTo;\n    const amountBch = Number(requirements.amount) / 1e8;\n    const changeAddressSet = bchWallet.getAddressSetAt(0);\n    const changeAddress = changeAddressSet.change;\n\n    if (!confirmed) {\n      return {\n        success: false, status: 402, error: 'Payment not confirmed.',\n        payment: { required: true, amount: requirements.amount, payTo: address },\n      };\n    }\n\n    let txid, vout = 0;\n    if (paymentMethod === 'lift') {\n      // Sell LIFT via Cauldron; the swap transaction pays the plan directly.\n      const liftPayment = await payWithLift(bchWallet, hdWallet, requirements, changeAddress);\n      txid = liftPayment.txid;\n      vout = liftPayment.vout;\n    } else {\n      const sendResult = await bchWallet.sendBch(amountBch, address, changeAddress);\n      if (!sendResult.success) {\n        return { success: false, status: 402, payment: { required: true, error: sendResult.error }, error: sendResult.error };\n      }\n      txid = sendResult.txid;\n    }\n\n    const paymentPayload = await x402Payer.createPaymentPayload(requirements, paymentRequired.resource.url, txid, vout, requirements.amount);\n    headers['PAYMENT-SIGNATURE'] = JSON.stringify(paymentPayload);\n\n    let retryResponse;\n    try {\n      retryResponse = await fetch(url, {\n        method,\n        headers,\n        body: ['POST', 'PUT', 'PATCH'].includes(method) ? body : undefined,\n        signal: AbortSignal.timeout(PAY_TIMEOUT_MS),\n      });\n    } catch (e) {\n      if (e.name === 'AbortError') {\n        return { success: false, timeout: true, error: 'Response timed out from server.' };\n      }\n      throw e;\n    }\n    const retryResponseHeaders = {};\n    retryResponse.headers.forEach((value, key) => { retryResponseHeaders[key] = value; });\n    const retryResponseText = await retryResponse.text();\n    let retryResponseData;\n    try { retryResponseData = JSON.parse(retryResponseText); } catch { retryResponseData = retryResponseText; }\n\n    return {\n      success: retryResponse.ok,\n      status: retryResponse.status,\n      statusText: retryResponse.statusText,\n      headers: retryResponseHeaders,\n      data: retryResponseData,\n      payment: { required: true, txid, recipientAddress: address, method: paymentMethod === 'lift' ? 'lift' : 'bch' },\n    };\n  }\n\n  return {\n    success: response.ok,\n    status: response.status,\n    statusText: response.statusText,\n    headers: responseHeaders,\n    data: responseData,\n    payment: { required: false },\n  };\n}\n\nmain();\n";
 //# sourceMappingURL=wrapper.d.ts.map

package/dist/bundled/wrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrapper.d.ts","sourceRoot":"","sources":["../../src/bundled/wrapper.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB,ozOAqMlC,CAAC"}
+{"version":3,"file":"wrapper.d.ts","sourceRoot":"","sources":["../../src/bundled/wrapper.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB,6lbAwUlC,CAAC"}

package/dist/bundled/wrapper.js

@@ -78,6 +78,30 @@ try {
   process.exit(1);
 }
 
+// Cauldron payment support (opt-in via config.paymentMethod === 'lift').
+// The LIFT token is sold in a single swap transaction whose output pays the
+// x402 payTo address directly. Uses the same machinery as paytaca-cli's
+// "paytaca swap" command, imported via absolute paths because the wrapper runs
+// outside any node_modules tree.
+const LIFT_TOKEN_ID = process.env.PAYTACA_PAYMENT_TOKEN_ID || '5932b2fd4915d6a75d3ec53282cd49118149a2176ee67ed68b1111ff0786f7fc';
+let cauldronLoaded = false;
+let fetchPoolsForToken, apiPoolToMicroPool, microPoolToPoolV0, attemptTrade, watchtowerUtxosToSpendableCoins, ExchangeLab, PayoutAmountRuleType, cashAddressToLockingBytecode, binToHex;
+try {
+  const basePath = findPaytacaCliPath();
+  const cauldronDir = join(basePath, 'dist', 'wallet', 'cauldron');
+  const cashlabDir = join(basePath, 'node_modules', '@cashlab');
+  ({ fetchPoolsForToken } = await import(join(cauldronDir, 'api.js')));
+  ({ apiPoolToMicroPool, microPoolToPoolV0 } = await import(join(cauldronDir, 'pools.js')));
+  ({ attemptTrade, watchtowerUtxosToSpendableCoins } = await import(join(cauldronDir, 'transact.js')));
+  ({ default: ExchangeLab } = await import(join(cashlabDir, 'cauldron', 'out', 'exchange-lab.js')));
+  ({ PayoutAmountRuleType } = await import(join(cashlabDir, 'common', 'out', 'constants.js')));
+  ({ cashAddressToLockingBytecode, binToHex } = await import(join(cashlabDir, 'common', 'out', 'libauth.js')));
+  cauldronLoaded = true;
+} catch (err) {
+  // Cauldron modules are only needed for LIFT payments; BCH payments still work.
+  cauldronLoaded = false;
+}
+
 async function main() {
   const configPath = process.argv[2];
   if (!configPath) {
@@ -86,7 +110,7 @@ async function main() {
   }
 
   const config = JSON.parse(readFileSync(configPath, 'utf8'));
-  const { url, method, headers, bodyFile, chipnet, confirmed } = config;
+  const { url, method, headers, bodyFile, chipnet, confirmed, paymentMethod } = config;
 
   const body = readFileSync(bodyFile, 'utf8');
 
@@ -103,7 +127,7 @@ async function main() {
   const x402Payer = new X402Payer({ hdWallet, addressIndex: 0 });
 
   try {
-    const result = await executePay(url, method, headers, body, bchWallet, x402Payer, isChipnet, confirmed);
+    const result = await executePay(url, method, headers, body, bchWallet, hdWallet, x402Payer, isChipnet, confirmed, paymentMethod);
     console.log(JSON.stringify(result, null, 2));
   } catch (err) {
     console.log(JSON.stringify({ success: false, error: err.message || String(err) }, null, 2));
@@ -111,7 +135,106 @@ async function main() {
   }
 }
 
-async function executePay(url, method, headers, body, bchWallet, x402Payer, isChipnet, confirmed) {
+// Sell LIFT tokens via Cauldron in a single swap transaction that pays the
+// x402 payTo address directly. Returns { txid, vout } for the payment payload.
+async function payWithLift(bchWallet, hdWallet, requirements, changeAddress) {
+  if (!cauldronLoaded) {
+    throw new Error('Cauldron payment modules unavailable. Update paytaca-cli to 0.5.0+ to pay with LIFT.');
+  }
+  const tokenId = LIFT_TOKEN_ID;
+  const amountSats = BigInt(requirements.amount);
+
+  const [apiPools, allUtxos, tokenUtxos] = await Promise.all([
+    fetchPoolsForToken(tokenId),
+    bchWallet.getUtxos(),
+    bchWallet.getUtxos({ category: tokenId }),
+  ]);
+  if (!apiPools || apiPools.length === 0) {
+    throw new Error('No active Cauldron pools for the payment token.');
+  }
+  const pools = apiPools.map(apiPoolToMicroPool).map(microPoolToPoolV0);
+
+  const tokenBalance = (tokenUtxos || []).reduce((sum, u) => sum + BigInt(u.amount || 0), 0n);
+  if (tokenBalance <= 0n) {
+    throw new Error('No LIFT tokens in the wallet. Add LIFT to pay this plan with tokens, or pay with BCH.');
+  }
+
+  const bchUtxos = allUtxos.filter((utxo) => !utxo.is_cashtoken);
+  const spendableCoins = watchtowerUtxosToSpendableCoins({
+    utxos: [...bchUtxos, ...(tokenUtxos || [])],
+    wallet: hdWallet,
+  });
+  if (spendableCoins.length === 0) {
+    throw new Error('No spendable UTXOs available.');
+  }
+
+  const payToDecoded = cashAddressToLockingBytecode(requirements.payTo);
+  if (!payToDecoded || typeof payToDecoded === 'string' || !payToDecoded.bytecode) {
+    throw new Error('Invalid payment address: ' + requirements.payTo);
+  }
+  const changeDecoded = cashAddressToLockingBytecode(changeAddress);
+  if (!changeDecoded || typeof changeDecoded === 'string' || !changeDecoded.bytecode) {
+    throw new Error('Invalid change address: ' + changeAddress);
+  }
+
+  const exlab = new ExchangeLab();
+  const payoutRules = [
+    { type: PayoutAmountRuleType.FIXED, locking_bytecode: payToDecoded.bytecode, amount: amountSats },
+    { type: PayoutAmountRuleType.CHANGE, locking_bytecode: changeDecoded.bytecode, allow_mixing_native_and_token: false, allow_mixing_native_and_token_when_bch_change_is_dust: false, add_change_to_txfee_when_bch_change_is_dust: true },
+  ];
+
+  // Back-compute the token supply for a demand target slightly above the plan
+  // cost so the received BCH covers the fixed payout plus fees (excess becomes
+  // change). Retry with a bigger buffer if the first target leaves no change.
+  let trade = null;
+  let tradeTx = null;
+  let lastError = null;
+  for (const buffer of [2000n, 20000n, 100000n]) {
+    try {
+      trade = attemptTrade({ pools, isBuyingToken: false, supply: undefined, demand: amountSats + buffer });
+      tradeTx = exlab.createTradeTx(trade.entries, spendableCoins, payoutRules, null, 1n);
+      exlab.verifyTradeTx(tradeTx);
+      break;
+    } catch (e) {
+      lastError = e;
+    }
+  }
+  if (!tradeTx) {
+    const supply = trade?.summary?.supply;
+    if (supply && tokenBalance < supply) {
+      throw new Error('Insufficient LIFT balance: this payment needs ' + supply + ' base units but the wallet has ' + tokenBalance + '.');
+    }
+    throw new Error('Could not fund the payment by selling LIFT: ' + (lastError?.message || 'unknown error'));
+  }
+
+  const tx = tradeTx.libauth_generated_transaction;
+  const payToHex = binToHex(payToDecoded.bytecode);
+  const vout = tx.outputs.findIndex((o) => binToHex(o.lockingBytecode) === payToHex);
+  if (vout === -1) {
+    throw new Error('Payment output missing from built transaction.');
+  }
+
+  const txHex = binToHex(tradeTx.txbin);
+  const broadcastResponse = await bchWallet.watchtower.BCH._api.post('broadcast/', { transaction: txHex });
+  const data = broadcastResponse.data;
+  if (data?.result) {
+    data[data.success ? 'txid' : 'error'] = data.result;
+    delete data.result;
+  }
+  if (!data?.success || !data?.txid) {
+    throw new Error(data?.error || 'Broadcast failed');
+  }
+  return { txid: data.txid, vout };
+}
+
+async function executePay(url, method, headers, body, bchWallet, hdWallet, x402Payer, isChipnet, confirmed, paymentMethod) {
+  // Tell the backend the payment method so it can apply the LIFT discount and
+  // record how the plan was paid. Set once here — the same headers object is
+  // reused for the 402 fetch and the PAYMENT-SIGNATURE retry.
+  if (paymentMethod === 'lift') {
+    headers['X-Payment-Method'] = 'lift';
+  }
+
   const response = await fetch(url, {
     method,
     headers,
@@ -151,13 +274,21 @@ async function executePay(url, method, headers, body, bchWallet, x402Payer, isCh
       };
     }
 
-    const sendResult = await bchWallet.sendBch(amountBch, address, changeAddress);
-    if (!sendResult.success) {
-      return { success: false, status: 402, payment: { required: true, error: sendResult.error }, error: sendResult.error };
+    let txid, vout = 0;
+    if (paymentMethod === 'lift') {
+      // Sell LIFT via Cauldron; the swap transaction pays the plan directly.
+      const liftPayment = await payWithLift(bchWallet, hdWallet, requirements, changeAddress);
+      txid = liftPayment.txid;
+      vout = liftPayment.vout;
+    } else {
+      const sendResult = await bchWallet.sendBch(amountBch, address, changeAddress);
+      if (!sendResult.success) {
+        return { success: false, status: 402, payment: { required: true, error: sendResult.error }, error: sendResult.error };
+      }
+      txid = sendResult.txid;
     }
 
-    const txid = sendResult.txid;
-    const paymentPayload = await x402Payer.createPaymentPayload(requirements, paymentRequired.resource.url, txid, 0, requirements.amount);
+    const paymentPayload = await x402Payer.createPaymentPayload(requirements, paymentRequired.resource.url, txid, vout, requirements.amount);
     headers['PAYMENT-SIGNATURE'] = JSON.stringify(paymentPayload);
 
     let retryResponse;
@@ -186,7 +317,7 @@ async function executePay(url, method, headers, body, bchWallet, x402Payer, isCh
       statusText: retryResponse.statusText,
       headers: retryResponseHeaders,
       data: retryResponseData,
-      payment: { required: true, txid, recipientAddress: address },
+      payment: { required: true, txid, recipientAddress: address, method: paymentMethod === 'lift' ? 'lift' : 'bch' },
     };
   }
 

package/dist/bundled/wrapper.js.map

@@ -1 +1 @@
-{"version":3,"file":"wrapper.js","sourceRoot":"","sources":["../../src/bundled/wrapper.ts"],"names":[],"mappings":";AAAA,oEAAoE;AACpE,4EAA4E;AAC5E,mFAAmF;;;AAEtE,QAAA,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqMrC,CAAC"}
+{"version":3,"file":"wrapper.js","sourceRoot":"","sources":["../../src/bundled/wrapper.ts"],"names":[],"mappings":";AAAA,oEAAoE;AACpE,4EAA4E;AAC5E,mFAAmF;;;AAEtE,QAAA,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwUrC,CAAC"}

package/dist/proxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../src/proxy.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAc5C,wBAAgB,iBAAiB,IAAI,MAAM,CA4C1C;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAYpE;AAuCD,wBAAsB,iBAAiB,CAAC,SAAS,GAAE,MAAa,EAAE,OAAO,GAAE,MAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAOzG;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAOrD;AAED,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAiBlH;AAED,wBAAsB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CA+GtF;AAqBD,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAU5G"}
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../src/proxy.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAc5C,wBAAgB,iBAAiB,IAAI,MAAM,CA4C1C;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAYpE;AAuCD,wBAAsB,iBAAiB,CAAC,SAAS,GAAE,MAAa,EAAE,OAAO,GAAE,MAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAOzG;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAOrD;AAED,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAiBlH;AAED,wBAAsB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAiHtF;AAqBD,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAU5G"}

package/dist/proxy.js

@@ -173,17 +173,21 @@ async function startProxy(configDir, config) {
     const logFile = (0, config_1.getLogFile)(configDir);
     const wrapperScript = (0, config_1.getWrapperScript)(configDir);
     (0, config_1.ensureConfigDir)(configDir);
+    // Always refresh the payment wrapper on disk. It is executed fresh on every
+    // payment, so it must never go stale even when the proxy is reused/restarted.
+    fs.writeFileSync(wrapperScript, wrapper_1.WRAPPER_SCRIPT_CONTENT, 'utf8');
+    fs.chmodSync(wrapperScript, '755');
     const currentHash = scriptHash();
     const persistedConfig = (0, config_1.loadConfig)(configDir);
     let existingStatus = await getProxyStatus(configDir);
     const needsRestart = existingStatus.running &&
         (existingStatus.pid || 0) > 0 &&
         persistedConfig.proxyScriptHash !== currentHash;
-    fs.writeFileSync(proxyScript, proxy_1.PROXY_SCRIPT_CONTENT, 'utf8');
-    fs.chmodSync(proxyScript, '755');
     if (existingStatus.running && existingStatus.pid && existingStatus.port && !needsRestart) {
         return await reuseExistingProxy(configDir, config, { port: existingStatus.port, pid: existingStatus.pid }, currentHash);
     }
+    fs.writeFileSync(proxyScript, proxy_1.PROXY_SCRIPT_CONTENT, 'utf8');
+    fs.chmodSync(proxyScript, '755');
     if (existingStatus.running && existingStatus.pid) {
         try {
             process.kill(existingStatus.pid);
@@ -197,8 +201,6 @@ async function startProxy(configDir, config) {
     if (adopted) {
         return adopted;
     }
-    fs.writeFileSync(wrapperScript, wrapper_1.WRAPPER_SCRIPT_CONTENT, 'utf8');
-    fs.chmodSync(wrapperScript, '755');
     const paytacaCmd = getPaytacaCommand();
     const MAX_ATTEMPTS = 3;
     for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {