Merge branch 'main' into feature/user-data-export

Author: jhayniffy

backend/src/claims/claims.controller.ts

@@ -6,6 +6,10 @@ import {
   UseGuards,
   ParseIntPipe,
   DefaultValuePipe,
+  Post,
+  HttpCode,
+  HttpStatus,
+  Body,
 } from '@nestjs/common';
 import {
   ApiTags,
@@ -16,6 +20,8 @@ import {
 } from '@nestjs/swagger';
 import { ClaimsService } from './claims.service';
 import { ClaimsListResponseDto, ClaimDetailResponseDto } from './dto/claim.dto';
+import { BuildClaimTransactionDto } from './dto/build-claim-transaction.dto';
+import { SubmitTransactionDto } from './dto/submit-transaction.dto';
 import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
 import { WalletAddress } from '../auth/decorators/wallet-address.decorator';
 
@@ -62,4 +68,27 @@ export class ClaimsController {
   async getClaim(@Param('id', ParseIntPipe) id: number): Promise<ClaimDetailResponseDto> {
     return this.claimsService.getClaimById(id);
   }
+
+  @Post('build-transaction')
+  @HttpCode(HttpStatus.OK)
+  @Throttle({ default: { limit: 10, ttl: 60_000 } })
+  @ApiOperation({ summary: 'Build unsigned file_claim transaction' })
+  @ApiResponse({ status: 200, description: 'Unsigned transaction XDR + fee estimates' })
+  async buildTransaction(@Body() dto: BuildClaimTransactionDto) {
+    return this.claimsService.buildTransaction({
+      holder: dto.holder,
+      policyId: dto.policyId,
+      amount: BigInt(dto.amount),
+      details: dto.details,
+      imageUrls: dto.imageUrls,
+    });
+  }
+
+  @Post('submit')
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: 'Submit signed claim transaction' })
+  @ApiResponse({ status: 200, description: 'Transaction submitted' })
+  async submitTransaction(@Body() dto: SubmitTransactionDto) {
+    return this.claimsService.submitTransaction(dto.transactionXdr);
+  }
 }

backend/src/claims/claims.module.ts

@@ -2,8 +2,10 @@ import { Module } from '@nestjs/common';
 import { ClaimsController } from './claims.controller';
 import { ClaimsService } from './claims.service';
 import { SanitizationService } from './sanitization.service';
