scripter-x 1.0.28 → 1.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scripter-x",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "description": "ScripterX — local Flipkart session extractor (runs on your residential IP, syncs to marthunt)",
   "type": "module",
   "bin": {

package/src/commands.js

@@ -8,9 +8,10 @@ import * as tp from './providers/tempotp.js';
 import * as oc from './providers/otpcart.js';
 import * as kuku from './providers/kuku.js';
 import * as zepto from './providers/zepto.js';
+import { checkCouponTier } from './providers/zeptoCoupon.js';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
-import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { mkdirSync, writeFileSync, appendFileSync, readFileSync, existsSync } from 'node:fs';
 import { Worker } from './worker.js';
 import { RunController } from './controller.js';
 import { STATUS } from './theme.js';
@@ -288,12 +289,47 @@ export async function recheck(io, _api, args = {}) {
 // code → we verify, build the ZAUTH1 envelope, and write {phone}-{timestamp}.txt.
 // LOOPS: after each one it asks for the next number — keep going until the user
 // presses Esc (or double Ctrl+C). Runs entirely on your IP.
+// Resolve the base dir for Zepto envelope output.
+function zeptoBaseDir(args) {
+  if (args.out) {
+    const expanded = args.out.startsWith('~') ? join(homedir(), args.out.slice(1)) : args.out;
+    return /\.(txt|json)$/i.test(expanded) ? dirname(expanded) : expanded;
+  }
+  const downloads = join(homedir(), 'Downloads');
+  return join(existsSync(downloads) ? downloads : homedir(), 'scripterx', 'zepto');
+}
+
+// Save one envelope. With a tier → APPEND to {tier}.txt (one envelope per block,
+// blank-line separated, so the file is readable + paste-friendly). Without a tier →
+// a single per-number timestamped file (legacy behaviour). Returns the path written.
+function saveZeptoEnvelope(args, number, envelope, tier) {
+  const baseDir = zeptoBaseDir(args);
+  if (tier) {
+    mkdirSync(baseDir, { recursive: true });
+    const dest = join(baseDir, `${tier}.txt`);
+    // append with a blank-line separator if the file already has content
+    const block = (existsSync(dest) ? '\n' : '') + envelope + '\n';
+    appendFileSync(dest, block);
+    return dest;
+  }
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const dest = join(baseDir, `${number}-${stamp}.txt`);
+  mkdirSync(baseDir, { recursive: true });
+  writeFileSync(dest, envelope + '\n');
+  return dest;
+}
+
 export async function zeptoCmd(io, api, args = {}) {
   const mode = args.manual ? 'manual' : (args.auto ? 'auto' : (await io.select('Choose Zepto login flow', [
     { label: 'Auto', value: 'auto', description: 'Headless extraction via OTPCart (Recommended)' },
     { label: 'Manual', value: 'manual', description: 'Enter phone + type OTP manually' }
   ])).value || 'auto');
 
+  // Optional: check the coupon tier (₹50/₹75/₹100/normal) per account + split into
+  // 4 files. Runs headlessly right after verify while the token is fresh.
+  const checkCoupon = args.checkCoupon != null ? args.checkCoupon
+    : await io.confirm('check coupon tier (₹50/₹75/₹100) + split into files?', false);
+
   if (mode === 'manual') {
     io.print('  ◉ Zepto — local OTP → ZAUTH1 envelope (Manual)');
     io.print('  ◉ press esc to cancel', 'accent');
@@ -335,21 +371,18 @@ export async function zeptoCmd(io, api, args = {}) {
           // Build the ZAUTH1 envelope — the format the ZeptoAuthManager tool imports.
           const envelope = zepto.encodeEnvelope(zepto.toSessionKeys(session), args.cert);
 
-          // {phone}-{timestamp}.txt  in the chosen dir (default ~/Downloads/scripterx/zepto)
-          const stamp = new Date().toISOString().replace(/[:.]/g, '-');
-          const fname = `${number}-${stamp}.txt`;
-          let dest;
-          if (args.out) {
-            const expanded = args.out.startsWith('~') ? join(homedir(), args.out.slice(1)) : args.out;
-            dest = /\.(txt|json)$/i.test(expanded) ? expanded : join(expanded, fname);
-          } else {
-            const downloads = join(homedir(), 'Downloads');
-            dest = join(existsSync(downloads) ? downloads : homedir(), 'scripterx', 'zepto', fname);
+          // Optional coupon-tier check (token is fresh right now) → split into 4 files.
+          let tier = '';
+          if (checkCoupon) {
+            io.print('  ◉ checking coupon tier …');
+            const c = await checkCouponTier(session);
+            tier = c.tier; // rs50 | rs75 | rs100 | normal | unchecked
+            io.print(`  ✓ coupon: ${c.label}`, c.tier === 'normal' || c.tier === 'unchecked' ? undefined : 'accent');
           }
-          mkdirSync(dirname(dest), { recursive: true });
-          writeFileSync(dest, envelope + '\n');
+
+          const dest = saveZeptoEnvelope(args, number, envelope, tier);
           done++;
-          io.print('  ✓ envelope saved to:');
+          io.print(`  ✓ envelope saved${tier ? ` (${tier})` : ''} to:`);
           io.print(`     ${dest}`, 'accent');
           io.print('  ◉ paste into ZeptoAuthManager → Import:');
           io.print(`     ${envelope}`, 'accent');
@@ -412,6 +445,7 @@ export async function zeptoCmd(io, api, args = {}) {
     requested: count,
     concurrency,
     certSha: cert,
+    checkCoupon,
     onEvent: controller.handleEvent,
   });
   controller.stop = () => worker.stop();
@@ -450,11 +484,29 @@ export async function zeptoCmd(io, api, args = {}) {
       io.print(`  ✓ saved ${saved.count} session(s) to 2 files:`);
       io.print(`     full   → ${saved.fullPath}`, 'accent');
       io.print(`     zauth  → ${saved.zauthPath}`, 'accent');
+    }
+    // If coupon-tier was checked, ALSO split the envelopes into per-tier files.
+    if (checkCoupon) {
+      const tiers = {};
+      for (const r of results) {
+        if (r.status !== 'success') continue;
+        const tier = r.coupon_tier || 'unchecked';
+        (tiers[tier] = tiers[tier] || []).push(r.envelope);
+      }
+      io.print('  ◉ coupon tiers:');
+      for (const tier of ['rs100', 'rs75', 'rs50', 'normal', 'unchecked']) {
+        if (!tiers[tier]?.length) continue;
+        const dir = zeptoTierDir(args, name);
+        const dest = join(dir, `${tier}.txt`);
+        mkdirSync(dir, { recursive: true });
+        // one envelope per block, separated by a blank line — readable + paste-friendly
+        writeFileSync(dest, tiers[tier].join('\n\n') + '\n');
+        io.print(`     ${TIER_LABEL[tier]} (${tiers[tier].length}) → ${dest}`, 'accent');
+      }
+    } else {
       io.print('  ◉ ZAUTH1 envelopes:');
       for (const r of results) {
-        if (r.status === 'success') {
-          io.print(`     +91${r.mobile}  →  ${r.envelope}`, 'accent');
-        }
+        if (r.status === 'success') io.print(`     +91${r.mobile}  →  ${r.envelope}`, 'accent');
       }
     }
   } else {
@@ -462,6 +514,21 @@ export async function zeptoCmd(io, api, args = {}) {
   }
 }
 
+const TIER_LABEL = { rs100: '🟢 ₹100', rs75: '🟢 ₹75', rs50: '🟢 ₹50', normal: '⚪ normal', unchecked: '❔ unchecked' };
+
+// The directory the per-tier files go in for an auto run.
+function zeptoTierDir(args, name) {
+  let baseDir;
+  if (args.out) {
+    const expanded = args.out.startsWith('~') ? join(homedir(), args.out.slice(1)) : args.out;
+    baseDir = /\.(txt|json)$/i.test(expanded) ? dirname(expanded) : expanded;
+  } else {
+    const downloads = join(homedir(), 'Downloads');
+    baseDir = join(existsSync(downloads) ? downloads : homedir(), 'scripterx', 'zepto');
+  }
+  return join(baseDir, name);
+}
+
 async function saveZeptoSessions(results, name, out) {
   const { statSync } = await import('node:fs');
   const ok = results.filter((r) => r.status === 'success');

package/src/index.js

@@ -119,6 +119,7 @@ async function main() {
     target: flags.target, // run: 'flipkart' | 'zepto'
     number: flags.number, otp: flags.otp, cert: flags.cert, // zepto: local OTP login → ZAUTH1 envelope
     auto: flags.auto, manual: flags.manual,
+    checkCoupon: flags['check-coupon'] === true ? true : (flags['check-coupon'] === false ? false : null),
     campaign: flags._[0], out: flags.out, action: flags._[0], value: flags._[1],
   };
   try { await REGISTRY[fnName](cliIo, null, args); }

package/src/providers/zeptoCoupon.js

@@ -0,0 +1,241 @@
+// Zepto coupon-tier checker — runs HEADLESSLY right after OTP verify, while the
+// access token is fresh. Reads which new-user coupon (₹50 / ₹75 / ₹100 / none) an
+// account is in, by building a cart over the MOV and reading the coupons fetch-list.
+//
+// Ported from zepto_coupon_checker/zeptoClient.js (CommonJS → ESM). Classification
+// mirrors zepto_coupon_checker/idcheck.js: an explicit Z-CARTBOOST<N> code or a
+// single {50,75,100} banner = that tier; a spread of 3+ amounts = the generic
+// catalog (normal account, no unlocked coupon).
+import https from 'node:https';
+import crypto from 'node:crypto';
+
+const API = 'api.zepto.co.in';
+const GW = 'api-gateway.zepto.co.in';
+const SEARCH = 'user-search.zepto.co.in';
+
+const uuid = () => crypto.randomUUID();
+const randHex = (n) => crypto.randomBytes(n).toString('hex').slice(0, n);
+
+const COMPATIBLE_COMPONENTS = 'EXTERNAL_COUPONS,BUNDLE,MULTI_SELLER_ENABLED,ROLLUPS,RE_PROMISE_ETA_ORDER_SCREEN_ENABLED,RECOMMENDED_COUPON_WIDGET,PHARMA_ENABLED,GAMIFICATION_ENABLED,DYNAMIC_FILTERS,HOMEPAGE_V2,COUPON_WIDGET_CART_REVAMP,AUTOSUGGESTION_PIP,NEW_ETA_BANNER,IS_DYNAMIC_NZS_SUPPORTED,ZEPTO_THREE,RECOMMENDED_COUPON_WIDGET,COUPON_UPSELLING_WIDGET,CART_BOX_MODEL_WIDGETS,NEW_BILL_INFO,COUPON_BOTTOM_STRIP,SUPERSTORE_V1,SUPER_SAVER:1,SUPER_SAVER_DYNAMIC_MOV_ENABLED,PROMO_CASH:2,GIFT_CARD,WISHLIST,CART_PERSISTENCE,CART_REDESIGN_ENABLED,CART_LOCKING:1,NEW_WALLET_INFO,COLLAPSIBLE_BILL_INFO,ITEMISATION_ENABLED,NO_BAG,NO_BAG_DELIVERY_V3';
+
+function baseHeaders(session, extra = {}) {
+  return {
+    'content-type': 'application/json; charset=utf-8',
+    'x-requested-with': 'XMLHttpRequest',
+    'user-agent': 'okhttp/4.12.0',
+    appversion: '26.5.5', app_version: '26.5.5',
+    platform: 'android', tenant: 'ZEPTO',
+    sessionid: session.sessionId, session_id: session.sessionId,
+    deviceuid: session.deviceUid, device_uid: session.deviceUid,
+    device_brand: 'samsung', device_model: 'SM-G991B',
+    system_version: '13', systemversion: '13',
+    source: 'PLAY_STORE', is_internal_user: 'false', isinternaluser: 'false',
+    ...(session.token ? { authorization: `Bearer ${session.token}` } : {}),
+    ...extra,
+  };
+}
+
+function cartHeaders(session, storeId, extra = {}) {
+  return baseHeaders(session, {
+    compatible_components: COMPATIBLE_COMPONENTS,
+    marketplace_type: 'SUPER_SAVER', experience_variant: 'SS_UNIFIED',
+    performance_mode: 'NORMAL', auth_revamp_flow: 'v2',
+    is_new_font: 'true', accessibility_layout: 'false',
+    ...(storeId ? { store_id: storeId, storeid: storeId, store_ids: storeId } : {}),
+    ...extra,
+  });
+}
+
+function req(host, method, path, hdrs, bodyObj) {
+  return new Promise((resolve) => {
+    const body = bodyObj != null ? JSON.stringify(bodyObj) : null;
+    const h = { ...hdrs, host };
+    if (body) h['content-length'] = Buffer.byteLength(body);
+    const r = https.request({ hostname: host, port: 443, method, path, headers: h, timeout: 20000 }, (res) => {
+      const ch = [];
+      res.on('data', (c) => ch.push(c));
+      res.on('end', () => {
+        const text = Buffer.concat(ch).toString('utf8');
+        let json = null;
+        try { json = JSON.parse(text); } catch { /* */ }
+        resolve({ status: res.statusCode, text, json });
+      });
+    });
+    r.on('error', (e) => resolve({ status: 0, text: 'err:' + e.message, json: null }));
+    r.on('timeout', () => { r.destroy(); resolve({ status: 0, text: 'timeout', json: null }); });
+    if (body) r.write(body);
+    r.end();
+  });
+}
+
+// Build a coupon-check session from a logged-in zepto provider session.
+function couponSession(session) {
+  return {
+    sessionId: session.sessionId || uuid(),
+    deviceUid: session.deviceUid || session.deviceId || randHex(16),
+    token: session.token || session.accessToken,
+    user: session.user || (session.userId ? { id: session.userId } : null),
+  };
+}
+
+// Parse coupon banners/codes out of a response. [{code, amount}].
+function parseCoupons(text) {
+  const found = new Map();
+  if (!text) return [];
+  for (const m of text.matchAll(/Z-CARTBOOST(\d+)/g)) {
+    found.set(`Z-CARTBOOST${m[1]}`, { code: `Z-CARTBOOST${m[1]}`, amount: Number(m[1]) });
+  }
+  for (const m of text.matchAll(/(?:Extra|FLAT|Get|Unlock(?:ed)?)\s*₹\s*(\d{2,3})\s*OFF/gi)) {
+    const amt = Number(m[1]);
+    if (!found.has(`Z-CARTBOOST${amt}`)) found.set(`banner${amt}`, { code: null, amount: amt, banner: true });
+  }
+  return [...found.values()];
+}
+
+async function resolveStore(session, lat, lng) {
+  const r = await req(GW, 'GET',
+    `/serviceability-service/api/v1/serviceability?lat=${lat}&long=${lng}&includeAddressDetails=true`,
+    cartHeaders(session));
+  let primary = null, anyServ = null;
+  const re = /\{"serviceable":(true|false),"storeId":"([0-9a-f-]{36})","storeConstruct":"([^"]+)"[^}]*?"isNightlyStore":(true|false)/g;
+  let m;
+  while ((m = re.exec(r.text))) {
+    const s = { serviceable: m[1] === 'true', storeId: m[2], construct: m[3] };
+    if (s.serviceable && !anyServ) anyServ = s;
+    if (s.serviceable && s.construct === 'PRIMARY_STORE' && !primary) primary = s;
+  }
+  return primary || anyServ;
+}
+
+async function findProduct(session, storeId, lat, lng, query) {
+  const r = await req(SEARCH, 'POST', '/api/v3/search',
+    cartHeaders(session, storeId, {
+      storeid: storeId, store_id: storeId, store_ids: storeId,
+      store_etas: JSON.stringify({ [storeId]: -1 }),
+      store_serviceability: JSON.stringify({ data: { [storeId]: { type: 'PRIMARY_STORE' } } }),
+      gps_latitude: String(lat), gps_longitude: String(lng),
+    }),
+    { query, userSessionId: '', mode: 'TYPED', intentId: uuid(), cartLastUpdatedAt: 0,
+      user_action_meta: [], requestMeta: {}, pageNumber: 0, retryCount: 0 });
+  const idx = r.text.indexOf('"storeProductId"');
+  if (idx < 0) return null;
+  const block = r.text.slice(Math.max(0, idx - 500), idx + 500);
+  const sp = block.match(/"storeProductId":"([0-9a-f-]{36})"/);
+  const pv = block.match(/"productVariantId":"([0-9a-f-]{36})"/);
+  const pr = block.match(/"(?:discountedSellingPrice|sellingPrice)":(\d+)/);
+  if (!sp || !pv) return null;
+  return { storeProductId: sp[1], productVariantId: pv[1], price: pr ? Number(pr[1]) : 10000 };
+}
+
+// Run the coupon check. Returns { coupons:[{code,amount}], status?, reason? }.
+async function fetchCoupons(session, opts = {}) {
+  const lat = opts.lat ?? 12.9263597;
+  const lng = opts.lng ?? 77.5838125;
+
+  let STORE_ID = opts.storeId;
+  if (!STORE_ID) STORE_ID = (await resolveStore(session, lat, lng))?.storeId;
+  if (!STORE_ID) STORE_ID = '5ec071fd-78df-41f6-b3ae-7298d9f96a3d';
+
+  // build a cart >= MOV (first 2 in-stock common items)
+  const PRODUCTS = [];
+  for (const q of ['water', 'milk', 'bread', 'redbull', 'chips']) {
+    if (PRODUCTS.length >= 2) break;
+    const p = await findProduct(session, STORE_ID, lat, lng, q);
+    if (p && !PRODUCTS.find((x) => x.productVariantId === p.productVariantId)) PRODUCTS.push(p);
+  }
+  if (PRODUCTS.length === 0) {
+    PRODUCTS.push({ storeProductId: 'b382dc23-0d70-4a50-82f3-5219a0bb8b12', productVariantId: '3e01e4c1-b31d-4305-810f-5c3a03a7401f', price: 21900 });
+  }
+
+  let cartId = '';
+  const cart = await req(GW, 'POST', '/cart-service/api/v1/cart/widget-action', cartHeaders(session, STORE_ID), {
+    actions: [{ widgetId: 'GET_CART_ID_WIDGET', actionType: 'GET_CART_ID', data: {} }],
+  });
+  const cm = cart.text.match(/"cartId"\s*:\s*"([0-9a-f-]{36})"/i) || cart.text.match(/"id"\s*:\s*"([0-9a-f-]{36})"/i);
+  if (cm) cartId = cm[1];
+
+  const cartProducts = PRODUCTS.map((p) => ({
+    quantity: 1, productVariantId: p.productVariantId, isAddedToGiftBag: false,
+    discountedSellingPrice: p.price, uclId: '', storeProductId: p.storeProductId,
+  }));
+  const putCart = await req(GW, 'PUT', '/cfs/api/v1/cart', cartHeaders(session, STORE_ID), {
+    storeId: STORE_ID, cartId, cartProducts,
+    cartProductsV2: cartProducts.map((p) => ({ cartProductId: p.productVariantId, ...p, addOns: [] })),
+    latitude: lat, longitude: lng,
+    deliveryInstructions: { leaveAtGate: false, additionalNote: '', doNotRingBell: false, bewareOfPets: false, returnPaperBag: false, leaveWithSecurity: false, returnCokePetBottle: false },
+    riderTip: 0, use_zepto_cash: true, zeptoPass: { isPassSelected: false },
+    isStoreChanged: false, isNightlyStore: false, manuallyAppliedFees: [], addAndSavePvIdsMap: {}, noBagDelivery: null,
+    userMeta: { whatsappOpted: 'PENDING', refresh: false, currentToPay: 0, currentGrandTotal: 0 },
+    userPreferences: { MANUAL_BXGY_BENEFIT: { opted: false }, Z_COINS: { opted: false } },
+    sessionMeta: { hasMovCrossed: true, lastMarketplaceType: 'SUPER_SAVER', toastNudgeViewed: {} },
+    openElements: { isPtpBottomSheetOpen: false, ptpBottomSheetLayoutId: '' },
+    user_action_meta: cartProducts.map((p) => ['atc', p.productVariantId]),
+    widgetLevelActions: {}, locationDistanceFromAddress: -1, installedUpiApps: [], isCredPayEligible: false,
+    isPtpLayoutMigrationEnabled: true, seenElementsInSession: { ptpBottomSheet: false, superSaverCart: true, seenWidgets: {} },
+  });
+  const pm = putCart.text.match(/"cartId"\s*:\s*"([0-9a-f-]{36})"/i);
+  if (pm) cartId = pm[1];
+
+  // store closed / paused → can't compute coupon
+  const ndr = putCart.text.match(/"nonDeliverableReason"\s*:\s*"([^"]+)"/);
+  const deliverable = /"isDeliverable"\s*:\s*true/.test(putCart.text);
+  if (!deliverable && ndr) {
+    return { coupons: [], status: 'store_unavailable', reason: ndr[1] };
+  }
+
+  // authoritative coupon source
+  const fl = await req(GW, 'POST', '/cfs/api/v1/cart/coupons/fetch-list', cartHeaders(session, STORE_ID), {
+    page_type: 'COUPON_REVAMP', useZCoins: false, activeTab: 'COUPONS_TAB', enableTabbedView: true,
+    props: {}, renderHeader: true, storeId: STORE_ID, cartId, latitude: lat, longitude: lng,
+    userAddressId: '', useZeptoCash: false, removedCampaignProducts: [], installedUpiApps: [], isCredPayEligible: false,
+  });
+  let coupons = parseCoupons(fl.text);
+
+  if (coupons.length === 0) {
+    const bwd = await req(GW, 'POST', '/cfs/api/v1/bulk-widget-data', cartHeaders(session, STORE_ID), {
+      widgets: [{ id: 100007034, pageIdentifier: 'cart_page', subscriptions: ['cart_change'] }],
+      cartProducts: PRODUCTS.map((p) => ({ storeProductId: p.storeProductId, productVariantId: p.productVariantId, mrp: p.price, markedPrice: p.price, quantity: 1, isDiscountApplicable: true, meta: {}, uclId: '' })),
+      enrichCall: true, campaignIds: [], couponIds: [], alreadyShownNudgeThresholds: [], alreadyShownNudgeThresholdsV2: [],
+      availedCampaignProducts: [], removedCampaigns: [], showAllOffers: true,
+      cartId, upsellPolicy: '', zeptoPassInfo: { isAddedToCart: false }, userActionMeta: [], latitude: lat, longitude: lng,
+    });
+    coupons = parseCoupons(bwd.text);
+  }
+  return { coupons, status: 'ok' };
+}
+
+// Classify the result into a tier. Returns { tier: 'rs50'|'rs75'|'rs100'|'normal'|'unchecked', amount, label }.
+export function classifyCoupon(result) {
+  if (!result || result.status === 'store_unavailable') {
+    return { tier: 'unchecked', amount: null, label: 'store closed — unchecked' };
+  }
+  const coupons = result.coupons || [];
+  const coded = coupons.filter((c) => c.code && /Z-CARTBOOST/.test(c.code));
+  if (coded.length) {
+    const amt = Math.max(...coded.map((c) => c.amount || 0));
+    return tierFor(amt, 'code');
+  }
+  const tierAmts = [...new Set(coupons.map((c) => c.amount).filter((a) => [50, 75, 100].includes(a)))];
+  const allAmts = [...new Set(coupons.map((c) => c.amount).filter(Boolean))];
+  if (allAmts.length >= 3) return { tier: 'normal', amount: 0, label: 'normal (no coupon)' };
+  if (tierAmts.length === 1) return tierFor(tierAmts[0], 'banner');
+  if (tierAmts.length > 1) return tierFor(Math.max(...tierAmts), 'banner');
+  return { tier: 'normal', amount: 0, label: 'normal (no coupon)' };
+}
+
+function tierFor(amt) {
+  if (amt >= 100) return { tier: 'rs100', amount: 100, label: '₹100 off' };
+  if (amt >= 75) return { tier: 'rs75', amount: 75, label: '₹75 off' };
+  if (amt >= 50) return { tier: 'rs50', amount: 50, label: '₹50 off' };
+  return { tier: 'normal', amount: 0, label: 'normal (no coupon)' };
+}
+
+// Top-level: given a logged-in zepto session, return the classified coupon tier.
+export async function checkCouponTier(session, opts = {}) {
+  const cs = couponSession(session);
+  if (!cs.token) return { tier: 'unchecked', amount: null, label: 'no token' };
+  let result;
+  try { result = await fetchCoupons(cs, opts); }
+  catch (e) { return { tier: 'unchecked', amount: null, label: `check failed: ${e.message}` }; }
+  return { ...classifyCoupon(result), coupons: result.coupons };
+}

package/src/worker.js

@@ -555,11 +555,12 @@ async function releaseNumber(provider, number, rentedAt, { log = () => {}, warn
 export const __releaseNumberForTest = releaseNumber;
 
 export class ZeptoWorker {
-  constructor(provider, { requested, concurrency, certSha, onEvent }) {
+  constructor(provider, { requested, concurrency, certSha, onEvent, checkCoupon }) {
     this.provider = provider;
     this.requested = requested;
     this.concurrency = Math.max(1, Math.min(concurrency, requested));
     this.certSha = certSha;
+    this.checkCoupon = !!checkCoupon; // also classify the ₹50/₹75/₹100 coupon tier
     this.onEvent = onEvent || (() => {});
     // Surface OTPCart re-logins (session taken over by another login) in the UI.
     if (provider && 'onNotice' in provider) provider.onNotice = (msg) => this.onEvent('warn', `⚠ ${msg}`);
@@ -727,9 +728,20 @@ export class ZeptoWorker {
       if (!v.ok) return fail(`verify: ${v.error}`);
 
       const envelope = zepto.encodeEnvelope(zepto.toSessionKeys(session), this.certSha);
-      this._emit(slot, { phase: 'saving', detail: 'encoding envelope' });
       res.status = 'success'; res.cost = number.cost; res.session = zepto.toSessionKeys(session); res.envelope = envelope;
-      releaseOnce(true, 'extracted', true); // success: OTP consumed → no cancel
+
+      // Optional coupon-tier check — token is fresh right now (just verified).
+      if (this.checkCoupon) {
+        this._emit(slot, { phase: 'coupon', detail: 'checking coupon tier' });
+        try {
+          const { checkCouponTier } = await import('./providers/zeptoCoupon.js');
+          const c = await checkCouponTier(session);
+          res.coupon_tier = c.tier; res.coupon_label = c.label; res.coupon_amount = c.amount;
+        } catch { res.coupon_tier = 'unchecked'; }
+      }
+
+      this._emit(slot, { phase: 'saving', detail: 'encoding envelope' });
+      releaseOnce(true, res.coupon_label || 'extracted', true); // success: OTP consumed → no cancel
       return res;
     } catch (e) {
       return fail(`unexpected: ${e.message}`);