Skip to content
Deploy holoclis to prod[mainnet]

test the ivs in mainnet #65

Sign in to view logs

test the ivs in mainnet

test the ivs in mainnet #65

Workflow file for this run

.github/workflows/cicd_mainnet_prod.yaml at 4b09fdc
name: Deploy holoclis to prod[mainnet]
permissions:
id-token: write
contents: read # This is required for actions/checkout@v2
env:
AWS_REGION: us-west-2
IAM_ROLE: arn:aws:iam::177635894328:role/Github_role_to_access_ECR
ECR_REPOSITORY: holo-cli # notice: the same for all cli apps
#
MAINNET_IMAGE_TAG: mainnet-${{ github.sha }}
#
CLUSTER_NAME: prod0
#
AWS_KEY_ID: ${{ secrets.PROD0_CICD_USER_AWS_ACCESS_KEY_ID }}
AWS_ACCESS_KEY: ${{ secrets.PROD0_CICD_USER_AWS_SECRET_ACCESS_KEY }}
ALB_CERT_ARN: ${{ secrets.PROD_ALB_CERT_ARN_FOR_HOLOGRAPH_XYZ }} # TIP: the 2 CERTs are separated with \, in Github secret
#
MAINNET_HOLO_INDEXER_OPERATOR_API_KEY: ${{ secrets.HOLO_INDEXER_MAINNET_OPERATOR_API_KEY }}
MAINNET_HOLO_OPERATOR_OPERATOR_API_KEY: ${{ secrets.HOLO_OPERATOR_MAINNET_OPERATOR_API_KEY}}
#
MAINNET_HOLOGRAPH_INDEXER_HOST: 'http://blondie-holo-api.mainnet.svc.cluster.local:443'
MAINNET_HOLOGRAPH_OPERATOR_HOST: 'http://blondie-holo-api.mainnet.svc.cluster.local:443'
#
MAINNET_HOLO_INDEXER_PASSWORD: ${{ secrets.MAINNET_HOLO_INDEXER_PASSWORD }}
MAINNET_HOLO_OPERATOR_PASSWORD: ${{ secrets.MAINNET_HOLO_OPERATOR_PASSWORD }}
#
# set the RPC endpoints config files
INDEXER_HOLO_CONFIG_FILE_DATA: mainnet-config-file
OPERATOR_HOLO_CONFIG_FILE_DATA: mainnet-config-file
#
HOLOGRAPH_ENVIRONMENT: mainnet
HOLOGRAPH_ADDRESS: ${{ secrets.MAINNET_HOLOGRAPH_ADDRESS }}
BLOCK_PROCESSING_VERSION: 'V2'
#
MAINNET_DOMAIN: 'holograph.xyz' # needed only for the health checks
#
MAINNET_COMMON_NAMESPACE: 'mainnet'
MAINNET_COMMON_NAMESPACE_V2: 'mainnet-v2'
#
# V1 INDEXER MAINNET rpc endpoints
indexer_mainnet_avalanche_rpc_url: ${{ secrets.INDEXER_MAINNET_AVALANCHE_RPC_URL }}
indexer_mainnet_polygon_rpc_url: ${{ secrets.INDEXER_MAINNET_POLYGON_RPC_URL }}
indexer_mainnet_ethereum_rpc_url: ${{ secrets.INDEXER_MAINNET_ETHEREUM_RPC_URL }}
indexer_mainnet_optimism_rpc_url: ${{ secrets.INDEXER_MAINNET_OPTIMISM_RPC_URL }}
indexer_mainnet_arbitrum_rpc_url: ${{ secrets.INDEXER_MAINNET_ARBITRUM_RPC_URL }}
indexer_mainnet_binance_rpc_url: ${{ secrets.INDEXER_MAINNET_BINANCE_RPC_URL }}
indexer_mainnet_mantle_rpc_url: 'https://rpc.mantle.xyz/'
indexer_mainnet_zora_rpc_url: 'https://rpc.zora.energy'
indexer_mainnet_base_rpc_url: ${{ secrets.INDEXER_MAINNET_BASE_RPC_URL }}
#
indexer_mainnet_private_key: ${{ secrets.INDEXER_MAINNET_PRIVATE_KEY }}
indexer_mainnet_address: ${{ secrets.INDEXER_MAINNET_ADDRESS }}
# V1 OPERATOR MAINNET rpc endpoints
operator_mainnet_avalanche_rpc_url: ${{ secrets.OPERATOR_MAINNET_AVALANCHE_RPC_URL }}
operator_mainnet_polygon_rpc_url: ${{ secrets.OPERATOR_MAINNET_POLYGON_RPC_URL }}
operator_mainnet_ethereum_rpc_url: ${{ secrets.OPERATOR_MAINNET_ETHEREUM_RPC_URL }}
operator_mainnet_optimism_rpc_url: ${{ secrets.OPERATOR_MAINNET_OPTIMISM_RPC_URL }}
operator_mainnet_arbitrum_rpc_url: ${{ secrets.OPERATOR_MAINNET_ARBITRUM_RPC_URL }}
operator_mainnet_binance_rpc_url: ${{ secrets.OPERATOR_MAINNET_BINANCE_RPC_URL }}
operator_mainnet_mantle_rpc_url: 'https://rpc.mantle.xyz/'
operator_mainnet_zora_rpc_url: 'https://rpc.zora.energy'
operator_mainnet_base_rpc_url: ${{ secrets.OPERATOR_MAINNET_BASE_RPC_URL }} # Notice: Operator should currently be disabled on Base
#
operator_mainnet_private_key: ${{ secrets.OPERATOR_MAINNET_PRIVATE_KEY }}
operator_mainnet_address: ${{ secrets.OPERATOR_MAINNET_ADDRESS }}
#
# V2 INDEXER MAINNET rpc endpoints
v2_indexer_mainnet_avalanche_rpc_url: ${{ secrets.INDEXER_MAINNET_AVALANCHE_RPC_URL }}
v2_indexer_mainnet_polygon_rpc_url: ${{ secrets.INDEXER_MAINNET_POLYGON_RPC_URL }}
v2_indexer_mainnet_ethereum_rpc_url: ${{ secrets.INDEXER_MAINNET_ETHEREUM_RPC_URL }}
v2_indexer_mainnet_optimism_rpc_url: ${{ secrets.INDEXER_MAINNET_OPTIMISM_RPC_URL }}
v2_indexer_mainnet_arbitrum_rpc_url: ${{ secrets.INDEXER_MAINNET_ARBITRUM_RPC_URL }}
v2_indexer_mainnet_binance_rpc_url: ${{ secrets.INDEXER_MAINNET_BINANCE_RPC_URL }}
v2_indexer_mainnet_mantle_rpc_url: 'https://rpc.mantle.xyz/'
v2_indexer_mainnet_zora_rpc_url: 'https://rpc.zora.energy'
v2_indexer_mainnet_base_rpc_url: ${{ secrets.INDEXER_MAINNET_BASE_RPC_URL }}
#
v2_indexer_mainnet_private_key: ${{ secrets.V2_INDEXER_MAINNET_PRIVATE_KEY }}
v2_indexer_mainnet_address: ${{ secrets.V2_INDEXER_MAINNET_ADDRESS }}
# V2 OPERATOR MAINNET rpc endpoints
v2_operator_mainnet_avalanche_rpc_url: ${{ secrets.OPERATOR_MAINNET_AVALANCHE_RPC_URL }}
v2_operator_mainnet_polygon_rpc_url: ${{ secrets.OPERATOR_MAINNET_POLYGON_RPC_URL }}
v2_operator_mainnet_ethereum_rpc_url: ${{ secrets.OPERATOR_MAINNET_ETHEREUM_RPC_URL }}
v2_operator_mainnet_optimism_rpc_url: ${{ secrets.OPERATOR_MAINNET_OPTIMISM_RPC_URL }}
v2_operator_mainnet_arbitrum_rpc_url: ${{ secrets.OPERATOR_MAINNET_ARBITRUM_RPC_URL }}
v2_operator_mainnet_binance_rpc_url: ${{ secrets.OPERATOR_MAINNET_BINANCE_RPC_URL }}
v2_operator_mainnet_mantle_rpc_url: 'https://rpc.mantle.xyz/'
v2_operator_mainnet_zora_rpc_url: 'https://rpc.zora.energy'
v2_operator_mainnet_base_rpc_url: ${{ secrets.OPERATOR_MAINNET_BASE_RPC_URL }} # Notice: Operator should currently be disabled on Base
#
v2_operator_mainnet_private_key: ${{ secrets.V2_OPERATOR_MAINNET_PRIVATE_KEY }}
v2_operator_mainnet_address: ${{ secrets.V2_OPERATOR_MAINNET_ADDRESS }}
#
# SQS User [indexer_processor_sqs_user]
SQS_USER_AWS_ACCESS_KEY_ID: ${{ secrets.SQS_INDEXER_PROCESSOR_USER_AWS_KEY_ID }}
SQS_USER_AWS_SECRET_ACCESS_KEY: ${{ secrets.SQS_INDEXER_PROCESSOR_USER_AWS_ACCESS_KEY }}
MAINNET_SQS_ENDPOINT: 'https://sqs.us-west-2.amazonaws.com'
MAINNET_SQS_QUEUE_URL: 'https://sqs.us-west-2.amazonaws.com/177635894328/mainnet-indexer-processor'
MAINNET_SQS_QUEUE_URL_V2: 'https://sqs.us-west-2.amazonaws.com/177635894328/mainnet-indexer-processor'
#######################################
MAINNET_HOLO_INDEXER_HELM_CHART_VERSION: 0.1.60
# INDEXER_RELEASE_NAME: 'blondie-indexer-mainnet' # format -> [release_name]-indexer-[env]
# INDEXER_RELEASE_NAME_V2: 'blondie-indexer-mainnet-v2'
INDEXER_RELEASE_NAME: 'iv-indexer-mainnet' # format -> [release_name]-indexer-[env]
INDEXER_RELEASE_NAME_V2: 'iv-indexer-mainnet-v2'
#
MAINNET_HOLO_OPERATOR_HELM_CHART_VERSION: 0.0.99
# OPERATOR_RELEASE_NAME: 'blondie-operator-mainnet' # format -> [release_name]-operator-[env]
# OPERATOR_RELEASE_NAME_V2: 'blondie-operator-mainnet-v2'
OPERATOR_RELEASE_NAME: 'iv-operator-mainnet' # format -> [release_name]-operator-[env]
OPERATOR_RELEASE_NAME_V2: 'iv-operator-mainnet-v2'
#######################################
## notice: the trigger
on:
push:
branches:
- 'something'
- 'feat/vi-key-address-for-v2'
# Excluded branches
- '!develop'
- '!main'
- '!master'
# notice: the trigger
#on:
# pull_request:
# branches:
# - 'mainnet'
# types: [closed]
jobs:
deploy-to-prod-mainnet:
# if: github.event.pull_request.merged == true # so no workflow runs when some PR is just closed without being merged
name: Deploy-to-prod[mainnet]
runs-on: ubuntu-latest
steps:
- name: Use Githubs federated identity with AWS
uses: aws-actions/configure-aws-credentials@v1
with:
role-to-assume: ${{ env.IAM_ROLE }}
aws-region: ${{ env.AWS_REGION }}
- name: Login to ECR
id: login-ecr
uses: aws-actions/amazon-ecr-login@v1
- name: Checkout the code
uses: actions/checkout@v2
# # This is a separate action that sets up buildx runner
# - name: Set up Docker Buildx
# id: buildx
# uses: docker/setup-buildx-action@v2
#
# # So now you can use Actions' own caching!
# - name: Cache Docker layers
# uses: actions/cache@v2
# with:
# path: /tmp/.buildx-cache
# key: ${{ runner.os }}-single-buildx-${{ github.sha }}
# restore-keys: |
# ${{ runner.os }}-single-buildx
#
# # And make it available for builds
# - name: Build image
# uses: docker/build-push-action@v2
# with:
# context: .
# builder: ${{ steps.buildx.outputs.name }}
# file: Dockerfile
# build-args: AWS_ECR_URL=${{ steps.login-ecr.outputs.registry }}
# platforms: linux/amd64
# tags: ${{ steps.login-ecr.outputs.registry }}/${{ env.ECR_REPOSITORY }}:${{ env.MAINNET_IMAGE_TAG }}
# cache-from: type=local,src=/tmp/.buildx-cache
# cache-to: type=local,dest=/tmp/.buildx-cache-new
# push: true # set false to deactivate the push to ECR
#
# # This ugly bit is necessary if you don't want your cache to grow forever until it hits GitHub's limit of 5GB.
# # https://github.com/docker/build-push-action/issues/252 & https://github.com/moby/buildkit/issues/1896
# - name: Move cache
# run: |
# rm -rf /tmp/.buildx-cache
# mv /tmp/.buildx-cache-new /tmp/.buildx-cache
- name: Configure AWS creds to access EKS
# TIP: the deployment user must be in the masters group in the aws-auth config map in the cluster
uses: aws-actions/configure-aws-credentials@v1
with:
aws-access-key-id: ${{ env.AWS_KEY_ID }} #notice: unique for each env
aws-secret-access-key: ${{ env.AWS_ACCESS_KEY }} #notice: unique for each env
aws-region: ${{ env.AWS_REGION }}
# - name: Create ns [${{ env.MAINNET_COMMON_NAMESPACE }}]
# uses: tensor-hq/eksctl-helm-action@main
# with:
# eks_cluster: ${{ env.CLUSTER_NAME }}
# command: |-
# kubectl create namespace ${{ env.MAINNET_COMMON_NAMESPACE }} --dry-run=client -o yaml | kubectl apply -f -
# NOTICE: --- INDEXER ---
- name: Pull the holograph-indexer helm chart version x.x.x from ECR
shell: bash
env:
#
CHART_REPO: holo-indexer
CHART_VERSION: ${{ env.MAINNET_HOLO_INDEXER_HELM_CHART_VERSION }}
#
ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
run: |
helm pull oci://$ECR_REGISTRY/$CHART_REPO --version $CHART_VERSION
helm pull --untar oci://$ECR_REGISTRY/$CHART_REPO --version $CHART_VERSION
# NOTICE: ##### V1 deployments ######
- name: -> V1 -- Deploy INDEXER cli in MAINNET [namespace -> ${{ env.MAINNET_COMMON_NAMESPACE }}]
uses: tensor-hq/eksctl-helm-action@main
env:
RELEASE_NAME: ${{ env.INDEXER_RELEASE_NAME }} # notice
HOLOGRAPH_VERSION: "V1"
#
ENABLE_DEBUG: 'true'
HEALTHCHECK: 'true'
MODE: 'auto'
ENABLE_UNSAFE: 'true'
ENABLE_SYNC: 'true'
ENABLE_PROCESS_BLOCK_RANGE: 'true' # undefined/true
UPDATE_BLOCK_HEIGHT: 'api' # api/file/disable
#
ENABLE_PROCESS_BLOCK_RANGE_arbitrum: 'true' # undefined/true
ENABLE_PROCESS_BLOCK_RANGE_optimism: 'true'
ENABLE_PROCESS_BLOCK_RANGE_binance: 'true'
ENABLE_PROCESS_BLOCK_RANGE_mantle: 'true'
ENABLE_PROCESS_BLOCK_RANGE_zora: 'true'
ENABLE_PROCESS_BLOCK_RANGE_avalanche: 'true'
ENABLE_PROCESS_BLOCK_RANGE_ethereum: 'true'
ENABLE_PROCESS_BLOCK_RANGE_polygon: 'true'
ENABLE_PROCESS_BLOCK_RANGE_base: 'true'
#
AVALANCHE_NETWORK: 'avalanche'
POLYGON_NETWORK: 'polygon'
BINANCE_NETWORK: 'binanceSmartChain'
MANTLE_NETWORK: 'mantle'
ETHEREUM_NETWORK: '{ethereum}'
OPTIMISM_NETWORK: '{optimism}'
ARBITRUM_NETWORK: '{arbitrumOne}'
ZORA_NETWORK: '{zora}'
BASE_NETWORK: '{base}'
with:
eks_cluster: ${{ env.CLUSTER_NAME }}
command: |-
helm upgrade --install $RELEASE_NAME \
holo-indexer-${{ env.MAINNET_HOLO_INDEXER_HELM_CHART_VERSION }}.tgz \
-n ${{ env.MAINNET_COMMON_NAMESPACE }} \
\
--set image.repository=${{ env.ECR_REPOSITORY }} \
--set image.image_tag=${{ env.MAINNET_IMAGE_TAG }} \
--set config_file_data=${{ env.INDEXER_HOLO_CONFIG_FILE_DATA }} \
--set holo_indexer_password=${{ env.MAINNET_HOLO_INDEXER_PASSWORD }} \
--set HOLO_INDEXER_HOST=${{ env.MAINNET_HOLOGRAPH_INDEXER_HOST }} \
--set OPERATOR_API_KEY=${{ env.MAINNET_HOLO_INDEXER_OPERATOR_API_KEY }} \
--set HOLOGRAPH_ENVIRONMENT=${{ env.HOLOGRAPH_ENVIRONMENT }} \
--set HOLOGRAPH_VERSION=${{ env.HOLOGRAPH_VERSION }} \
--set BLOCK_PROCESSING_VERSION=${{ env.BLOCK_PROCESSING_VERSION }} \
\
--set ENABLE_DEBUG=$ENABLE_DEBUG \
--set ENABLE_SYNC=$ENABLE_SYNC \
--set HEALTHCHECK=$HEALTHCHECK \
--set MODE=$MODE \
\
--set AVALANCHE_NETWORK="${AVALANCHE_NETWORK}" \
--set POLYGON_NETWORK="${POLYGON_NETWORK}" \
--set BINANCE_NETWORK="${BINANCE_NETWORK}" \
--set MANTLE_NETWORK="${MANTLE_NETWORK}" \
--set ETHEREUM_NETWORK="${ETHEREUM_NETWORK}" \
--set OPTIMISM_NETWORK="${OPTIMISM_NETWORK}" \
--set ARBITRUM_NETWORK="${ARBITRUM_NETWORK}" \
--set ZORA_NETWORK="${ZORA_NETWORK}" \
--set BASE_NETWORK="${BASE_NETWORK}" \
\
--set ENABLE_UNSAFE="${ENABLE_UNSAFE}" \
--set UPDATE_BLOCK_HEIGHT=$UPDATE_BLOCK_HEIGHT \
\
--set ENABLE_PROCESS_BLOCK_RANGE.arbitrum=$ENABLE_PROCESS_BLOCK_RANGE_arbitrum \
--set ENABLE_PROCESS_BLOCK_RANGE.binance=$ENABLE_PROCESS_BLOCK_RANGE_binance \
--set ENABLE_PROCESS_BLOCK_RANGE.avalanche=$ENABLE_PROCESS_BLOCK_RANGE_avalanche \
--set ENABLE_PROCESS_BLOCK_RANGE.optimism=$ENABLE_PROCESS_BLOCK_RANGE_optimism \
--set ENABLE_PROCESS_BLOCK_RANGE.ethereum=$ENABLE_PROCESS_BLOCK_RANGE_ethereum \
--set ENABLE_PROCESS_BLOCK_RANGE.polygon=$ENABLE_PROCESS_BLOCK_RANGE_polygon \
--set ENABLE_PROCESS_BLOCK_RANGE.mantle=$ENABLE_PROCESS_BLOCK_RANGE_mantle \
--set ENABLE_PROCESS_BLOCK_RANGE.zora=$ENABLE_PROCESS_BLOCK_RANGE_zora \
--set ENABLE_PROCESS_BLOCK_RANGE.base=$ENABLE_PROCESS_BLOCK_RANGE_base \
\
--set mainnet_rpc_config_values.avalanche_rpc_url=${{ env.indexer_mainnet_avalanche_rpc_url }} \
--set mainnet_rpc_config_values.polygon_rpc_url=${{ env.indexer_mainnet_polygon_rpc_url }} \
--set mainnet_rpc_config_values.ethereum_rpc_url=${{ env.indexer_mainnet_ethereum_rpc_url }} \
--set mainnet_rpc_config_values.optimism_rpc_url=${{ env.indexer_mainnet_optimism_rpc_url }} \
--set mainnet_rpc_config_values.arbitrum_rpc_url=${{ env.indexer_mainnet_arbitrum_rpc_url }} \
--set mainnet_rpc_config_values.binance_rpc_url=${{ env.indexer_mainnet_binance_rpc_url }} \
--set mainnet_rpc_config_values.mantle_rpc_url=${{ env.indexer_mainnet_mantle_rpc_url }} \
--set mainnet_rpc_config_values.zora_rpc_url=${{ env.indexer_mainnet_zora_rpc_url }} \
--set mainnet_rpc_config_values.base_rpc_url=${{ env.indexer_mainnet_base_rpc_url }} \
\
--set mainnet_rpc_config_values.private_key=${{ env.indexer_mainnet_private_key }} \
--set mainnet_rpc_config_values.address=${{ env.indexer_mainnet_address }} \
--set mainnet_rpc_config_values.version="beta3" \
\
--set datadog_tags.env=${{ env.CLUSTER_NAME }} \
--set datadog_tags.service=$RELEASE_NAME \
--set datadog_tags.version=$RELEASE_NAME-${{ env.MAINNET_HOLO_INDEXER_HELM_CHART_VERSION }} \
\
--set autoscaling.enabled=false \
--set replicaCountAvalanche=0 \
--set replicaCountPolygon=0 \
--set replicaCountBinance=0 \
--set replicaCountMantle=0 \
--set replicaCountEthereum=0 \
--set replicaCountArbitrum=0 \
--set replicaCountOptimism=0 \
--set replicaCountBase=0 \
--set replicaCountZora=0 \
\
--set resources.ethereum.limits.memory=2048Mi \
--set resources.ethereum.requests.cpu=950m \
--set resources.ethereum.requests.memory=2000Mi \
\
--set resources.optimism.limits.memory=2048Mi \
--set resources.optimism.requests.cpu=950m \
--set resources.optimism.requests.memory=2000Mi \
\
--set resources.arbitrum.limits.memory=2048Mi \
--set resources.arbitrum.requests.cpu=950m \
--set resources.arbitrum.requests.memory=2000Mi \
\
--set resources.polygon.limits.memory=2048Mi \
--set resources.polygon.requests.cpu=950m \
--set resources.polygon.requests.memory=2000Mi \
\
--set resources.avalanche.limits.memory=2048Mi \
--set resources.avalanche.requests.cpu=950m \
--set resources.avalanche.requests.memory=2000Mi \
\
--set resources.binance.limits.memory=2048Mi \
--set resources.binance.requests.cpu=950m \
--set resources.binance.requests.memory=2000Mi \
\
--set resources.mantle.limits.memory=2048Mi \
--set resources.mantle.requests.cpu=950m \
--set resources.mantle.requests.memory=2000Mi \
\
--set resources.zora.limits.memory=2048Mi \
--set resources.zora.requests.cpu=950m \
--set resources.zora.requests.memory=2000Mi \
\
--set resources.base.limits.memory=2048Mi \
--set resources.base.requests.cpu=950m \
--set resources.base.requests.memory=2000Mi \
\
--set sqs.SQS_USER_AWS_ACCESS_KEY_ID=${{ env.SQS_USER_AWS_ACCESS_KEY_ID }} \
--set sqs.SQS_USER_AWS_SECRET_ACCESS_KEY=${{ env.SQS_USER_AWS_SECRET_ACCESS_KEY }} \
--set sqs.SQS_ENDPOINT=${{ env.MAINNET_SQS_ENDPOINT }} \
--set sqs.SQS_QUEUE_URL=${{ env.MAINNET_SQS_QUEUE_URL }} \
--set sqs.AWS_REGION=us-west-2 \
\
--values ./holo-indexer/values-v1-mainnet-iv.yaml
# \
# --values .github/values_for_prod_alb_ingress.yaml \
# --set ingress.annotations."alb\.ingress\.kubernetes\.io/certificate-arn"='${{ env.ALB_CERT_ARN }}' \
# --set ingress.ingress_name=ing-$RELEASE_NAME-health \
# --set ingress.host=$RELEASE_NAME-health.${{ env.MAINNET_DOMAIN }} \
# --set ingress.target_svc_name=$RELEASE_NAME-holo-indexer \
# --set ingress.blue_green_deployment=false
# - name: Pause for 60 seconds
# shell: bash
# run: |
# sleep 60
# NOTICE: --- OPERATOR ---
- name: Pull the holograph-operator helm chart version x.x.x from ECR
shell: bash
env:
#
CHART_REPO: holo-operator
CHART_VERSION: ${{ env.MAINNET_HOLO_OPERATOR_HELM_CHART_VERSION }}
#
ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
run: |
helm pull oci://$ECR_REGISTRY/$CHART_REPO --version $CHART_VERSION
helm pull --untar oci://$ECR_REGISTRY/$CHART_REPO --version $CHART_VERSION
- name: -> V1 -- Deploy OPERATOR cli in MAINNET [namespace -> ${{ env.MAINNET_COMMON_NAMESPACE }}]
uses: tensor-hq/eksctl-helm-action@main
env:
RELEASE_NAME: ${{ env.OPERATOR_RELEASE_NAME }} # notice
HOLOGRAPH_VERSION: "V1"
#
ENABLE_DEBUG: 'true'
ENABLE_SYNC: 'true'
HEALTHCHECK: 'true'
MODE: 'auto'
ENABLE_UNSAFE: 'true'
ENABLE_PROCESS_BLOCK_RANGE: 'true' # undefined/true
UPDATE_BLOCK_HEIGHT: 'api' # api/file/disable
#
ENABLE_PROCESS_BLOCK_RANGE_arbitrum: 'true' # undefined/true
ENABLE_PROCESS_BLOCK_RANGE_optimism: 'true'
ENABLE_PROCESS_BLOCK_RANGE_binance: 'true'
ENABLE_PROCESS_BLOCK_RANGE_mantle: 'true'
ENABLE_PROCESS_BLOCK_RANGE_zora: 'true'
ENABLE_PROCESS_BLOCK_RANGE_avalanche: 'true'
ENABLE_PROCESS_BLOCK_RANGE_ethereum: 'true'
ENABLE_PROCESS_BLOCK_RANGE_polygon: 'true'
ENABLE_PROCESS_BLOCK_RANGE_base: 'true'
#
AVALANCHE_NETWORK: 'avax'
POLYGON_NETWORK: 'matic'
BINANCE_NETWORK: 'binanceSmartChain'
MANTLE_NETWORK: 'mantle'
ETHEREUM_NETWORK: '{eth}'
OPTIMISM_NETWORK: '{optimism}'
ARBITRUM_NETWORK: '{arbitrumOne}'
ZORA_NETWORK: '{zora}'
BASE_NETWORK: '{base}'
with:
eks_cluster: ${{ env.CLUSTER_NAME }}
command: |-
helm upgrade --install $RELEASE_NAME \
holo-operator-${{ env.MAINNET_HOLO_OPERATOR_HELM_CHART_VERSION }}.tgz \
-n ${{ env.MAINNET_COMMON_NAMESPACE }} \
\
--set image.repository=${{ env.ECR_REPOSITORY }} \
--set image.image_tag=${{ env.MAINNET_IMAGE_TAG }} \
--set config_file_data=${{ env.OPERATOR_HOLO_CONFIG_FILE_DATA }} \
--set holo_operator_password=${{ env.MAINNET_HOLO_OPERATOR_PASSWORD }} \
--set HOLO_OPERATOR_HOST=${{ env.MAINNET_HOLOGRAPH_OPERATOR_HOST }} \
--set OPERATOR_API_KEY=${{ env.MAINNET_HOLO_OPERATOR_OPERATOR_API_KEY }} \
--set HOLOGRAPH_ENVIRONMENT=${{ env.HOLOGRAPH_ENVIRONMENT }} \
--set HOLOGRAPH_VERSION=${{ env.HOLOGRAPH_VERSION }} \
\
--set ENABLE_DEBUG=$ENABLE_DEBUG \
--set ENABLE_SYNC=$ENABLE_SYNC \
--set HEALTHCHECK=$HEALTHCHECK \
--set MODE=$MODE \
--set ENABLE_UNSAFE="${ENABLE_UNSAFE}" \
--set UPDATE_BLOCK_HEIGHT=$UPDATE_BLOCK_HEIGHT \
\
--set ENABLE_PROCESS_BLOCK_RANGE.arbitrum=$ENABLE_PROCESS_BLOCK_RANGE_arbitrum \
--set ENABLE_PROCESS_BLOCK_RANGE.binance=$ENABLE_PROCESS_BLOCK_RANGE_binance \
--set ENABLE_PROCESS_BLOCK_RANGE.avalanche=$ENABLE_PROCESS_BLOCK_RANGE_avalanche \
--set ENABLE_PROCESS_BLOCK_RANGE.optimism=$ENABLE_PROCESS_BLOCK_RANGE_optimism \
--set ENABLE_PROCESS_BLOCK_RANGE.ethereum=$ENABLE_PROCESS_BLOCK_RANGE_ethereum \
--set ENABLE_PROCESS_BLOCK_RANGE.polygon=$ENABLE_PROCESS_BLOCK_RANGE_polygon \
--set ENABLE_PROCESS_BLOCK_RANGE.mantle=$ENABLE_PROCESS_BLOCK_RANGE_mantle \
--set ENABLE_PROCESS_BLOCK_RANGE.zora=$ENABLE_PROCESS_BLOCK_RANGE_zora \
--set ENABLE_PROCESS_BLOCK_RANGE.base=$ENABLE_PROCESS_BLOCK_RANGE_base \
\
--set AVALANCHE_NETWORK="${AVALANCHE_NETWORK}" \
--set POLYGON_NETWORK="${POLYGON_NETWORK}" \
--set BINANCE_NETWORK="${BINANCE_NETWORK}" \
--set MANTLE_NETWORK="${MANTLE_NETWORK}" \
--set ETHEREUM_NETWORK="${ETHEREUM_NETWORK}" \
--set OPTIMISM_NETWORK="${OPTIMISM_NETWORK}" \
--set ARBITRUM_NETWORK="${ARBITRUM_NETWORK}" \
--set ZORA_NETWORK="${ZORA_NETWORK}" \
--set BASE_NETWORK="${BASE_NETWORK}" \
\
--set mainnet_rpc_config_values.avalanche_rpc_url=${{ env.operator_mainnet_avalanche_rpc_url }} \
--set mainnet_rpc_config_values.polygon_rpc_url=${{ env.operator_mainnet_polygon_rpc_url }} \
--set mainnet_rpc_config_values.binance_rpc_url=${{ env.operator_mainnet_binance_rpc_url }} \
--set mainnet_rpc_config_values.mantle_rpc_url=${{ env.operator_mainnet_mantle_rpc_url }} \
--set mainnet_rpc_config_values.ethereum_rpc_url=${{ env.operator_mainnet_ethereum_rpc_url }} \
--set mainnet_rpc_config_values.optimism_rpc_url=${{ env.operator_mainnet_optimism_rpc_url }} \
--set mainnet_rpc_config_values.arbitrum_rpc_url=${{ env.operator_mainnet_arbitrum_rpc_url }} \
--set mainnet_rpc_config_values.zora_rpc_url=${{ env.operator_mainnet_zora_rpc_url }} \
--set mainnet_rpc_config_values.base_rpc_url=${{ env.operator_mainnet_base_rpc_url }} \
\
--set mainnet_rpc_config_values.private_key=${{ env.operator_mainnet_private_key }} \
--set mainnet_rpc_config_values.address=${{ env.operator_mainnet_address }} \
\
--set autoscaling.enabled=false \
--set replicaCountAvalanche=0 \
--set replicaCountPolygon=0 \
--set replicaCountBinance=0 \
--set replicaCountMantle=0 \
--set replicaCountEthereum=0 \
--set replicaCountArbitrum=0 \
--set replicaCountOptimism=0 \
--set replicaCountBase=0 \
--set replicaCountZora=0 \
\
--set resources.ethereum.limits.memory=1024Mi \
--set resources.ethereum.requests.cpu=300m \
--set resources.ethereum.requests.memory=1000Mi \
\
--set resources.optimism.limits.memory=550Mi \
--set resources.optimism.requests.cpu=200m \
--set resources.optimism.requests.memory=500Mi \
\
--set resources.arbitrum.limits.memory=550Mi \
--set resources.arbitrum.requests.cpu=200m \
--set resources.arbitrum.requests.memory=500Mi \
\
--set resources.polygon.limits.memory=550Mi \
--set resources.polygon.requests.cpu=200m \
--set resources.polygon.requests.memory=500Mi \
\
--set resources.avalanche.limits.memory=550Mi \
--set resources.avalanche.requests.cpu=200m \
--set resources.avalanche.requests.memory=500Mi \
\
--set resources.binance.limits.memory=820Mi \
--set resources.binance.requests.cpu=300m \
--set resources.binance.requests.memory=800Mi \
\
--set resources.mantle.limits.memory=820Mi \
--set resources.mantle.requests.cpu=300m \
--set resources.mantle.requests.memory=800Mi \
\
--set resources.zora.limits.memory=820Mi \
--set resources.zora.requests.cpu=300m \
--set resources.zora.requests.memory=800Mi \
\
--set resources.base.limits.memory=820Mi \
--set resources.base.requests.cpu=300m \
--set resources.base.requests.memory=800Mi \
\
--set datadog_tags.env=${{ env.CLUSTER_NAME }} \
--set datadog_tags.service=$RELEASE_NAME \
--set datadog_tags.version=$RELEASE_NAME-${{ env.MAINNET_HOLO_OPERATOR_HELM_CHART_VERSION }} \
\
--values ./holo-operator/values-v1-mainnet-iv.yaml
# --values .github/values_for_prod_alb_ingress.yaml \
# --set ingress.annotations."alb\.ingress\.kubernetes\.io/certificate-arn"='${{ env.ALB_CERT_ARN }}' \
# --set ingress.ingress_name=ing-$RELEASE_NAME-health \
# --set ingress.host=$RELEASE_NAME-health.${{ env.MAINNET_DOMAIN }} \
# --set ingress.target_svc_name=$RELEASE_NAME-holo-operator \
# --set ingress.blue_green_deployment=false
# - name: -> Info for the new deployments
# uses: tensor-hq/eksctl-helm-action@main
# env:
# INDEXER_RELEASE_NAME: ${{ env.INDEXER_RELEASE_NAME }}
# OPERATOR_RELEASE_NAME: ${{ env.OPERATOR_RELEASE_NAME }}
# LB_URL: 'https://prod0-alb-1736382478.us-west-2.elb.amazonaws.com'
# with:
# eks_cluster: ${{ env.CLUSTER_NAME }}
# command: |-
# echo "------------------------- Last n Helm releases -------------------------"
# echo "--INDEXER--"
# helm history $INDEXER_RELEASE_NAME -n ${{ env.MAINNET_COMMON_NAMESPACE }} --max 3
# echo "--OPERATOR--"
# helm history $OPERATOR_RELEASE_NAME -n ${{ env.MAINNET_COMMON_NAMESPACE }} --max 3
#
# echo "------------------------ Newly deployed image [same for all clis] ------------------------ "
# echo "$MAINNET_IMAGE_TAG"
##
## echo "------------------------ Healthchecks ------------------------"
## sleep 55
##
## ENDPOINT=$INDEXER_RELEASE_NAME-health.${{ env.MAINNET_DOMAIN }}
## echo "curl -k -H \"Host: $ENDPOINT\" $LB_URL/healthcheck"
## curl -k -H "Host: $ENDPOINT" $LB_URL/healthcheck | jq '.status'
##
## ENDPOINT=$OPERATOR_RELEASE_NAME-health.${{ env.MAINNET_DOMAIN }}
## echo "curl -k -H \"Host: $ENDPOINT\" $LB_URL/healthcheck"
## curl -k -H "Host: $ENDPOINT" $LB_URL/healthcheck | jq '.status'
# NOTICE: ##### V2 deployments ######
- name: -> V2 -- Deploy INDEXER cli in MAINNET [namespace -> ${{ env.MAINNET_COMMON_NAMESPACE_V2 }}]
uses: tensor-hq/eksctl-helm-action@main
env:
RELEASE_NAME: ${{ env.INDEXER_RELEASE_NAME_V2 }} # notice
HOLOGRAPH_VERSION: "V2"
#
ENABLE_DEBUG: 'true'
HEALTHCHECK: 'true'
MODE: 'auto'
ENABLE_UNSAFE: 'true'
ENABLE_SYNC: 'true'
ENABLE_PROCESS_BLOCK_RANGE: 'true' # undefined/true
UPDATE_BLOCK_HEIGHT: 'api' # api/file/disable
#
ENABLE_PROCESS_BLOCK_RANGE_arbitrum: 'true' # undefined/true
ENABLE_PROCESS_BLOCK_RANGE_optimism: 'true'
ENABLE_PROCESS_BLOCK_RANGE_binance: 'true'
ENABLE_PROCESS_BLOCK_RANGE_mantle: 'true'
ENABLE_PROCESS_BLOCK_RANGE_zora: 'true'
ENABLE_PROCESS_BLOCK_RANGE_avalanche: 'true'
ENABLE_PROCESS_BLOCK_RANGE_ethereum: 'true'
ENABLE_PROCESS_BLOCK_RANGE_polygon: 'true'
ENABLE_PROCESS_BLOCK_RANGE_base: 'true'
#
AVALANCHE_NETWORK: 'avalanche'
POLYGON_NETWORK: 'polygon'
BINANCE_NETWORK: 'binanceSmartChain'
MANTLE_NETWORK: 'mantle'
ETHEREUM_NETWORK: '{ethereum}'
OPTIMISM_NETWORK: '{optimism}'
ARBITRUM_NETWORK: '{arbitrumOne}'
ZORA_NETWORK: '{zora}'
BASE_NETWORK: '{base}'
with:
eks_cluster: ${{ env.CLUSTER_NAME }}
command: |-
helm upgrade --install $RELEASE_NAME \
holo-indexer-${{ env.MAINNET_HOLO_INDEXER_HELM_CHART_VERSION }}.tgz \
-n ${{ env.MAINNET_COMMON_NAMESPACE_V2 }} \
\
--set image.repository=${{ env.ECR_REPOSITORY }} \
--set image.image_tag=${{ env.MAINNET_IMAGE_TAG }} \
--set config_file_data=${{ env.INDEXER_HOLO_CONFIG_FILE_DATA }} \
--set holo_indexer_password=${{ env.MAINNET_HOLO_INDEXER_PASSWORD }} \
--set HOLO_INDEXER_HOST=${{ env.MAINNET_HOLOGRAPH_INDEXER_HOST }} \
--set OPERATOR_API_KEY=${{ env.MAINNET_HOLO_INDEXER_OPERATOR_API_KEY }} \
--set HOLOGRAPH_ENVIRONMENT=${{ env.HOLOGRAPH_ENVIRONMENT }} \
--set HOLOGRAPH_ADDRESS=${{ env.HOLOGRAPH_ADDRESS }} \
--set HOLOGRAPH_VERSION=${{ env.HOLOGRAPH_VERSION }} \
--set BLOCK_PROCESSING_VERSION=${{ env.BLOCK_PROCESSING_VERSION }} \
\
--set ENABLE_DEBUG=$ENABLE_DEBUG \
--set ENABLE_SYNC=$ENABLE_SYNC \
--set HEALTHCHECK=$HEALTHCHECK \
--set MODE=$MODE \
\
--set AVALANCHE_NETWORK="${AVALANCHE_NETWORK}" \
--set POLYGON_NETWORK="${POLYGON_NETWORK}" \
--set BINANCE_NETWORK="${BINANCE_NETWORK}" \
--set MANTLE_NETWORK="${MANTLE_NETWORK}" \
--set ETHEREUM_NETWORK="${ETHEREUM_NETWORK}" \
--set OPTIMISM_NETWORK="${OPTIMISM_NETWORK}" \
--set ARBITRUM_NETWORK="${ARBITRUM_NETWORK}" \
--set ZORA_NETWORK="${ZORA_NETWORK}" \
--set BASE_NETWORK="${BASE_NETWORK}" \
\
--set ENABLE_UNSAFE="${ENABLE_UNSAFE}" \
--set UPDATE_BLOCK_HEIGHT=$UPDATE_BLOCK_HEIGHT \
\
--set ENABLE_PROCESS_BLOCK_RANGE.arbitrum=$ENABLE_PROCESS_BLOCK_RANGE_arbitrum \
--set ENABLE_PROCESS_BLOCK_RANGE.binance=$ENABLE_PROCESS_BLOCK_RANGE_binance \
--set ENABLE_PROCESS_BLOCK_RANGE.avalanche=$ENABLE_PROCESS_BLOCK_RANGE_avalanche \
--set ENABLE_PROCESS_BLOCK_RANGE.optimism=$ENABLE_PROCESS_BLOCK_RANGE_optimism \
--set ENABLE_PROCESS_BLOCK_RANGE.ethereum=$ENABLE_PROCESS_BLOCK_RANGE_ethereum \
--set ENABLE_PROCESS_BLOCK_RANGE.polygon=$ENABLE_PROCESS_BLOCK_RANGE_polygon \
--set ENABLE_PROCESS_BLOCK_RANGE.mantle=$ENABLE_PROCESS_BLOCK_RANGE_mantle \
--set ENABLE_PROCESS_BLOCK_RANGE.zora=$ENABLE_PROCESS_BLOCK_RANGE_zora \
--set ENABLE_PROCESS_BLOCK_RANGE.base=$ENABLE_PROCESS_BLOCK_RANGE_base \
\
--set mainnet_rpc_config_values.avalanche_rpc_url=${{ env.indexer_mainnet_avalanche_rpc_url }} \
--set mainnet_rpc_config_values.polygon_rpc_url=${{ env.indexer_mainnet_polygon_rpc_url }} \
--set mainnet_rpc_config_values.ethereum_rpc_url=${{ env.indexer_mainnet_ethereum_rpc_url }} \
--set mainnet_rpc_config_values.optimism_rpc_url=${{ env.indexer_mainnet_optimism_rpc_url }} \
--set mainnet_rpc_config_values.arbitrum_rpc_url=${{ env.indexer_mainnet_arbitrum_rpc_url }} \
--set mainnet_rpc_config_values.binance_rpc_url=${{ env.indexer_mainnet_binance_rpc_url }} \
--set mainnet_rpc_config_values.mantle_rpc_url=${{ env.indexer_mainnet_mantle_rpc_url }} \
--set mainnet_rpc_config_values.zora_rpc_url=${{ env.indexer_mainnet_zora_rpc_url }} \
--set mainnet_rpc_config_values.base_rpc_url=${{ env.indexer_mainnet_base_rpc_url }} \
\
--set mainnet_rpc_config_values.private_key=${{ env.v2_indexer_mainnet_private_key }} \
--set mainnet_rpc_config_values.address=${{ env.v2_indexer_mainnet_address }} \
--set mainnet_rpc_config_values.version="beta3" \
\
--set datadog_tags.env=${{ env.CLUSTER_NAME }} \
--set datadog_tags.service=$RELEASE_NAME \
--set datadog_tags.version=$RELEASE_NAME-${{ env.MAINNET_HOLO_INDEXER_HELM_CHART_VERSION }} \
\
--set autoscaling.enabled=false \
--set replicaCountAvalanche=0 \
--set replicaCountPolygon=0 \
--set replicaCountBinance=0 \
--set replicaCountMantle=0 \
--set replicaCountEthereum=0 \
--set replicaCountArbitrum=0 \
--set replicaCountOptimism=0 \
--set replicaCountBase=0 \
--set replicaCountZora=0 \
\
--set resources.ethereum.limits.memory=2048Mi \
--set resources.ethereum.requests.cpu=950m \
--set resources.ethereum.requests.memory=2000Mi \
\
--set resources.optimism.limits.memory=2048Mi \
--set resources.optimism.requests.cpu=950m \
--set resources.optimism.requests.memory=2000Mi \
\
--set resources.arbitrum.limits.memory=2048Mi \
--set resources.arbitrum.requests.cpu=950m \
--set resources.arbitrum.requests.memory=2000Mi \
\
--set resources.polygon.limits.memory=2048Mi \
--set resources.polygon.requests.cpu=950m \
--set resources.polygon.requests.memory=2000Mi \
\
--set resources.avalanche.limits.memory=2048Mi \
--set resources.avalanche.requests.cpu=950m \
--set resources.avalanche.requests.memory=2000Mi \
\
--set resources.binance.limits.memory=2048Mi \
--set resources.binance.requests.cpu=950m \
--set resources.binance.requests.memory=2000Mi \
\
--set resources.mantle.limits.memory=2048Mi \
--set resources.mantle.requests.cpu=950m \
--set resources.mantle.requests.memory=2000Mi \
\
--set resources.zora.limits.memory=2048Mi \
--set resources.zora.requests.cpu=950m \
--set resources.zora.requests.memory=2000Mi \
\
--set resources.base.limits.memory=2048Mi \
--set resources.base.requests.cpu=950m \
--set resources.base.requests.memory=2000Mi \
\
--set sqs.SQS_USER_AWS_ACCESS_KEY_ID=${{ env.SQS_USER_AWS_ACCESS_KEY_ID }} \
--set sqs.SQS_USER_AWS_SECRET_ACCESS_KEY=${{ env.SQS_USER_AWS_SECRET_ACCESS_KEY }} \
--set sqs.SQS_ENDPOINT=${{ env.MAINNET_SQS_ENDPOINT }} \
--set sqs.SQS_QUEUE_URL=${{ env.MAINNET_SQS_QUEUE_URL_V2 }} \
--set sqs.AWS_REGION=us-west-2 \
\
--values ./holo-indexer/values-v2-mainnet-iv.yaml
# --values .github/values_for_prod_alb_ingress.yaml \
# --set ingress.annotations."alb\.ingress\.kubernetes\.io/certificate-arn"='${{ env.ALB_CERT_ARN }}' \
# --set ingress.ingress_name=ing-$RELEASE_NAME-health \
# --set ingress.host=$RELEASE_NAME-health.${{ env.MAINNET_DOMAIN }} \
# --set ingress.target_svc_name=$RELEASE_NAME-holo-indexer \
# --set ingress.blue_green_deployment=false
# - name: Pause for 60 seconds
# shell: bash
# run: |
# sleep 60
- name: -> V2 -- Deploy OPERATOR cli in MAINNET [namespace -> ${{ env.MAINNET_COMMON_NAMESPACE_V2 }}]
uses: tensor-hq/eksctl-helm-action@main
env:
RELEASE_NAME: ${{ env.OPERATOR_RELEASE_NAME_V2 }} # notice
HOLOGRAPH_VERSION: "V2"
#
ENABLE_DEBUG: 'true'
ENABLE_SYNC: 'true'
HEALTHCHECK: 'true'
MODE: 'auto'
ENABLE_UNSAFE: 'true'
ENABLE_PROCESS_BLOCK_RANGE: 'true' # undefined/true
UPDATE_BLOCK_HEIGHT: 'api' # api/file/disable
#
ENABLE_PROCESS_BLOCK_RANGE_arbitrum: 'true' # undefined/true
ENABLE_PROCESS_BLOCK_RANGE_optimism: 'true'
ENABLE_PROCESS_BLOCK_RANGE_binance: 'true'
ENABLE_PROCESS_BLOCK_RANGE_mantle: 'true'
ENABLE_PROCESS_BLOCK_RANGE_zora: 'true'
ENABLE_PROCESS_BLOCK_RANGE_avalanche: 'true'
ENABLE_PROCESS_BLOCK_RANGE_ethereum: 'true'
ENABLE_PROCESS_BLOCK_RANGE_polygon: 'true'
ENABLE_PROCESS_BLOCK_RANGE_base: 'true'
#
AVALANCHE_NETWORK: 'avax'
POLYGON_NETWORK: 'matic'
BINANCE_NETWORK: 'binanceSmartChain'
MANTLE_NETWORK: 'mantle'
ETHEREUM_NETWORK: '{eth}'
OPTIMISM_NETWORK: '{optimism}'
ARBITRUM_NETWORK: '{arbitrumOne}'
ZORA_NETWORK: '{zora}'
BASE_NETWORK: '{base}'
with:
eks_cluster: ${{ env.CLUSTER_NAME }}
command: |-
helm upgrade --install $RELEASE_NAME \
holo-operator-${{ env.MAINNET_HOLO_OPERATOR_HELM_CHART_VERSION }}.tgz \
-n ${{ env.MAINNET_COMMON_NAMESPACE_V2 }} \
\
--set image.repository=${{ env.ECR_REPOSITORY }} \
--set image.image_tag=${{ env.MAINNET_IMAGE_TAG }} \
--set config_file_data=${{ env.OPERATOR_HOLO_CONFIG_FILE_DATA }} \
--set holo_operator_password=${{ env.MAINNET_HOLO_OPERATOR_PASSWORD }} \
--set HOLO_OPERATOR_HOST=${{ env.MAINNET_HOLOGRAPH_OPERATOR_HOST }} \
--set OPERATOR_API_KEY=${{ env.MAINNET_HOLO_OPERATOR_OPERATOR_API_KEY }} \
--set HOLOGRAPH_ENVIRONMENT=${{ env.HOLOGRAPH_ENVIRONMENT }} \
--set HOLOGRAPH_ADDRESS=${{ env.HOLOGRAPH_ADDRESS }} \
--set HOLOGRAPH_VERSION=${{ env.HOLOGRAPH_VERSION }} \
\
--set ENABLE_DEBUG=$ENABLE_DEBUG \
--set ENABLE_SYNC=$ENABLE_SYNC \
--set HEALTHCHECK=$HEALTHCHECK \
--set MODE=$MODE \
--set ENABLE_UNSAFE="${ENABLE_UNSAFE}" \
--set UPDATE_BLOCK_HEIGHT=$UPDATE_BLOCK_HEIGHT \
\
--set ENABLE_PROCESS_BLOCK_RANGE.arbitrum=$ENABLE_PROCESS_BLOCK_RANGE_arbitrum \
--set ENABLE_PROCESS_BLOCK_RANGE.binance=$ENABLE_PROCESS_BLOCK_RANGE_binance \
--set ENABLE_PROCESS_BLOCK_RANGE.avalanche=$ENABLE_PROCESS_BLOCK_RANGE_avalanche \
--set ENABLE_PROCESS_BLOCK_RANGE.optimism=$ENABLE_PROCESS_BLOCK_RANGE_optimism \
--set ENABLE_PROCESS_BLOCK_RANGE.ethereum=$ENABLE_PROCESS_BLOCK_RANGE_ethereum \
--set ENABLE_PROCESS_BLOCK_RANGE.polygon=$ENABLE_PROCESS_BLOCK_RANGE_polygon \
--set ENABLE_PROCESS_BLOCK_RANGE.mantle=$ENABLE_PROCESS_BLOCK_RANGE_mantle \
--set ENABLE_PROCESS_BLOCK_RANGE.zora=$ENABLE_PROCESS_BLOCK_RANGE_zora \
--set ENABLE_PROCESS_BLOCK_RANGE.base=$ENABLE_PROCESS_BLOCK_RANGE_base \
\
--set AVALANCHE_NETWORK="${AVALANCHE_NETWORK}" \
--set POLYGON_NETWORK="${POLYGON_NETWORK}" \
--set BINANCE_NETWORK="${BINANCE_NETWORK}" \
--set MANTLE_NETWORK="${MANTLE_NETWORK}" \
--set ETHEREUM_NETWORK="${ETHEREUM_NETWORK}" \
--set OPTIMISM_NETWORK="${OPTIMISM_NETWORK}" \
--set ARBITRUM_NETWORK="${ARBITRUM_NETWORK}" \
--set ZORA_NETWORK="${ZORA_NETWORK}" \
--set BASE_NETWORK="${BASE_NETWORK}" \
\
--set mainnet_rpc_config_values.avalanche_rpc_url=${{ env.operator_mainnet_avalanche_rpc_url }} \
--set mainnet_rpc_config_values.polygon_rpc_url=${{ env.operator_mainnet_polygon_rpc_url }} \
--set mainnet_rpc_config_values.binance_rpc_url=${{ env.operator_mainnet_binance_rpc_url }} \
--set mainnet_rpc_config_values.mantle_rpc_url=${{ env.operator_mainnet_mantle_rpc_url }} \
--set mainnet_rpc_config_values.ethereum_rpc_url=${{ env.operator_mainnet_ethereum_rpc_url }} \
--set mainnet_rpc_config_values.optimism_rpc_url=${{ env.operator_mainnet_optimism_rpc_url }} \
--set mainnet_rpc_config_values.arbitrum_rpc_url=${{ env.operator_mainnet_arbitrum_rpc_url }} \
--set mainnet_rpc_config_values.zora_rpc_url=${{ env.operator_mainnet_zora_rpc_url }} \
--set mainnet_rpc_config_values.base_rpc_url=${{ env.operator_mainnet_base_rpc_url }} \
\
--set mainnet_rpc_config_values.private_key=${{ env.v2_operator_mainnet_private_key }} \
--set mainnet_rpc_config_values.address=${{ env.v2_operator_mainnet_address }} \
\
--set autoscaling.enabled=false \
--set replicaCountAvalanche=0 \
--set replicaCountPolygon=0 \
--set replicaCountBinance=0 \
--set replicaCountMantle=0 \
--set replicaCountEthereum=0 \
--set replicaCountArbitrum=0 \
--set replicaCountOptimism=0 \
--set replicaCountBase=0 \
--set replicaCountZora=0 \
\
--set resources.ethereum.limits.memory=1024Mi \
--set resources.ethereum.requests.cpu=300m \
--set resources.ethereum.requests.memory=1000Mi \
\
--set resources.optimism.limits.memory=550Mi \
--set resources.optimism.requests.cpu=200m \
--set resources.optimism.requests.memory=500Mi \
\
--set resources.arbitrum.limits.memory=550Mi \
--set resources.arbitrum.requests.cpu=200m \
--set resources.arbitrum.requests.memory=500Mi \
\
--set resources.polygon.limits.memory=550Mi \
--set resources.polygon.requests.cpu=200m \
--set resources.polygon.requests.memory=500Mi \
\
--set resources.avalanche.limits.memory=550Mi \
--set resources.avalanche.requests.cpu=200m \
--set resources.avalanche.requests.memory=500Mi \
\
--set resources.binance.limits.memory=820Mi \
--set resources.binance.requests.cpu=300m \
--set resources.binance.requests.memory=800Mi \
\
--set resources.mantle.limits.memory=820Mi \
--set resources.mantle.requests.cpu=300m \
--set resources.mantle.requests.memory=800Mi \
\
--set resources.zora.limits.memory=820Mi \
--set resources.zora.requests.cpu=300m \
--set resources.zora.requests.memory=800Mi \
\
--set resources.base.limits.memory=820Mi \
--set resources.base.requests.cpu=300m \
--set resources.base.requests.memory=800Mi \
\
--set datadog_tags.env=${{ env.CLUSTER_NAME }} \
--set datadog_tags.service=$RELEASE_NAME \
--set datadog_tags.version=$RELEASE_NAME-${{ env.MAINNET_HOLO_OPERATOR_HELM_CHART_VERSION }} \
\
--values ./holo-operator/values-v2-mainnet-iv.yaml
# --values .github/values_for_prod_alb_ingress.yaml \
# --set ingress.annotations."alb\.ingress\.kubernetes\.io/certificate-arn"='${{ env.ALB_CERT_ARN }}' \
# --set ingress.ingress_name=ing-$RELEASE_NAME-health \
# --set ingress.host=$RELEASE_NAME-health.${{ env.MAINNET_DOMAIN }} \
# --set ingress.target_svc_name=$RELEASE_NAME-holo-operator \
# --set ingress.blue_green_deployment=false
# - name: -> V2 -- Info for the new V2 deployments
# uses: tensor-hq/eksctl-helm-action@main
# env:
# INDEXER_RELEASE_NAME: ${{ env.INDEXER_RELEASE_NAME_V2 }}
# OPERATOR_RELEASE_NAME: ${{ env.OPERATOR_RELEASE_NAME_V2 }}
# LB_URL: 'https://staging-alb-1490082055.us-west-2.elb.amazonaws.com'
# with:
# eks_cluster: ${{ env.CLUSTER_NAME }}
# command: |-
# echo "------------------------- Last n Helm releases -------------------------"
# echo "--V2 INDEXER--"
# helm history $INDEXER_RELEASE_NAME -n ${{ env.MAINNET_COMMON_NAMESPACE_V2 }} --max 3
# echo "--V2 OPERATOR--"
# helm history $OPERATOR_RELEASE_NAME -n ${{ env.MAINNET_COMMON_NAMESPACE_V2 }} --max 3
#
# echo "------------------------ Newly deployed image [same for all apps] ------------------------"
# echo "$MAINNET_IMAGE_TAG"
##
## echo "------------------------ Healthchecks ------------------------"
## sleep 55
##
## ENDPOINT=$INDEXER_RELEASE_NAME-health.${{ env.MAINNET_DOMAIN }}
## echo "curl -k -H \"Host: $ENDPOINT\" $LB_URL/healthcheck"
## curl -k -H "Host: $ENDPOINT" $LB_URL/healthcheck | jq '.status'
##
## ENDPOINT=$OPERATOR_RELEASE_NAME-health.${{ env.MAINNET_DOMAIN }}
## echo "curl -k -H \"Host: $ENDPOINT\" $LB_URL/healthcheck"
## curl -k -H "Host: $ENDPOINT" $LB_URL/healthcheck | jq '.status'