@developeruche/tx-spammer-sdk 1.0.0 → 1.0.1

package/dist/SpamOrchestrator.d.ts

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

package/dist/SpamOrchestrator.js

@@ -33,7 +33,11 @@ class SpamOrchestrator {
     constructor(config, rootPrivateKey) {
         // Validate config
         this.config = types_1.SpamSequenceConfigSchema.parse(config);
-        this.chain = { ...chains_1.mainnet, id: this.config.chainId, rpcUrls: { default: { http: [this.config.rpcUrl] } } };
+        this.chain = {
+            ...chains_1.mainnet,
+            id: this.config.chainId,
+            rpcUrls: { default: { http: [this.config.rpcUrl] } },
+        };
         this.rootAccount = (0, accounts_1.privateKeyToAccount)(rootPrivateKey);
         this.rootClient = (0, viem_1.createWalletClient)({
             account: this.rootAccount,
@@ -60,7 +64,9 @@ class SpamOrchestrator {
         // Fund workers
         console.log(`Funding workers with ${fundingAmount} wei each...`);
         const fundingTxs = [];
-        const nonce = await this.publicClient.getTransactionCount({ address: this.rootAccount.address });
+        const nonce = await this.publicClient.getTransactionCount({
+            address: this.rootAccount.address,
+        });
         for (let i = 0; i < this.workers.length; i++) {
             const tx = await this.rootClient.sendTransaction({
                 to: this.workers[i].address,
@@ -72,14 +78,14 @@ class SpamOrchestrator {
         }
         console.log(`Waiting for ${fundingTxs.length} funding transactions to confirm...`);
         // Ideally we wait for all receipt. For MVP, we wait for Promise.all(waitForTransactionReceipt)
-        await Promise.all(fundingTxs.map(hash => this.publicClient.waitForTransactionReceipt({ hash })));
-        console.log("All workers funded. Initializing worker nonces...");
+        await Promise.all(fundingTxs.map((hash) => this.publicClient.waitForTransactionReceipt({ hash })));
+        console.log('All workers funded. Initializing worker nonces...');
         // Initialize nonces
         await Promise.all(this.workers.map(async (worker) => {
             const n = await this.publicClient.getTransactionCount({ address: worker.address });
             worker.setNonce(n);
         }));
-        console.log("Setup complete.");
+        console.log('Setup complete.');
     }
     /**
      * Starts the spam sequence based on the configured strategy.
@@ -91,10 +97,13 @@ class SpamOrchestrator {
      * Stops when the duration expires or gas limits are reached.
      */
     async start() {
-        console.log("Starting spam sequence...");
+        console.log('Starting spam sequence...');
         const strategy = this.config.strategy;
-        const duration = this.config.durationSeconds ? this.config.durationSeconds * 1000 : Infinity;
+        const duration = this.config.durationSeconds
+            ? this.config.durationSeconds * 1000
+            : Infinity;
         const startTime = Date.now();
+        let lastTxHash = null;
         // Helper to run a strategy loop for a subset of workers
         const runLoop = async (workers, stratConfig, guardian) => {
             const loopTasks = workers.map(async (worker, index) => {
@@ -104,17 +113,21 @@ class SpamOrchestrator {
                     if (Date.now() - startTime > duration)
                         break;
                     try {
+                        let txHash;
                         if (stratConfig.mode === 'transfer') {
-                            await (0, strategies_1.executeEthTransfer)(worker, stratConfig, guardian, this.publicClient);
+                            txHash = await (0, strategies_1.executeEthTransfer)(worker, stratConfig, guardian, this.publicClient);
                         }
                         else if (stratConfig.mode === 'deploy') {
-                            await (0, strategies_1.executeContractDeploy)(worker, stratConfig, guardian, this.publicClient);
+                            txHash = await (0, strategies_1.executeContractDeploy)(worker, stratConfig, guardian, this.publicClient);
                         }
                         else if (stratConfig.mode === 'read') {
                             await (0, strategies_1.executeContractRead)(worker, stratConfig, guardian, this.publicClient);
                         }
                         else if (stratConfig.mode === 'write') {
-                            await (0, strategies_1.executeContractWrite)(worker, stratConfig, guardian, this.publicClient);
+                            txHash = await (0, strategies_1.executeContractWrite)(worker, stratConfig, guardian, this.publicClient);
+                        }
+                        if (txHash) {
+                            lastTxHash = txHash;
                         }
                     }
                     catch (e) {
@@ -130,7 +143,7 @@ class SpamOrchestrator {
             await Promise.all(loopTasks);
         };
         if (strategy.mode === 'mixed') {
-            console.log("Executing Mixed Strategy...");
+            console.log('Executing Mixed Strategy...');
             let workerOffset = 0;
             const tasks = [];
             // Sort strategies to handle remainder logic deterministically? Or just iterate.
@@ -150,7 +163,7 @@ class SpamOrchestrator {
                 const assignedWorkers = this.workers.slice(workerOffset, workerOffset + count);
                 workerOffset += count;
                 // Gas Limit
-                // For 'read', gas limit is effectively infinity/ignored by strategy logic, 
+                // For 'read', gas limit is effectively infinity/ignored by strategy logic,
                 // 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);
@@ -163,7 +176,16 @@ class SpamOrchestrator {
             // Single Mode
             await runLoop(this.workers, strategy, this.gasGuardian);
         }
-        console.log("Spam sequence finished.");
+        console.log('Spam sequence finished.');
+        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 };
+        }
+        else {
+            const blockNumber = await this.publicClient.getBlockNumber();
+            return { blockNumber, txHash: null };
+        }
     }
 }
 exports.SpamOrchestrator = SpamOrchestrator;

package/dist/Worker.js

@@ -51,7 +51,7 @@ class Worker {
      */
     getAndIncrementNonce() {
         if (this.nonce === null) {
-            throw new Error("Nonce not initialized for worker");
+            throw new Error('Nonce not initialized for worker');
         }
         return this.nonce++;
     }
@@ -69,7 +69,7 @@ class Worker {
             value,
             data,
             // @ts-ignore - nonce override is valid but viem types might be strict depending on version
-            nonce: this.getAndIncrementNonce()
+            nonce: this.getAndIncrementNonce(),
         });
     }
 }

package/dist/strategies/ContractDeploy.d.ts

@@ -1,7 +1,7 @@
 import { Worker } from '../Worker';
 import { ContractDeployConfig } from '../types';
 import { GasGuardian } from '../GasGuardian';
-import { type PublicClient } from 'viem';
+import { type PublicClient, type Hash } from 'viem';
 /**
  * Executes a contract deployment transaction.
  * Estimates gas for deployment and enforces limits before broadcasting.
@@ -11,4 +11,4 @@ import { type PublicClient } from 'viem';
  * @param gasGuardian The gas guardian to track usage.
  * @param publicClient The viem public client for gas estimation.
  */
-export declare function executeContractDeploy(worker: Worker, config: ContractDeployConfig, gasGuardian: GasGuardian, publicClient: PublicClient): Promise<void>;
+export declare function executeContractDeploy(worker: Worker, config: ContractDeployConfig, gasGuardian: GasGuardian, publicClient: PublicClient): Promise<Hash>;

package/dist/strategies/ContractDeploy.js

@@ -19,7 +19,7 @@ async function executeContractDeploy(worker, config, gasGuardian, publicClient)
         const estimatedGas = await publicClient.estimateGas({
             account: worker.account,
             data: bytecode,
-            // TODO: handle args encoding for estimation if strict? 
+            // TODO: handle args encoding for estimation if strict?
             // Typically just data + args encoded is fine, but estimateGas with 'data' works for deploy
         });
         gasGuardian.checkLimit(estimatedGas);
@@ -33,6 +33,7 @@ async function executeContractDeploy(worker, config, gasGuardian, publicClient)
             nonce: worker.getAndIncrementNonce(),
         });
         gasGuardian.recordUsage(estimatedGas);
+        return hash;
     }
     catch (error) {
         throw error;

package/dist/strategies/ContractRead.js

@@ -11,13 +11,13 @@ exports.executeContractRead = executeContractRead;
  * @param publicClient The viem client to perform the call.
  */
 async function executeContractRead(worker, config, gasGuardian, publicClient) {
-    // Reads are "eth_call" and do not consume gas on-chain in the same way, 
+    // Reads are "eth_call" and do not consume gas on-chain in the same way,
     // but they do put load on the node. The user prompt says "High-frequency eth_call operations".
     // The GasGuardian tracks "Gas Cap". Usually gas cap refers to on-chain gas used.
     // However, if we want to limit the *spam load*, we might count it or not.
-    // Given the "29M Gas Cap" constraint usually applies to blocks/throughput, 
+    // Given the "29M Gas Cap" constraint usually applies to blocks/throughput,
     // and reads don't fill blocks, maybe we don't count them against the Guardian?
-    // BUT the prompt tracks cumulative gas used. 
+    // BUT the prompt tracks cumulative gas used.
     // eth_calls don't use gas on chain. I will NOT count them towards the cap unless specified.
     try {
         await publicClient.readContract({

package/dist/strategies/ContractWrite.d.ts

@@ -1,7 +1,7 @@
 import { Worker } from '../Worker';
 import { ContractWriteConfig } from '../types';
 import { GasGuardian } from '../GasGuardian';
-import { type PublicClient } from 'viem';
+import { type PublicClient, type Hash } from 'viem';
 /**
  * Executes a state-changing contract write transaction.
  * Estimates gas and enforces limits. Supports dynamic arguments via generator or static args.
@@ -11,4 +11,4 @@ import { type PublicClient } from 'viem';
  * @param gasGuardian The gas guardian to track usage.
  * @param publicClient The viem public client for gas estimation.
  */
-export declare function executeContractWrite(worker: Worker, config: ContractWriteConfig, gasGuardian: GasGuardian, publicClient: PublicClient): Promise<void>;
+export declare function executeContractWrite(worker: Worker, config: ContractWriteConfig, gasGuardian: GasGuardian, publicClient: PublicClient): Promise<Hash>;

package/dist/strategies/ContractWrite.js

@@ -22,7 +22,7 @@ async function executeContractWrite(worker, config, gasGuardian, publicClient) {
             abi: config.abi,
             functionName: config.functionName,
             args: args,
-            account: worker.account
+            account: worker.account,
         });
         gasGuardian.checkLimit(estimatedGas);
         const hash = await worker.client.writeContract({
@@ -36,6 +36,7 @@ async function executeContractWrite(worker, config, gasGuardian, publicClient) {
             nonce: worker.getAndIncrementNonce(),
         });
         gasGuardian.recordUsage(estimatedGas);
+        return hash;
     }
     catch (error) {
         throw error;

package/dist/strategies/EthTransfer.d.ts

@@ -1,7 +1,7 @@
 import { Worker } from '../Worker';
 import { EthTransferConfig } from '../types';
 import { GasGuardian } from '../GasGuardian';
-import { type PublicClient } from 'viem';
+import { type PublicClient, type Hash } from 'viem';
 /**
  * Executes a single ETH transfer transaction.
  *
@@ -10,4 +10,4 @@ import { type PublicClient } from 'viem';
  * @param gasGuardian The gas guardian to check and record usage.
  * @param publicClient The viem public client for gas estimation.
  */
-export declare function executeEthTransfer(worker: Worker, config: EthTransferConfig, gasGuardian: GasGuardian, publicClient: PublicClient): Promise<void>;
+export declare function executeEthTransfer(worker: Worker, config: EthTransferConfig, gasGuardian: GasGuardian, publicClient: PublicClient): Promise<Hash>;

package/dist/strategies/EthTransfer.js

@@ -16,16 +16,17 @@ async function executeEthTransfer(worker, config, gasGuardian, publicClient) {
         const estimatedGas = await publicClient.estimateGas({
             account: worker.account,
             to: recipient,
-            value: amount
+            value: amount,
         });
         gasGuardian.checkLimit(estimatedGas);
         const hash = await worker.sendTransaction(recipient, amount);
-        // We assume the tx will consume 21000 gas for simplicity in tracking, 
-        // though in reality we'd wait for receipt to be exact. 
+        // We assume the tx will consume 21000 gas for simplicity in tracking,
+        // though in reality we'd wait for receipt to be exact.
         // For high-performance spamming, we pre-check and post-record.
         gasGuardian.recordUsage(estimatedGas);
-        // In a real recursive scenario (depth > 1), we would chain additional transfers here 
-        // or wait for this one to mine. For high-volume spam, we often fire-and-forget 
+        return hash;
+        // In a real recursive scenario (depth > 1), we would chain additional transfers here
+        // or wait for this one to mine. For high-volume spam, we often fire-and-forget
         // or batch them if nonces allow.
         // The requirement mentions A -> B -> C.
         // If depth is > 1, this specific call might just be one step.

package/dist/types.js

@@ -76,13 +76,15 @@ exports.MixedStrategyConfigSchema = zod_1.z.object({
      * List of strategies with their respective percentage allocation.
      * Percentages must sum to 100.
      */
-    strategies: zod_1.z.array(zod_1.z.object({
+    strategies: zod_1.z
+        .array(zod_1.z.object({
         config: SingleStrategySchema,
         percentage: zod_1.z.number().nonnegative().max(100),
-    })).refine((items) => {
+    }))
+        .refine((items) => {
         const sum = items.reduce((acc, item) => acc + item.percentage, 0);
         return Math.abs(sum - 100) < 0.1; // Allow small float error
-    }, { message: "Percentages must sum to 100" }),
+    }, { message: 'Percentages must sum to 100' }),
 });
 /**
  * Union schema for all possible spam strategies.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@developeruche/tx-spammer-sdk",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -26,6 +26,7 @@
   },
   "devDependencies": {
     "@types/node": "^25.1.0",
+    "prettier": "^3.8.1",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
   }