feat: ofac implementation

prisma/schema.prisma

@@ -12,21 +12,22 @@ generator client {
 
 model Transfer {
   id           String         @id @default(auto()) @map("_id") @db.ObjectId
-  depositNonce Int            
+  depositNonce Int
   resource     Resource?      @relation(fields: [resourceID], references: [id])
   resourceID   String?
   fromDomain   Domain         @relation(name: "fromDomainRelation", fields: [fromDomainId], references: [id])
-  fromDomainId Int 
+  fromDomainId Int
   toDomain     Domain?        @relation(name: "toDomainRelation", fields: [toDomainId], references: [id])
   toDomainId   Int?
-  sender       String?
   destination  String?
   amount       String?
   timestamp    DateTime?
   status       TransferStatus
   deposit      Deposit?
   execution    Execution?
   fee          Fee?
+  account      Account?       @relation(name: "accountRelation", fields: [accountId], references: [id])
+  accountId    String?
 
   @@unique(fields: [depositNonce, fromDomainId, toDomainId], name: "transferId")
 }
@@ -37,14 +38,21 @@ enum TransferStatus {
   failed
 }
 
+model Account {
+  id            String     @id @map("_id")
+  address       String?
+  addressStatus String
+  Transfer      Transfer[] @relation(name: "accountRelation")
+}
+
 model Resource {
   id        String     @id @map("_id")
   type      String
   transfers Transfer[]
 }
 
 model Domain {
-  id   Int @id @map("_id")
+  id   Int    @id @map("_id")
   name String
 
   lastIndexedBlock String

src/Interfaces/TransfersInterfaces/index.ts

@@ -58,5 +58,11 @@ export type IncludedQueryParams = {
         blockNumber: boolean
       }
     }
+    account: {
+      select: {
+        address: boolean
+        addressStatus: boolean
+      }
+    }
   }
 }

src/indexer/index.ts

@@ -10,6 +10,7 @@ import ExecutionRepository from "./repository/execution"
 import FeeRepository from "./repository/fee"
 import ResourceRepository from "./repository/resource"
 import { healthcheckRoute } from "./healthcheck"
