const AUTH_PAYLOAD = {
  "adId": "uuid", //[a UUID, I'm not sure what it's for]
  "appVersion": "X.X.X", // app version
  "email": "", // since I signed up for facebook with my number, it kept this empty
  "gender": "", // didn't specify
  "id": "1220987183XXXXXXXX", // my facebook ID associated with the facebook app
  "idToken": "", // related with google auth, keeping it empty worked since I did facebook auth
  "nickname": "string", // the name of the login
  "profileUrl": "https://graph.facebook.com/v6.0/[user ID]/picture?type=large", // profile picture that contained my facebook user ID
  "timezone": -999, // the time zone relative to UTC?
  "token": "EAAXXX", // some blob that facebook callback returned; this doesn't seem to expire
  "type": "fb", // facebook auth
  "uniqueKey": "ABC123", // this comes up later
  "useDayLightType": 1 // day light time
};

[Desktop Entry]
Name=FB OAuth Handler (cashwalk)
Exec=/usr/bin/env node /path/to/fb_scheme_handler.js %u
Type=Application
StartupNotify=false
MimeType=x-scheme-handler/fb3063132263700744;
NoDisplay=true

#!/usr/bin/env node
// Usage: the OS will call this script with the custom-scheme URL as the first argument - this simulates what the phone would do
// The script will then POST the full URL to a local srever expected at http://localhost:8088/fb_token
// and also write it to /tmp/fb_oauth_capture.txt for debugging.

const http = require('http'); // use built in module so we dont need npm

