serverless.yml

# Welcome to serverless. Read the docs
# https://serverless.com/framework/docs/

# Serverless.yml is the configuration the CLI
# uses to deploy your code to your provider of choice

# The `service` block is the name of the service
service: hathor-explorer-service
useDotenv: true
# The `provider` block defines where your service will be deployed
provider:
  name: aws
  # WARN: If you change this, make sure you also change the `Dockerfile_Serverless` base image to match the python version
  runtime: "python3.9"
  region: ${env:AWS_DEFAULT_REGION}
  lambdaHashingVersion: 20201221
  stackTags:
    Application: "hathor-explorer-service"
    Stage: "${self:custom.stage}"
  apiGateway:
    apiKeys:
      - explorer-service-${self:custom.stage}-healthcheck-api-key
  logs:
    restApi: # TODO: add data to make the serverless create this role by itself
      role: arn:aws:iam::${env:AWS_ACCOUNT_ID}:role/APIGatewayPushLogsToCloudWatch
  vpc:
    securityGroupIds:
      - ${env:AWS_VPC_DEFAULT_SG_ID}
    subnetIds:
      - ${env:AWS_SUBNET_ID_1}
      - ${env:AWS_SUBNET_ID_2}
      - ${env:AWS_SUBNET_ID_3}
  environment:
    HATHOR_CORE_URL: ${env:HATHOR_CORE_URL}
    HATHOR_NODES: ${env:HATHOR_NODES}
    REDIS_KEY_PREFIX: ${env:REDIS_KEY_PREFIX}
    REDIS_HOST: ${env:REDIS_HOST}
    REDIS_PORT: ${env:REDIS_PORT}
    REDIS_DB: ${env:REDIS_DB}
    METADATA_BUCKET: ${env:METADATA_BUCKET}
    CORS_ALLOWED_REGEX: ${env:CORS_ALLOWED_REGEX}
    NODE_CACHE_TTL: ${env:NODE_CACHE_TTL}
    ELASTIC_CLOUD_ID: ${env:ELASTIC_CLOUD_ID}
    ELASTIC_USER: ${env:ELASTIC_USER}
    ELASTIC_PASSWORD: ${env:ELASTIC_PASSWORD}
    ELASTIC_INDEX: ${env:ELASTIC_INDEX}
    ELASTIC_TOKEN_BALANCES_INDEX: ${env:ELASTIC_TOKEN_BALANCES_INDEX}
    ELASTIC_RESULTS_PER_PAGE: ${env:ELASTIC_RESULTS_PER_PAGE}
    ELASTIC_SEARCH_TIMEOUT: ${env:ELASTIC_SEARCH_TIMEOUT}
    ELASTIC_TX_INDEX: ${env:ELASTIC_TX_INDEX}
    WALLET_SERVICE_DB_USERNAME: ${env:WALLET_SERVICE_DB_USERNAME}
    WALLET_SERVICE_DB_PASSWORD: ${env:WALLET_SERVICE_DB_PASSWORD}
    WALLET_SERVICE_DB_HOST: ${env:WALLET_SERVICE_DB_HOST}
    WALLET_SERVICE_DB_NAME: ${env:WALLET_SERVICE_DB_NAME}
    HEALTHCHECK_HATHOR_CORE_ENABLED: ${env:HEALTHCHECK_HATHOR_CORE_ENABLED}
    HEALTHCHECK_WALLET_SERVICE_DB_ENABLED: ${env:HEALTHCHECK_WALLET_SERVICE_DB_ENABLED}
    HEALTHCHECK_ELASTICSEARCH_ENABLED: ${env:HEALTHCHECK_ELASTICSEARCH_ENABLED}
    HEALTHCHECK_REDIS_ENABLED: ${env:HEALTHCHECK_REDIS_ENABLED}

plugins:
  - serverless-better-credentials
  - serverless-s3-local
  - serverless-offline
  - serverless-python-requirements
  - serverless-api-gateway-caching
  - serverless-plugin-aws-alerts
  - serverless-api-gateway-throttling

package:
  individually: true
  patterns:
    - '!*'
    - '!**/*'
    - 'common/**'
    - 'domain/**'
    - 'gateways/**'
    - 'usecases/**'
    - 'utils/**'
    - '!**/__pycache__'