+import { OfacComplianceService } from "./services/evmIndexer/ofac"
 
 interface DomainIndexer {
   listenToEvents(): Promise<void>
@@ -38,6 +39,7 @@ init()
 
 async function init(): Promise<Array<DomainIndexer>> {
   const sharedConfig = await getSharedConfig(process.env.SHARED_CONFIG_URL!)
+  const ofacComplianceService = new OfacComplianceService(process.env.CHAIN_ANALYSIS_URL!, process.env.CHAIN_ANALYSIS_API_KEY!)
 
   const domainRepository = new DomainRepository()
   const depositRepository = new DepositRepository()
@@ -79,7 +81,16 @@ async function init(): Promise<Array<DomainIndexer>> {
       }
     } else if (domain.type == DomainTypes.EVM) {
       try {
-        const evmIndexer = new EvmIndexer(domain, rpcURL, domainRepository, depositRepository, transferRepository, executionRepository, feeRepository)
+        const evmIndexer = new EvmIndexer(
+          domain,
+          rpcURL,
+          domainRepository,
+          depositRepository,
+          transferRepository,
+          executionRepository,
+          feeRepository,
+          ofacComplianceService,
+        )
         domainIndexers.push(evmIndexer)
       } catch (err) {
         logger.error(`error on domain: ${domain.id}... skipping`)

src/indexer/repository/transfer.ts

@@ -2,27 +2,31 @@ import { PrismaClient, Transfer, TransferStatus } from "@prisma/client"
 import { ObjectId } from "mongodb"
 import { DecodedDepositLog, DecodedFailedHandlerExecution, DecodedProposalExecutionLog } from "../services/evmIndexer/evmTypes"
 
-export type TransferMetadataeta = {
+export type TransferMetadata = {
   id: string
   depositNonce: number
-  sender: string
   amount: string
   destination: string
   fromDomainId: string
   toDomainId: string
   resourceID: string
-
+  timestamp: Date
   resource: {
     connect: {
       id: string
     }
   }
   fromDomain: {
     connect: {
-      id: string
+      id: number
     }
   }
   toDomain: {
+    connect: {
+      id: number
+    }
+  }
+  account?: {
     connect: {
       id: string
     }
@@ -31,11 +35,10 @@ export type TransferMetadataeta = {
 class TransferRepository {
   public transfer = new PrismaClient().transfer
 
-  public async insertDepositTransfer(decodedLog: DecodedDepositLog): Promise<Transfer> {
+  public async insertDepositTransfer(decodedLog: DecodedDepositLog, senderStatus: string): Promise<Transfer> {
     const transferData = {
       id: new ObjectId().toString(),
       depositNonce: decodedLog.depositNonce,
-      sender: decodedLog.sender,
       amount: decodedLog.amount,
       destination: decodedLog.destination,
       status: TransferStatus.pending,
@@ -55,6 +58,13 @@ class TransferRepository {
         },
       },
       timestamp: new Date(decodedLog.timestamp * 1000), // this is only being used by evm service
+      account: {
+        create: {
+          id: new ObjectId().toString(),
+          address: decodedLog.sender,
+          addressStatus: senderStatus,
+        },
+      },
     }
     return await this.transfer.create({ data: transferData })
   }
@@ -106,7 +116,6 @@ class TransferRepository {
       id: new ObjectId().toString(),
       depositNonce: depositNonce,
       status: TransferStatus.executed,
-      sender: null,
       destination: null,
       amount: null,
       resource: resourceID !== null ? resourceID : undefined,
@@ -152,19 +161,21 @@ class TransferRepository {
   public async updateTransfer(
     {
       depositNonce,
-      sender,
       amount,
       destination,
       resourceID,
       fromDomainId,
       toDomainId,
       timestamp,
-    }: Pick<DecodedDepositLog, "depositNonce" | "sender" | "amount" | "destination" | "resourceID" | "fromDomainId" | "toDomainId" | "timestamp">,
+    }: Pick<
+      DecodedDepositLog,
+      "depositNonce" | "amount" | "destination" | "resourceID" | "fromDomainId" | "toDomainId" | "timestamp" | "senderStatus"
+    >,
     id: string,
+    accountId?: string,
   ): Promise<Transfer> {
-    const transferData = {
+    let transferData = {
       depositNonce: depositNonce,
-      sender: sender,
       amount: amount,
       destination: destination,
       resource: {
@@ -183,7 +194,19 @@ class TransferRepository {
         },
       },
       timestamp: new Date(timestamp),
+    } as Pick<TransferMetadata, "depositNonce" | "amount" | "destination" | "resource" | "fromDomain" | "toDomain" | "timestamp" | "account">
+
+    if (accountId) {
+      transferData = {
+        ...transferData,
+        account: {
+          connect: {
+            id: accountId,
+          },
+        },
+      }
     }
+
     return await this.transfer.update({ where: { id: id }, data: transferData })
   }
 

src/indexer/services/evmIndexer/evmIndexer.ts

@@ -11,6 +11,7 @@ import FeeRepository from "../../repository/fee"
 import { logger } from "../../../utils/logger"
 import { getLogs } from "./evmfilter"
 import { decodeLogs } from "./evmEventParser"
+import { OfacComplianceService } from "./ofac"
 
 const BLOCK_TIME = 15000
 
@@ -27,6 +28,7 @@ export class EvmIndexer {
   private domain: Domain
   private resourceMap: Map<string, EvmResource>
   private stopped = false
+  private ofacComplianceService: OfacComplianceService
 
   constructor(
     domain: Domain,
@@ -36,6 +38,7 @@ export class EvmIndexer {
     transferRepository: TransferRepository,
     executionRepository: ExecutionRepository,
     feeRepository: FeeRepository,
+    ofacComplianceService: OfacComplianceService,
   ) {
     this.provider = new ethers.JsonRpcProvider(rpcURL)
     this.domainRepository = domainRepository
@@ -44,6 +47,7 @@ export class EvmIndexer {
     this.transferRepository = transferRepository
     this.executionRepository = executionRepository
     this.feeRepository = feeRepository
+    this.ofacComplianceService = ofacComplianceService
 
     this.resourceMap = new Map<string, EvmResource>()
     domain.resources.map((resource: EvmResource) => this.resourceMap.set(resource.resourceId, resource))
@@ -98,7 +102,9 @@ export class EvmIndexer {
 
     const transferMap = new Map<string, string>()
     await Promise.all(
-      decodedLogs.deposit.map(async decodedLog => saveDepositLogs(decodedLog, this.transferRepository, this.depositRepository, transferMap)),
+      decodedLogs.deposit.map(async decodedLog =>
+        saveDepositLogs(decodedLog, this.transferRepository, this.depositRepository, transferMap, this.ofacComplianceService),
+      ),
     )
 
     await Promise.all(decodedLogs.feeCollected.map(async fee => saveFeeLogs(fee, transferMap, this.feeRepository)))

src/indexer/services/evmIndexer/evmTypes.ts

@@ -19,6 +19,7 @@ export type DecodedDepositLog = {
   handlerResponse: string
   transferType: string
   amount: string
+  senderStatus?: string
 }
 
 export type DecodedProposalExecutionLog = {

src/indexer/services/evmIndexer/ofac/index.ts

@@ -0,0 +1,34 @@
+import url from "url"
+
+type ChainAnalysisIdentIfication = {
+  category: string
+  name: string
+  description: string
+  url: string
+}
+
+type ChainAnalysisResponse = {
+  identifications: Array<ChainAnalysisIdentIfication> | []
+}
+
+export class OfacComplianceService {
+  private chainAnalisysUrl: string
+  private chainAnalisysApiKey: string
+
+  constructor(chainAnalysisUrl: string, chainAnalisysApiKey: string) {
+    this.chainAnalisysUrl = chainAnalysisUrl
+    this.chainAnalisysApiKey = chainAnalisysApiKey
+  }
+
+  public async checkSanctionedAddress(address: string): Promise<string> {
+    const urlToUse = url.resolve(this.chainAnalisysUrl, address)
+    const response = await fetch(urlToUse, {
+      headers: {
+        "X-API-Key": `${this.chainAnalisysApiKey}`,
+        Accept: "application/json",
+      },
+    })
+    const data = (await response.json()) as ChainAnalysisResponse
+    return data.identifications.length ? "ofac" : ""
+  }
+}

src/indexer/utils/evm/index.ts

@@ -33,6 +33,7 @@ import {
 import { getERC20Contract } from "../../services/contract"
 import FeeRepository from "../../repository/fee"
 import ExecutionRepository from "../../repository/execution"
+import { OfacComplianceService } from "../../services/evmIndexer/ofac"
 
 export const nativeTokenAddress = "0x0000000000000000000000000000000000000000"
 
@@ -196,16 +197,22 @@ export async function saveDepositLogs(
   transferRepository: TransferRepository,
   depositRepository: DepositRepository,
   transferMap: Map<string, string>,
+  ofacComplianceService: OfacComplianceService,
 ): Promise<void> {
   let transfer = await transferRepository.findTransfer(decodedLog.depositNonce, Number(decodedLog.fromDomainId), Number(decodedLog.toDomainId))
+
+  const { sender } = decodedLog
+
+  const senderStatus = await ofacComplianceService.checkSanctionedAddress(sender)
+
   if (!transfer) {
-    transfer = await transferRepository.insertDepositTransfer(decodedLog)
+    transfer = await transferRepository.insertDepositTransfer(decodedLog, senderStatus)
   } else {
     const dataToSave = {
       ...decodedLog,
       timestamp: decodedLog.timestamp * 1000,
     }
-    await transferRepository.updateTransfer(dataToSave, transfer.id)
+    await transferRepository.updateTransfer(dataToSave, transfer.id, transfer.accountId!)
   }
 
   const deposit = {

src/indexer/utils/substrate/index.ts

@@ -116,7 +116,6 @@ export async function saveDeposit(
   if (transfer) {
     const dataTransferToUpdate = {
       depositNonce: Number(depositNonce),
-      sender,
       amount: decodedAmount,
       resourceID: resourceId,
       fromDomainId: originDomainId.toString(),

src/services/transfers.service.ts

@@ -8,13 +8,15 @@ export type TransfersByCursorOptions = {
   [key: string]: string | undefined
 }
 
+export type WhereClause = { [key: string]: string | undefined }
+
 class TransfersService {
   public transfers = new PrismaClient().transfer
 
   private prepareQueryParams(args: TransfersByCursorOptions): {
     skip: number
     take: number
-    where: (TransferStatus & { sender: string }) | {}
+    where: WhereClause
   } {
     const { page, limit, ...rest } = args
 
@@ -23,7 +25,7 @@ class TransfersService {
     const skip = (pageIndex - 1) * pageSize
     const take = pageSize
 
-    const where = rest ? { ...rest } : ({} as (TransferStatus & { sender: string }) | {})
+    const where = rest ? { ...rest } : ({} as TransferStatus | {})
 
     return {
       skip,
@@ -69,11 +71,21 @@ class TransfersService {
   public async findTransferByFilterParams(args: TransfersByCursorOptions): Promise<Transfer[]> {
     const { page, limit, status, sender } = args
 
-    const queryParams = this.prepareQueryParams({ page, limit, status, sender })
+    const queryParams = this.prepareQueryParams({ page, limit, status })
     const { skip, take, where } = queryParams
 
-    const transfer = await this.transfers.findMany({
-      where,
+    let whereToUse = { ...where } as { [key: string]: string | { [key: string]: string } | undefined }
+
+    if (sender) {
+      whereToUse = {
+        account: {
+          address: sender,
+        },
+      }
+    }
+
+    const transfers = await this.transfers.findMany({
+      where: whereToUse,
       take,
       skip,
       orderBy: [
@@ -86,7 +98,7 @@ class TransfersService {
       },
     })
 
-    return transfer
+    return transfers
   }
 }
 export default TransfersService