function parseFragmentParams(fragment) {
	// fragment might be like access_token=...&id_token=...&state=... etc.
	if (!fragment) return null;
	const out = {};
	const parts = fragment.replace(/^#/, '').split('&');
	for (const p of parts) {
		const [k, v] = p.split('=');
		if (!k) continue;
		try { out[k] = decodeURIComponent(v || ''); } catch (e) { out[k] = v || ''; }
	}
	return Object.keys(out).length ? out : null;
}

async function postToLocal(dataObj) {
	try {
		const data = JSON.stringify(dataObj);
		const options = {
			hostname: 'localhost',
			port: 8088,
			path: '/fb_token',
			method: 'POST',
			headers: {
				'Content-Type': 'application/json',
				'Content-Length': Buffer.byteLength(data)
			}
		};
		return await new Promise((resolve, reject) => {
			const req = http.request(options, (res) => {
				let body = '';
				res.on('data', chunk => body += chunk);
				res.on('end', () => resolve({ status: res.statusCode, body }));
			});
			req.on('error', reject);
			req.write(data);
			req.end();
		});
	} catch (e) {
		return { error: e.message };
	}
}

(async function main(){
	try {
		const url = process.argv[2];
		if (!url) {
			console.error('No URL provided to scheme handler');
			process.exit(1);
		}
			// write to tmp for debugging/local inspection
			try { require('fs').writeFileSync('/tmp/fb_oauth_capture.txt', url + '\n', { flag: 'a' }); } catch (e) {}

			// parse the URL and fragment into token fields when possible
			let payload = null;
			try {
				const parsed = new URL(url);
				// fragment after '#'
				const frag = parsed.hash || '';
				const fragParams = parseFragmentParams(frag);
				if (fragParams && (fragParams.access_token || fragParams.id_token)) {
					payload = fragParams;
				} else {
					const q = {};
					for (const [k, v] of parsed.searchParams.entries()) q[k] = v;
					if (q.access_token || q.id_token) payload = q;
				}
			} catch (e) {
				// malformed URL, fallback to raw
				payload = null;
			}

			const res = await postToLocal(payload ? payload : { url });
		if (res && res.status) {
			console.log('Posted to local server:', res.status);
			process.exit(0);
		}
		console.error('Failed to POST to local server:', res.error || res);
		process.exit(1);
	} catch (err) {
		console.error('Handler error:', err && err.message ? err.message : err);
		process.exit(2);
	}
})();

cp fb3063132263700744.desktop ~/.local/share/applications/
update-desktop-database ~/.local/share/applications || true
xdg-mime default fb3063132263700744.desktop x-scheme-handler/fb3063132263700744

const crypto = require('crypto');
let fetch;
try { fetch = globalThis.fetch; } catch (e) { /* ignore */ }
if (!fetch) {
  try { fetch = require('node-fetch'); } catch (e) { /* node-fetch not installed */ }
}
const http = require('http');
const { exec } = require('child_process');

// --- API Endpoints ---
const AUTH_ENDPOINT = 'http://api.cashwalklabs.io/v1/user';
const STEP_RECORD_ENDPOINT = 'http://api.cashwalklabs.io/v2/record/step';
const STEP_COIN_ENDPOINT_V1 = 'http://api.cashwalklabs.io/v1/stepcoin';
const LUCKYBOX_ENDPOINT = 'http://api.cashwalklabs.io/v2/lucky-box';
const BONUS_ENDPOINT = 'http://api.cashwalklabs.io/v2/lucky-box/bonus';

// --- Configuration ---
const AUTH_PAYLOAD = {
  adId: crypto.randomUUID(),
  "appVersion": "1.4.9",
  email: '',
  gender: '',
  id: '',
  idToken: '',
  nickname: '',
  profileUrl: '',
  timezone: -360,
  "token": null, // This will be populated by the Facebook OAuth flow
  type: 'fb',
  "uniqueKey": "[redacted]", // I redacted my uniqueKey
  useDayLightType: 1
};
const DEFAULT_FB_APP_ID = '3063132263700744';

// --- Helper Functions ---
const sleep = ms => new Promise(res => setTimeout(res, ms));

async function apiRequest(url, options) {
  try {
    const res = await fetch(url, options);
    const text = await res.text();
    let json = null;
    try { json = text ? JSON.parse(text) : null; } catch (e) { json = null; }
    return { status: res.status, ok: res.ok, json, rawText: text };
  } catch (err) {
    return { status: 500, ok: false, json: { error: err.message } };
  }
}

// --- Authentication ---
async function facebookOAuthFlow({ appId, port = 8088, scope = 'public_profile,email' } = {}) {
  return new Promise((resolve, reject) => {
    const nonce = crypto.randomBytes(16).toString('hex');
    const redirectUri = `fb${appId}://authorize/`;
    const openAuthUrl = (authUrl) => {
      console.log('Opening browser to Facebook login — if it does not open, visit:');
      console.log(authUrl);
      const opener = process.platform === 'win32' ? 'start' : process.platform === 'darwin' ? 'open' : 'xdg-open';
      exec(`${opener} "${authUrl}"`, (err) => { if (err) console.log('Please open the URL manually'); });
    };
    const base64url = (buf) => buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
    const codeVerifier = base64url(crypto.randomBytes(32));
    const codeChallenge = base64url(crypto.createHash('sha256').update(codeVerifier).digest());
    const stateObj = { "0_auth_logger_id": crypto.randomUUID(), "3_method": "custom_tab", "7_challenge": codeChallenge.slice(0, 20) };
    const stateParam = JSON.stringify(stateObj);
    const cbt = Date.now();
    const e2e = JSON.stringify({ init: cbt });
    const authParams = new URLSearchParams({
      cct_prefetching: '0', client_id: appId, cbt: String(cbt), e2e, ies: '0',
      sdk: 'android-16.3.0', sso: 'chrome_custom_tab', nonce, scope,
      response_type: 'id_token,token,signed_request,graph_domain',
      state: stateParam, code_challenge_method: 'S256', code_challenge: codeChallenge,
      default_audience: 'friends', login_behavior: 'NATIVE_WITH_FALLBACK',
      redirect_uri: redirectUri, auth_type: 'rerequest', return_scopes: 'true'
    });
    const authUrl = `https://m.facebook.com/v16.0/dialog/oauth?${authParams.toString()}`;
    const server = http.createServer(async (req, res) => {
      if (req.method === 'POST' && req.url === '/fb_token') {
        let body = '';
        req.on('data', chunk => body += chunk.toString());
        req.on('end', () => {
          const parsed = JSON.parse(body);
          const accessToken = parsed.access_token || parsed.token || null;
          if (!accessToken) {
            server.close();
            return reject(new Error('Missing token in POST from browser'));
          }
          res.writeHead(200, { 'Content-Type': 'text/html' });
          res.end('<html><body><h2>Authentication successful! You can close this window.</h2></body></html>');
          server.close();
          resolve(accessToken);
        });
        return;
      }
      res.writeHead(200, { 'Content-Type': 'text/html' });
      res.end(`<!doctype html><html><body><script>
        (function(){
          const hash = location.hash.substring(1);
          const parts = hash.split('&').reduce((acc, kv)=>{ const [k,v]=kv.split('='); if(k) acc[k]=decodeURIComponent(v); return acc; },{});
          fetch('/fb_token', {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(parts)})
            .then(()=>document.body.innerText='Logged in! You can close this window.')
            .catch(e=>document.body.innerText='Error sending token to script.');
        })();
      </script></body></html>`);
    });
    server.listen(port, () => openAuthUrl(authUrl));
    setTimeout(() => { try { server.close(); } catch (e) {} ; reject(new Error('OAuth flow timed out')); }, 5 * 60 * 1000);
  });
}

async function authenticate() {
  console.log('Authenticating...');
  console.log('Attempting interactive Facebook OAuth flow...');
  try {
    const fbToken = await facebookOAuthFlow({ appId: DEFAULT_FB_APP_ID });
    AUTH_PAYLOAD.token = fbToken;
    console.log('Fetching Facebook profile...');
    const graphUrl = new URL('https://graph.facebook.com/v16.0/me');
    graphUrl.search = new URLSearchParams({ fields: 'id,name,picture.type(large)', access_token: fbToken }).toString();
    const fbRes = await apiRequest(graphUrl.toString(), { method: 'GET' });
    if (!fbRes.ok || !fbRes.json) {
      throw new Error(`Failed to fetch Facebook profile: HTTP ${fbRes.status} ${fbRes.rawText}`);
    }
    const { id, name, picture } = fbRes.json;
    if (!id || !name || !picture?.data?.url) {
      throw new Error('Incomplete data received from Facebook Graph API');
    }
    AUTH_PAYLOAD.id = id;
    AUTH_PAYLOAD.nickname = name;
    AUTH_PAYLOAD.profileUrl = picture.data.url;
    console.log(`✅ Fetched profile for: ${name} (ID: ${id})`);

    const { ok, json, status } = await apiRequest(AUTH_ENDPOINT, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json; charset=UTF-8', 'User-Agent': 'okhttp/4.10.0' },
      body: JSON.stringify(AUTH_PAYLOAD)
    });
    if (!ok) throw new Error(`Auth failed: HTTP ${status} ${JSON.stringify(json)}`);
    const token = json?.result?.token;
    if (!token) throw new Error('Token not found in auth response after FB OAuth');
    console.log('✅ Authenticated successfully!');
    return token;
  } catch (err) {
    console.error('Authentication failed:', err.message || err);
    throw err;
  }
}

