Merge pull request #42 from Divineifed1/main

IMPLEMENTATION OF END TO END SCAN TESTING FEATURE

Author: mijinummi

packages/rules/gasGuard/gasguard.engine.ts

@@ -0,0 +1,21 @@
+import { SorobanAnalyzer } from "./src/languages/soroban.analyzer";
+export type ScanInput = {
+  language: 'soroban' | 'solidity' | 'vyper';
+  source: string;
+};
+
+export type ScanResult = {
+  issues: any[];
+};
+
+export class GasGuardEngine {
+  async scan(input: ScanInput): Promise<ScanResult> {
+    switch (input.language) {
+      case 'soroban':
+        return new SorobanAnalyzer().analyze(input.source);
+
+      default:
+        throw new Error(`Unsupported language: ${input.language}`);
+    }
+  }
+}

packages/rules/gasGuard/src/languages/soroban.analyzer.ts

@@ -0,0 +1,34 @@
+export class SorobanAnalyzer {
+  analyze(source: string) {
+    const issues = [];
+
+    if (source.includes('storage().instance().get')) {
+      issues.push({
+        ruleId: 'SOROBAN_STORAGE_REDUNDANT_READ',
+        severity: 'medium',
+        message: 'Repeated storage reads detected',
+        suggestion: 'Cache storage value in a local variable',
+      });
+    }
+
+    if (source.includes('for') && source.includes('storage().instance().get')) {
+      issues.push({
+        ruleId: 'SOROBAN_LOOP_STORAGE_ACCESS',
+        severity: 'high',
+        message: 'Storage access inside loop detected',
+        suggestion: 'Batch reads or redesign storage layout',
+      });
+    }
+
+    if (source.includes('.clone()')) {
+      issues.push({
+        ruleId: 'SOROBAN_REDUNDANT_CLONE',
+        severity: 'low',
+        message: 'Unnecessary clone detected',
+        suggestion: 'Avoid cloning; return original or borrow',
+      });
+    }
+
+    return { issues };
+  }
+}

packages/rules/src/soroban/inefficient_loop.rs

@@ -0,0 +1,20 @@
+#![no_std]
+use soroban_sdk::{contract, contractimpl, Env};
+
+#[contract]
+pub struct InefficientLoop;
+
+#[contractimpl]
+impl InefficientLoop {
+    pub fn sum(env: Env, n: u32) -> u32 {
+        let mut total = 0;
+
+        // ❌ Inefficient: loop + storage access
+        for i in 0..n {
+            let val: u32 = env.storage().instance().get(&i).unwrap_or(0);
+            total += val;
+        }
+
+        total
+    }
+}

packages/rules/src/soroban/inefficient_storage.rs

@@ -0,0 +1,18 @@
+#![no_std]
+use soroban_sdk::{contract, contractimpl, Env, Symbol};
+
+#[contract]
+pub struct InefficientStorage;
+
+#[contractimpl]
+impl InefficientStorage {
+    pub fn get_sum(env: Env) -> i32 {
+        let key = Symbol::short("count");
+
+        // ❌ Inefficient: multiple storage reads
+        let a: i32 = env.storage().instance().get(&key).unwrap_or(0);
+        let b: i32 = env.storage().instance().get(&key).unwrap_or(0);
+
+        a + b
+    }
+}

packages/rules/src/soroban/redundant_clone.rs

@@ -0,0 +1,15 @@
+#![no_std]
+use soroban_sdk::{contract, contractimpl, Env, Vec};
+
+#[contract]
+pub struct RedundantClone;
+
+#[contractimpl]
+impl RedundantClone {
+    pub fn duplicate(env: Env, data: Vec<i32>) -> Vec<i32> {
+        
+        let copy = data.clone();
+        copy
+    }
+}
+

tests/soroban_scan.spec.ts

@@ -0,0 +1,42 @@
+import { GasGuardEngine } from '../packages/rules/gasGuard/gasguard.engine'
+import * as path from 'path';
+
+describe('Soroban Full Scan Lifecycle', () => {
+  const fixturesDir = path.join(
+    __dirname,
+    '../../../fixtures/soroban',
+  );
+
+  const expectedDir = path.join(fixturesDir, 'expected');
+
+  let engine: GasGuardEngine;
+
+  beforeAll(() => {
+    engine = new GasGuardEngine();
+  });
+
+  it.each([
+    'inefficient_storage.rs',
+    'inefficient_loop.rs',
+    'redundant_clone.rs',
+  ])('scans %s and returns expected findings', async (file) => {
+    const source = fs.readFileSync(
+      path.join(fixturesDir, file),
+      'utf8',
+    );
+
+    const expected = JSON.parse(
+      fs.readFileSync(
+        path.join(expectedDir, file.replace('.rs', '.json')),
+        'utf8',
+      ),
+    );
+
+    const result = await engine.scan({
+      language: 'soroban',
+      source,
+    });
+
+    expect(result.issues).toEqual(expected.issues);
+  });
+});