+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| src | +
+
+ |
+ 0% | +0/101 | +0% | +0/22 | +0% | +0/14 | +0% | +0/96 | +
| src/auth | +
+
+ |
+ 68.75% | +11/16 | +100% | +0/0 | +50% | +1/2 | +69.23% | +9/13 | +
| src/auth/__tests__ | +
+
+ |
+ 0% | +0/5 | +100% | +0/0 | +100% | +0/0 | +0% | +0/5 | +
| src/auth/decorators | +
+
+ |
+ 74.07% | +20/27 | +0% | +0/4 | +55.55% | +5/9 | +70.58% | +12/17 | +
| src/auth/guards | +
+
+ |
+ 89.13% | +41/46 | +95.45% | +21/22 | +75% | +6/8 | +92.3% | +36/39 | +
| src/auth/strategies | +
+
+ |
+ 92.3% | +24/26 | +100% | +16/16 | +66.66% | +2/3 | +95.65% | +22/23 | +
| src/controllers | +
+
+ |
+ 0% | +0/163 | +0% | +0/96 | +0% | +0/26 | +0% | +0/155 | +
| src/example | +
+
+ |
+ 0% | +0/6 | +100% | +0/0 | +0% | +0/1 | +0% | +0/4 | +
| src/middleware | +
+
+ |
+ 0% | +0/15 | +0% | +0/16 | +0% | +0/4 | +0% | +0/15 | +
| src/routes | +
+
+ |
+ 0% | +0/15 | +100% | +0/0 | +0% | +0/5 | +0% | +0/15 | +
| src/services | +
+
+ |
+ 0% | +0/311 | +0% | +0/166 | +0% | +0/71 | +0% | +0/294 | +
| src/validation | +
+
+ |
+ 0% | +0/74 | +0% | +0/78 | +0% | +0/8 | +0% | +0/71 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { Controller, Get } from '@nestjs/common'; +import { Public } from './auth'; + +@Controller() +export class AppController { + /** + * Root endpoint - API info + * Public endpoint for API discovery + */ + @Public() + @Get() + getRoot(): { name: string; version: string; health: string } { + return { + name: 'GasGuard API', + version: '0.1.0', + health: '/health', + }; + } + + /** + * Health check endpoint + * Returns a simple status to verify the API is running + * Public endpoint for monitoring and load balancers + */ + @Public() + @Get('health') + getHealth(): { status: string } { + return { status: 'ok' }; + } +} + |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { Module } from '@nestjs/common'; +import { APP_GUARD } from '@nestjs/core'; +import { ConfigModule } from '@nestjs/config'; +import { ThrottlerModule, ThrottlerGuard } from '@nestjs/throttler'; +import { AppController } from './app.controller'; +import { ExampleController } from './example/example.controller'; +import { FailedTransactionController } from './controllers/failed-transaction.controller'; +import { CrossChainGasController } from './controllers/cross-chain-gas.controller'; +import { FailedTransactionService } from './services/failed-transaction.service'; +import { MitigationService } from './services/mitigation.service'; +import { TransactionAnalysisService } from './services/transaction-analysis.service'; +import { CrossChainGasService } from './services/cross-chain-gas.service'; +import { AuthModule, JwtAuthGuard, RolesGuard } from './auth'; + +@Module({ + imports: [ + // Global configuration module for environment variables + ConfigModule.forRoot({ + isGlobal: true, + envFilePath: ['.env', '.env.local'], + }), + // Configure rate limiting: 10 requests per 60 seconds per IP + ThrottlerModule.forRoot([ + { + name: 'default', + ttl: 60000, // 60 seconds in milliseconds + limit: 10, // 10 requests per TTL window + }, + ]), + // JWT Authentication module + AuthModule, + ], + controllers: [ + AppController, + ExampleController, + FailedTransactionController, + CrossChainGasController, + // Add your controllers here - remember to add @Version('1') decorator + ], + providers: [ + // Apply ThrottlerGuard globally to all routes + { + provide: APP_GUARD, + useClass: ThrottlerGuard, + }, + // Apply JWT authentication guard globally to all routes + { + provide: APP_GUARD, + useClass: JwtAuthGuard, + }, + // Apply roles guard globally for RBAC enforcement + { + provide: APP_GUARD, + useClass: RolesGuard, + }, + FailedTransactionService, + MitigationService, + TransactionAnalysisService, + CrossChainGasService, + ], +}) +export class AppModule { } + |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| index.ts | +
+
+ |
+ 0% | +0/5 | +100% | +0/0 | +100% | +0/0 | +0% | +0/5 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 | + + + + + + | // Auth module test exports +export * from './jwt.strategy.spec'; +export * from './jwt-auth.guard.spec'; +export * from './roles.guard.spec'; +export * from './decorators.spec'; +export * from './auth.module.spec'; + |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 | 1x +1x +1x +1x +1x +1x +1x + + + + + + +14x + + + + + + + + + + + + +1x + | import { Module } from '@nestjs/common';
+import { JwtModule } from '@nestjs/jwt';
+import { PassportModule } from '@nestjs/passport';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { JwtStrategy } from './strategies/jwt.strategy';
+import { JwtAuthGuard } from './guards/jwt-auth.guard';
+import { RolesGuard } from './guards/roles.guard';
+
+@Module({
+ imports: [
+ PassportModule.register({ defaultStrategy: 'jwt' }),
+ JwtModule.registerAsync({
+ imports: [ConfigModule],
+ useFactory: async (configService: ConfigService) => ({
+ secret: configService.get<string>('JWT_SECRET'),
+ signOptions: {
+ issuer: configService.get<string>('JWT_ISSUER', 'gasguard-api'),
+ audience: configService.get<string>('JWT_AUDIENCE', 'gasguard-client'),
+ },
+ }),
+ inject: [ConfigService],
+ }),
+ ],
+ providers: [JwtStrategy, JwtAuthGuard, RolesGuard],
+ exports: [JwtAuthGuard, RolesGuard, PassportModule, JwtModule],
+})
+export class AuthModule {}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 | 1x + + + + + + + + + + + + + + + + + + +1x + + + + + + + + + + + + | import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+import { JwtUser } from '../strategies/jwt.strategy';
+
+/**
+ * Extracts the current authenticated user from the request.
+ * Returns the full user object or a specific property if key is provided.
+ *
+ * @param key - Optional property key to extract from user object
+ * @returns The user object or the specified property value
+ *
+ * @example
+ * ```typescript
+ * @Get('profile')
+ * getProfile(@CurrentUser() user: JwtUser) { ... }
+ *
+ * @Get('user-id')
+ * getUserId(@CurrentUser('userId') userId: string) { ... }
+ * ```
+ */
+export const CurrentUser = createParamDecorator(
+ (key: keyof JwtUser | undefined, ctx: ExecutionContext) => {
+ const request = ctx.switchToHttp().getRequest<{ user: JwtUser }>();
+ const user = request.user;
+
+ if (!user) {
+ return undefined;
+ }
+
+ return key ? user[key] : user;
+ },
+);
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| current-user.decorator.ts | +
+
+ |
+ 28.57% | +2/7 | +0% | +0/4 | +0% | +0/1 | +28.57% | +2/7 | +
| index.ts | +
+
+ |
+ 100% | +9/9 | +100% | +0/0 | +83.33% | +5/6 | +100% | +3/3 | +
| public.decorator.ts | +
+
+ |
+ 80% | +4/5 | +100% | +0/0 | +0% | +0/1 | +100% | +3/3 | +
| roles.decorator.ts | +
+
+ |
+ 83.33% | +5/6 | +100% | +0/0 | +0% | +0/1 | +100% | +4/4 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 | 2x +9x +1x + | export { Public, IS_PUBLIC_KEY } from './public.decorator';
+export { Roles, Role, RoleType, ROLES_KEY } from './roles.decorator';
+export { CurrentUser } from './current-user.decorator';
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 | 3x + +3x + + + + + + + + + + + + +3x + | import { SetMetadata } from '@nestjs/common';
+
+export const IS_PUBLIC_KEY = 'isPublic';
+
+/**
+ * Marks a route or controller as public, bypassing JWT authentication.
+ * Use this decorator on endpoints that don't require authentication.
+ *
+ * @example
+ * ```typescript
+ * @Public()
+ * @Get('health')
+ * getHealth() { ... }
+ * ```
+ */
+export const Public = () => SetMetadata(IS_PUBLIC_KEY, true);
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 | 3x + +3x + + + + + + + + + + + + + + +3x + + + + +3x + + + + + + + + | import { SetMetadata } from '@nestjs/common';
+
+export const ROLES_KEY = 'roles';
+
+/**
+ * Defines the roles required to access a route or controller.
+ * Must be used in combination with JwtAuthGuard and RolesGuard.
+ *
+ * @param roles - Array of role names required for access
+ *
+ * @example
+ * ```typescript
+ * @Roles('admin', 'analyst')
+ * @Get('sensitive-data')
+ * getSensitiveData() { ... }
+ * ```
+ */
+export const Roles = (...roles: string[]) => SetMetadata(ROLES_KEY, roles);
+
+/**
+ * Predefined role constants for consistent role naming across the application.
+ */
+export const Role = {
+ ADMIN: 'admin',
+ ANALYST: 'analyst',
+ USER: 'user',
+ READONLY: 'readonly',
+} as const;
+
+export type RoleType = (typeof Role)[keyof typeof Role];
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| index.ts | +
+
+ |
+ 0% | +0/4 | +100% | +0/0 | +0% | +0/2 | +0% | +0/2 | +
| jwt-auth.guard.ts | +
+
+ |
+ 95.65% | +22/23 | +91.66% | +11/12 | +100% | +3/3 | +95.23% | +20/21 | +
| roles.guard.ts | +
+
+ |
+ 100% | +19/19 | +100% | +10/10 | +100% | +3/3 | +100% | +16/16 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 | + + | export { JwtAuthGuard } from './jwt-auth.guard'; +export { RolesGuard } from './roles.guard'; + |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 | 2x + + + + +2x +2x +2x + + +2x +23x +23x + + + + +1x + + + + +1x +1x + + + + + + + + +8x +7x + +7x +1x +6x +1x +5x +1x + + +7x + + + + + + +1x + + + | import {
+ Injectable,
+ ExecutionContext,
+ UnauthorizedException,
+} from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+import { IS_PUBLIC_KEY } from '../decorators/public.decorator';
+
+@Injectable()
+export class JwtAuthGuard extends AuthGuard('jwt') {
+ constructor(private reflector: Reflector) {
+ super();
+ }
+
+ canActivate(context: ExecutionContext) {
+ // Check if route is marked as public
+ const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
+ context.getHandler(),
+ context.getClass(),
+ ]);
+
+ Eif (isPublic) {
+ return true;
+ }
+
+ // Otherwise, apply JWT authentication
+ return super.canActivate(context);
+ }
+
+ handleRequest(err: any, user: any, info: any) {
+ // Custom error handling
+ if (err || !user) {
+ let message = 'Invalid or expired JWT access token.';
+
+ if (info?.name === 'TokenExpiredError') {
+ message = 'JWT access token has expired.';
+ } else if (info?.name === 'JsonWebTokenError') {
+ message = 'Invalid JWT access token format.';
+ } else if (info?.message) {
+ message = info.message;
+ }
+
+ throw new UnauthorizedException({
+ error: 'Unauthorized',
+ message,
+ timestamp: new Date().toISOString(),
+ });
+ }
+
+ return user;
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 | 2x + + + + + +2x +2x + + + +2x +25x + + +13x + + + + + +13x +3x + + +10x + +10x +2x + + + + + + +8x + + +11x + +8x +6x + + + + + + +2x + + + | import {
+ Injectable,
+ CanActivate,
+ ExecutionContext,
+ ForbiddenException,
+} from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { ROLES_KEY } from '../decorators/roles.decorator';
+import { JwtUser } from '../strategies/jwt.strategy';
+
+@Injectable()
+export class RolesGuard implements CanActivate {
+ constructor(private reflector: Reflector) {}
+
+ canActivate(context: ExecutionContext): boolean {
+ const requiredRoles = this.reflector.getAllAndOverride<string[]>(ROLES_KEY, [
+ context.getHandler(),
+ context.getClass(),
+ ]);
+
+ // If no roles are required, allow access
+ if (!requiredRoles || requiredRoles.length === 0) {
+ return true;
+ }
+
+ const { user } = context.switchToHttp().getRequest<{ user: JwtUser }>();
+
+ if (!user) {
+ throw new ForbiddenException({
+ error: 'Forbidden',
+ message: 'Access denied: User not authenticated',
+ timestamp: new Date().toISOString(),
+ });
+ }
+
+ const userRoles = user.roles || [];
+
+ // Check if user has at least one of the required roles
+ const hasRole = requiredRoles.some((role) => userRoles.includes(role));
+
+ if (!hasRole) {
+ throw new ForbiddenException({
+ error: 'Forbidden',
+ message: `Access denied: Required roles are [${requiredRoles.join(', ')}]`,
+ timestamp: new Date().toISOString(),
+ });
+ }
+
+ return true;
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| auth.module.ts | +
+
+ |
+ 100% | +11/11 | +100% | +0/0 | +100% | +1/1 | +100% | +9/9 | +
| index.ts | +
+
+ |
+ 0% | +0/5 | +100% | +0/0 | +0% | +0/1 | +0% | +0/4 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 | + + + + | export { AuthModule } from './auth.module'; +export * from './decorators'; +export * from './guards'; +export * from './strategies'; + |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| index.ts | +
+
+ |
+ 0% | +0/2 | +100% | +0/0 | +0% | +0/1 | +0% | +0/1 | +
| jwt.strategy.ts | +
+
+ |
+ 100% | +24/24 | +100% | +16/16 | +100% | +2/2 | +100% | +22/22 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 | + | export { JwtStrategy, JwtPayload, JwtUser } from './jwt.strategy';
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 | 2x +2x +2x +2x + + + + + + + + + + + + + + + + + + + +2x +24x +26x +26x +2x + + +24x + + + + + + + + + + + +8x +1x + + +7x +1x + + +6x +1x + + +5x +1x + + + +4x +4x +2x + + + +2x + + + + + + + | import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { PassportStrategy } from '@nestjs/passport';
+import { ExtractJwt, Strategy } from 'passport-jwt';
+
+export interface JwtPayload {
+ sub: string;
+ iss: string;
+ aud: string;
+ exp: number;
+ iat: number;
+ roles?: string[];
+ permissions?: string[];
+ [key: string]: any;
+}
+
+export interface JwtUser {
+ userId: string;
+ roles: string[];
+ permissions: string[];
+}
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+ constructor(private readonly configService: ConfigService) {
+ const secret = configService.get<string>('JWT_SECRET');
+ if (!secret) {
+ throw new Error('JWT_SECRET environment variable is required');
+ }
+
+ super({
+ jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+ ignoreExpiration: false,
+ secretOrKey: secret,
+ issuer: configService.get<string>('JWT_ISSUER', 'gasguard-api'),
+ audience: configService.get<string>('JWT_AUDIENCE', 'gasguard-client'),
+ algorithms: ['HS256'],
+ });
+ }
+
+ async validate(payload: JwtPayload): Promise<JwtUser> {
+ // Validate required claims
+ if (!payload.sub) {
+ throw new UnauthorizedException('Invalid token: missing subject claim');
+ }
+
+ if (!payload.iss) {
+ throw new UnauthorizedException('Invalid token: missing issuer claim');
+ }
+
+ if (!payload.aud) {
+ throw new UnauthorizedException('Invalid token: missing audience claim');
+ }
+
+ if (!payload.exp) {
+ throw new UnauthorizedException('Invalid token: missing expiration claim');
+ }
+
+ // Check token expiration (passport-jwt also does this, but double-check)
+ const now = Math.floor(Date.now() / 1000);
+ if (payload.exp < now) {
+ throw new UnauthorizedException('Token has expired');
+ }
+
+ // Return user object that will be attached to request
+ return {
+ userId: payload.sub,
+ roles: payload.roles || [],
+ permissions: payload.permissions || [],
+ };
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { Request, Response } from 'express';
+import { Queue } from 'bullmq';
+import {
+ CodebaseSubmissionRequest,
+ AnalysisResponse,
+ AnalysisStatus,
+ AnalysisResult,
+ ApiErrorResponse
+} from '../schemas/analysis.schema';
+import { AnalysisValidator } from '../validation/analysis.validator';
+
+export class AnalysisController {
+ constructor(private queue: Queue) {}
+
+ async submitCodebase(req: Request, res: Response): Promise<void> {
+ try {
+ const payload = req.body as CodebaseSubmissionRequest;
+
+ // Determine if this is a large job
+ const isLarge = this.isLargeSubmission(payload);
+
+ // Add job to queue with appropriate priority and options
+ const job = await this.queue.add('analyze-codebase', {
+ payload,
+ isLarge,
+ submittedAt: new Date().toISOString(),
+ requestId: req.headers['x-request-id'] as string || 'unknown'
+ }, {
+ removeOnComplete: false,
+ removeOnFail: false,
+ attempts: isLarge ? 3 : 5,
+ backoff: {
+ type: 'exponential',
+ delay: 2000
+ },
+ priority: isLarge ? 10 : 100
+ });
+
+ const response: AnalysisResponse = {
+ jobId: job.id as string,
+ status: 'queued',
+ submittedAt: new Date().toISOString(),
+ estimatedDuration: this.estimateAnalysisDuration(payload),
+ statusUrl: `/analysis/${job.id}/status`,
+ resultUrl: `/analysis/${job.id}/result`
+ };
+
+ res.status(202).json(response);
+ } catch (error) {
+ console.error('Error submitting codebase:', error);
+ this.sendErrorResponse(res, 'SUBMISSION_ERROR', 'Failed to submit codebase for analysis', error);
+ }
+ }
+
+ async getAnalysisStatus(req: Request, res: Response): Promise<void> {
+ try {
+ const jobId = req.params.id;
+
+ if (!jobId) {
+ res.status(400).json({
+ error: {
+ code: 'MISSING_JOB_ID',
+ message: 'Job ID is required',
+ timestamp: new Date().toISOString(),
+ requestId: req.headers['x-request-id'] as string || 'unknown'
+ }
+ });
+ return;
+ }
+
+ const job = await this.queue.getJob(jobId);
+
+ if (!job) {
+ res.status(404).json({
+ error: {
+ code: 'JOB_NOT_FOUND',
+ message: `Analysis job with ID ${jobId} not found`,
+ timestamp: new Date().toISOString(),
+ requestId: req.headers['x-request-id'] as string || 'unknown'
+ }
+ });
+ return;
+ }
+
+ const state = await job.getState();
+ const progress = job.progress || 0;
+
+ const status: AnalysisStatus = {
+ jobId,
+ status: this.mapJobState(state),
+ progress: typeof progress === 'number' ? progress : 0,
+ currentStep: job.data?.currentStep,
+ startedAt: job.data?.startedAt,
+ completedAt: job.finishedOn ? new Date(job.finishedOn).toISOString() : undefined,
+ error: job.failedReason ? {
+ code: 'JOB_FAILED',
+ message: job.failedReason,
+ timestamp: new Date().toISOString()
+ } : undefined
+ };
+
+ res.json(status);
+ } catch (error) {
+ console.error('Error getting analysis status:', error);
+ this.sendErrorResponse(res, 'STATUS_ERROR', 'Failed to retrieve analysis status', error);
+ }
+ }
+
+ async getAnalysisResult(req: Request, res: Response): Promise<void> {
+ try {
+ const jobId = req.params.id;
+
+ if (!jobId) {
+ res.status(400).json({
+ error: {
+ code: 'MISSING_JOB_ID',
+ message: 'Job ID is required',
+ timestamp: new Date().toISOString(),
+ requestId: req.headers['x-request-id'] as string || 'unknown'
+ }
+ });
+ return;
+ }
+
+ const job = await this.queue.getJob(jobId);
+
+ if (!job) {
+ res.status(404).json({
+ error: {
+ code: 'JOB_NOT_FOUND',
+ message: `Analysis job with ID ${jobId} not found`,
+ timestamp: new Date().toISOString(),
+ requestId: req.headers['x-request-id'] as string || 'unknown'
+ }
+ });
+ return;
+ }
+
+ const state = await job.getState();
+
+ if (state !== 'completed') {
+ const status: AnalysisStatus = {
+ jobId,
+ status: this.mapJobState(state),
+ progress: typeof job.progress === 'number' ? job.progress : 0,
+ startedAt: job.data?.startedAt,
+ completedAt: job.finishedOn ? new Date(job.finishedOn).toISOString() : undefined
+ };
+
+ res.status(202).json(status);
+ return;
+ }
+
+ const result = job.returnvalue as AnalysisResult;
+
+ if (!result) {
+ res.status(500).json({
+ error: {
+ code: 'NO_RESULT',
+ message: 'Analysis completed but no result available',
+ timestamp: new Date().toISOString(),
+ requestId: req.headers['x-request-id'] as string || 'unknown'
+ }
+ });
+ return;
+ }
+
+ res.json({ result });
+ } catch (error) {
+ console.error('Error getting analysis result:', error);
+ this.sendErrorResponse(res, 'RESULT_ERROR', 'Failed to retrieve analysis result', error);
+ }
+ }
+
+ async cancelAnalysis(req: Request, res: Response): Promise<void> {
+ try {
+ const jobId = req.params.id;
+
+ if (!jobId) {
+ res.status(400).json({
+ error: {
+ code: 'MISSING_JOB_ID',
+ message: 'Job ID is required',
+ timestamp: new Date().toISOString(),
+ requestId: req.headers['x-request-id'] as string || 'unknown'
+ }
+ });
+ return;
+ }
+
+ const job = await this.queue.getJob(jobId);
+
+ if (!job) {
+ res.status(404).json({
+ error: {
+ code: 'JOB_NOT_FOUND',
+ message: `Analysis job with ID ${jobId} not found`,
+ timestamp: new Date().toISOString(),
+ requestId: req.headers['x-request-id'] as string || 'unknown'
+ }
+ });
+ return;
+ }
+
+ const state = await job.getState();
+
+ if (state === 'completed') {
+ res.status(400).json({
+ error: {
+ code: 'ALREADY_COMPLETED',
+ message: 'Cannot cancel a completed analysis',
+ timestamp: new Date().toISOString(),
+ requestId: req.headers['x-request-id'] as string || 'unknown'
+ }
+ });
+ return;
+ }
+
+ await job.remove();
+
+ res.json({
+ message: 'Analysis cancelled successfully',
+ jobId,
+ cancelledAt: new Date().toISOString()
+ });
+ } catch (error) {
+ console.error('Error cancelling analysis:', error);
+ this.sendErrorResponse(res, 'CANCEL_ERROR', 'Failed to cancel analysis', error);
+ }
+ }
+
+ private isLargeSubmission(payload: CodebaseSubmissionRequest): boolean {
+ const totalSize = payload.files.reduce((sum, file) => sum + (file.size || 0), 0);
+ const fileCount = payload.files.length;
+
+ return totalSize > 5 * 1024 * 1024 || fileCount > 50 || JSON.stringify(payload).length > 200_000;
+ }
+
+ private estimateAnalysisDuration(payload: CodebaseSubmissionRequest): number {
+ const fileCount = payload.files.length;
+ const rustFileCount = payload.files.filter(f => f.language === 'rust').length;
+ const totalLines = payload.files.reduce((sum, file) => sum + (file.content.split('\n').length), 0);
+
+ // Base time: 30 seconds
+ let estimatedSeconds = 30;
+
+ // Add time per file
+ estimatedSeconds += fileCount * 2;
+
+ // Add extra time for Rust files (more complex analysis)
+ estimatedSeconds += rustFileCount * 5;
+
+ // Add time per 1000 lines of code
+ estimatedSeconds += Math.ceil(totalLines / 1000) * 10;
+
+ // Cap at 10 minutes
+ return Math.min(estimatedSeconds, 600);
+ }
+
+ private mapJobState(state: string): 'queued' | 'processing' | 'completed' | 'failed' {
+ switch (state) {
+ case 'waiting':
+ case 'waiting-children':
+ return 'queued';
+ case 'active':
+ return 'processing';
+ case 'completed':
+ return 'completed';
+ case 'failed':
+ return 'failed';
+ default:
+ return 'queued';
+ }
+ }
+
+ private sendErrorResponse(res: Response, code: string, message: string, error?: any): void {
+ const response: ApiErrorResponse = {
+ error: {
+ code,
+ message,
+ details: error?.message || error,
+ timestamp: new Date().toISOString(),
+ requestId: res.locals.requestId || 'unknown'
+ }
+ };
+
+ res.status(500).json(response);
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { Controller, Get, Query, BadRequestException, UseGuards } from '@nestjs/common'; +import { ApiTags, ApiOperation, ApiResponse, ApiQuery, ApiBearerAuth } from '@nestjs/swagger'; +import { CrossChainGasService } from '../services/cross-chain-gas.service'; +import { + CrossChainGasRequest, + CrossChainGasResponse, + SupportedChain +} from '../schemas/cross-chain-gas.schema'; +import { Public, Roles, Role, JwtAuthGuard, RolesGuard } from '../auth'; + +@ApiTags('Cross-Chain Gas Comparison') +@ApiBearerAuth() +@Controller() +export class CrossChainGasController { + constructor(private readonly crossChainGasService: CrossChainGasService) {} + + @Get('v1/analytics/cross-chain-gas') + @ApiOperation({ + summary: 'Compare gas costs across supported chains', + description: 'Get real-time gas cost comparison across all supported chains, normalized to USD and ranked by efficiency' + }) + @ApiQuery({ + name: 'txType', + enum: ['transfer', 'contract-call', 'swap'], + required: true, + description: 'Type of transaction to compare costs for' + }) + @ApiResponse({ + status: 200, + description: 'Cross-chain gas comparison retrieved successfully' + }) + @ApiResponse({ + status: 400, + description: 'Invalid transaction type provided' + }) + async getCrossChainGasComparison( + @Query('txType') txType: string + ): Promise<CrossChainGasResponse> { + if (!['transfer', 'contract-call', 'swap'].includes(txType)) { + throw new BadRequestException('Invalid transaction type. Must be one of: transfer, contract-call, swap'); + } + + const request: CrossChainGasRequest = { + txType: txType as 'transfer' | 'contract-call' | 'swap' + }; + + return this.crossChainGasService.getCrossChainGasComparison(request); + } + + @Get('v1/analytics/supported-chains') + @ApiOperation({ + summary: 'Get list of supported chains', + description: 'Retrieve all supported chains with their metadata and configuration' + }) + @ApiResponse({ + status: 200, + description: 'Supported chains retrieved successfully' + }) + async getSupportedChains(): Promise<SupportedChain[]> { + return this.crossChainGasService.getSupportedChains(); + } + + @Roles(Role.ADMIN) + @Get('v1/analytics/cross-chain-gas/refresh') + @ApiOperation({ + summary: 'Refresh gas price data', + description: 'Force refresh of gas price data and native token prices (admin endpoint). Requires admin role.' + }) + @ApiResponse({ + status: 200, + description: 'Gas price data refreshed successfully' + }) + @ApiResponse({ + status: 403, + description: 'Forbidden - Requires admin role' + }) + async refreshGasData(): Promise<{ message: string; timestamp: number }> { + await this.crossChainGasService.updateNativeTokenPrices(); + return { + message: 'Gas price data refreshed successfully', + timestamp: Date.now() + }; + } + + @Get('v1/analytics/cross-chain-gas/history') + @ApiOperation({ + summary: 'Get historical gas price data', + description: 'Retrieve historical gas price data for a specific chain' + }) + @ApiQuery({ + name: 'chainId', + type: 'number', + required: true, + description: 'Chain ID to fetch historical data for' + }) + @ApiQuery({ + name: 'hours', + type: 'number', + required: false, + description: 'Number of hours of historical data to fetch (default: 24)' + }) + @ApiResponse({ + status: 200, + description: 'Historical gas data retrieved successfully' + }) + async getGasHistory( + @Query('chainId') chainId: number, + @Query('hours') hours?: number + ): Promise<any[]> { + if (!chainId || isNaN(chainId)) { + throw new BadRequestException('Valid chain ID is required'); + } + + return this.crossChainGasService.getChainGasMetricsHistory(chainId, hours); + } +} + |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { + Controller, + Get, + Post, + Body, + Param, + Query, + HttpException, + HttpStatus, + Logger, + UseGuards, +} from '@nestjs/common'; +import { ApiTags, ApiOperation, ApiResponse, ApiParam, ApiQuery, ApiBearerAuth } from '@nestjs/swagger'; +import { + TransactionAnalysisRequest, + TransactionAnalysisResponse, + FailedTransaction, + FailedTransactionEvent +} from '../schemas/failed-transaction.schema'; +import { TransactionAnalysisService } from '../services/transaction-analysis.service'; +import { Public, Roles, Role, JwtAuthGuard, RolesGuard } from '../auth'; + +@ApiTags('failed-transactions') +@ApiBearerAuth() +@Controller({ path: 'failed-transactions', version: '1' }) +export class FailedTransactionController { + private readonly logger = new Logger(FailedTransactionController.name); + + constructor(private readonly transactionAnalysisService: TransactionAnalysisService) {} + + @Post('analyze') + @ApiOperation({ + summary: 'Analyze failed transactions for a wallet', + description: 'Provides comprehensive analysis of failed transactions including cost metrics, failure categories, and mitigation recommendations' + }) + @ApiResponse({ + status: 200, + description: 'Analysis completed successfully' + }) + @ApiResponse({ + status: 400, + description: 'Invalid request parameters' + }) + async analyzeWalletFailures( + @Body() request: TransactionAnalysisRequest + ): Promise<TransactionAnalysisResponse> { + try { + this.logger.log(`Analyzing failed transactions for wallet: ${request.wallet}`); + + if (!request.wallet || !request.wallet.match(/^0x[a-fA-F0-9]{40}$/)) { + throw new HttpException('Invalid wallet address', HttpStatus.BAD_REQUEST); + } + + return await this.transactionAnalysisService.analyzeWalletFailures(request); + } catch (error) { + this.logger.error(`Error analyzing wallet failures: ${error.message}`); + throw new HttpException( + `Failed to analyze wallet failures: ${error.message}`, + HttpStatus.INTERNAL_SERVER_ERROR + ); + } + } + + @Get(':wallet/summary') + @ApiOperation({ + summary: 'Get wallet failure summary', + description: 'Returns a quick summary of failed transaction metrics for a wallet' + }) + @ApiParam({ + name: 'wallet', + description: 'Wallet address to analyze' + }) + @ApiQuery({ + name: 'chainIds', + required: false, + description: 'Comma-separated list of chain IDs to filter by', + example: '1,137,42161' + }) + @ApiResponse({ + status: 200, + description: 'Summary retrieved successfully' + }) + async getWalletSummary( + @Param('wallet') wallet: string, + @Query('chainIds') chainIds?: string + ): Promise<any> { + try { + if (!wallet.match(/^0x[a-fA-F0-9]{40}$/)) { + throw new HttpException('Invalid wallet address', HttpStatus.BAD_REQUEST); + } + + const chainIdArray = chainIds + ? chainIds.split(',').map(id => parseInt(id.trim())).filter(id => !isNaN(id)) + : undefined; + + return await this.transactionAnalysisService.getWalletSummary(wallet, chainIdArray); + } catch (error) { + this.logger.error(`Error getting wallet summary: ${error.message}`); + throw new HttpException( + `Failed to get wallet summary: ${error.message}`, + HttpStatus.INTERNAL_SERVER_ERROR + ); + } + } + + @Get(':wallet/mitigation') + @ApiOperation({ + summary: 'Get immediate mitigation for recent failure', + description: 'Provides immediate action steps to resolve the most recent failed transaction' + }) + @ApiParam({ + name: 'wallet', + description: 'Wallet address' + }) + @ApiQuery({ + name: 'txHash', + required: false, + description: 'Specific transaction hash to get mitigation for' + }) + @ApiResponse({ + status: 200, + description: 'Mitigation recommendations retrieved successfully' + }) + async getImmediateMitigation( + @Param('wallet') wallet: string, + @Query('txHash') txHash?: string + ): Promise<any> { + try { + if (!wallet.match(/^0x[a-fA-F0-9]{40}$/)) { + throw new HttpException('Invalid wallet address', HttpStatus.BAD_REQUEST); + } + + return await this.transactionAnalysisService.getImmediateMitigation(wallet, txHash); + } catch (error) { + this.logger.error(`Error getting immediate mitigation: ${error.message}`); + throw new HttpException( + `Failed to get mitigation: ${error.message}`, + HttpStatus.INTERNAL_SERVER_ERROR + ); + } + } + + @Post('track') + @ApiOperation({ + summary: 'Track a failed transaction', + description: 'Records a failed transaction for analysis and future recommendations' + }) + @ApiResponse({ + status: 201, + description: 'Failed transaction tracked successfully' + }) + @ApiResponse({ + status: 400, + description: 'Invalid transaction data' + }) + async trackFailedTransaction( + @Body() transactionData: Partial<FailedTransaction> + ): Promise<FailedTransaction> { + try { + // Validate required fields + if (!transactionData.hash || !transactionData.wallet || !transactionData.chainId) { + throw new HttpException( + 'Missing required fields: hash, wallet, chainId', + HttpStatus.BAD_REQUEST + ); + } + + if (!transactionData.wallet.match(/^0x[a-fA-F0-9]{40}$/)) { + throw new HttpException('Invalid wallet address', HttpStatus.BAD_REQUEST); + } + + if (!transactionData.hash.match(/^0x[a-fA-F0-9]{64}$/)) { + throw new HttpException('Invalid transaction hash', HttpStatus.BAD_REQUEST); + } + + this.logger.log(`Tracking failed transaction: ${transactionData.hash} for wallet: ${transactionData.wallet}`); + + return await this.transactionAnalysisService.processFailedTransaction(transactionData); + } catch (error) { + this.logger.error(`Error tracking failed transaction: ${error.message}`); + throw new HttpException( + `Failed to track transaction: ${error.message}`, + HttpStatus.INTERNAL_SERVER_ERROR + ); + } + } + + @Get('chains/:chainId/stats') + @ApiOperation({ + summary: 'Get chain-specific failure statistics', + description: 'Returns failure statistics for a specific blockchain network' + }) + @ApiParam({ + name: 'chainId', + description: 'Blockchain network ID' + }) + @ApiQuery({ + name: 'timeframe', + required: false, + description: 'Timeframe for analysis (7d, 30d, 90d)', + example: '30d' + }) + @ApiResponse({ + status: 200, + description: 'Chain statistics retrieved successfully' + }) + async getChainStats( + @Param('chainId') chainId: string, + @Query('timeframe') timeframe?: string + ): Promise<any> { + try { + const chainIdNum = parseInt(chainId); + if (isNaN(chainIdNum)) { + throw new HttpException('Invalid chain ID', HttpStatus.BAD_REQUEST); + } + + // This would typically query a database for chain-wide statistics + // For now, return a mock response + return { + chainId: chainIdNum, + timeframe: timeframe || '30d', + totalFailures: Math.floor(Math.random() * 1000), + totalGasWasted: (Math.random() * 10).toFixed(4) + ' ETH', + topFailureCategory: 'underpriced_gas', + averageGasWastePerFailure: (Math.random() * 0.1).toFixed(6) + ' ETH', + processedAt: new Date().toISOString() + }; + } catch (error) { + this.logger.error(`Error getting chain stats: ${error.message}`); + throw new HttpException( + `Failed to get chain stats: ${error.message}`, + HttpStatus.INTERNAL_SERVER_ERROR + ); + } + } + + @Public() + @Get('health') + @ApiOperation({ + summary: 'Health check endpoint', + description: 'Returns the health status of the failed transaction analyzer service' + }) + @ApiResponse({ + status: 200, + description: 'Service is healthy' + }) + async getHealth(): Promise<any> { + return { + status: 'healthy', + service: 'failed-transaction-analyzer', + timestamp: new Date().toISOString(), + version: '1.0.0' + }; + } +} + |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| analysis.controller.ts | +
+
+ |
+ 0% | +0/85 | +0% | +0/67 | +0% | +0/12 | +0% | +0/82 | +
| cross-chain-gas.controller.ts | +
+
+ |
+ 0% | +0/22 | +0% | +0/6 | +0% | +0/5 | +0% | +0/20 | +
| failed-transaction.controller.ts | +
+
+ |
+ 0% | +0/56 | +0% | +0/23 | +0% | +0/9 | +0% | +0/53 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 | + + + + + + + + + + + + + + + + + + + + + | import { Controller, Get } from '@nestjs/common'; + +/** + * Example controller demonstrating API versioning + * + * This controller is accessible at: + * - GET /v1/example + * + * Unversioned requests (e.g., /example) will return 404 + */ +@Controller({ path: 'example', version: '1' }) +export class ExampleController { + @Get() + getExample() { + return { + message: 'This is a versioned endpoint', + version: '1', + path: '/v1/example', + }; + } +} + |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| example.controller.ts | +
+
+ |
+ 0% | +0/6 | +100% | +0/0 | +0% | +0/1 | +0% | +0/4 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| app.controller.ts | +
+
+ |
+ 0% | +0/9 | +100% | +0/0 | +0% | +0/2 | +0% | +0/7 | +
| app.module.ts | +
+
+ |
+ 0% | +0/16 | +100% | +0/0 | +100% | +0/0 | +0% | +0/14 | +
| index.ts | +
+
+ |
+ 0% | +0/4 | +0% | +0/2 | +0% | +0/1 | +0% | +0/4 | +
| main.ts | +
+
+ |
+ 0% | +0/10 | +0% | +0/2 | +0% | +0/1 | +0% | +0/10 | +
| scan.ts | +
+
+ |
+ 0% | +0/12 | +0% | +0/2 | +0% | +0/3 | +0% | +0/11 | +
| server.ts | +
+
+ |
+ 0% | +0/50 | +0% | +0/16 | +0% | +0/7 | +0% | +0/50 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 | + + + + + | import { createServer } from './server.js' + +const port = Number(process.env.PORT || 3000) +const app = createServer({} as any) // Pass empty queue for now + +app.listen(port, () => {}) |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 | + + + + + + + + + + + + + + + + + + + + + | import { NestFactory } from '@nestjs/core'; +import { VersioningType } from '@nestjs/common'; +import { AppModule } from './app.module'; + +async function bootstrap() { + const app = await NestFactory.create(AppModule); + + // Enable API versioning with URI-based strategy + // All routes must include /v1/ prefix, unversioned requests return 404 + app.enableVersioning({ + type: VersioningType.URI, + // No defaultVersion - unversioned requests will return 404 + }); + + const port = process.env.PORT || 3000; + await app.listen(port); + console.log(`🚀 GasGuard API is running on: http://localhost:${port}`); + console.log(`API versioning enabled - all endpoints require /v1/ prefix`); +} + +bootstrap(); + |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { Request, Response, NextFunction } from 'express';
+import { ApiErrorResponse } from '../schemas/analysis.schema';
+
+export interface CustomError extends Error {
+ statusCode?: number;
+ code?: string;
+ details?: any;
+}
+
+export function errorHandler(
+ error: CustomError,
+ req: Request,
+ res: Response,
+ next: NextFunction
+): void {
+ console.error('Error occurred:', {
+ message: error.message,
+ stack: error.stack,
+ url: req.url,
+ method: req.method,
+ requestId: req.headers['x-request-id'],
+ timestamp: new Date().toISOString()
+ });
+
+ const statusCode = error.statusCode || 500;
+ const errorCode = error.code || 'INTERNAL_SERVER_ERROR';
+
+ const response: ApiErrorResponse = {
+ error: {
+ code: errorCode,
+ message: error.message || 'An unexpected error occurred',
+ details: error.details,
+ timestamp: new Date().toISOString(),
+ requestId: req.headers['x-request-id'] as string || 'unknown'
+ }
+ };
+
+ // Don't expose stack trace in production
+ if (process.env.NODE_ENV !== 'production') {
+ response.error.details = {
+ ...response.error.details,
+ stack: error.stack
+ };
+ }
+
+ res.status(statusCode).json(response);
+}
+
+export function notFoundHandler(req: Request, res: Response): void {
+ res.status(404).json({
+ error: {
+ code: 'NOT_FOUND',
+ message: `Route ${req.method} ${req.path} not found`,
+ timestamp: new Date().toISOString(),
+ requestId: req.headers['x-request-id'] as string || 'unknown'
+ }
+ });
+}
+
+export function requestIdHandler(req: Request, res: Response, next: NextFunction): void {
+ req.headers['x-request-id'] = req.headers['x-request-id'] ||
+ `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+ next();
+}
+
+export function rateLimitHandler(req: Request, res: Response): void {
+ res.status(429).json({
+ error: {
+ code: 'RATE_LIMIT_EXCEEDED',
+ message: 'Too many requests, please try again later',
+ timestamp: new Date().toISOString(),
+ requestId: req.headers['x-request-id'] as string || 'unknown'
+ }
+ });
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| error.middleware.ts | +
+
+ |
+ 0% | +0/15 | +0% | +0/16 | +0% | +0/4 | +0% | +0/15 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { Router } from 'express'; +import { AnalysisController } from '../controllers/analysis.controller'; +import { AnalysisValidator } from '../validation/analysis.validator'; + +export function createAnalysisRoutes(queue: any): Router { + const router = Router(); + const controller = new AnalysisController(queue); + + // Submit codebase for analysis + router.post('/analysis', + AnalysisValidator.validateSubmission, + (req, res) => controller.submitCodebase(req, res) + ); + + // Get analysis status + router.get('/analysis/:id/status', + (req, res) => controller.getAnalysisStatus(req, res) + ); + + // Get analysis result + router.get('/analysis/:id/result', + (req, res) => controller.getAnalysisResult(req, res) + ); + + // Cancel analysis + router.delete('/analysis/:id', + (req, res) => controller.cancelAnalysis(req, res) + ); + + return router; +} + |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| analysis.routes.ts | +
+
+ |
+ 0% | +0/15 | +100% | +0/0 | +0% | +0/5 | +0% | +0/15 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 | + + + + + + + + + + + + + + + + | type ProgressCb = (p: number) => Promise<void> | void + +export async function performScan(input: any, onProgress: ProgressCb) { + await onProgress(25) + await sleep(500) + await onProgress(50) + await sleep(500) + await onProgress(75) + await sleep(500) + const result = { summary: 'ok', issues: [], inputSize: JSON.stringify(input || {}).length } + await onProgress(100) + return result +} + +function sleep(ms: number) { + return new Promise(resolve => setTimeout(resolve, ms)) +} |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import express, { Request, Response } from 'express' +import { Queue } from 'bullmq' +import { createAnalysisRoutes } from './routes/analysis.routes' +import { errorHandler, notFoundHandler, requestIdHandler } from './middleware/error.middleware' + +export function createServer(queue: Queue) { + const app = express() + + // Middleware + app.use(express.json({ limit: '50mb' })) + app.use(requestIdHandler) + + // CORS headers + app.use((req, res, next) => { + res.header('Access-Control-Allow-Origin', '*') + res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS') + res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization, X-Request-ID') + res.header('Access-Control-Max-Age', '86400') + + if (req.method === 'OPTIONS') { + res.status(200).end() + return + } + next() + }) + + // Health check endpoint + app.get('/health', (req: Request, res: Response) => { + res.json({ + status: 'healthy', + timestamp: new Date().toISOString(), + version: process.env.npm_package_version || '1.0.0', + requestId: req.headers['x-request-id'] + }) + }) + + // API documentation endpoint + app.get('/docs', (req: Request, res: Response) => { + res.json({ + title: 'GasGuard Analysis API', + version: '1.0.0', + description: 'API for submitting codebases for security and performance analysis', + endpoints: { + 'POST /analysis': 'Submit codebase for analysis', + 'GET /analysis/:id/status': 'Get analysis status', + 'GET /analysis/:id/result': 'Get analysis results', + 'DELETE /analysis/:id': 'Cancel analysis', + 'GET /health': 'Health check' + }, + documentation: 'https://docs.gasguard.dev' + }) + }) + + // Legacy scan endpoints (for backward compatibility) + app.post('/scan', async (req: Request, res: Response) => { + const payload = req.body || {} + const isLarge = JSON.stringify(payload).length > 200_000 || payload?.large === true + const job = await queue.add('scan', { payload, isLarge }, { removeOnComplete: true, removeOnFail: true }) + res.status(202).json({ jobId: job.id, statusUrl: `/scan/${job.id}/status`, resultUrl: `/scan/${job.id}/result` }) + }) + + app.get('/scan/:id/status', async (req: Request, res: Response) => { + const id = req.params.id + const job = await queue.getJob(id) + if (!job) { + res.status(404).json({ error: 'not_found' }) + return + } + const state = await job.getState() + const progress = job.progress || 0 + res.json({ state, progress }) + }) + + app.get('/scan/:id/result', async (req: Request, res: Response) => { + const id = req.params.id + const job = await queue.getJob(id) + if (!job) { + res.status(404).json({ error: 'not_found' }) + return + } + const state = await job.getState() + if (state !== 'completed') { + res.status(202).json({ state }) + return + } + const result = job.returnvalue + res.json({ result }) + }) + + // New analysis endpoints + app.use('/', createAnalysisRoutes(queue)) + + // Error handling + app.use(notFoundHandler) + app.use(errorHandler) + + return app +} |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { Injectable } from '@nestjs/common'; +import { + ChainGasMetrics, + CrossChainGasRequest, + CrossChainGasResponse, + TransactionCost, + GasNormalizationResult, + SupportedChain +} from '../schemas/cross-chain-gas.schema'; + +@Injectable() +export class CrossChainGasService { + private readonly supportedChains: SupportedChain[] = [ + { + chainId: 1, + chainName: 'Ethereum', + nativeToken: 'ETH', + rpcUrl: process.env.ETHEREUM_RPC_URL || 'https://eth-mainnet.alchemyapi.io/v2/demo', + blockTime: 12 + }, + { + chainId: 137, + chainName: 'Polygon', + nativeToken: 'MATIC', + rpcUrl: process.env.POLYGON_RPC_URL || 'https://polygon-mainnet.alchemyapi.io/v2/demo', + blockTime: 2 + }, + { + chainId: 56, + chainName: 'Binance Smart Chain', + nativeToken: 'BNB', + rpcUrl: process.env.BSC_RPC_URL || 'https://bsc-dataseed.binance.org', + blockTime: 3 + }, + { + chainId: 42161, + chainName: 'Arbitrum', + nativeToken: 'ETH', + rpcUrl: process.env.ARBITRUM_RPC_URL || 'https://arb1.arbitrum.io/rpc', + blockTime: 0.5 + }, + { + chainId: 10, + chainName: 'Optimism', + nativeToken: 'ETH', + rpcUrl: process.env.OPTIMISM_RPC_URL || 'https://mainnet.optimism.io', + blockTime: 2 + } + ]; + + private readonly averageGasUsage = { + transfer: 21000, + 'contract-call': 50000, + swap: 150000 + }; + + private readonly nativeTokenPricesUSD = { + 1: 2000, // ETH + 137: 0.85, // MATIC + 56: 300, // BNB + 42161: 2000, // ETH (Arbitrum) + 10: 2000 // ETH (Optimism) + }; + + async getCrossChainGasComparison(request: CrossChainGasRequest): Promise<CrossChainGasResponse> { + const chainMetrics = await Promise.all( + this.supportedChains.map(chain => this.getChainGasMetrics(chain)) + ); + + const normalizedCosts = chainMetrics.map(metrics => + this.normalizeGasCost(metrics, request.txType) + ); + + const rankedChains = this.rankChainsByCost(normalizedCosts); + + return { + txType: request.txType, + timestamp: Date.now(), + chains: rankedChains + }; + } + + private async getChainGasMetrics(chain: SupportedChain): Promise<ChainGasMetrics> { + // Mock implementation - in production, this would fetch real-time data + const mockGasPrices = { + 1: { baseFee: '20000000000', priorityFee: '2000000000' }, + 137: { baseFee: '30000000000', priorityFee: '1000000000' }, + 56: { baseFee: '5000000000', priorityFee: '1000000000' }, + 42161: { baseFee: '10000000000', priorityFee: '500000000' }, + 10: { baseFee: '15000000000', priorityFee: '1000000000' } + }; + + const gasPrice = (mockGasPrices as Record<number, { baseFee: string; priorityFee: string }>)[chain.chainId] || { baseFee: '20000000000', priorityFee: '2000000000' }; + + return { + chainId: chain.chainId, + chainName: chain.chainName, + baseFee: gasPrice.baseFee, + priorityFee: gasPrice.priorityFee, + averageGasUsed: this.averageGasUsage, + nativeTokenPriceUSD: (this.nativeTokenPricesUSD as Record<number, number>)[chain.chainId] || 1, + averageConfirmationTime: chain.blockTime + }; + } + + private normalizeGasCost(metrics: ChainGasMetrics, txType: string): GasNormalizationResult { + const gasUsed = metrics.averageGasUsed[txType as keyof typeof metrics.averageGasUsed]; + const baseFee = BigInt(metrics.baseFee || '20000000000'); + const priorityFee = BigInt(metrics.priorityFee || '2000000000'); + const effectiveGasPrice = baseFee + priorityFee; + + const totalCostWei = gasUsed * Number(effectiveGasPrice); + const totalCostNative = (totalCostWei / 1e18).toFixed(6); + const totalCostUSD = (parseFloat(totalCostNative) * metrics.nativeTokenPriceUSD); + + return { + chainId: metrics.chainId, + txType, + gasUsed, + effectiveGasPrice: effectiveGasPrice.toString(), + totalCostNative, + totalCostUSD + }; + } + + private rankChainsByCost(costs: GasNormalizationResult[]): TransactionCost[] { + const sortedCosts = costs.sort((a, b) => a.totalCostUSD - b.totalCostUSD); + + return sortedCosts.map((cost, index) => ({ + chainId: cost.chainId, + chainName: this.getChainName(cost.chainId), + estimatedCostUSD: cost.totalCostUSD, + estimatedCostNative: cost.totalCostNative, + averageConfirmationTime: this.formatConfirmationTime(cost.chainId), + rank: index + 1 + })); + } + + private getChainName(chainId: number): string { + const chain = this.supportedChains.find(c => c.chainId === chainId); + return chain?.chainName || `Chain ${chainId}`; + } + + private formatConfirmationTime(chainId: number): string { + const chain = this.supportedChains.find(c => c.chainId === chainId); + const seconds = chain?.blockTime || 12; + + if (seconds < 1) { + return `${Math.round(seconds * 1000)}ms`; + } else if (seconds < 60) { + return `${Math.round(seconds)} seconds`; + } else { + return `${Math.round(seconds / 60)} minutes`; + } + } + + async getSupportedChains(): Promise<SupportedChain[]> { + return this.supportedChains; + } + + async updateNativeTokenPrices(): Promise<void> { + // Mock implementation - in production, this would fetch real prices from price oracle + console.log('Updating native token prices...'); + } + + async getChainGasMetricsHistory(chainId: number, hours: number = 24): Promise<any[]> { + // Mock implementation - in production, this would fetch historical data + return []; + } +} + |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { Injectable } from '@nestjs/common'; +import { + FailedTransaction, + FailureCategory, + TransactionMetadata, + RootCauseAnalysis, + CostMetrics +} from '../schemas/failed-transaction.schema'; + +@Injectable() +export class FailedTransactionService { + private failedTransactions: Map<string, FailedTransaction> = new Map(); + private walletFailures: Map<string, FailedTransaction[]> = new Map(); + + /** + * Track a failed transaction + */ + async trackFailedTransaction(transactionData: Partial<FailedTransaction>): Promise<FailedTransaction> { + const category = await this.classifyFailure(transactionData); + const rootCause = await this.analyzeRootCause(transactionData, category); + + const failedTx: FailedTransaction = { + id: this.generateId(), + hash: transactionData.hash!, + wallet: transactionData.wallet!, + chainId: transactionData.chainId!, + blockNumber: transactionData.blockNumber, + gasUsed: transactionData.gasUsed || '0', + gasPrice: transactionData.gasPrice || '0', + effectiveFee: this.calculateEffectiveFee(transactionData), + failureCategory: category, + revertReason: transactionData.revertReason || rootCause.evidence.join('; '), + timestamp: transactionData.timestamp || new Date().toISOString(), + metadata: transactionData.metadata! + }; + + // Store transaction + this.failedTransactions.set(failedTx.id, failedTx); + + // Update wallet failures + const walletTxs = this.walletFailures.get(failedTx.wallet) || []; + walletTxs.push(failedTx); + this.walletFailures.set(failedTx.wallet, walletTxs); + + return failedTx; + } + + /** + * Get failed transactions for a wallet + */ + async getWalletFailures(wallet: string, chainIds?: number[]): Promise<FailedTransaction[]> { + const failures = this.walletFailures.get(wallet) || []; + + if (chainIds && chainIds.length > 0) { + return failures.filter(tx => chainIds.includes(tx.chainId)); + } + + return failures; + } + + /** + * Classify the failure category based on transaction data + */ + private async classifyFailure(transactionData: Partial<FailedTransaction>): Promise<FailureCategory> { + const { revertReason, metadata, gasUsed, gasPrice } = transactionData; + + // Check for underpriced gas + if (gasPrice && await this.isUnderpriced(gasPrice, transactionData.chainId!)) { + return 'underpriced_gas'; + } + + // Check for out of gas + if (gasUsed && metadata?.gasLimit) { + const utilization = (parseInt(gasUsed) / parseInt(metadata.gasLimit)) * 100; + if (utilization >= 99.5) { + return 'out_of_gas'; + } + } + + // Check revert reason patterns + if (revertReason) { + const reason = revertReason.toLowerCase(); + + if (reason.includes('insufficient funds') || reason.includes('balance')) { + return 'insufficient_balance'; + } + + if (reason.includes('nonce') || reason.includes('replacement')) { + return 'nonce_conflict'; + } + + if (reason.includes('slippage') || reason.includes('too much requested')) { + return 'slippage_exceeded'; + } + + if (reason.includes('revert') || reason.includes('require')) { + return 'contract_revert'; + } + } + + // Check nonce conflicts + if (metadata?.nonce !== undefined) { + const walletTxs = this.walletFailures.get(transactionData.wallet!) || []; + const hasSameNonce = walletTxs.some(tx => + tx.metadata.nonce === metadata.nonce && + tx.timestamp > new Date(Date.now() - 300000).toISOString() // Last 5 minutes + ); + + if (hasSameNonce) { + return 'nonce_conflict'; + } + } + + return 'unknown'; + } + + /** + * Analyze root cause with detailed evidence + */ + private async analyzeRootCause( + transactionData: Partial<FailedTransaction>, + category: FailureCategory + ): Promise<RootCauseAnalysis> { + const evidence: string[] = []; + const patterns: any = {}; + + switch (category) { + case 'underpriced_gas': + evidence.push(`Gas price: ${transactionData.gasPrice} wei`); + evidence.push(`Chain ID: ${transactionData.chainId}`); + patterns.pricing = { + gasPrice: transactionData.gasPrice!, + networkGasPrice: await this.getNetworkGasPrice(transactionData.chainId!), + deviation: await this.calculateGasPriceDeviation(transactionData.gasPrice!, transactionData.chainId!) + }; + break; + + case 'out_of_gas': + evidence.push(`Gas used: ${transactionData.gasUsed}`); + evidence.push(`Gas limit: ${transactionData.metadata?.gasLimit}`); + if (transactionData.gasUsed && transactionData.metadata?.gasLimit) { + const utilization = (parseInt(transactionData.gasUsed) / parseInt(transactionData.metadata.gasLimit)) * 100; + evidence.push(`Utilization: ${utilization.toFixed(2)}%`); + patterns.gasUsage = { + used: transactionData.gasUsed, + limit: transactionData.metadata.gasLimit, + utilization + }; + } + break; + + case 'slippage_exceeded': + evidence.push(`Revert reason: ${transactionData.revertReason}`); + evidence.push('DEX transaction detected'); + break; + + case 'nonce_conflict': + evidence.push(`Nonce: ${transactionData.metadata?.nonce}`); + evidence.push('Duplicate nonce detected in recent transactions'); + break; + + case 'insufficient_balance': + evidence.push(`Value: ${transactionData.metadata?.value}`); + evidence.push(`Gas cost: ${transactionData.effectiveFee}`); + evidence.push(`Revert reason: ${transactionData.revertReason}`); + break; + } + + return { + category, + confidence: this.calculateConfidence(category, evidence), + evidence, + patterns + }; + } + + /** + * Calculate cost metrics for a wallet + */ + async calculateCostMetrics(wallet: string, chainIds?: number[]): Promise<CostMetrics> { + const failures = await this.getWalletFailures(wallet, chainIds); + + let totalGasWasted = BigInt(0); + const wasteByCategory: Record<FailureCategory, string> = {} as any; + const wasteByChain: Record<number, string> = {} as any; + + // Initialize category counters + const categories: FailureCategory[] = [ + 'underpriced_gas', 'out_of_gas', 'contract_revert', + 'slippage_exceeded', 'nonce_conflict', 'insufficient_balance', + 'network_error', 'unknown' + ]; + + categories.forEach(cat => { + wasteByCategory[cat] = '0'; + }); + + // Calculate totals + failures.forEach(tx => { + const waste = BigInt(tx.effectiveFee); + totalGasWasted += waste; + + // Add to category total + wasteByCategory[tx.failureCategory] = ( + BigInt(wasteByCategory[tx.failureCategory]) + waste + ).toString(); + + // Add to chain total + if (!wasteByChain[tx.chainId]) { + wasteByChain[tx.chainId] = '0'; + } + wasteByChain[tx.chainId] = ( + BigInt(wasteByChain[tx.chainId]) + waste + ).toString(); + }); + + // Calculate historical trend (last 30 days) + const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000); + const dailyFailures = new Map<string, { waste: bigint; count: number }>(); + + failures + .filter(tx => new Date(tx.timestamp) >= thirtyDaysAgo) + .forEach(tx => { + const date = tx.timestamp.split('T')[0]; + const current = dailyFailures.get(date) || { waste: BigInt(0), count: 0 }; + current.waste += BigInt(tx.effectiveFee); + current.count += 1; + dailyFailures.set(date, current); + }); + + const historicalTrend = Array.from(dailyFailures.entries()) + .map(([date, data]) => ({ + date, + waste: data.waste.toString(), + failures: data.count + })) + .sort((a, b) => a.date.localeCompare(b.date)); + + return { + totalGasWasted: totalGasWasted.toString(), + totalGasWastedUSD: await this.convertToUSD(totalGasWasted.toString()), + averageWastePerFailure: failures.length > 0 + ? (totalGasWasted / BigInt(failures.length)).toString() + : '0', + wasteByCategory, + wasteByChain, + historicalTrend + }; + } + + /** + * Helper methods + */ + private generateId(): string { + return `ft_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`; + } + + private calculateEffectiveFee(transactionData: Partial<FailedTransaction>): string { + const gasUsed = BigInt(transactionData.gasUsed || '0'); + const gasPrice = BigInt(transactionData.gasPrice || '0'); + return (gasUsed * gasPrice).toString(); + } + + private async isUnderpriced(gasPrice: string, chainId: number): Promise<boolean> { + const networkGasPrice = await this.getNetworkGasPrice(chainId); + const deviation = await this.calculateGasPriceDeviation(gasPrice, chainId); + return deviation < -20; // More than 20% below network gas price + } + + private async getNetworkGasPrice(chainId: number): Promise<string> { + // Mock implementation - in real scenario, this would call RPC + const mockPrices: Record<number, string> = { + 1: '20000000000', // Ethereum mainnet + 137: '30000000000', // Polygon + 56: '5000000000', // BSC + 42161: '100000000', // Arbitrum + 10: '100000000' // Optimism + }; + return mockPrices[chainId] || '20000000000'; + } + + private async calculateGasPriceDeviation(gasPrice: string, chainId: number): Promise<number> { + const networkGasPrice = await this.getNetworkGasPrice(chainId); + const price = BigInt(gasPrice); + const network = BigInt(networkGasPrice); + return Number(((price - network) * BigInt(100)) / network); + } + + private calculateConfidence(category: FailureCategory, evidence: string[]): number { + // Base confidence by category + const baseConfidence: Record<FailureCategory, number> = { + 'underpriced_gas': 0.9, + 'out_of_gas': 0.95, + 'contract_revert': 0.8, + 'slippage_exceeded': 0.85, + 'nonce_conflict': 0.9, + 'insufficient_balance': 0.95, + 'network_error': 0.7, + 'unknown': 0.3 + }; + + // Adjust based on evidence strength + let confidence = baseConfidence[category]; + if (evidence.length > 2) confidence += 0.05; + if (evidence.length > 4) confidence += 0.05; + + return Math.min(confidence, 1.0); + } + + private async convertToUSD(weiAmount: string): Promise<number> { + // Mock implementation - in real scenario, this would use price oracle + const ethPriceUSD = 2000; // Mock ETH price + const ethAmount = Number(weiAmount) / 1e18; + return ethAmount * ethPriceUSD; + } +} + |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| cross-chain-gas.service.ts | +
+
+ |
+ 0% | +0/42 | +0% | +0/27 | +0% | +0/16 | +0% | +0/36 | +
| failed-transaction.service.ts | +
+
+ |
+ 0% | +0/118 | +0% | +0/77 | +0% | +0/21 | +0% | +0/113 | +
| mitigation.service.ts | +
+
+ |
+ 0% | +0/71 | +0% | +0/25 | +0% | +0/9 | +0% | +0/69 | +
| transaction-analysis.service.ts | +
+
+ |
+ 0% | +0/80 | +0% | +0/37 | +0% | +0/25 | +0% | +0/76 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { Injectable } from '@nestjs/common'; +import { + FailureCategory, + MitigationRecommendation, + FailedTransaction, + FailureAnalysis +} from '../schemas/failed-transaction.schema'; + +@Injectable() +export class MitigationService { + /** + * Generate mitigation recommendations based on failure analysis + */ + async generateRecommendations(analysis: FailureAnalysis): Promise<MitigationRecommendation[]> { + const recommendations: MitigationRecommendation[] = []; + + // Generate recommendations based on top failure category + const topCategory = analysis.topFailureCategory; + recommendations.push(...await this.getCategorySpecificRecommendations(topCategory, analysis)); + + // Generate recommendations based on patterns + recommendations.push(...await this.getPatternBasedRecommendations(analysis)); + + // Generate chain-specific recommendations + recommendations.push(...await this.getChainSpecificRecommendations(analysis)); + + // Sort by priority and return top recommendations + return recommendations + .sort((a, b) => this.getPriorityScore(b.priority) - this.getPriorityScore(a.priority)) + .slice(0, 5); // Return top 5 recommendations + } + + /** + * Get category-specific mitigation recommendations + */ + private async getCategorySpecificRecommendations( + category: FailureCategory, + analysis: FailureAnalysis + ): Promise<MitigationRecommendation[]> { + const recommendations: MitigationRecommendation[] = []; + + switch (category) { + case 'underpriced_gas': + recommendations.push({ + id: 'increase_gas_price', + category: 'underpriced_gas', + priority: 'high', + title: 'Increase Gas Price', + description: 'Your transactions are failing due to gas prices that are too low for network conditions.', + action: 'Increase priority fee by 25-50% during peak hours', + estimatedImpact: 'Reduces failure rate by 80-90%', + parameters: { + priorityFeeIncrease: '30%', + congestionMultiplier: 1.5 + } + }); + recommendations.push({ + id: 'use_gas_tier', + category: 'underpriced_gas', + priority: 'medium', + title: 'Use Dynamic Gas Tiers', + description: 'Implement adaptive gas pricing based on network congestion.', + action: 'Use Medium/High gas tiers during peak hours, Low during off-peak', + estimatedImpact: 'Optimizes cost while maintaining reliability' + }); + break; + + case 'out_of_gas': + recommendations.push({ + id: 'increase_gas_limit', + category: 'out_of_gas', + priority: 'high', + title: 'Increase Gas Limit', + description: 'Transactions are failing due to insufficient gas limits.', + action: 'Increase gas limit by 20-30% for complex operations', + estimatedImpact: 'Eliminates out-of-gas failures', + parameters: { + gasLimitMultiplier: 1.25, + minIncrease: '21000' + } + }); + recommendations.push({ + id: 'gas_limit_optimization', + category: 'out_of_gas', + priority: 'medium', + title: 'Optimize Gas Limit Estimation', + description: 'Implement better gas estimation algorithms.', + action: 'Use historical data to predict gas requirements more accurately', + estimatedImpact: 'Reduces wasted gas by 15-25%' + }); + break; + + case 'slippage_exceeded': + recommendations.push({ + id: 'adjust_slippage', + category: 'slippage_exceeded', + priority: 'high', + title: 'Adjust Slippage Tolerance', + description: 'DEX trades are failing due to price movement exceeding slippage tolerance.', + action: 'Increase slippage tolerance to 1-2% during high volatility', + estimatedImpact: 'Reduces DEX failure rate by 70%', + parameters: { + defaultSlippage: '1%', + highVolatilitySlippage: '2%' + } + }); + recommendations.push({ + id: 'timing_optimization', + category: 'slippage_exceeded', + priority: 'medium', + title: 'Optimize Trading Timing', + description: 'Avoid trading during high volatility periods.', + action: 'Use volatility indicators to time trades optimally', + estimatedImpact: 'Improves success rate and reduces slippage' + }); + break; + + case 'nonce_conflict': + recommendations.push({ + id: 'nonce_management', + category: 'nonce_conflict', + priority: 'high', + title: 'Implement Nonce Management', + description: 'Transactions are failing due to nonce conflicts.', + action: 'Replace stuck transactions with higher gas prices', + estimatedImpact: 'Resolves stuck transactions immediately', + parameters: { + replacementMultiplier: 1.1, + maxRetries: 3 + } + }); + break; + + case 'insufficient_balance': + recommendations.push({ + id: 'balance_check', + category: 'insufficient_balance', + priority: 'high', + title: 'Pre-transaction Balance Check', + description: 'Transactions are failing due to insufficient balance.', + action: 'Verify balance + gas costs before submitting transactions', + estimatedImpact: 'Eliminates balance-related failures' + }); + break; + } + + return recommendations; + } + + /** + * Get pattern-based recommendations from failure patterns + */ + private async getPatternBasedRecommendations(analysis: FailureAnalysis): Promise<MitigationRecommendation[]> { + const recommendations: MitigationRecommendation[] = []; + + // Check for repeated failures + if (analysis.totalFailures > 10) { + recommendations.push({ + id: 'batch_optimization', + category: 'unknown', + priority: 'medium', + title: 'Implement Batch Processing', + description: 'High failure rate suggests systematic issues with transaction handling.', + action: 'Group similar transactions and optimize batch processing', + estimatedImpact: 'Reduces overall failure rate by 40%' + }); + } + + // Check for chain-specific patterns + const chainIds = Object.keys(analysis.chainBreakdown).map(Number); + if (chainIds.length > 3) { + recommendations.push({ + id: 'chain_optimization', + category: 'unknown', + priority: 'low', + title: 'Optimize Multi-chain Strategy', + description: 'Failures across multiple chains suggest suboptimal chain selection.', + action: 'Use chain-specific optimization strategies', + estimatedImpact: 'Improves cross-chain success rates' + }); + } + + return recommendations; + } + + /** + * Get chain-specific recommendations + */ + private async getChainSpecificRecommendations(analysis: FailureAnalysis): Promise<MitigationRecommendation[]> { + const recommendations: MitigationRecommendation[] = []; + + for (const [chainId, stats] of Object.entries(analysis.chainBreakdown)) { + const chainNum = parseInt(chainId); + + if (stats.failures > 5) { + switch (chainNum) { + case 1: // Ethereum Mainnet + recommendations.push({ + id: `ethereum_optimization_${chainId}`, + category: stats.mostCommonCategory, + priority: 'medium', + title: 'Ethereum Mainnet Optimization', + description: 'Optimize transactions for Ethereum mainnet conditions.', + action: 'Use EIP-1559 with dynamic base fee tracking', + estimatedImpact: 'Reduces mainnet failure rate by 30%' + }); + break; + + case 137: // Polygon + recommendations.push({ + id: `polygon_optimization_${chainId}`, + category: stats.mostCommonCategory, + priority: 'medium', + title: 'Polygon Network Optimization', + description: 'Optimize for Polygon\'s faster block times.', + action: 'Reduce confirmation time expectations', + estimatedImpact: 'Improves Polygon success rates' + }); + break; + + case 42161: // Arbitrum + recommendations.push({ + id: `arbitrum_optimization_${chainId}`, + category: stats.mostCommonCategory, + priority: 'medium', + title: 'Arbitrum Optimization', + description: 'Optimize for Arbitrum\'s L2 characteristics.', + action: 'Account for Arbitrum\'s gas pricing model', + estimatedImpact: 'Optimizes L2 transaction costs' + }); + break; + } + } + } + + return recommendations; + } + + /** + * Get real-time mitigation for a specific failed transaction + */ + async getImmediateMitigation(transaction: FailedTransaction): Promise<MitigationRecommendation[]> { + const recommendations: MitigationRecommendation[] = []; + + switch (transaction.failureCategory) { + case 'underpriced_gas': + const suggestedGasPrice = await this.calculateOptimalGasPrice(transaction.chainId); + recommendations.push({ + id: 'immediate_gas_increase', + category: 'underpriced_gas', + priority: 'high', + title: 'Immediate Gas Price Increase', + description: 'Replace transaction with higher gas price.', + action: `Set gas price to ${suggestedGasPrice} wei`, + estimatedImpact: 'Immediate transaction confirmation', + parameters: { + suggestedGasPrice, + replacementMultiplier: 1.1 + } + }); + break; + + case 'out_of_gas': + const suggestedGasLimit = this.calculateOptimalGasLimit(transaction); + recommendations.push({ + id: 'immediate_gas_limit_increase', + category: 'out_of_gas', + priority: 'high', + title: 'Immediate Gas Limit Increase', + description: 'Resubmit with higher gas limit.', + action: `Set gas limit to ${suggestedGasLimit}`, + estimatedImpact: 'Transaction will execute successfully', + parameters: { + suggestedGasLimit + } + }); + break; + + case 'nonce_conflict': + recommendations.push({ + id: 'immediate_nonce_fix', + category: 'nonce_conflict', + priority: 'high', + title: 'Replace Stuck Transaction', + description: 'Cancel and replace the stuck transaction.', + action: 'Send 0 ETH transaction with same nonce and higher gas', + estimatedImpact: 'Clears nonce conflict immediately' + }); + break; + } + + return recommendations; + } + + /** + * Helper methods + */ + private getPriorityScore(priority: string): number { + const scores = { high: 3, medium: 2, low: 1 }; + return scores[priority as keyof typeof scores] || 0; + } + + private async calculateOptimalGasPrice(chainId: number): Promise<string> { + // Mock implementation - in real scenario, this would call gas price oracle + const baseGasPrices: Record<number, string> = { + 1: '30000000000', // Ethereum mainnet + 137: '50000000000', // Polygon + 56: '10000000000', // BSC + 42161: '200000000', // Arbitrum + 10: '200000000' // Optimism + }; + + const basePrice = baseGasPrices[chainId] || '20000000000'; + const multiplier = 1.2; // 20% above base for reliability + + return (BigInt(basePrice) * BigInt(Math.floor(multiplier * 100)) / BigInt(100)).toString(); + } + + private calculateOptimalGasLimit(transaction: FailedTransaction): string { + const currentLimit = BigInt(transaction.metadata.gasLimit); + const used = BigInt(transaction.gasUsed); + + // Calculate utilization + const utilization = Number((used * BigInt(100)) / currentLimit); + + if (utilization >= 99.5) { + // Out of gas - increase by 30% + return (currentLimit * BigInt(130) / BigInt(100)).toString(); + } else if (utilization >= 95) { + // Near limit - increase by 20% + return (currentLimit * BigInt(120) / BigInt(100)).toString(); + } else { + // Moderate utilization - increase by 10% + return (currentLimit * BigInt(110) / BigInt(100)).toString(); + } + } +} + |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { Injectable } from '@nestjs/common'; +import { FailedTransactionService } from './failed-transaction.service'; +import { MitigationService } from './mitigation.service'; +import { + TransactionAnalysisRequest, + TransactionAnalysisResponse, + FailureAnalysis, + ChainFailureStats, + FailedTransaction, + FailureCategory +} from '../schemas/failed-transaction.schema'; + +@Injectable() +export class TransactionAnalysisService { + constructor( + private readonly failedTransactionService: FailedTransactionService, + private readonly mitigationService: MitigationService, + ) {} + + /** + * Analyze failed transactions for a wallet + */ + async analyzeWalletFailures(request: TransactionAnalysisRequest): Promise<TransactionAnalysisResponse> { + const { wallet, chainIds, timeframe, includeRecommendations = true } = request; + + // Get failed transactions + const failures = await this.failedTransactionService.getWalletFailures(wallet, chainIds); + + // Filter by timeframe if specified + const filteredFailures = this.filterByTimeframe(failures, timeframe); + + // Calculate cost metrics + const costMetrics = await this.failedTransactionService.calculateCostMetrics(wallet, chainIds); + + // Analyze failure categories + const failureCategories = this.categorizeFailures(filteredFailures); + + // Calculate chain breakdown + const chainBreakdown = this.calculateChainBreakdown(filteredFailures); + + // Generate recommendations + const recommendations = includeRecommendations + ? await this.mitigationService.generateRecommendations({ + wallet, + totalFailures: filteredFailures.length, + totalGasWasted: costMetrics.totalGasWasted, + totalGasWastedUSD: costMetrics.totalGasWastedUSD, + failureCategories, + topFailureCategory: this.getTopFailureCategory(failureCategories), + recommendations: [], // Will be populated + timeframe: { + start: timeframe?.start || this.getDefaultStartDate(filteredFailures), + end: timeframe?.end || new Date().toISOString() + }, + chainBreakdown + }) + : []; + + const analysis: FailureAnalysis = { + wallet, + totalFailures: filteredFailures.length, + totalGasWasted: costMetrics.totalGasWasted, + totalGasWastedUSD: costMetrics.totalGasWastedUSD, + failureCategories, + topFailureCategory: this.getTopFailureCategory(failureCategories), + recommendations, + timeframe: { + start: timeframe?.start || this.getDefaultStartDate(filteredFailures), + end: timeframe?.end || new Date().toISOString() + }, + chainBreakdown + }; + + return { + wallet, + analysis, + processedAt: new Date().toISOString(), + requestId: this.generateRequestId() + }; + } + + /** + * Get immediate mitigation for a recent failure + */ + async getImmediateMitigation(wallet: string, transactionHash?: string): Promise<any> { + const failures = await this.failedTransactionService.getWalletFailures(wallet); + + // Get the most recent failure or specific transaction + const targetFailure = transactionHash + ? failures.find(f => f.hash === transactionHash) + : failures.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())[0]; + + if (!targetFailure) { + throw new Error('No failed transaction found'); + } + + const recommendations = await this.mitigationService.getImmediateMitigation(targetFailure); + + return { + transaction: targetFailure, + recommendations, + processedAt: new Date().toISOString() + }; + } + + /** + * Get wallet statistics summary + */ + async getWalletSummary(wallet: string, chainIds?: number[]): Promise<any> { + const failures = await this.failedTransactionService.getWalletFailures(wallet, chainIds); + const costMetrics = await this.failedTransactionService.calculateCostMetrics(wallet, chainIds); + + const last30Days = failures.filter(f => + new Date(f.timestamp) >= new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) + ); + + const last7Days = failures.filter(f => + new Date(f.timestamp) >= new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) + ); + + return { + wallet, + summary: { + totalFailures: failures.length, + totalGasWasted: costMetrics.totalGasWasted, + totalGasWastedUSD: costMetrics.totalGasWastedUSD, + last30DaysFailures: last30Days.length, + last7DaysFailures: last7Days.length, + averageFailuresPerDay: (last30Days.length / 30).toFixed(2), + mostActiveChain: this.getMostActiveChain(failures), + topFailureCategory: this.getTopFailureCategory(this.categorizeFailures(failures)) + }, + processedAt: new Date().toISOString() + }; + } + + /** + * Process a failed transaction event + */ + async processFailedTransaction(transactionData: Partial<FailedTransaction>): Promise<FailedTransaction> { + return await this.failedTransactionService.trackFailedTransaction(transactionData); + } + + /** + * Helper methods + */ + private filterByTimeframe(failures: FailedTransaction[], timeframe?: { start?: string; end?: string }): FailedTransaction[] { + if (!timeframe) return failures; + + return failures.filter(tx => { + const txDate = new Date(tx.timestamp); + const startDate = timeframe.start ? new Date(timeframe.start) : new Date(0); + const endDate = timeframe.end ? new Date(timeframe.end) : new Date(); + + return txDate >= startDate && txDate <= endDate; + }); + } + + private categorizeFailures(failures: FailedTransaction[]): Record<string, number> { + const categories: Record<string, number> = {}; + + failures.forEach(tx => { + categories[tx.failureCategory] = (categories[tx.failureCategory] || 0) + 1; + }); + + return categories; + } + + private calculateChainBreakdown(failures: FailedTransaction[]): Record<number, ChainFailureStats> { + const chainStats: Record<number, ChainFailureStats> = {}; + + failures.forEach(tx => { + if (!chainStats[tx.chainId]) { + chainStats[tx.chainId] = { + chainId: tx.chainId, + failures: 0, + gasWasted: '0', + mostCommonCategory: 'unknown' + }; + } + + const stats = chainStats[tx.chainId]; + stats.failures += 1; + stats.gasWasted = ( + BigInt(stats.gasWasted) + BigInt(tx.effectiveFee) + ).toString(); + }); + + // Calculate most common category for each chain + Object.keys(chainStats).forEach(chainId => { + const chainFailures = failures.filter(tx => tx.chainId === parseInt(chainId)); + const categories = this.categorizeFailures(chainFailures); + chainStats[parseInt(chainId)].mostCommonCategory = this.getTopFailureCategory(categories); + }); + + return chainStats; + } + + private getTopFailureCategory(categories: Record<string, number>): FailureCategory { + let maxCount = 0; + let topCategory: FailureCategory = 'unknown'; + + Object.entries(categories).forEach(([category, count]) => { + if (count > maxCount) { + maxCount = count; + topCategory = category as FailureCategory; + } + }); + + return topCategory; + } + + private getMostActiveChain(failures: FailedTransaction[]): number { + const chainCounts: Record<number, number> = {}; + + failures.forEach(tx => { + chainCounts[tx.chainId] = (chainCounts[tx.chainId] || 0) + 1; + }); + + let maxCount = 0; + let topChain = 1; + + Object.entries(chainCounts).forEach(([chainId, count]) => { + if (count > maxCount) { + maxCount = count; + topChain = parseInt(chainId); + } + }); + + return topChain; + } + + private getDefaultStartDate(failures: FailedTransaction[]): string { + if (failures.length === 0) { + return new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString(); // 30 days ago + } + + const oldestTx = failures.reduce((oldest, current) => + new Date(current.timestamp) < new Date(oldest.timestamp) ? current : oldest + ); + + return oldestTx.timestamp; + } + + private generateRequestId(): string { + return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`; + } +} + |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { Request, Response, NextFunction } from 'express';
+import { CodebaseSubmissionRequest, ValidationError } from '../schemas/analysis.schema';
+
+export class AnalysisValidator {
+ private static readonly SUPPORTED_LANGUAGES = ['rust', 'typescript', 'javascript', 'solidity', 'soroban'];
+ private static readonly SUPPORTED_FRAMEWORKS = ['soroban', 'solidity', 'general'];
+ private static readonly MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+ private static readonly MAX_FILES = 100;
+ private static readonly MAX_CONTENT_LENGTH = 50 * 1024 * 1024; // 50MB
+
+ static validateSubmission(req: Request, res: Response, next: NextFunction): void {
+ const body = req.body as CodebaseSubmissionRequest;
+ const errors: ValidationError[] = [];
+
+ try {
+ // Validate project information
+ if (!body.project) {
+ errors.push({
+ field: 'project',
+ message: 'Project information is required',
+ constraint: 'required'
+ });
+ } else {
+ if (!body.project.name || body.project.name.trim().length === 0) {
+ errors.push({
+ field: 'project.name',
+ message: 'Project name is required',
+ value: body.project.name,
+ constraint: 'required'
+ });
+ }
+
+ if (body.project.name && body.project.name.length > 100) {
+ errors.push({
+ field: 'project.name',
+ message: 'Project name must be less than 100 characters',
+ value: body.project.name,
+ constraint: 'maxLength'
+ });
+ }
+
+ if (body.project.repositoryUrl && !this.isValidUrl(body.project.repositoryUrl)) {
+ errors.push({
+ field: 'project.repositoryUrl',
+ message: 'Invalid repository URL format',
+ value: body.project.repositoryUrl,
+ constraint: 'url'
+ });
+ }
+ }
+
+ // Validate files
+ if (!body.files || !Array.isArray(body.files) || body.files.length === 0) {
+ errors.push({
+ field: 'files',
+ message: 'At least one file must be submitted',
+ constraint: 'required'
+ });
+ } else {
+ if (body.files.length > this.MAX_FILES) {
+ errors.push({
+ field: 'files',
+ message: `Maximum ${this.MAX_FILES} files allowed`,
+ value: body.files.length,
+ constraint: 'maxFiles'
+ });
+ }
+
+ let totalSize = 0;
+ body.files.forEach((file, index) => {
+ const prefix = `files[${index}]`;
+
+ if (!file.path || file.path.trim().length === 0) {
+ errors.push({
+ field: `${prefix}.path`,
+ message: 'File path is required',
+ constraint: 'required'
+ });
+ }
+
+ if (!file.content || file.content.trim().length === 0) {
+ errors.push({
+ field: `${prefix}.content`,
+ message: 'File content is required',
+ constraint: 'required'
+ });
+ }
+
+ if (!file.language || !this.SUPPORTED_LANGUAGES.includes(file.language)) {
+ errors.push({
+ field: `${prefix}.language`,
+ message: `Language must be one of: ${this.SUPPORTED_LANGUAGES.join(', ')}`,
+ value: file.language,
+ constraint: 'enum'
+ });
+ }
+
+ if (file.size && file.size > this.MAX_FILE_SIZE) {
+ errors.push({
+ field: `${prefix}.size`,
+ message: `File size exceeds maximum of ${this.MAX_FILE_SIZE} bytes`,
+ value: file.size,
+ constraint: 'maxSize'
+ });
+ }
+
+ totalSize += file.size || 0;
+ });
+
+ if (totalSize > this.MAX_CONTENT_LENGTH) {
+ errors.push({
+ field: 'files',
+ message: `Total content size exceeds maximum of ${this.MAX_CONTENT_LENGTH} bytes`,
+ value: totalSize,
+ constraint: 'maxTotalSize'
+ });
+ }
+ }
+
+ // Validate options
+ if (body.options) {
+ if (!this.SUPPORTED_FRAMEWORKS.includes(body.options.scanType)) {
+ errors.push({
+ field: 'options.scanType',
+ message: `Scan type must be one of: security, performance, gas-optimization, full`,
+ value: body.options.scanType,
+ constraint: 'enum'
+ });
+ }
+
+ if (!['low', 'medium', 'high', 'critical'].includes(body.options.severity)) {
+ errors.push({
+ field: 'options.severity',
+ message: `Severity must be one of: low, medium, high, critical`,
+ value: body.options.severity,
+ constraint: 'enum'
+ });
+ }
+ }
+
+ // Validate metadata
+ if (body.metadata) {
+ if (body.metadata.framework && !this.SUPPORTED_FRAMEWORKS.includes(body.metadata.framework)) {
+ errors.push({
+ field: 'metadata.framework',
+ message: `Framework must be one of: ${this.SUPPORTED_FRAMEWORKS.join(', ')}`,
+ value: body.metadata.framework,
+ constraint: 'enum'
+ });
+ }
+
+ // Soroban-specific validation
+ if (body.metadata.framework === 'soroban') {
+ this.validateSorobanProject(body.files, body.metadata, errors);
+ }
+ }
+
+ if (errors.length > 0) {
+ res.status(400).json({
+ error: {
+ code: 'VALIDATION_ERROR',
+ message: 'Request validation failed',
+ timestamp: new Date().toISOString(),
+ requestId: req.headers['x-request-id'] as string || 'unknown'
+ },
+ validationErrors: errors
+ });
+ return;
+ }
+
+ next();
+ } catch (error) {
+ res.status(500).json({
+ error: {
+ code: 'VALIDATION_EXCEPTION',
+ message: 'An error occurred during validation',
+ timestamp: new Date().toISOString(),
+ requestId: req.headers['x-request-id'] as string || 'unknown'
+ }
+ });
+ }
+ }
+
+ private static validateSorobanProject(files: any[], metadata: any, errors: ValidationError[]): void {
+ const rustFiles = files.filter(f => f.language === 'rust');
+
+ if (rustFiles.length === 0) {
+ errors.push({
+ field: 'files',
+ message: 'Soroban projects must contain at least one Rust file',
+ constraint: 'sorobanRequiresRust'
+ });
+ return;
+ }
+
+ // Check for Cargo.toml
+ const hasCargoToml = files.some(f => f.path === 'Cargo.toml' || f.path.endsWith('/Cargo.toml'));
+ if (!hasCargoToml) {
+ errors.push({
+ field: 'files',
+ message: 'Soroban projects must include a Cargo.toml file',
+ constraint: 'sorobanRequiresCargoToml'
+ });
+ }
+
+ // Validate Soroban-specific dependencies in Cargo.toml if present
+ const cargoToml = files.find(f => f.path.endsWith('Cargo.toml'));
+ if (cargoToml) {
+ const content = cargoToml.content;
+ const hasSorobanSdk = content.includes('soroban-sdk') || content.includes('stellar-sdk');
+
+ if (!hasSorobanSdk) {
+ errors.push({
+ field: 'metadata.dependencies',
+ message: 'Soroban projects must include soroban-sdk or stellar-sdk dependency',
+ constraint: 'sorobanRequiresSdk'
+ });
+ }
+ }
+
+ // Check for contract structure
+ const contractFiles = rustFiles.filter(f =>
+ f.content.includes('#[contractimpl]') ||
+ f.content.includes('soroban_sdk::contract') ||
+ f.content.includes('ContractType')
+ );
+
+ if (contractFiles.length === 0) {
+ errors.push({
+ field: 'files',
+ message: 'No Soroban contract implementation found. Files should contain #[contractimpl] or contract definitions.',
+ constraint: 'sorobanRequiresContract'
+ });
+ }
+ }
+
+ private static isValidUrl(url: string): boolean {
+ try {
+ new URL(url);
+ return true;
+ } catch {
+ return false;
+ }
+ }
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| analysis.validator.ts | +
+
+ |
+ 0% | +0/74 | +0% | +0/78 | +0% | +0/8 | +0% | +0/71 | +