// --- Step Points Logic ---
async function getExistingDaySteps(token, dateStr) {
  const url = `${STEP_RECORD_ENDPOINT}?access_token=${encodeURIComponent(token)}&from=${dateStr}&to=${dateStr}&type=day`;
  const { ok, json } = await apiRequest(url, { method: 'GET', headers: { 'User-Agent': 'okhttp/4.10.0' } });
  if (!ok) return null;
  const rec = json?.result?.[0];
  const stepArr = rec && Array.isArray(rec.step) ? rec.step : null;
  if (!stepArr) return null;
  const out = Array(24).fill(0);
  for (let i = 0; i < Math.min(24, stepArr.length); i++) out[i] = Number(stepArr[i] || 0);
  return out;
}

async function uploadSteps(token, stepsDelta) {
  const now = new Date();
  const dateStr = now.toISOString().slice(0, 10);
  const currentHour = now.getHours();
  const stepArray = await getExistingDaySteps(token, dateStr) || Array(24).fill(0);
  let remainingSteps = stepsDelta;
  if (currentHour > 0) {
    const scatterPercentage = Math.random() * 0.3 + 0.2;
    let stepsToScatter = Math.floor(stepsDelta * scatterPercentage);
    remainingSteps -= stepsToScatter;
    const numActivityBlocks = Math.floor(Math.random() * 3) + 1;
    for (let i = 0; i < numActivityBlocks; i++) {
      if (stepsToScatter <= 0) break;
      const pastHour = Math.floor(Math.random() * currentHour);
      const stepsForThisBlock = (i === numActivityBlocks - 1) ? stepsToScatter : Math.floor(stepsToScatter * Math.random());
      stepArray[pastHour] = (stepArray[pastHour] || 0) + stepsForThisBlock;
      stepsToScatter -= stepsForThisBlock;
    }
  }
  stepArray[currentHour] = (stepArray[currentHour] || 0) + remainingSteps;
  const finalStepArray = stepArray.map(s => Math.floor(s));
  const body = { record: [{ date: dateStr, step: finalStepArray }], timezone: -360, useDayLightType: 1 };
  const url = `${STEP_RECORD_ENDPOINT}?access_token=${encodeURIComponent(token)}`;
  const { ok, status, json } = await apiRequest(url, {
    method: 'PUT',
    headers: { 'Content-Type': 'application/json; charset=UTF-8', 'User-Agent': 'okhttp/4.10.0' },
    body: JSON.stringify(body)
  });
  if (!ok) throw new Error(`Upload failed: HTTP ${status} ${JSON.stringify(json)}`);
  console.log(`✅ PUT ${stepsDelta} steps, distributed across hours up to hour ${currentHour} (date ${dateStr})`);
}