custom:
  stage: ${opt:stage, 'dev'}
  serverless-offline:
    httpPort: ${env:API_PORT}
    host: 0.0.0.0
  pythonRequirements:
    layer: true
    pythonBin: python3
    dockerizePip: true
    dockerFile: ./Dockerfile_Serverless
    useStaticCache: false
    useDownloadCache: false
  s3:
    host: localhost
    directory: /tmp
    buckets: ${env:METADATA_BUCKET}
  apiGatewayCaching:
    enabled: true
    ttlInSeconds: 300
  apiGatewayThrottling:
    # Apply to all http endpoints, unless overridden
    # According to AWS: "Each method in this stage will respect these rate and burst settings."
    maxRequestsPerSecond: 50
    maxConcurrentRequests: 25
  alerts:
    stages: # Select which stages to deploy alarms to
      - mainnet
      - testnet
    topics: # SNS Topics to send alerts to
      major:
        alarm:
          topic: arn:aws:sns:${self:provider.region}:${env:AWS_ACCOUNT_ID}:opsgenie-cloudwatch-integration-production-major
      medium:
        alarm:
          topic: arn:aws:sns:${self:provider.region}:${env:AWS_ACCOUNT_ID}:opsgenie-cloudwatch-integration-production-medium
      minor:
        alarm:
          topic: arn:aws:sns:${self:provider.region}:${env:AWS_ACCOUNT_ID}:opsgenie-cloudwatch-integration-production-minor
    definitions: # Definition of alarms
      majorFunctionErrors:
        description: "More than 10 errors in the Lambda for 3 consecutive minutes. Runbook: https://github.com/HathorNetwork/ops-tools/blob/master/docs/runbooks/hathor-explorer-service/errors-in-lambdas.md"
        namespace: 'AWS/Lambda'
        metric: Errors
        threshold: 10
        statistic: Sum
        period: 60
        evaluationPeriods: 3
        comparisonOperator: GreaterThanOrEqualToThreshold
        treatMissingData: notBreaching
        alarmActions:
          - major
      mediumFunctionErrors:
        description: "More than 3 errors in the Lambda for 3 consecutive minutes. Runbook: https://github.com/HathorNetwork/ops-tools/blob/master/docs/runbooks/hathor-explorer-service/errors-in-lambdas.md"
        namespace: 'AWS/Lambda'
        metric: Errors
        threshold: 3
        statistic: Sum
        period: 60
        evaluationPeriods: 3
        comparisonOperator: GreaterThanOrEqualToThreshold
        treatMissingData: notBreaching
        alarmActions:
          - medium
      minorFunctionErrors:
        description: "More than 2 errors in the Lambda in 1 minute. Runbook: https://github.com/HathorNetwork/ops-tools/blob/master/docs/runbooks/hathor-explorer-service/errors-in-lambdas.md"
        namespace: 'AWS/Lambda'
        metric: Errors
        threshold: 2
        statistic: Sum
        period: 60
        evaluationPeriods: 1
        comparisonOperator: GreaterThanOrEqualToThreshold
        treatMissingData: notBreaching
        alarmActions:
          - minor
    alarms: # Alarms that will be applied to all functions
      - majorFunctionErrors
      - mediumFunctionErrors
      - minorFunctionErrors

