@developeruche/tx-spammer-sdk 1.0.1 → 1.0.3

package/dist/SpamOrchestrator.d.ts

@@ -1,5 +1,4 @@
-import { type Hash } from 'viem';
-import { SpamSequenceConfig } from './types';
+import { SpamSequenceConfig, SpamResult } from './types';
 /**
  * The central coordinator for the spam sequence.
  *
@@ -38,8 +37,5 @@ export declare class SpamOrchestrator {
      *
      * Stops when the duration expires or gas limits are reached.
      */
-    start(): Promise<{
-        blockNumber: bigint;
-        txHash: Hash | null;
-    }>;
+    start(): Promise<SpamResult>;
 }

package/dist/SpamOrchestrator.js

@@ -104,8 +104,9 @@ class SpamOrchestrator {
             : Infinity;
         const startTime = Date.now();
         let lastTxHash = null;
+        const activeGuardians = [this.gasGuardian];
         // Helper to run a strategy loop for a subset of workers
-        const runLoop = async (workers, stratConfig, guardian) => {
+        const runLoop = async (workers, stratConfig, guardian, onSuccess) => {
             const loopTasks = workers.map(async (worker, index) => {
                 while (true) {
                     if (guardian.isLimitReached)
@@ -114,17 +115,25 @@ class SpamOrchestrator {
                         break;
                     try {
                         let txHash;
+                        let executed = false;
                         if (stratConfig.mode === 'transfer') {
                             txHash = await (0, strategies_1.executeEthTransfer)(worker, stratConfig, guardian, this.publicClient);
+                            executed = true;
                         }
                         else if (stratConfig.mode === 'deploy') {
                             txHash = await (0, strategies_1.executeContractDeploy)(worker, stratConfig, guardian, this.publicClient);
+                            executed = true;
                         }
                         else if (stratConfig.mode === 'read') {
                             await (0, strategies_1.executeContractRead)(worker, stratConfig, guardian, this.publicClient);
+                            executed = true;
                         }
                         else if (stratConfig.mode === 'write') {
                             txHash = await (0, strategies_1.executeContractWrite)(worker, stratConfig, guardian, this.publicClient);
+                            executed = true;
+                        }
+                        if (executed) {
+                            onSuccess();
                         }
                         if (txHash) {
                             lastTxHash = txHash;
@@ -142,6 +151,7 @@ class SpamOrchestrator {
             });
             await Promise.all(loopTasks);
         };
+        const stats = {};
         if (strategy.mode === 'mixed') {
             console.log('Executing Mixed Strategy...');
             let workerOffset = 0;
@@ -167,25 +177,43 @@ class SpamOrchestrator {
                 // but we can assign a portion of the max limit to its guardian just in case.
                 const gasLimitShare = BigInt(Math.floor(Number(this.config.maxGasLimit) * sharePercent));
                 const subGuardian = new GasGuardian_1.GasGuardian(gasLimitShare);
+                activeGuardians.push(subGuardian);
                 console.log(`- Sub-strategy '${subStrat.config.mode}': ${count} workers, ~${gasLimitShare} gas limit`);
-                tasks.push(runLoop(assignedWorkers, subStrat.config, subGuardian));
+                const label = `Strategy ${i} (${subStrat.config.mode})`;
+                stats[label] = 0;
+                tasks.push(runLoop(assignedWorkers, subStrat.config, subGuardian, () => {
+                    stats[label]++;
+                }));
             }
             await Promise.all(tasks);
         }
         else {
             // Single Mode
-            await runLoop(this.workers, strategy, this.gasGuardian);
+            const label = `Strategy (${strategy.mode})`;
+            stats[label] = 0;
+            await runLoop(this.workers, strategy, this.gasGuardian, () => {
+                stats[label]++;
+            });
         }
         console.log('Spam sequence finished.');
+        let blockNumber;
         if (lastTxHash) {
             console.log(`Waiting for last transaction ${lastTxHash} to be mined...`);
             const receipt = await this.publicClient.waitForTransactionReceipt({ hash: lastTxHash });
-            return { blockNumber: receipt.blockNumber, txHash: lastTxHash };
+            blockNumber = receipt.blockNumber;
         }
         else {
-            const blockNumber = await this.publicClient.getBlockNumber();
-            return { blockNumber, txHash: null };
+            blockNumber = await this.publicClient.getBlockNumber();
         }
+        const statsBlock = await this.publicClient.getBlock({ blockNumber });
+        const totalGasUsed = activeGuardians.reduce((acc, g) => acc + g.gasUsed, 0n);
+        return {
+            blockNumber,
+            txHash: lastTxHash,
+            totalGasUsed,
+            finalBlockGasUsed: statsBlock.gasUsed,
+            stats,
+        };
     }
 }
 exports.SpamOrchestrator = SpamOrchestrator;

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { Hex } from 'viem';
 /**
  * Configuration for ETH transfer spam strategy.
  * Includes depth for recursive transfers (if implemented) and recipient handling.
@@ -204,3 +205,20 @@ export type MixedStrategyConfig = z.infer<typeof MixedStrategyConfigSchema>;
 export type SpamStrategyConfig = z.infer<typeof SpamStrategySchema>;
 /** TypeScript type alias for the full Spam Sequence config. */
 export type SpamSequenceConfig = z.infer<typeof SpamSequenceConfigSchema>;
+/**
+ * Result returned after the spam sequence completes.
+ */
+export interface SpamResult {
+    /** The block number of the last transaction mined (or current block if no txs). */
+    blockNumber: bigint;
+    /** The hash of the last transaction sent, if any. */
+    txHash: Hex | null;
+    /** Total cumulative gas used by all transactions in this sequence (local estimate). */
+    totalGasUsed: bigint;
+    /** The total gas used in the block corresponding to blockNumber. */
+    finalBlockGasUsed: bigint;
+    /** Breakdown of operations performed by each strategy. Key is strategy label, value is count. */
+    stats: {
+        [key: string]: number;
+    };
+}

package/dist/types.js

@@ -111,7 +111,7 @@ exports.SpamSequenceConfigSchema = zod_1.z.object({
     /** The selected spam strategy configuration. */
     strategy: exports.SpamStrategySchema,
     /** Optional duration in seconds to run the spam sequence. */
-    durationSeconds: zod_1.z.number().int().positive().optional(),
+    durationSeconds: zod_1.z.number().int().nonnegative().optional(),
     /** Optional maximum total transactions to attempts (if implemented). */
     totalTxs: zod_1.z.number().int().positive().optional(),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@developeruche/tx-spammer-sdk",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -30,4 +30,4 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
   }
-}
+}