async function getDayTotal(token, dateStr) {
  const arr = await getExistingDaySteps(token, dateStr);
  return arr ? arr.reduce((a, b) => a + Number(b || 0), 0) : 0;
}

async function claimStepcoin(token, points = 1) {
  const requestId = crypto.randomUUID();
  const params = new URLSearchParams({ timezone: '-360', useDaylightType: '1', requestId }).toString();
  const url = `${STEP_COIN_ENDPOINT_V1}/${points}?${params}`;
  const body = new URLSearchParams({ access_token: token }).toString();
  const headers = {
    'Content-Type': 'application/x-www-form-urlencoded',
    'User-Agent': 'okhttp/4.10.0'
  };
  const { ok, json, status } = await apiRequest(url, { method: 'PUT', headers, body });
  if (!ok) {
    console.error(`Claim of ${points} points failed: HTTP ${status}`);
    if (status === 500 && json?.error?.code === 452) {
      return { success: false, limitReached: true };
    }
    return { success: false, limitReached: false };
  }
  console.log(`✅ Claimed ${points} stepcoin (requestId=${requestId})`);
  return { success: true };
}

async function performSingleSprint(token) {
  let totalPointsClaimedThisRun = 0;
  let dailyLimitReached = false;
  const dailyTarget = 100;
  const maxChunk = 6;
  while (totalPointsClaimedThisRun < dailyTarget && !dailyLimitReached) {
    const stepsThisBatch = Math.floor(Math.random() * 50 + 500);
    await uploadSteps(token, stepsThisBatch);
    const today = new Date().toISOString().slice(0, 10);
    const serverTotalSteps = await getDayTotal(token, today);
    console.log(`Server total for ${today}: ${serverTotalSteps} steps`);
    const availablePoints = Math.floor(serverTotalSteps / 100);
    let remainingToClaim = Math.min(availablePoints - totalPointsClaimedThisRun, dailyTarget - totalPointsClaimedThisRun);
    if (remainingToClaim <= 0) {
      console.log('Not enough steps banked to claim more points. Adding more steps...');
      await sleep(2000 + Math.floor(Math.random() * 2000));
      continue;
    }
    console.log(`Will attempt to claim up to ${remainingToClaim} point(s) in chunks`);
    while (remainingToClaim > 0) {
      const chunk = Math.min(remainingToClaim, maxChunk);
      const result = await claimStepcoin(token, chunk);
      if (result.success) {
        totalPointsClaimedThisRun += chunk;
        remainingToClaim -= chunk;
        await sleep(600 + Math.floor(Math.random() * 400));
      } else {
        if (result.limitReached) {
          console.log('Server indicated daily limit has been reached. Halting all claims.');
          dailyLimitReached = true;
          break;
        }
        if (chunk > 1) {
          const smaller = Math.max(1, Math.floor(chunk / 2));
          console.log(`Chunk ${chunk} failed; trying smaller chunk ${smaller}`);
          const retryResult = await claimStepcoin(token, smaller);
          if (retryResult.success) {
            totalPointsClaimedThisRun += smaller;
            remainingToClaim -= smaller;
            await sleep(600 + Math.floor(Math.random() * 400));
            continue;
          }
        }
        console.error('Chunk claim failed; stopping claims for this cycle.');
        break;
      }
    }
    console.log(`Points claimed in this run: ${totalPointsClaimedThisRun}/${dailyTarget}`);
    if (dailyLimitReached) break;
  }
  console.log(`🎉 Sprint Finished. Total points claimed: ${totalPointsClaimedThisRun}`);
  return dailyLimitReached;
}

