strade-stx-scripts 1.0.0 → 1.0.1

package/auto-activity.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+REPO_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+echo "Auto-activity started. Running every 3 minutes. Press Ctrl+C to stop."
+while true; do
+  echo "[$(date '+%Y-%m-%d %H:%M:%S')] Running generate-activity..."
+  cd "$REPO_DIR" && npx tsx scripts/generate-activity.ts
+  echo "[$(date '+%Y-%m-%d %H:%M:%S')] Done. Sleeping 3 minutes..."
+  sleep 180
+done

package/cancel-pending.ts

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// Cancels all pending mempool txs by replacing them with 0-value self-transfers at higher fee
+import { generateWallet, generateNewAccount } from '@stacks/wallet-sdk';
+import { getAddressFromPrivateKey, makeSTXTokenTransfer, AnchorMode } from '@stacks/transactions';
+import { StacksMainnet } from '@stacks/network';
+import { readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { resolve } from 'path';
+import { execSync } from 'child_process';
+
+const ACCOUNTS_TO_CANCEL = [24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49];
+const CANCEL_FEE = 2000n; // higher than original to replace
+
+const toml = readFileSync(resolve('settings/Mainnet.toml'), 'utf8');
+const mnemonic = toml.match(/mnemonic\s*=\s*"([^"]+)"/)![1];
+
+let wallet = await generateWallet({ secretKey: mnemonic, password: '' });
+for (let i = 1; i < 50; i++) wallet = generateNewAccount(wallet);
+
+const network = new StacksMainnet();
+
+for (const i of ACCOUNTS_TO_CANCEL) {
+  const pk = wallet.accounts[i].stxPrivateKey;
+  const address = getAddressFromPrivateKey(pk, network.version);
+
+  // Get pending txs from mempool
+  const mempool = JSON.parse(execSync(`curl -s 'https://api.hiro.so/extended/v1/address/${address}/mempool?limit=50'`).toString());
+  const pendingTxs = mempool.results ?? [];
+
+  if (pendingTxs.length === 0) {
+    console.log(`Account ${i}: ${address} — no pending txs`);
+    continue;
+  }
+
+  // Get unique nonces of pending txs
+  const nonces: Set<number> = new Set(pendingTxs.map((tx: any) => tx.nonce));
+  console.log(`Account ${i}: ${address} — cancelling nonces: ${[...nonces].join(', ')}`);
+
+  for (const nonce of nonces) {
+    const bal = BigInt(JSON.parse(execSync(`curl -s 'https://api.hiro.so/v2/accounts/${address}?proof=0'`).toString()).balance);
+    if (bal < CANCEL_FEE) { console.log(`  nonce ${nonce}: insufficient balance, skipping`); continue; }
+
+    const tx = await makeSTXTokenTransfer({
+      recipient: address, // send to self
+      amount: 1n,
+      senderKey: pk,
+      network,
+      anchorMode: AnchorMode.Any,
+      nonce,
+      fee: CANCEL_FEE,
+    });
+
+    const tmp = `/tmp/cancel_${i}_${nonce}.bin`;
+    writeFileSync(tmp, tx.serialize());
+    const result = execSync(`curl -s --max-time 30 -X POST 'https://api.hiro.so/v2/transactions' -H 'Content-Type: application/octet-stream' --data-binary @${tmp}`, { timeout: 35000 }).toString();
+    unlinkSync(tmp);
+
+    const parsed = JSON.parse(result);
+    if (typeof parsed === 'string' && parsed.length === 64) {
+      console.log(`  ✅ nonce ${nonce} replaced — txid: ${parsed}`);
+    } else {
+      console.error(`  ❌ nonce ${nonce} — ${result}`);
+    }
+    await new Promise(r => setTimeout(r, 500));
+  }
+}
+
+console.log('\nDone! Run drain-accounts.ts after these confirm.');

package/check-balances.ts

@@ -0,0 +1,23 @@
+import { generateWallet, generateNewAccount } from '@stacks/wallet-sdk';
+import { getAddressFromPrivateKey } from '@stacks/transactions';
+import { StacksMainnet } from '@stacks/network';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { execSync } from 'child_process';
+
+const toml = readFileSync(resolve('settings/Mainnet.toml'), 'utf8');
+const mnemonic = toml.match(/mnemonic\s*=\s*"([^"]+)"/)![1];
+let wallet = await generateWallet({ secretKey: mnemonic, password: '' });
+for (let i = 1; i < 50; i++) wallet = generateNewAccount(wallet);
+const network = new StacksMainnet();
+
+let total = 0;
+for (let i = 0; i < 50; i++) {
+  const address = getAddressFromPrivateKey(wallet.accounts[i].stxPrivateKey, network.version);
+  const d = JSON.parse(execSync(`curl -s 'https://api.hiro.so/v2/accounts/${address}?proof=0'`).toString());
+  const bal = parseInt(d.balance, 16) / 1e6;
+  total += bal;
+  console.log(`Account ${i.toString().padStart(2)}: ${address} — ${bal.toFixed(6)} STX`);
+  await new Promise(r => setTimeout(r, 300));
+}
+console.log(`\nTotal: ${total.toFixed(6)} STX`);

