strade-stx 1.0.0

package/mainnetcontracts.md

@@ -0,0 +1,16 @@
+# Strade Mainnet Contracts
+
+**Deployer Address**: `SPB669EVRTKWYGY5GNQ7VEBZ7RF8A3K01EP6GN8N`
+
+| Contract | Address |
+|----------|---------|
+| CoreMarketPlace | `SPB669EVRTKWYGY5GNQ7VEBZ7RF8A3K01EP6GN8N.CoreMarketPlace` |
+| EscrowService | `SPB669EVRTKWYGY5GNQ7VEBZ7RF8A3K01EP6GN8N.EscrowService` |
+| DisputeResolution | `SPB669EVRTKWYGY5GNQ7VEBZ7RF8A3K01EP6GN8N.DisputeResolution_clar` |
+| UserProfile | `SPB669EVRTKWYGY5GNQ7VEBZ7RF8A3K01EP6GN8N.UserProfile` |
+| BST Token | `SPB669EVRTKWYGY5GNQ7VEBZ7RF8A3K01EP6GN8N.token` |
+| FT Trait | `SPB669EVRTKWYGY5GNQ7VEBZ7RF8A3K01EP6GN8N.ft-trait` |
+
+**Explorer**: https://explorer.hiro.so/address/SPB669EVRTKWYGY5GNQ7VEBZ7RF8A3K01EP6GN8N
+
+**Deployed**: 2026-03-21

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "strade-stx",
+  "version": "1.0.0",
+  "description": "Stacks blockchain project for Strade - smart contracts and tooling",
+  "type": "module",
+  "scripts": {
+    "test": "vitest run",
+    "test:report": "vitest run -- --coverage --costs",
+    "test:watch": "chokidar \"tests/**/*.ts\" \"contracts/**/*.clar\" -c \"npm run test:report\""
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@hirosystems/clarinet-sdk": "^2.3.2",
+    "@prisma/client": "^7.8.0",
+    "@stacks/transactions": "^6.12.0",
+    "@stacks/wallet-sdk": "^7.2.0",
+    "axios": "^1.18.1",
+    "chalk": "^5.6.2",
+    "cheerio": "^1.2.0",
+    "chokidar-cli": "^3.0.0",
+    "cli-table3": "^0.6.5",
+    "commander": "^15.0.0",
+    "date-fns": "^4.4.0",
+    "express": "^5.2.1",
+    "fast-check": "^3.15.1",
+    "figlet": "^1.11.0",
+    "graphql": "^17.0.1",
+    "inquirer": "^14.0.2",
+    "ioredis": "^5.11.1",
+    "lodash": "^4.18.1",
+    "luxon": "^3.7.2",
+    "moment": "^2.30.1",
+    "mongoose": "^9.7.2",
+    "nanoid": "^5.1.16",
+    "next": "^16.2.9",
+    "ora": "^9.4.1",
+    "pino": "^10.3.1",
+    "playwright": "^1.61.1",
+    "prisma": "^7.8.0",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "redis": "^6.0.1",
+    "sharp": "^0.35.2",
+    "socket.io": "^4.8.3",
+    "typescript": "^5.3.3",
+    "vite": "^5.1.4",
+    "vitest": "^1.3.1",
+    "vitest-environment-clarinet": "^2.0.0",
+    "yargs": "^18.0.0",
+    "zod": "^4.4.3"
+  }
+}

package/scripts/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/scripts/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/scripts/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/scripts/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/scripts/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/scripts/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/scripts/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/scripts/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!');