functions:
  get_node_handler:
    handler: handlers/get_node_handler.handle
    package:
      patterns:
        - 'handlers/get_node_handler.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node/{hash}
          method: get
          cors: true
          request:
            parameters:
              paths:
                hash: true

  list_nodes_handler:
    handler: handlers/list_nodes_handler.handle
    package:
      patterns:
        - 'handlers/list_nodes_handler.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node/
          method: get
          cors: true

  get_network_handler:
    handler: handlers/get_network_handler.handle
    package:
      patterns:
        - 'handlers/get_network_handler.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: network/
          method: get
          cors: true

  node_data_aggregator_handler:
    handler: handlers/node_data_aggregator.handle
    timeout: 30
    package:
      patterns:
        - 'handlers/node_data_aggregator.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }

  get_token_handler:
    handler: handlers/get_token_handler.handle
    package:
      patterns:
        - 'handlers/get_token_handler.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: token/{hash}
          method: get
          cors: true
          request:
            parameters:
              paths:
                hash: true
          caching:
            enabled: true
            ttlInSeconds: 15
            cacheKeyParameters:
              - name: request.path.hash
              - name: request.header.origin

  get_tokenbalances_handler:
    handler: handlers/token_balance_api.get_token_balances
    timeout: 6
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/token_balance_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: token_balances
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 300
            cacheKeyParameters:
              - name: request.querystring.token_id
              - name: request.querystring.sort_by
              - name: request.querystring.order
              - name: request.querystring.search_after
              - name: request.header.origin

  get_tokenbalance_info_handler:
    handler: handlers/token_balance_api.get_token_information
    timeout: 6
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/token_balance_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: token_balances/information
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 300
            cacheKeyParameters:
              - name: request.querystring.token_id

  get_tokens_handler:
    handler: handlers/token_api.get_tokens
    timeout: 15
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/token_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: tokens
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 300
            cacheKeyParameters:
              - name: request.querystring.search_text
              - name: request.querystring.sort_by
              - name: request.querystring.order
              - name: request.querystring.search_after
              - name: request.header.origin

  # This get_token will get tokens from the elasticsearch index
  es_get_token_handler:
    handler: handlers/token_api.get_token
    timeout: 15
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/token_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: tokens/{token_id}
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 300
            cacheKeyParameters:
              - name: request.header.origin
              - name: request.path.token_id

  get_best_chain_height:
    handler: handlers/block_api.get_best_chain_height
    timeout: 30
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/block_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: blocks/best_chain_height
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 60
            cacheKeyParameters:
              - name: request.header.origin

  get_dag_metadata_handler:
    handler: handlers/dag_metadata_handler.handle_get
    package:
      patterns:
        - 'handlers/dag_metadata_handler.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: metadata/dag
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 10
            cacheKeyParameters:
              - name: request.querystring.id
              - name: request.header.origin

  create_or_update_dag_metadata:
    handler: handlers/dag_metadata_handler.handle_create_or_update
    package:
      patterns:
        - 'handlers/dag_metadata_handler.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }

  node_api_get_address_balance:
    handler: handlers/node_api.get_address_balance
    timeout: 15
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/address_balance
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 300
            cacheKeyParameters:
              - name: request.querystring.address
              - name: request.header.origin

  node_api_get_address_search:
    handler: handlers/node_api.get_address_search
    timeout: 15
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/address_search
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 300
            cacheKeyParameters:
              - name: request.querystring.address
              - name: request.querystring.count
              - name: request.querystring.token
              - name: request.querystring.page
              - name: request.querystring.hash
              - name: request.header.origin

  node_api_get_version:
    handler: handlers/node_api.get_version
    timeout: 6
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/version
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 3600
            cacheKeyParameters:
              - name: request.header.origin

  node_api_get_dashboard_tx:
    handler: handlers/node_api.get_dashboard_tx
    timeout: 6
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/dashboard_tx
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 10
            cacheKeyParameters:
              - name: request.querystring.block
              - name: request.querystring.tx
              - name: request.header.origin

  node_api_get_tx_acc_w:
    handler: handlers/node_api.get_transaction_acc_weight
    timeout: 6
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/transaction_acc_weight
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 5
            cacheKeyParameters:
              - name: request.querystring.id
              - name: request.header.origin

  node_api_get_token_history:
    handler: handlers/node_api.get_token_history
    timeout: 6
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/token_history
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 10
            cacheKeyParameters:
              - name: request.querystring.id
              - name: request.querystring.count
              - name: request.querystring.hash
              - name: request.querystring.page
              - name: request.querystring.timestamp
              - name: request.header.origin

  node_api_get_transaction:
    handler: handlers/node_api.get_transaction
    timeout: 6
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/transaction
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 10
            cacheKeyParameters:
              - name: request.querystring.id
              - name: request.header.origin

  node_api_get_feature:
    handler: handlers/node_api.get_feature
    timeout: 6
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/feature
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 10
            cacheKeyParameters:
              - name: request.querystring.block
              - name: request.header.origin

  node_api_list_transactions:
    handler: handlers/node_api.list_transactions
    timeout: 6
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/transactions
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 10
            cacheKeyParameters:
              - name: request.querystring.type
              - name: request.querystring.count
              - name: request.querystring.hash
              - name: request.querystring.page
              - name: request.querystring.timestamp
              - name: request.header.origin

  node_api_get_token:
    handler: handlers/node_api.get_token
    timeout: 6
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/token
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 10
            cacheKeyParameters:
              - name: request.querystring.id
              - name: request.header.origin

  node_api_decode_tx:
    handler: handlers/node_api.decode_tx
    timeout: 6
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/decode_tx
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 300
            cacheKeyParameters:
              - name: request.querystring.hex_tx
              - name: request.header.origin

  node_api_push_tx:
    handler: handlers/node_api.push_tx
    timeout: 6
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/push_tx
          method: post
          cors: true
          caching:
            enabled: false

  node_api_gviz_dot_neighbors:
    handler: handlers/node_api.graphviz_dot_neighbors
    timeout: 6
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/graphviz/neighbours.dot
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 10
            cacheKeyParameters:
              - name: request.querystring.tx
              - name: request.querystring.graph_type
              - name: request.querystring.max_level
              - name: request.header.origin

  # This API doesn't have cache because our plugin doesn't support
  # multivalue caching. An issue was created to discuss this.
  # https://github.com/HathorNetwork/hathor-explorer-service/issues/318
  node_api_nc_state:
    handler: handlers/node_api.nc_state
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/nc_state
          method: get
          cors: true

  node_api_nc_history:
    handler: handlers/node_api.nc_history
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/nc_history
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 300
            cacheKeyParameters:
              - name: request.querystring.id
              - name: request.querystring.after
              - name: request.querystring.before
              - name: request.querystring.count
              - name: request.header.origin

  node_api_nc_blueprint_info:
    handler: handlers/node_api.nc_blueprint_information
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/nc_blueprint_information
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 300
            cacheKeyParameters:
              - name: request.querystring.blueprint_id
              - name: request.header.origin

  node_api_nc_blueprint_code:
    handler: handlers/node_api.nc_blueprint_source_code
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/node_api.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: node_api/nc_blueprint_source_code
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 300
            cacheKeyParameters:
              - name: request.querystring.blueprint_id
              - name: request.header.origin

  walletServiceAddressBalance:
    handler: handlers/wallet_service.handle_address_balance
    timeout: 15
    package:
      patterns:
        - 'handlers/wallet_service.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: address/balance
          method: get
          cors: true
          throttling:
            maxRequestsPerSecond: 100
            maxConcurrentRequests: 4
          caching:
            enabled: true
            ttlInSeconds: 5
            cacheKeyParameters:
              - name: request.querystring.address
              - name: request.querystring.token
              - name: request.header.origin

  walletServiceAddressHistory:
    handler: handlers/wallet_service.handle_address_history
    timeout: 15
    package:
      patterns:
        - 'handlers/wallet_service.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: address/history
          method: get
          cors: true
          throttling:
            maxRequestsPerSecond: 100
            maxConcurrentRequests: 4
          caching:
            enabled: true
            ttlInSeconds: 5
            cacheKeyParameters:
              - name: request.querystring.address
              - name: request.querystring.token
              - name: request.querystring.limit
              - name: request.querystring.last_tx
              - name: request.querystring.last_ts
              - name: request.header.origin

  walletServiceAddressTokens:
    handler: handlers/wallet_service.handle_address_tokens
    timeout: 15
    package:
      patterns:
        - 'handlers/wallet_service.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: address/tokens
          method: get
          cors: true
          throttling:
            maxRequestsPerSecond: 100
            maxConcurrentRequests: 4
          caching:
            enabled: true
            ttlInSeconds: 10
            cacheKeyParameters:
              - name: request.querystring.address
              - name: request.querystring.limit
              - name: request.querystring.offset
              - name: request.header.origin

  network_statistics_handler:
    handler: handlers/network_statistics.get_basic_statistics
    timeout: 5
    maximumRetryAttempts: 0
    package:
      patterns:
        - 'handlers/network_statistics.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          path: network-statistics
          method: get
          cors: true
          caching:
            enabled: true
            ttlInSeconds: 60
            perKeyInvalidation:  # add invalidation policy
              requireAuthorization: true
              handleUnauthorizedRequests: Fail # fail if the request don't have the permission to invalidate the cache

  healthcheck_handler:
    handler: handlers/get_healthcheck.get_healthcheck
    timeout: 15
    package:
      patterns:
        - 'handlers/get_healthcheck.py'
    layers:
      - { Ref: PythonRequirementsLambdaLayer }
    events:
      - http:
          private: true
          path: health
          method: get
          cors: true
          throttling:
            maxRequestsPerSecond: 1
            maxConcurrentRequests: 1