package/distribute-evenly.ts

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+// Distributes 15 STX evenly among all 50 accounts: 0.3 STX each. Account 0 retains its 0.3 STX share, sends 0.3 STX to accounts 1-49.
+import { generateWallet, generateNewAccount } from '@stacks/wallet-sdk';
+import { getAddressFromPrivateKey, makeSTXTokenTransfer, AnchorMode } from '@stacks/transactions';
+import { StacksMainnet } from '@stacks/network';
+import { readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { resolve } from 'path';
+import { execSync } from 'child_process';
+
+const curlFetch = async (url: string, opts: any = {}) => {
+  const method = opts.method || 'GET';
+  const headers = opts.headers ? Object.entries(opts.headers).map(([k,v]) => `-H '${k}: ${v}'`).join(' ') : '';
+  if (opts.body) {
+    const tmp = `/tmp/cf_${Date.now()}.bin`;
+    writeFileSync(tmp, opts.body);
+    const r = execSync(`curl -s --max-time 30 -X ${method} ${headers} --data-binary @${tmp} '${url}'`, { timeout: 35000 }).toString();
+    unlinkSync(tmp);
+    return { ok: true, json: async () => JSON.parse(r), text: async () => r };
+  }
+  const r = execSync(`curl -s --max-time 15 '${url}'`, { timeout: 20000 }).toString();
+  return { ok: true, json: async () => JSON.parse(r), text: async () => r };
+};
+
+const SEND_AMOUNT = 300_000n; // 0.3 STX each × 49 = 14.7 STX sent, account 0 retains 0.3 STX = 15 STX total
+const toml = readFileSync(resolve('settings/Mainnet.toml'), 'utf8');
+const mnemonic = toml.match(/mnemonic\s*=\s*"([^"]+)"/)![1];
+
+let wallet = await generateWallet({ secretKey: mnemonic, password: '' });
+for (let i = 1; i < 50; i++) wallet = generateNewAccount(wallet);
+
+const network = new StacksMainnet({ fetchFn: curlFetch as any });
+const senderKey = wallet.accounts[0].stxPrivateKey;
+const senderAddress = getAddressFromPrivateKey(senderKey, network.version);
+const nonceData = JSON.parse(execSync(`curl -s 'https://api.hiro.so/extended/v1/address/${senderAddress}/nonces'`).toString());
+let nonce = nonceData.possible_next_nonce;
+
+console.log(`\nSender: ${senderAddress} | Nonce: ${nonce}`);
+console.log(`Distributing ${Number(SEND_AMOUNT * 49n) / 1e6} STX total — account 0 retains ${Number(SEND_AMOUNT) / 1e6} STX, accounts 1-49 each receive ${Number(SEND_AMOUNT) / 1e6} STX\n`);
+
+for (let i = 1; i < 50; i++) {
+  const address = getAddressFromPrivateKey(wallet.accounts[i].stxPrivateKey, network.version);
+  const tx = await makeSTXTokenTransfer({ recipient: address, amount: SEND_AMOUNT, senderKey, network, anchorMode: AnchorMode.Any, nonce });
+  const tmp = `/tmp/dist_${i}.bin`;
+  writeFileSync(tmp, tx.serialize());
+  const result = execSync(`curl -s --max-time 30 -X POST 'https://api.hiro.so/v2/transactions' -H 'Content-Type: application/octet-stream' --data-binary @${tmp}`, { timeout: 35000 }).toString();
+  unlinkSync(tmp);
+  const parsed = JSON.parse(result);
+  if (typeof parsed === 'string' && parsed.length === 64) {
+    console.log(`✅ Account ${i}: ${address} — sent ${Number(SEND_AMOUNT) / 1e6} STX`);
+  } else {
+    console.error(`❌ Account ${i}: ${address} — ${result}`);
+  }
+  nonce++;
+  await new Promise(r => setTimeout(r, 500));
+}
+console.log(`\nDone! ${Number(SEND_AMOUNT * 49n) / 1e6} STX distributed across 49 accounts. Account 0 retains ${Number(SEND_AMOUNT) / 1e6} STX. Total: 15 STX evenly split among all 50 accounts.`);

package/drain-accounts.ts

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+// Drains accounts 10-49 back to account 0
+import { generateWallet, generateNewAccount } from '@stacks/wallet-sdk';
+import { getAddressFromPrivateKey, makeSTXTokenTransfer, AnchorMode } from '@stacks/transactions';
+import { StacksMainnet } from '@stacks/network';
+import { readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { resolve } from 'path';
+import { execSync } from 'child_process';
+
+const NUM_ACCOUNTS = 41; // only drain accounts 35 and 40
+const KEEP_ACCOUNTS = 35;
+const FEE = 300n;
+
+const toml = readFileSync(resolve('settings/Mainnet.toml'), 'utf8');
+const mnemonic = toml.match(/mnemonic\s*=\s*"([^"]+)"/)![1];
+
+let wallet = await generateWallet({ secretKey: mnemonic, password: '' });
+for (let i = 1; i < NUM_ACCOUNTS; i++) wallet = generateNewAccount(wallet);
+
+const network = new StacksMainnet();
+const recipient = getAddressFromPrivateKey(wallet.accounts[0].stxPrivateKey, network.version);
+console.log(`Draining accounts ${KEEP_ACCOUNTS}-${NUM_ACCOUNTS - 1} → ${recipient}\n`);
+
+for (let i = KEEP_ACCOUNTS; i < NUM_ACCOUNTS; i++) {
+  await new Promise(r => setTimeout(r, 4000)); // delay before each account to avoid rate limits
+  const pk = wallet.accounts[i].stxPrivateKey;
+  const address = getAddressFromPrivateKey(pk, network.version);
+  let d: any;
+  try {
+    d = JSON.parse(execSync(`curl -s 'https://api.hiro.so/v2/accounts/${address}?proof=0'`).toString());
+  } catch { console.log(`Account ${i}: rate limited, skipping`); continue; }
+  const balance = BigInt(d.balance ?? '0x0');
+  const sendAmount = balance - FEE;
+
+  if (sendAmount <= 0n) {
+    console.log(`Account ${i}: ${address} — skipped (balance: ${Number(balance)/1e6} STX)`);
+    continue;
+  }
+
+  const nonceRaw = execSync(`curl -s 'https://api.hiro.so/extended/v1/address/${address}/nonces'`).toString();
+  if (nonceRaw.includes('rate limit')) { console.log(`Account ${i}: rate limited on nonce, skipping`); continue; }
+  const nonceData = JSON.parse(nonceRaw);
+  const nonce = nonceData.possible_next_nonce;
+
+  const tx = await makeSTXTokenTransfer({
+    recipient,
+    amount: sendAmount,
+    senderKey: pk,
+    network,
+    anchorMode: AnchorMode.Any,
+    nonce,
+    fee: FEE,
+  });
+
+  const tmp = `/tmp/drain_${i}.bin`;
+  writeFileSync(tmp, tx.serialize());
+  const result = execSync(`curl -s --max-time 30 -X POST 'https://api.hiro.so/v2/transactions' -H 'Content-Type: application/octet-stream' --data-binary @${tmp}`, { timeout: 35000 }).toString();
+  unlinkSync(tmp);
+
+  if (result.includes('rate limit')) { console.log(`Account ${i}: rate limited on broadcast, skipping`); continue; }
+  const parsed = JSON.parse(result);
+  if (typeof parsed === 'string' && parsed.length === 64) {
+    console.log(`✅ Account ${i}: ${address} — drained ${Number(sendAmount)/1e6} STX — txid: ${parsed}`);
+  } else {
+    console.error(`❌ Account ${i}: ${address} — ${result}`);
+  }
+  await new Promise(r => setTimeout(r, 1000));
+}
+
+console.log('\nDone!');