// --- Lucky Box Logic ---
async function openLuckyBoxes(token) {
  console.log('\n--- 🎁 Starting Lucky Box Opening ---');
  for (let i = 0; i < 7; i++) {
    // Step 1: Normal lucky box open
    const boxBody = { boxNumber: i, timeZone: -360, useDaylightType: true, isLuckyBoxTimeOut: false };
    const url = `${LUCKYBOX_ENDPOINT}?access_token=${encodeURIComponent(token)}`;
    console.log(`Opening lucky box #${i}...`);
    const res1 = await apiRequest(url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json; charset=UTF-8', 'User-Agent': 'okhttp/4.10.0' },
        body: JSON.stringify(boxBody),
    });
    console.log(`Box #${i} normal response:`, res1.status, res1.json ?? '(no JSON)');
    await sleep(500 + Math.random() * 500); // Small delay

    // Step 2: Bonus lucky box open
    const bonusBody = new URLSearchParams({ boxNumber: i, timeZone: -360 }).toString();
    console.log(`Claiming bonus for box #${i}...`);
    const res2 = await apiRequest(BONUS_ENDPOINT, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
            'User-Agent': 'okhttp/4.10.0',
            'Authorization': `Bearer ${token}`
        },
        body: bonusBody,
    });
    console.log(`Box #${i} bonus response:`, res2.status, res2.json ?? '(no JSON)');
    await sleep(1000 + Math.random() * 1000); // Longer delay between boxes
  }
}

// --- Main Execution ---
async function main() {
  let token;
  try {
    token = await authenticate();
  } catch (err) {
    console.error('Initial authentication failed. The script cannot continue.', err.message || err);
    return;
  }

  try {
    console.log('\n--- 🚀 Starting Step Sprints ---');
    let limitWasHit = false;
    let sprintCount = 1;
    while (!limitWasHit) {
      console.log(`\n--- Sprint #${sprintCount} ---`);
      limitWasHit = await performSingleSprint(token);
      if (limitWasHit) {
        console.log('\n✅ Daily stepcoin limit reached.');
      } else {
        console.log(`\n--- Sprint #${sprintCount} complete. ---`);
        sprintCount++;
        await sleep(2000);
      }
    }

    await openLuckyBoxes(token);

    console.log('\n🎉 All tasks have been completed successfully!');

  } catch (err) {
    console.error('A fatal error occurred during script execution:', err.message || err);
  }
}

main();

#!/bin/bash

# --- Configuration ---
AVD_NAME="cashwalk"
MEMORY="8096"
PROXY="http://127.0.0.1:8080"
CERT_FILE="c8750f0d.0" # Make sure this file is in the same directory as the script

# --- Script Start ---
echo "✅ Starting the All-in-One AVD Prep Script..."

# Step 1: Launch the emulator in the background in writable mode
echo "⏳ Launching AVD '$AVD_NAME' in writable mode..."
emulator -avd "$AVD_NAME" -writable-system -no-snapshot-load -memory "$MEMORY" -http-proxy "$PROXY" &

# Step 2: Wait for the device to be fully booted
echo "⏳ Waiting for emulator to boot completely..."
adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;'
echo "✅ Emulator is booted."

# Step 3: Prepare the certificate
echo "🔧 Preparing the certificate for installation..."
echo "✅ Certificate renamed to $CERT_FILE"

# Step 4: Install the certificate
echo "⏳ Installing certificate as a system trusted CA..."
adb root
adb remount
adb push "$CERT_FILE" /system/etc/security/cacerts/
adb shell "chmod 644 /system/etc/security/cacerts/$CERT_FILE && reboot"
echo "✅ Certificate pushed and permissions set. Rebooting emulator..."

# Step 5: Clean up the temporary cert file
rm "$CERT_FILE"

echo "🎉 --- SETUP COMPLETE --- 🎉"
echo "The emulator has rebooted with the system certificate installed."
echo "You can now launch it normally for your analysis."