@portal-hq/web 3.8.0 → 3.9.0

package/src/__mocks/constants.ts

@@ -1,3 +1,4 @@
+import { BlockaidAddressScanRequest, BlockaidAddressScanResponse, BlockaidBulkTokenScanRequest, BlockaidBulkTokenScanResponse, BlockaidScanEvmTxRequest, BlockaidScanEvmTxResponse, BlockaidScanSolanaTxRequest, BlockaidScanSolanaTxResponse, BlockaidSiteScanRequest, BlockaidSiteScanResponse } from 'src/shared/types'
 import type { ClientResponse } from '../../types'
 import { BackupMethods, PortalCurve, ChainNamespace } from '../index'
 
@@ -1729,3 +1730,205 @@ export const mockScanUrlResponse = {
     },
   },
 }
+
+// Blockaid mock data
+export const mockBlockaidScanEvmTxRequest = {
+  chain: 'ethereum',
+  data: {
+    from: '0x1234567890123456789012345678901234567890',
+    to: '0x0987654321098765432109876543210987654321',
+    data: '0xabcdef',
+    value: '1000000000000000000',
+  },
+  metadata: {
+    domain: 'https://example.com',
+  },
+  account_address: '0x1234567890123456789012345678901234567890',
+  options: ['validation', 'simulation'],
+} as BlockaidScanEvmTxRequest
+
+export const mockBlockaidScanEvmTxResponse = {
+  data: {
+    rawResponse: {
+      validation: {
+        classification: 'benign',
+        description: 'This transaction appears safe',
+        features: [
+          {
+            type: 'Benign',
+            feature_id: 'safe_transfer',
+            description: 'Standard ETH transfer',
+          },
+        ],
+        reason: 'Standard transfer',
+        result_type: 'Benign',
+        status: 'Success',
+      },
+      simulation: {
+        account_address: '0x1234567890123456789012345678901234567890',
+        account_summary: {},
+        address_details: {},
+        assets_diffs: {},
+        block: 18500000,
+        chain: 'ethereum',
+        exposures: {},
+        status: 'Success',
+        total_usd_diff: {},
+        total_usd_exposure: {},
+        transaction_action: 'transfer',
+        session_key: {},
+      },
+      block: '18500000',
+      chain: 'ethereum',
+      account_address: '0x1234567890123456789012345678901234567890',
+    },
+  },
+} as BlockaidScanEvmTxResponse
+
+export const mockBlockaidScanSolanaTxRequest = {
+  account_address: 'CqQMFUCEMbK9Cp9yMonmthKqzc59Ta48JpZMZsh1bDqf',
+  transactions: ['base64encodedtransaction'],
+  metadata: {
+    url: 'https://example.com',
+  },
+  chain: 'mainnet',
+  options: ['validation', 'simulation'],
+} as BlockaidScanSolanaTxRequest
+
+export const mockBlockaidScanSolanaTxResponse = {
+  data: {
+    rawResponse: {
+      encoding: 'base64',
+      status: 'Success',
+      request_id: 'test-request-id',
+      result: {
+        validation: {
+          features: [],
+          reason: 'Standard transaction',
+          result_type: 'Benign',
+        },
+        simulation: {
+          account_summary: {
+            account_assets_diff: [],
+          },
+          accounts_details: [],
+          assets_diff: {},
+          assets_ownership_diff: {},
+          delegations: {},
+        },
+      },
+    },
+  },
+} as BlockaidScanSolanaTxResponse
+
+export const mockBlockaidScanAddressRequest = {
+  chain: 'ethereum',
+  address: '0x1234567890123456789012345678901234567890',
+  metadata: {
+    domain: 'https://example.com',
+  },
+} as BlockaidAddressScanRequest
+
+export const mockBlockaidScanAddressResponse = {
+  data: {
+    rawResponse: {
+      result_type: 'Benign',
+      features: [
+        {
+          type: 'Benign',
+          feature_id: 'verified_contract',
+          description: 'Verified contract on Etherscan',
+        },
+      ],
+    },
+  },
+} as BlockaidAddressScanResponse
+
+export const mockBlockaidScanTokensRequest = {
+  chain: 'ethereum',
+  tokens: [
+    '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    '0xdac17f958d2ee523a2206206994597c13d831ec7',
+  ],
+  metadata: {
+    domain: 'https://example.com',
+  },
+} as BlockaidBulkTokenScanRequest
+
+export const mockBlockaidScanTokensResponse = {
+  data: {
+    rawResponse: {
+      results: {
+        '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48': {
+          result_type: 'Benign',
+          malicious_score: '0',
+          attack_types: {},
+          chain: 'ethereum',
+          address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+          metadata: {
+            type: 'ERC20',
+            name: 'USD Coin',
+            symbol: 'USDC',
+            decimals: 6,
+          },
+          fees: {},
+          trading_limits: {},
+          financial_stats: {
+            holders_count: 1000000,
+          },
+        },
+        '0xdac17f958d2ee523a2206206994597c13d831ec7': {
+          result_type: 'Benign',
+          malicious_score: '0',
+          attack_types: {},
+          chain: 'ethereum',
+          address: '0xdac17f958d2ee523a2206206994597c13d831ec7',
+          metadata: {
+            type: 'ERC20',
+            name: 'Tether USD',
+            symbol: 'USDT',
+            decimals: 6,
+          },
+          fees: {},
+          trading_limits: {},
+          financial_stats: {
+            holders_count: 2000000,
+          },
+        },
+      },
+    },
+  },
+} as BlockaidBulkTokenScanResponse
+
+export const mockBlockaidScanUrlRequest = {
+  url: 'https://example.com',
+  metadata: {
+    type: 'catalog',
+  },
+} as BlockaidSiteScanRequest
+
+export const mockBlockaidScanUrlResponse = {
+  data: {
+    rawResponse: {
+      status: 'hit',
+      url: 'https://example.com',
+      scan_start_time: '2024-01-01T00:00:00Z',
+      scan_end_time: '2024-01-01T00:00:01Z',
+      malicious_score: 0,
+      is_reachable: true,
+      is_web3_site: true,
+      is_malicious: false,
+      attack_types: {},
+      network_operations: [],
+      json_rpc_operations: [],
+      contract_write: {
+        contract_addresses: [],
+        functions: {},
+      },
+      contract_read: {
+        contract_addresses: [],
+        functions: {},
+      },
+    },
+  },
+} as BlockaidSiteScanResponse