package/fund-accounts.ts

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+/**
+ * Funds derived accounts 1-49 from account 0.
+ * Run once before generate-activity.ts
+ */
+import {
+  makeSTXTokenTransfer,
+  AnchorMode,
+  getAddressFromPrivateKey,
+} from '@stacks/transactions';
+import { StacksMainnet } from '@stacks/network';
+import { generateWallet, generateNewAccount } from '@stacks/wallet-sdk';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { execSync } from 'child_process';
+
+// Use curl-based fetch to bypass Node.js network restrictions
+const curlFetch = async (url: string, opts: any = {}) => {
+  const method = opts.method || 'GET';
+  const body = opts.body ? `-d '${opts.body}'` : '';
+  const headers = opts.headers ? Object.entries(opts.headers).map(([k,v]) => `-H '${k}: ${v}'`).join(' ') : '';
+  const result = execSync(`curl -s -X ${method} ${headers} ${body} '${url}'`, { timeout: 15000 }).toString();
+  return { ok: true, json: async () => JSON.parse(result), text: async () => result };
+};
+
+const NUM_ACCOUNTS = 50;
+const FUND_AMOUNT = 100_000n; // 0.1 STX in microSTX
+const FEE = 300n;
+
+const toml = readFileSync(resolve('settings/Mainnet.toml'), 'utf8');
+const mnemonic = toml.match(/mnemonic\s*=\s*"([^"]+)"/)![1];
+
+let wallet = await generateWallet({ secretKey: mnemonic, password: '' });
+for (let i = 1; i < NUM_ACCOUNTS; i++) wallet = generateNewAccount(wallet);
+
+const network = new StacksMainnet({ fetchFn: curlFetch as any });
+const senderKey = wallet.accounts[0].stxPrivateKey;
+const senderAddress = getAddressFromPrivateKey(senderKey, network.version);
+
+const res = await curlFetch(`https://api.hiro.so/v2/accounts/${senderAddress}?proof=0`);
+const data = await res.json() as { nonce: number; balance: string };
+let nonce = data.nonce;
+const balance = BigInt(data.balance);
+
+console.log(`Sender: ${senderAddress}`);
+console.log(`Balance: ${Number(balance) / 1e6} STX`);
+console.log(`Funding ${NUM_ACCOUNTS - 1} accounts with ${Number(FUND_AMOUNT) / 1e6} STX each\n`);
+
+const totalNeeded = (FUND_AMOUNT + FEE) * BigInt(NUM_ACCOUNTS - 1) + FEE;
+if (balance < totalNeeded) {
+  console.error(`Insufficient balance. Need ${Number(totalNeeded) / 1e6} STX, have ${Number(balance) / 1e6} STX`);
+  process.exit(1);
+}
+
+import { writeFileSync, unlinkSync } from 'fs';
+
+for (let i = 1; i < NUM_ACCOUNTS; i++) {
+  const recipient = getAddressFromPrivateKey(wallet.accounts[i].stxPrivateKey, network.version);
+  const tx = await makeSTXTokenTransfer({
+    recipient,
+    amount: FUND_AMOUNT,
+    senderKey,
+    network,
+    anchorMode: AnchorMode.Any,
+    nonce,
+    fee: FEE,
+  });
+
+  // Write serialized tx to temp file and POST via curl
+  const tmpFile = `/tmp/stx_tx_${i}.bin`;
+  writeFileSync(tmpFile, tx.serialize());
+  const result = execSync(
+    `curl -s -X POST 'https://api.hiro.so/v2/transactions' -H 'Content-Type: application/octet-stream' --data-binary @${tmpFile}`,
+    { timeout: 15000 }
+  ).toString();
+  unlinkSync(tmpFile);
+
+  const parsed = JSON.parse(result);
+  if (typeof parsed === 'string' && parsed.length === 64) {
+    console.log(`✅ Funded account ${i}: ${recipient} — txid: ${parsed}`);
+  } else {
+    console.error(`❌ Failed account ${i}: ${recipient} — ${result}`);
+  }
+  nonce++;
+  await new Promise(r => setTimeout(r, 500));
+}
+
+console.log('\nDone! Wait ~10 min for txs to confirm before running generate-activity.ts');