+import { RpcModule } from '../rpc/rpc.module';
 
 @Module({
+  imports: [RpcModule],
   controllers: [ClaimsController],
   providers: [ClaimsService, SanitizationService],
   exports: [ClaimsService],

backend/src/claims/claims.service.ts

@@ -1,9 +1,7 @@
 import { Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { Prisma } from '@prisma/client';
-import { RedisService } from '../cache/redis.service';
-import { PrismaService } from '../prisma/prisma.service';
-import { SanitizationService } from './sanitization.service';
+import { SorobanService } from '../rpc/soroban.service';
 import {
   ClaimDetailResponseDto,
   ClaimMetadataDto,
@@ -42,6 +40,7 @@ export class ClaimsService {
     private readonly redis: RedisService,
     private readonly sanitization: SanitizationService,
     private readonly config: ConfigService,
+    private readonly soroban: SorobanService,
   ) {
     this.cacheTtl = this.config.get<number>('CACHE_TTL_SECONDS', 60);
     this.ipfsGateway = this.config.get<string>('IPFS_GATEWAY', 'https://ipfs.io');
@@ -286,4 +285,29 @@ export class ClaimsService {
     await this.redis.delPattern('claims:list:*');
     this.logger.log(`Cache invalidated for claim ${claimId || 'all'}`);
   }
+
+  /**
+   * Build an unsigned file_claim transaction
+   */
+  async buildTransaction(args: {
+    holder: string;
+    policyId: number;
+    amount: bigint;
+    details: string;
+    imageUrls: string[];
+  }) {
+    return this.soroban.buildFileClaimTransaction(args);
+  }
+
+  /**
+   * Submit a signed transaction
+   */
+  async submitTransaction(transactionXdr: string) {
+    const result = await this.soroban.submitTransaction(transactionXdr);
+    
+    // Invalidate claims list cache so the new claim appears
+    await this.invalidateCache();
+    
+    return result;
+  }
 }

backend/src/claims/dto/build-claim-transaction.dto.ts

@@ -0,0 +1,66 @@
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  IsArray,
+  IsInt,
+  IsPositive,
+  IsString,
+  Matches,
+  MaxLength,
+  Validate,
+  ValidatorConstraint,
+  ValidatorConstraintInterface,
+} from 'class-validator';
+
+@ValidatorConstraint({ name: 'posIntString', async: false })
+class PositiveIntStringConstraint implements ValidatorConstraintInterface {
+  validate(value: string) {
+    return /^\d+$/.test(value) && BigInt(value) > BigInt(0);
+  }
+  defaultMessage() {
+    return 'amount must be a positive integer string (stroops)';
+  }
+}
+
+export class BuildClaimTransactionDto {
+  @ApiProperty({
+    description: 'Stellar public key of the claimant.',
+    example: 'GDVOEGATQV4FGUJKDEBEYT5NAPWJ55MEMJVLC5TU7Y74WD73PPAS4TYW',
+  })
+  @IsString()
+  @Matches(/^G[A-Z2-7]{55}$/, {
+    message: 'holder must be a valid Stellar public key (G...)',
+  })
+  holder: string;
+
+  @ApiProperty({
+    description: 'The ID of the policy to claim against.',
+    example: 1,
+  })
+  @IsInt()
+  @IsPositive()
+  policyId: number;
+
+  @ApiProperty({
+    description: 'Claim amount in stroops as an integer string.',
+    example: '500000000',
+  })
+  @IsString()
+  @Validate(PositiveIntStringConstraint)
+  amount: string;
+
+  @ApiProperty({
+    description: 'Narrative description of the claim.',
+    example: 'Water damage in the kitchen due to pipe burst.',
+  })
+  @IsString()
+  @MaxLength(1000)
+  details: string;
+
+  @ApiProperty({
+    description: 'List of IPFS URLs (or CIDs) for evidence images.',
+    example: ['https://ipfs.io/ipfs/Qm...'],
+  })
+  @IsArray()
+  @IsString({ each: true })
+  imageUrls: string[];
+}

backend/src/claims/dto/submit-transaction.dto.ts

@@ -0,0 +1,12 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsString, IsNotEmpty } from 'class-validator';
+
+export class SubmitTransactionDto {
+  @ApiProperty({
+    description: 'Base64-encoded signed transaction envelope (XDR).',
+    example: 'AAAAAgAAA...',
+  })
+  @IsString()
+  @IsNotEmpty()
+  transactionXdr: string;
+}

backend/src/rpc/soroban.service.ts

@@ -312,6 +312,117 @@ export class SorobanService {
     };
   }
 
+  /**
+   * Build unsigned file_claim transaction.
+   * Signature: file_claim(holder, policy_id, amount, details, image_urls)
+   */
+  async buildFileClaimTransaction(args: {
+    holder: string;
+    policyId: number;
+    amount: bigint;
+    details: string;
+    imageUrls: string[];
+  }): Promise<BuildTransactionResult> {
+    const server = this.makeServer();
+    const account = await this.loadAccount(server, args.holder);
+    const ledgerInfo = await server.getLatestLedger();
+
+    const scArgs = [
+      new Address(args.holder).toScVal(),
+      nativeToScVal(args.policyId, { type: 'u32' }),
+      nativeToScVal(args.amount, { type: 'i128' }),
+      nativeToScVal(args.details, { type: 'string' }),
+      xdr.ScVal.scvVec(
+        args.imageUrls.map((url) => nativeToScVal(url, { type: 'string' })),
+      ),
+    ];
+
+    const contract = new Contract(this.contractId);
+    const tx = new TransactionBuilder(account, {
+      fee: BASE_FEE,
+      networkPassphrase: this.networkPassphrase,
+    })
+      .addOperation(contract.call('file_claim', ...scArgs))
+      .setTimeout(30)
+      .build();
+
+    const simulation = await server.simulateTransaction(tx);
+
+    if (Api.isSimulationError(simulation)) {
+      const err = simulation as SorobanRpc.Api.SimulateTransactionErrorResponse;
+      this.mapSimulationError(err.error);
+    }
+
+    const successSim =
+      simulation as SorobanRpc.Api.SimulateTransactionSuccessResponse;
+    const assembled = assembleTransaction(tx, successSim);
+    const unsignedXdr = assembled.build().toEnvelope().toXDR('base64');
+
+    const baseFee = BigInt(BASE_FEE);
+    const resourceFee = BigInt(successSim.minResourceFee ?? '0');
+    const totalFee = baseFee + resourceFee;
+
+    const authRequirements: AuthRequirement[] = [];
+    for (const authEntry of successSim.result?.auth ?? []) {
+      const credentials = authEntry.credentials();
+      if (
+        credentials.switch().value ===
+        xdr.SorobanCredentialsType.sorobanCredentialsAddress().value
+      ) {
+        const addrObj = credentials.address().address();
+        const stellarAddr = Address.fromScAddress(addrObj);
+        const isContract =
+          addrObj.switch().value ===
+          xdr.ScAddressType.scAddressTypeContract().value;
+        authRequirements.push({ address: stellarAddr.toString(), isContract });
+      }
+    }
+
+    if (!authRequirements.some((r) => r.address === args.holder)) {
+      authRequirements.unshift({ address: args.holder, isContract: false });
+    }
+
+    return {
+      unsignedXdr,
+      minResourceFee: successSim.minResourceFee ?? '0',
+      baseFee: BASE_FEE.toString(),
+      totalEstimatedFee: totalFee.toString(),
+      totalEstimatedFeeXlm: SorobanService.stroopsToXlm(totalFee),
+      authRequirements,
+      memoConvention:
+        'NiffyInsure does not use memos for protocol correlation. ' +
+        'Claim details are embedded in the contract call.',
+      currentLedger: ledgerInfo.sequence,
+    };
+  }
+
+  /**
+   * Submit a signed transaction to the Soroban RPC.
+   * Expects base64-encoded XDR (envelope).
+   */
+  async submitTransaction(transactionXdr: string): Promise<SorobanRpc.Api.SendTransactionResponse> {
+    const server = this.makeServer();
+    const tx = TransactionBuilder.fromEnvelope(transactionXdr, this.networkPassphrase);
+    
+    try {
+      const response = await server.sendTransaction(tx);
+      if (response.status === 'ERROR') {
+        throw new BadRequestException({
+          code: 'TRANSACTION_REJECTED',
+          message: 'The transaction was rejected by the network.',
+          details: response.errorResultXdr,
+        });
+      }
+      return response;
+    } catch (err) {
+      this.logger.error('Transaction submission error', err);
+      throw new ServiceUnavailableException({
+        code: 'SUBMISSION_FAILED',
+        message: 'Failed to submit transaction to the network.',
+      });
+    }
+  }
+
   /**
    * Fetch events for the configured contract ID within a ledger range.
    */

frontend/src/app/policy/[id]/claim/page.tsx

@@ -0,0 +1,87 @@
+'use client';
+
+import React, { useEffect, useState } from 'react';
+import { useParams, useRouter } from 'next/navigation';
+import { PolicyAPI } from '@/lib/api/policy';
+import { Policy } from '@/lib/schemas/policy';
+import { ClaimWizard } from '@/components/claims/ClaimWizard';
+import { Button, Card, CardContent, Skeleton, useToast } from '@/components/ui';
+import { AlertCircle, ArrowLeft } from 'lucide-react';
+
+export default function FileClaimPage() {
+  const params = useParams();
+  const router = useRouter();
+  const { toast } = useToast();
+  const policyId = params.id as string;
+
+  const [policy, setPolicy] = useState<Policy | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    async function loadPolicy() {
+      try {
+        const data = await PolicyAPI.getPolicy(policyId);
+        setPolicy(data);
+      } catch (err) {
+        console.error('Failed to load policy:', err);
+        setError('Could not load policy details. Please ensure the policy exists and you have access.');
+      } finally {
+        setIsLoading(false);
+      }
+    }
+
+    if (policyId) {
+      loadPolicy();
+    }
+  }, [policyId]);
+
+  if (isLoading) {
+    return (
+      <div className="container max-w-3xl py-10 space-y-4">
+        <Skeleton className="h-10 w-48" />
+        <Skeleton className="h-[400px] w-full" />
+      </div>
+    );
+  }
+
+  if (error || !policy) {
+    return (
+      <div className="container max-w-3xl py-20">
+        <Card className="border-destructive/50 bg-destructive/10">
+          <CardContent className="pt-6 text-center space-y-4">
+            <AlertCircle className="mx-auto h-12 w-12 text-destructive" />
+            <div className="space-y-2">
+              <h2 className="text-xl font-bold">Error Loading Policy</h2>
+              <p className="text-muted-foreground">{error}</p>
+            </div>
+            <Button onClick={() => router.push('/dashboard')} variant="outline">
+              Back to Dashboard
+            </Button>
+          </CardContent>
+        </Card>
+      </div>
+    );
+  }
+
+  return (
+    <div className="container max-w-4xl py-10 space-y-6">
+      <div className="flex items-center gap-4">
+        <Button 
+          variant="ghost" 
+          size="icon" 
+          onClick={() => router.back()}
+          className="h-9 w-9"
+        >
+          <ArrowLeft className="h-5 w-5" />
+        </Button>
+        <h1 className="text-3xl font-bold tracking-tight">File Insurance Claim</h1>
+      </div>
+
+      <ClaimWizard 
+        policyId={policyId} 
+        maxCoverage={policy.coverageAmount.toString()} 
+      />
+    </div>
+  );
+}