package/src/integrations/security/blockaid/index.test.ts

@@ -0,0 +1,146 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import Blockaid from '.'
+import Mpc from '../../../mpc'
+import portalMock from '../../../__mocks/portal/portal'
+import {
+  mockHost,
+  mockBlockaidScanEvmTxRequest,
+  mockBlockaidScanEvmTxResponse,
+  mockBlockaidScanSolanaTxRequest,
+  mockBlockaidScanSolanaTxResponse,
+  mockBlockaidScanAddressRequest,
+  mockBlockaidScanAddressResponse,
+  mockBlockaidScanTokensRequest,
+  mockBlockaidScanTokensResponse,
+  mockBlockaidScanUrlRequest,
+  mockBlockaidScanUrlResponse,
+} from '../../../__mocks/constants'
+
+describe('Blockaid', () => {
+  let blockaid: Blockaid
+  let mpc: Mpc
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    portalMock.host = mockHost
+    mpc = new Mpc({
+      portal: portalMock,
+    })
+
+    blockaid = new Blockaid({ mpc })
+  })
+
+  describe('scanEVMTx', () => {
+    it('should call mpc.blockaidScanEvmTx with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'blockaidScanEvmTx')
+        .mockResolvedValue(mockBlockaidScanEvmTxResponse)
+
+      const result = await blockaid.scanEVMTx(mockBlockaidScanEvmTxRequest)
+
+      expect(spy).toHaveBeenCalledWith(mockBlockaidScanEvmTxRequest)
+      expect(result).toEqual(mockBlockaidScanEvmTxResponse)
+    })
+
+    it('should propagate errors from mpc.blockaidScanEvmTx', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'blockaidScanEvmTx').mockRejectedValue(error)
+
+      await expect(
+        blockaid.scanEVMTx(mockBlockaidScanEvmTxRequest),
+      ).rejects.toThrow('Test error')
+    })
+  })
+
+  describe('scanSolanaTx', () => {
+    it('should call mpc.blockaidScanSolanaTx with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'blockaidScanSolanaTx')
+        .mockResolvedValue(mockBlockaidScanSolanaTxResponse)
+
+      const result = await blockaid.scanSolanaTx(mockBlockaidScanSolanaTxRequest)
+
+      expect(spy).toHaveBeenCalledWith(mockBlockaidScanSolanaTxRequest)
+      expect(result).toEqual(mockBlockaidScanSolanaTxResponse)
+    })
+
+    it('should propagate errors from mpc.blockaidScanSolanaTx', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'blockaidScanSolanaTx').mockRejectedValue(error)
+
+      await expect(
+        blockaid.scanSolanaTx(mockBlockaidScanSolanaTxRequest),
+      ).rejects.toThrow('Test error')
+    })
+  })
+
+  describe('scanAddress', () => {
+    it('should call mpc.blockaidScanAddress with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'blockaidScanAddress')
+        .mockResolvedValue(mockBlockaidScanAddressResponse)
+
+      const result = await blockaid.scanAddress(mockBlockaidScanAddressRequest)
+
+      expect(spy).toHaveBeenCalledWith(mockBlockaidScanAddressRequest)
+      expect(result).toEqual(mockBlockaidScanAddressResponse)
+    })
+
+    it('should propagate errors from mpc.blockaidScanAddress', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'blockaidScanAddress').mockRejectedValue(error)
+
+      await expect(
+        blockaid.scanAddress(mockBlockaidScanAddressRequest),
+      ).rejects.toThrow('Test error')
+    })
+  })
+
+  describe('scanTokens', () => {
+    it('should call mpc.blockaidScanTokens with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'blockaidScanTokens')
+        .mockResolvedValue(mockBlockaidScanTokensResponse)
+
+      const result = await blockaid.scanTokens(mockBlockaidScanTokensRequest)
+
+      expect(spy).toHaveBeenCalledWith(mockBlockaidScanTokensRequest)
+      expect(result).toEqual(mockBlockaidScanTokensResponse)
+    })
+
+    it('should propagate errors from mpc.blockaidScanTokens', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'blockaidScanTokens').mockRejectedValue(error)
+
+      await expect(
+        blockaid.scanTokens(mockBlockaidScanTokensRequest),
+      ).rejects.toThrow('Test error')
+    })
+  })
+
+  describe('scanURL', () => {
+    it('should call mpc.blockaidScanUrl with the correct arguments', async () => {
+      const spy = jest
+        .spyOn(mpc, 'blockaidScanUrl')
+        .mockResolvedValue(mockBlockaidScanUrlResponse)
+
+      const result = await blockaid.scanURL(mockBlockaidScanUrlRequest)
+
+      expect(spy).toHaveBeenCalledWith(mockBlockaidScanUrlRequest)
+      expect(result).toEqual(mockBlockaidScanUrlResponse)
+    })
+
+    it('should propagate errors from mpc.blockaidScanUrl', async () => {
+      const error = new Error('Test error')
+      jest.spyOn(mpc, 'blockaidScanUrl').mockRejectedValue(error)
+
+      await expect(
+        blockaid.scanURL(mockBlockaidScanUrlRequest),
+      ).rejects.toThrow('Test error')
+    })
+  })
+})