package/fund-active.ts

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+// Funds only accounts 1-9 (the 10 active accounts) if balance < 0.05 STX
+import { generateWallet, generateNewAccount } from '@stacks/wallet-sdk';
+import { getAddressFromPrivateKey, makeSTXTokenTransfer, AnchorMode } from '@stacks/transactions';
+import { StacksMainnet } from '@stacks/network';
+import { readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { resolve } from 'path';
+import { execSync } from 'child_process';
+
+const curlFetch = async (url: string, opts: any = {}) => {
+  const method = opts.method || 'GET';
+  const headers = opts.headers ? Object.entries(opts.headers).map(([k,v]) => `-H '${k}: ${v}'`).join(' ') : '';
+  if (opts.body) {
+    const tmp = `/tmp/cf_${Date.now()}.bin`;
+    writeFileSync(tmp, opts.body);
+    const r = execSync(`curl -s --max-time 30 -X ${method} ${headers} --data-binary @${tmp} '${url}'`, { timeout: 35000 }).toString();
+    unlinkSync(tmp);
+    return { ok: true, json: async () => JSON.parse(r), text: async () => r };
+  }
+  const r = execSync(`curl -s --max-time 15 '${url}'`, { timeout: 20000 }).toString();
+  return { ok: true, json: async () => JSON.parse(r), text: async () => r };
+};
+
+const FUND_AMOUNT = 300_000n; // 0.3 STX — evenly distributes ~15 STX across 50 accounts
+const toml = readFileSync(resolve('settings/Mainnet.toml'), 'utf8');
+const mnemonic = toml.match(/mnemonic\s*=\s*"([^"]+)"/)![1];
+
+let wallet = await generateWallet({ secretKey: mnemonic, password: '' });
+for (let i = 1; i < 50; i++) wallet = generateNewAccount(wallet);
+
+const network = new StacksMainnet({ fetchFn: curlFetch as any });
+const senderKey = wallet.accounts[0].stxPrivateKey;
+const senderAddress = getAddressFromPrivateKey(senderKey, network.version);
+const nonceData = JSON.parse(execSync(`curl -s 'https://api.hiro.so/extended/v1/address/${senderAddress}/nonces'`).toString());
+let nonce = nonceData.possible_next_nonce;
+
+console.log(`Sender: ${senderAddress} | Nonce: ${nonce}\n`);
+
+for (let i = 1; i < 50; i++) {
+  const address = getAddressFromPrivateKey(wallet.accounts[i].stxPrivateKey, network.version);
+  const d = JSON.parse(execSync(`curl -s 'https://api.hiro.so/v2/accounts/${address}?proof=0'`).toString());
+  const bal = parseInt(d.balance, 16);
+  if (bal >= 50_000) { console.log(`Account ${i}: ${address} — ${(bal/1e6).toFixed(3)} STX OK`); continue; }
+
+  const tx = await makeSTXTokenTransfer({ recipient: address, amount: FUND_AMOUNT, senderKey, network, anchorMode: AnchorMode.Any, nonce });
+  const tmp = `/tmp/fund10_${i}.bin`;
+  writeFileSync(tmp, tx.serialize());
+  const result = execSync(`curl -s --max-time 30 -X POST 'https://api.hiro.so/v2/transactions' -H 'Content-Type: application/octet-stream' --data-binary @${tmp}`, { timeout: 35000 }).toString();
+  unlinkSync(tmp);
+  const parsed = JSON.parse(result);
+  if (typeof parsed === 'string' && parsed.length === 64) {
+    console.log(`✅ Account ${i}: ${address} — funded 0.2 STX`);
+  } else {
+    console.error(`❌ Account ${i}: ${address} — ${result}`);
+  }
+  nonce++;
+  await new Promise(r => setTimeout(r, 500));
+}
+console.log('\nDone!');

package/fund-unfunded.ts

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import { generateWallet, generateNewAccount } from '@stacks/wallet-sdk';
+import { getAddressFromPrivateKey, makeSTXTokenTransfer, AnchorMode } from '@stacks/transactions';
+import { StacksMainnet } from '@stacks/network';
+import { readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { resolve } from 'path';
+import { execSync } from 'child_process';
+
+const curlFetch = async (url: string, opts: any = {}) => {
+  const method = opts.method || 'GET';
+  const headers = opts.headers ? Object.entries(opts.headers).map(([k,v]) => `-H '${k}: ${v}'`).join(' ') : '';
+  if (opts.body) {
+    const tmp = `/tmp/stx_fund_${Date.now()}.bin`;
+    writeFileSync(tmp, opts.body);
+    const r = execSync(`curl -s -X ${method} ${headers} --data-binary @${tmp} '${url}'`, { timeout: 15000 }).toString();
+    unlinkSync(tmp);
+    return { ok: true, json: async () => JSON.parse(r), text: async () => r };
+  }
+  const r = execSync(`curl -s '${url}'`, { timeout: 15000 }).toString();
+  return { ok: true, json: async () => JSON.parse(r), text: async () => r };
+};
+
+const FUND_AMOUNT = 200_000n; // 0.2 STX
+const NUM_ACCOUNTS = 50;
+
+const toml = readFileSync(resolve('settings/Mainnet.toml'), 'utf8');
+const mnemonic = toml.match(/mnemonic\s*=\s*"([^"]+)"/)![1];
+
+let wallet = await generateWallet({ secretKey: mnemonic, password: '' });
+for (let i = 1; i < NUM_ACCOUNTS; i++) wallet = generateNewAccount(wallet);
+
+const network = new StacksMainnet({ fetchFn: curlFetch as any });
+const senderKey = wallet.accounts[0].stxPrivateKey;
+const senderAddress = getAddressFromPrivateKey(senderKey, network.version);
+
+// Get sender nonce (possible_next to include mempool)
+const nonceData = JSON.parse(execSync(`curl -s 'https://api.hiro.so/extended/v1/address/${senderAddress}/nonces'`).toString());
+let nonce = nonceData.possible_next_nonce;
+
+const balData = JSON.parse(execSync(`curl -s 'https://api.hiro.so/v2/accounts/${senderAddress}?proof=0'`).toString());
+const balance = BigInt(balData.balance);
+console.log(`Sender: ${senderAddress} | Balance: ${Number(balance)/1e6} STX | Nonce: ${nonce}\n`);
+
+// Find accounts with low balance (< 0.05 STX)
+const unfunded: { idx: number; address: string }[] = [];
+for (let i = 1; i < NUM_ACCOUNTS; i++) {
+  const address = getAddressFromPrivateKey(wallet.accounts[i].stxPrivateKey, network.version);
+  const d = JSON.parse(execSync(`curl -s 'https://api.hiro.so/v2/accounts/${address}?proof=0'`).toString());
+  const bal = parseInt(d.balance, 16);
+  console.log(`Account ${i}: ${address} — ${(bal/1e6).toFixed(3)} STX`);
+  if (bal < 50_000) unfunded.push({ idx: i, address }); // top up if < 0.05 STX
+  await new Promise(r => setTimeout(r, 600));
+}
+
+console.log(`\nFound ${unfunded.length} accounts with low balance. Topping up each with 0.1 STX...\n`);
+
+const totalNeeded = FUND_AMOUNT * BigInt(unfunded.length);
+if (balance < totalNeeded) {
+  console.error(`Insufficient balance. Need ${Number(totalNeeded)/1e6} STX, have ${Number(balance)/1e6} STX`);
+  process.exit(1);
+}
+
+for (const { idx, address } of unfunded) {
+  const tx = await makeSTXTokenTransfer({
+    recipient: address,
+    amount: FUND_AMOUNT,
+    senderKey,
+    network,
+    anchorMode: AnchorMode.Any,
+    nonce,
+  });
+
+  const tmp = `/tmp/stx_fund_${idx}.bin`;
+  writeFileSync(tmp, tx.serialize());
+  const result = execSync(`curl -s --max-time 30 -X POST 'https://api.hiro.so/v2/transactions' -H 'Content-Type: application/octet-stream' --data-binary @${tmp}`, { timeout: 35000 }).toString();
+  unlinkSync(tmp);
+
+  const parsed = JSON.parse(result);
+  if (typeof parsed === 'string' && parsed.length === 64) {
+    console.log(`✅ Account ${idx}: ${address} — txid: ${parsed}`);
+  } else {
+    console.error(`❌ Account ${idx}: ${address} — ${result}`);
+  }
+  nonce++;
+  await new Promise(r => setTimeout(r, 300));
+}
+
+console.log('\nDone!');