package/src/integrations/security/blockaid/index.ts

@@ -0,0 +1,81 @@
+import Mpc from '../../../mpc'
+import {
+  BlockaidScanEvmTxRequest,
+  BlockaidScanEvmTxResponse,
+  BlockaidScanSolanaTxRequest,
+  BlockaidScanSolanaTxResponse,
+  BlockaidAddressScanRequest,
+  BlockaidAddressScanResponse,
+  BlockaidBulkTokenScanRequest,
+  BlockaidBulkTokenScanResponse,
+  BlockaidSiteScanRequest,
+  BlockaidSiteScanResponse,
+} from '../../../shared/types'
+
+export default class Blockaid {
+  private mpc: Mpc
+
+  constructor({ mpc }: { mpc: Mpc }) {
+    this.mpc = mpc
+  }
+
+  /**
+   * Scans an EVM transaction for security risks using Blockaid.
+   * @param params - The parameters for the EVM transaction scan request.
+   * @returns A `BlockaidScanEvmTxResponse` promise.
+   * @throws An error if the operation fails.
+   */
+  public async scanEVMTx(
+    params: BlockaidScanEvmTxRequest,
+  ): Promise<BlockaidScanEvmTxResponse> {
+    return this.mpc.blockaidScanEvmTx(params)
+  }
+
+  /**
+   * Scans a Solana transaction for security risks using Blockaid.
+   * @param params - The parameters for the Solana transaction scan request.
+   * @returns A `BlockaidScanSolanaTxResponse` promise.
+   * @throws An error if the operation fails.
+   */
+  public async scanSolanaTx(
+    params: BlockaidScanSolanaTxRequest,
+  ): Promise<BlockaidScanSolanaTxResponse> {
+    return this.mpc.blockaidScanSolanaTx(params)
+  }
+
+  /**
+   * Scans an address for security risks using Blockaid.
+   * @param params - The parameters for the address scan request.
+   * @returns A `BlockaidAddressScanResponse` promise.
+   * @throws An error if the operation fails.
+   */
+  public async scanAddress(
+    params: BlockaidAddressScanRequest,
+  ): Promise<BlockaidAddressScanResponse> {
+    return this.mpc.blockaidScanAddress(params)
+  }
+
+  /**
+   * Scans tokens for security risks using Blockaid.
+   * @param params - The parameters for the token scan request.
+   * @returns A `BlockaidBulkTokenScanResponse` promise.
+   * @throws An error if the operation fails.
+   */
+  public async scanTokens(
+    params: BlockaidBulkTokenScanRequest,
+  ): Promise<BlockaidBulkTokenScanResponse> {
+    return this.mpc.blockaidScanTokens(params)
+  }
+
+  /**
+   * Scans a URL for malicious content using Blockaid.
+   * @param params - The parameters for the URL scan request.
+   * @returns A `BlockaidSiteScanResponse` promise.
+   * @throws An error if the operation fails.
+   */
+  public async scanURL(
+    params: BlockaidSiteScanRequest,
+  ): Promise<BlockaidSiteScanResponse> {
+    return this.mpc.blockaidScanUrl(params)
+  }
+}

package/src/integrations/security/index.ts

@@ -1,14 +1,17 @@
 import Mpc from '../../mpc'
+import Blockaid from './blockaid'
 import Hypernative from './hypernative'
 
 /**
- * This class is a container for the Hypernative class.
+ * This class is a container for the Hypernative and Blockaid classes.
  * In the future, Security domain logic should be here.
  */
 export default class Security {
+  public blockaid: Blockaid
   public hypernative: Hypernative
 
   constructor({ mpc }: { mpc: Mpc }) {
+    this.blockaid = new Blockaid({ mpc })
     this.hypernative = new Hypernative({ mpc })
   }
 }