package/generate-activity.ts

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+/**
+ * Strade Activity Generator
+ * Usage:
+ *   1. Set PRIVATE_KEY below (64-char hex)
+ *   2. Set DRY_RUN=false when ready
+ *   3. npx tsx scripts/generate-activity.ts
+ */
+
+import {
+  broadcastTransaction,
+  makeContractCall,
+  noneCV,
+  principalCV,
+  stringUtf8CV,
+  uintCV,
+  AnchorMode,
+} from '@stacks/transactions';
+import { StacksMainnet } from '@stacks/network';
+import { generateWallet, generateNewAccount } from '@stacks/wallet-sdk';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { execSync } from 'child_process';
+
+const DRY_RUN = false; // set to false to broadcast
+
+// curl-based fetch to bypass Node.js network restrictions
+const curlFetch = async (url: string, opts: any = {}) => {
+  const method = opts.method || 'GET';
+  const headers = opts.headers ? Object.entries(opts.headers).map(([k,v]) => `-H '${k}: ${v}'`).join(' ') : '';
+  if (opts.body) {
+    const tmpFile = `/tmp/stx_req_${Date.now()}.bin`;
+    const { writeFileSync, unlinkSync } = await import('fs');
+    writeFileSync(tmpFile, opts.body);
+    const result = execSync(`curl -s --max-time 30 -X ${method} ${headers} --data-binary @${tmpFile} '${url}'`, { timeout: 35000 }).toString();
+    unlinkSync(tmpFile);
+    return { ok: true, json: async () => JSON.parse(result), text: async () => result };
+  }
+  const result = execSync(`curl -s -X ${method} ${headers} '${url}'`, { timeout: 15000 }).toString();
+  return { ok: true, json: async () => JSON.parse(result), text: async () => result };
+};
+
+// Read mnemonic from settings/Mainnet.toml
+const toml = readFileSync(resolve('settings/Mainnet.toml'), 'utf8');
+const mnemonicMatch = toml.match(/mnemonic\s*=\s*"([^"]+)"/);
+if (!mnemonicMatch) { console.error('mnemonic not found in settings/Mainnet.toml'); process.exit(1); }
+const MNEMONIC = mnemonicMatch[1];
+
+// Derive 100 accounts from the same mnemonic (indices 0-99)
+const NUM_ACCOUNTS = 50;
+const baseWallet = await generateWallet({ secretKey: MNEMONIC, password: '' });
+let wallet = baseWallet;
+for (let i = 1; i < NUM_ACCOUNTS; i++) {
+  wallet = generateNewAccount(wallet);
+}
+const accounts = wallet.accounts.slice(0, NUM_ACCOUNTS).map(a => a.stxPrivateKey);
+const CONTRACT_PRINCIPAL = 'SPB669EVRTKWYGY5GNQ7VEBZ7RF8A3K01EP6GN8N';
+const DELAY_MS = 3000;
+
+const network = new StacksMainnet({ fetchFn: curlFetch as any });
+const rand = () => Math.random().toString(36).slice(2, 8);
+
+async function getNonce(address: string): Promise<number> {
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    try {
+      const result = execSync(`curl -s --max-time 15 'https://api.hiro.so/extended/v1/address/${address}/nonces'`, { timeout: 20000 }).toString();
+      if (result.includes('Per-minute') || result.includes('rate limit')) throw new Error('rate limited');
+      const data = JSON.parse(result) as { possible_next_nonce: number };
+      return data.possible_next_nonce;
+    } catch (e: any) {
+      console.error(`  getNonce attempt ${attempt}/3 failed: ${e.message}`);
+      if (attempt < 3) await new Promise(r => setTimeout(r, 10000)); // 10s backoff on rate limit
+    }
+  }
+  throw new Error('Failed to get nonce after 3 attempts');
+}
+
+async function sendTx(contractName: string, fn: string, args: any[], nonce: number, privateKey: string) {
+  const tx = await makeContractCall({
+    contractAddress: CONTRACT_PRINCIPAL,
+    contractName,
+    functionName: fn,
+    functionArgs: args,
+    senderKey: privateKey,
+    validateWithAbi: false,
+    network,
+    anchorMode: AnchorMode.Any,
+    nonce,
+    fee: 4_000, // 0.2 STX total per cycle across 50 accounts
+  });
+
+  console.log(`[${nonce}] ${contractName}.${fn}`);
+
+  if (DRY_RUN) {
+    console.log('  DRY-RUN: skipped');
+    return;
+  }
+
+  try {
+    const res = await broadcastTransaction(tx, network);
+    if ('txid' in res) {
+      console.log(`  ✅ https://explorer.hiro.so/txid/${res.txid}`);
+    } else {
+      console.error(`  ❌ ${JSON.stringify(res)}`);
+    }
+  } catch (e: any) {
+    console.error(`  ❌ ${e.message}`);
+  }
+
+  await new Promise(r => setTimeout(r, DELAY_MS));
+}
+
+async function main() {
+  const { getAddressFromPrivateKey } = await import('@stacks/transactions');
+
+  // Build per-account state sequentially to avoid rate limiting
+  const allStates = [];
+  for (let i = 0; i < accounts.length; i++) {
+    const pk = accounts[i];
+    const { getAddressFromPrivateKey } = await import('@stacks/transactions');
+    const address = getAddressFromPrivateKey(pk, network.version);
+    const nonce = await getNonce(address);
+    let pending = 0, balance = 0;
+    try {
+      const mempool = JSON.parse(execSync(`curl -s --max-time 15 'https://api.hiro.so/extended/v1/address/${address}/mempool?limit=1'`, { timeout: 20000 }).toString());
+      pending = mempool.total ?? 0;
+      const balData = JSON.parse(execSync(`curl -s --max-time 15 'https://api.hiro.so/v2/accounts/${address}?proof=0'`, { timeout: 20000 }).toString());
+      balance = parseInt(balData.balance, 16);
+    } catch { pending = 0; }
+    console.log(`Account ${i}: ${address} (nonce: ${nonce}, pending: ${pending}, balance: ${(balance/1e6).toFixed(4)} STX)`);
+    allStates.push({ pk, address, nonce, pending, balance });
+    await new Promise(r => setTimeout(r, 2000));
+  }
+
+  const accountStates = allStates.filter(s => s.pending < 3 && s.balance > 1000);
+  if (accountStates.length === 0) { console.log('All accounts have too many pending txs. Try again later.'); return; }
+  console.log(`\nUsing ${accountStates.length}/${allStates.length} accounts\nDRY_RUN=${DRY_RUN}\n`);
+
+  // 1 tx per account per run — rotate through different contract calls
+  // Rotate through different contract calls - 1 per account per run
+  const calls = [
+    (s: any) => sendTx('UserProfile', 'update-profile', [
+      stringUtf8CV(`Bio ${rand()}`), stringUtf8CV(`${rand()}@test.com`)
+    ], s.nonce++, s.pk),
+
+    (s: any) => sendTx('CoreMarketPlace', 'create-listing', [
+      stringUtf8CV(`Item ${rand()}`), stringUtf8CV(`Desc ${rand()}`), uintCV(500_000), uintCV(144)
+    ], s.nonce++, s.pk),
+
+    (s: any) => sendTx('CoreMarketPlace', 'update-listing', [
+      uintCV(Math.floor(Math.random() * 100) + 1),
+      uintCV(750_000),
+      stringUtf8CV(`Updated desc ${rand()}`)
+    ], s.nonce++, s.pk),
+
+    (s: any) => sendTx('UserProfile', 'rate-user', [
+      principalCV(accountStates[(accountStates.indexOf(s) + 1) % accountStates.length].address),
+      uintCV(Math.floor(Math.random() * 5) + 1)
+    ], s.nonce++, s.pk),
+
+    (s: any) => sendTx('UserProfile', 'calculate-reputation', [
+      principalCV(s.address)
+    ], s.nonce++, s.pk),
+
+    (s: any) => sendTx('CoreMarketPlace', 'create-listing', [
+      stringUtf8CV(`Product ${rand()}`), stringUtf8CV(`Details ${rand()}`), uintCV(1_000_000), uintCV(288)
+    ], s.nonce++, s.pk),
+  ];
+
+  for (let i = 0; i < accountStates.length; i++) {
+    const s = accountStates[i];
+    // Re-fetch nonce right before sending to avoid BadNonce
+    s.nonce = await getNonce(s.address);
+    await calls[i % calls.length](s);
+    await new Promise(r => setTimeout(r, 500));
+  }
+
+  console.log('\nDone!');
+}
+
+main().catch(console.error);

package/git-activity-generator.ts

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+/**
+ * Git Activity Generator for Strade
+ * Creates commits for GitHub activity. Supports resuming from existing commits.
+ * 
+ * Usage:
+ *   npx tsx scripts/git-activity-generator.ts --help
+ *   npx tsx scripts/git-activity-generator.ts --dry-run
+ *   npx tsx scripts/git-activity-generator.ts
+ *   npx tsx scripts/git-activity-generator.ts --total 500
+ * 
+ * WARNINGS:
+ * - Creates temp files in ./temp-commits/ and commits them.
+ * - Rate limited by GitHub (consider delays).
+ * - Check GitHub TOS; for testing only.
+ * - Runs `git push`, `gh pr create`. Ensure authenticated.
+ * - Cleanup: rm -rf temp-commits/ && git branch -D fake-activity-pr-*
+ */
+
+import { execSync } from 'child_process';
+import { mkdirSync, writeFileSync, existsSync, rmSync, readdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMP_DIR = join(__dirname, '../temp-commits');
+const NUM_PRS = 5;
+const TOTAL_COMMITS = process.argv.includes('--total') ? parseInt(process.argv[process.argv.indexOf('--total') + 1] || '100') : 100;
+const COMMITS_PER_PR = Math.ceil(TOTAL_COMMITS / NUM_PRS);
+const PR_START = 194;
+const COUNTER_OFFSET = 35044;
+const DRY_RUN = process.argv.includes('--dry-run');
+const HELP = process.argv.includes('--help');
+
+if (HELP) {
+  console.log(`Usage: npx tsx ${join('scripts/git-activity-generator.ts')} [--dry-run] [--help] [--total <num>]\n`);
+  console.log('Options:\n  --dry-run  Simulate without git/gh commands\n  --help     Show this help\n  --total   Number of commits to make (default: 500)\n');
+  process.exit(0);
+}
+
+function run(cmd: string, options: { cwd?: string; dryRun?: boolean } = {}) {
+  const { cwd, dryRun } = options;
+  if (dryRun || DRY_RUN) {
+    console.log(`[DRY-RUN] cd ${cwd || process.cwd()} && ${cmd}`);
+    return;
+  }
+  try {
+    execSync(cmd, { cwd, stdio: 'inherit' });
+  } catch (e: any) {
+    console.error(`Error: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+function log(msg: string) {
+  console.log(`\n>>> ${msg}`);
+}
+
+async function main() {
+  // Get existing file count to continue from where we left off
+  let startCommit = 1;
+  if (existsSync(TEMP_DIR)) {
+    const existingFiles = readdirSync(TEMP_DIR).filter(f => f.startsWith('counter') && f.endsWith('.txt'));
+    if (existingFiles.length > 0) {
+      const maxCounter = Math.max(...existingFiles.map(f => parseInt(f.replace('counter', '').replace('.txt', ''))));
+      startCommit = maxCounter - COUNTER_OFFSET + 1;
+      console.log(`\n>>> Continuing from existing commit ${startCommit} (found ${existingFiles.length} existing files, max counter: ${maxCounter})`);
+    } else {
+      // Cleanup previous if empty
+      rmSync(TEMP_DIR, { recursive: true });
+      mkdirSync(TEMP_DIR, { recursive: true });
+    }
+  } else {
+    mkdirSync(TEMP_DIR, { recursive: true });
+  }
+
+  // Create new temp files only for commits that don't exist yet
+  for (let i = startCommit; i <= TOTAL_COMMITS; i++) {
+    const file = join(TEMP_DIR, `counter${COUNTER_OFFSET + i}.txt`);
+    if (!existsSync(file)) {
+      writeFileSync(file, `Commit counter #${COUNTER_OFFSET + i} - ${Date.now()}\nMinor change for activity.\n`);
+    }
+  }
+
+  run('git add temp-commits/');
+  try { execSync('git commit -m "chore: add temp-commits dir for activity tracking"', { stdio: 'inherit' }); } catch {}
+
+  for (let pr = 1; pr <= NUM_PRS; pr++) {
+    log(`=== PR ${pr}/${NUM_PRS} (commits ${((pr-1)*COMMITS_PER_PR + 1)}-${pr*COMMITS_PER_PR}) ===`);
+
+    const branch = `fake-activity-pr-${PR_START + pr - 1}-${COUNTER_OFFSET}`;
+    
+    // Create & switch branch
+    run(`git checkout -b ${branch}`, { dryRun: DRY_RUN });
+    
+    // Make commits for this PR
+    for (let c = (pr-1)*COMMITS_PER_PR + 1; c <= Math.min(pr*COMMITS_PER_PR, TOTAL_COMMITS); c++) {
+      if (c > TOTAL_COMMITS) break;
+      const file = join(TEMP_DIR, `counter${COUNTER_OFFSET + c}.txt`);
+      const content = `Commit counter #${COUNTER_OFFSET + c} - ${Date.now() + c}\nUpdated at ${new Date().toISOString()}\nMinor change for activity.\n`;
+      writeFileSync(file, content);
+      
+      run(`git add temp-commits/counter${COUNTER_OFFSET + c}.txt`, { cwd: process.cwd(), dryRun: DRY_RUN });
+      if ((c - 1) % 50 === 0 || c === Math.min(pr*COMMITS_PER_PR, TOTAL_COMMITS)) {
+        console.log(`  Progress: PR${pr} commit ${c}/${Math.min(pr*COMMITS_PER_PR, TOTAL_COMMITS)} (${Math.min(TOTAL_COMMITS, pr*COMMITS_PER_PR)}/${TOTAL_COMMITS} total)`);
+      }
+      run(`git commit -m "chore: bump counter ${COUNTER_OFFSET + c} for activity tracking"`, { dryRun: DRY_RUN });
+    }
+    
+    // Push & create PR
+    run(`git push origin ${branch}`, { dryRun: DRY_RUN });
+    run(`gh pr create --title "chore: activity batch #${pr} - ${COMMITS_PER_PR} minor updates" --body "Batch of ${COMMITS_PER_PR} commits for activity tracking. Changes in temp-commits/. #automation" --base main`, { dryRun: DRY_RUN });
+    
+    log(`PR ${pr} created! Merging to main...`);
+
+    // Switch back to main
+    run(`git checkout main`, { dryRun: DRY_RUN });
+
+    // Merge the PR and delete the remote branch
+    run(`gh pr merge ${branch} --merge --delete-branch --subject "chore: merge activity batch #${pr}"`, { dryRun: DRY_RUN });
+
+    // Delete local branch if it still exists
+    try { execSync(`git branch -D ${branch}`, { stdio: 'inherit' }); } catch {}
+
+    // Pull latest main
+    run(`git pull origin main`, { dryRun: DRY_RUN });
+
+    log(`PR ${pr} merged and deleted!`);
+  }
+
+  // Safety: stash if dirty, checkout main
+  try { execSync('git stash push -m "pre-activity auto-save"', { stdio: 'inherit' }); } catch {}
+  try { execSync('git checkout main', { stdio: 'inherit' }); } catch {
+    execSync('git checkout master', { stdio: 'inherit' });
+  }
+  try { execSync('git stash pop', { stdio: 'inherit' }); } catch {}
+
+  // Clean up temp-commits
+  if (existsSync(TEMP_DIR)) {
+    rmSync(TEMP_DIR, { recursive: true });
+    log('Temp files cleaned up');
+  }
+
+  // Update counter file
+  writeFileSync('.activity_counter', TOTAL_COMMITS.toString());
+  console.log(`Updated .activity_counter to ${TOTAL_COMMITS}`);
+  
+  log('✅ Complete! All PRs merged and deleted.');
+  if (!DRY_RUN) {
+    console.log(`\nSummary: ${TOTAL_COMMITS} commits across ${NUM_PRS} PRs, all merged to main and PRs deleted.`);
+  }
+}
+
+main().catch(console.error);

package/mobile-server.ts

@@ -0,0 +1,123 @@
+#!/usr/bin/env tsx
+import { createServer } from "node:http";
+import { spawn } from "node:child_process";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { networkInterfaces } from "node:os";
+
+const PORT = parseInt(process.env.PORT || "3456", 10);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_DIR = join(__dirname, "..");
+
+let childProcess: ReturnType<typeof spawn> | null = null;
+
+const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width,initial-scale=1,user-scalable=no">
+<title>Strade Auto-Activity</title>
+<style>
+*{box-sizing:border-box;margin:0;padding:0}
+body{font-family:system-ui,-apple-system,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100dvh;background:#0f172a;color:#e2e8f0}
+.container{text-align:center;padding:2rem;width:100%;max-width:400px}
+h1{font-size:1.5rem;margin-bottom:.5rem;color:#f8fafc}
+p{font-size:.875rem;color:#94a3b8;margin-bottom:2rem}
+.btn{display:block;width:100%;padding:1rem;font-size:1.25rem;font-weight:600;border:none;border-radius:12px;cursor:pointer;margin-bottom:1rem;transition:opacity .2s}
+.btn:active{opacity:.7}
+.btn:disabled{opacity:.4;cursor:not-allowed}
+.btn-start{background:#22c55e;color:#052e16}
+.btn-stop{background:#ef4444;color:#450a0a}
+#status{margin-top:1rem;padding:.75rem 1rem;border-radius:8px;font-weight:600;font-size:1rem}
+.running{background:#166534;color:#86efac}
+.idle{background:#1e293b;color:#94a3b8}
+.error{background:#7f1d1d;color:#fca5a5}
+.log{background:#1e293b;border-radius:8px;padding:.75rem;margin-top:1rem;max-height:200px;overflow-y:auto;text-align:left;font-family:monospace;font-size:.75rem;line-height:1.4;color:#94a3b8}
+</style>
+</head>
+<body>
+<div class="container">
+<h1>Strade Auto-Activity</h1>
+<p>Start or stop the auto-activity loop</p>
+<button class="btn btn-start" id="startBtn" onclick="run('/start')">▶ Start</button>
+<button class="btn btn-stop" id="stopBtn" onclick="run('/stop')">■ Stop</button>
+<div id="status" class="idle">Idle</div>
+<div class="log" id="log">Ready.</div>
+</div>
+<script>
+function log(msg){const el=document.getElementById('log');el.textContent+=msg;el.scrollTop=el.scrollHeight}
+async function run(path){const btn=event.target;btn.disabled=true;try{const r=await fetch(path,{method:'POST'});log(await r.text()+'. ')}catch(e){log('Error: '+e.message+'. ')}finally{btn.disabled=false;poll()}}
+async function poll(){try{const r=await fetch('/status');const d=await r.json();const el=document.getElementById('status');if(d.running){el.textContent='Running';el.className='running'}else if(d.error){el.textContent='Error';el.className='error';log('['+d.error+'] ')}else{el.textContent='Idle';el.className='idle'}}catch(e){const el=document.getElementById('status');el.textContent='Offline';el.className='error'}}
+setInterval(poll,3000);poll()
+</script>
+</body>
+</html>`;
+
+const server = createServer((req, res) => {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+
+  if (req.method === "GET" && req.url === "/") {
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(html);
+    return;
+  }
+
+  if (req.method === "POST" && req.url === "/start") {
+    if (childProcess) {
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      res.end("Already running");
+      return;
+    }
+    const scriptPath = join(REPO_DIR, "scripts", "auto-activity.sh");
+    childProcess = spawn("bash", [scriptPath], {
+      cwd: REPO_DIR,
+      stdio: "inherit",
+    });
+    childProcess.on("exit", (code) => {
+      childProcess = null;
+    });
+    childProcess.on("error", () => {
+      childProcess = null;
+    });
+    res.writeHead(200, { "Content-Type": "text/plain" });
+    res.end("Started");
+    return;
+  }
+
+  if (req.method === "POST" && req.url === "/stop") {
+    if (childProcess) {
+      childProcess.kill("SIGTERM");
+      childProcess = null;
+    }
+    res.writeHead(200, { "Content-Type": "text/plain" });
+    res.end("Stopped");
+    return;
+  }
+
+  if (req.method === "GET" && req.url === "/status") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ running: childProcess !== null }));
+    return;
+  }
+
+  res.writeHead(404);
+  res.end("Not found");
+});
+
+server.listen(PORT, "0.0.0.0", () => {
+  const ifaces = networkInterfaces();
+  const ips: string[] = [];
+  for (const name of Object.keys(ifaces)) {
+    for (const iface of ifaces[name] || []) {
+      if (iface.family === "IPv4" && !iface.internal) {
+        ips.push(iface.address);
+      }
+    }
+  }
+  console.log(`Mobile control server running:`);
+  console.log(`  Local:    http://localhost:${PORT}`);
+  for (const ip of ips) {
+    console.log(`  Network:  http://${ip}:${PORT}`);
+  }
+  console.log(`Open one of the Network URLs on your phone's browser.`);
+});

package/package.json

@@ -1,7 +1,15 @@
 {
   "name": "strade-stx-scripts",
-  "version": "1.0.0",
-  "description": "Utility scripts for Strade - git activity generation, STX distribution, account management on Stacks",
-  "main": "index.js",
-  "license": "ISC"
+  "version": "1.0.1",
+  "description": "Utility scripts for Strade",
+  "type": "module",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Marvy247/Strade.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Marvy247/Strade/issues"
+  },
+  "homepage": "https://github.com/Marvy247/Strade"
 }

package/index.js

@@ -1 +0,0 @@
-module.exports = { name: "strade-stx-scripts", version: "1.0.0" };