Files

defiQUG a1466e4005 Initial commit

2025-12-12 14:56:07 -08:00

24 KiB

Raw Blame History

Complete Next Steps Guide - Phase 2 & Smart Contract Deployment

Overview

This guide provides comprehensive next steps for completing the DeFi Oracle Meta Mainnet (ChainID 138) deployment, including Phase 2 infrastructure deployment and all smart contract deployments.

⚡ Full Parallel Mode: All operations run in parallel where possible for maximum speed (~3-4x faster)

🔧 .env Integration: All configuration uses .env file - single source of truth, no duplication

Quick Start (Full Parallel)

# 1. Ensure .env is configured
source .env

# 2. Deploy everything in parallel (fastest)
./scripts/deployment/deploy-phase2-and-contracts-parallel.sh

# Or step-by-step parallel:
./scripts/deployment/generate-phase2-tfvars.sh
cd terraform/phases/phase2 && terraform apply
./terraform/phases/phase2/scripts/start-services.sh all
source .env && ./scripts/deployment/deploy-contracts-parallel.sh
./scripts/deployment/verify-contracts-parallel.sh

Estimated Time: ~10-15 minutes (vs ~40 minutes sequential)

Phase 2 Deployment Completion - All regions parallel
Prerequisites for Contract Deployment - .env configuration
Smart Contract Deployment Sequence - Full parallel mode
Configuration & Integration - Automated via .env
Testing & Verification - Parallel verification
Production Readiness Checklist
Complete Parallel Deployment - Master script

Phase 2 Deployment Completion

Prerequisites: Load .env Configuration

Important: All configuration is managed through .env file. Ensure you have a .env file in the project root with required variables:

# Load .env if not already loaded
cd /home/intlc/projects/smom-dbis-138
source .env  # or: set -a && source .env && set +a

# Required variables (add to .env if missing):
# ENVIRONMENT=prod
# VM_ADMIN_USERNAME=besuadmin
# SSH_PRIVATE_KEY_PATH=/path/to/ssh/private/key

Step 1: Verify Phase 1 Completion

cd terraform/phases/phase1
terraform output phase1_us_regions
terraform output ssh_connection_strings

Expected Output: 5 regions (centralus, eastus, eastus2, westus, westus2) with VM information.

Step 2: Generate Phase 2 Configuration (Automated)

Use the helper script to generate terraform.tfvars from Phase 1 outputs and .env:

# This script reads .env and Phase 1 outputs, generates terraform.tfvars automatically
./scripts/deployment/generate-phase2-tfvars.sh

# Review generated file
cat terraform/phases/phase2/terraform.tfvars

Manual alternative (if script fails):

Ensure your .env has these variables, then create terraform/phases/phase2/terraform.tfvars manually:

environment = "${ENVIRONMENT:-prod}"
vm_admin_username = "${VM_ADMIN_USERNAME:-besuadmin}"
ssh_private_key_path = "${SSH_PRIVATE_KEY_PATH}"

# Phase 1 VM information - get from: terraform/phases/phase1/terraform output -json phase1_us_regions
phase1_vm_info = {
  # ... (paste output from Phase 1)
}

Step 3: Deploy Phase 2 Docker Compose Files (Parallel)

Terraform deploys to all 5 regions in parallel automatically:

cd terraform/phases/phase2
terraform init
terraform plan
terraform apply

# All regions deploy concurrently - no sequential steps needed

Step 4: Start Phase 2 Services (Full Parallel)

All regions start simultaneously - script handles parallelization automatically:

cd terraform/phases/phase2/scripts

# Start all regions in parallel (automatically parallelized)
./start-services.sh all

# Script automatically:
# - Starts all 5 regions simultaneously
# - Waits for all to complete
# - Reports success/failure for each region
# - Exits with error if any region fails

Step 5: Verify Phase 2 Deployment (Full Parallel)

All regions checked simultaneously with organized output:

cd terraform/phases/phase2/scripts

# Check all regions in parallel (automatically parallelized)
./status.sh all

# Script automatically:
# - Checks all 5 regions simultaneously
# - Collects output from each region
# - Displays results in order
# - Cleans up temporary files

Expected: All docker-compose services running (Besu, FireFly, Cacti, Chainlink, databases, monitoring) across all 5 regions.

Prerequisites for Contract Deployment

1. Environment Setup

Ensure .env file exists in project root (created/updated from Phase 2 setup):

# Load .env
cd /home/intlc/projects/smom-dbis-138
source .env

# Required variables in .env:
# RPC Configuration
RPC_URL=http://<besu-rpc-node>:8545
CHAIN_ID=138

# Deployer Configuration
PRIVATE_KEY=<your_deployer_private_key>
DEPLOYER_ADDRESS=<your_deployer_address>  # Optional: auto-calculated from PRIVATE_KEY

# CCIP Configuration (required for bridges)
CCIP_ROUTER=<ccip_router_address_or_leave_empty_to_deploy>
CCIP_FEE_TOKEN=<link_token_address_or_zero_address_for_native>  # Use 0x0000000000000000000000000000000000000000 for native

# Oracle Configuration
ORACLE_DESCRIPTION="ETH/USD Price Feed"
ORACLE_HEARTBEAT=60
ORACLE_DEVIATION_THRESHOLD=50

# Deployment Flags
DEPLOY_WETH9=true
DEPLOY_WETH10=true
DEPLOY_BRIDGES=true

# MultiSig Configuration (optional)
MULTISIG_OWNERS=<comma_separated_owner_addresses>  # e.g., "0x123...,0x456...,0x789..."

All deployment scripts automatically load .env - no need to manually export variables.

2. Fund Deployer Address

Ensure your deployer address has sufficient native tokens (ETH) for:

Contract deployment gas costs
CCIP fees (if using native token)
Initial contract setup transactions

Estimated Costs: ~0.1-0.5 ETH for complete deployment

3. Verify RPC Connection

# Test RPC endpoint
curl -X POST $RPC_URL \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

4. Compile Contracts

forge build
forge test  # Run tests before deployment

Smart Contract Deployment Sequence

Deployment Order (Critical - Must Follow This Sequence)

1. CCIP Router (if deploying custom)
2. LINK Token (if deploying, or use existing/zero address)
3. Multicall
4. CREATE2 Factory
5. WETH9
6. WETH10
7. CCIPWETH9Bridge
8. CCIPWETH10Bridge
9. Oracle Aggregator
10. Oracle Proxy
11. MultiSig (Governance)
12. CCIP Sender/Receiver (if needed)

Method 1: Parallel Automated Deployment (Recommended)

Use the parallel deployment script (faster than sequential):

cd /home/intlc/projects/smom-dbis-138
source .env  # Ensure .env is loaded

# Parallel deployment (deploys independent contracts simultaneously)
./scripts/deployment/deploy-contracts-parallel.sh

This script:

Phase 1: Deploys independent contracts in parallel (Multicall, WETH9, WETH10 simultaneously)
Phase 2: Deploys CCIP Router (if needed)
Phase 3: Deploys bridge contracts in parallel (CCIPWETH9Bridge, CCIPWETH10Bridge simultaneously)
Phase 4: Deploys Oracle and MultiSig in parallel (independent contracts)
Automatically updates .env with deployed addresses
Handles dependencies between contracts
Provides deployment summary

Performance: ~3-4x faster than sequential deployment (all independent operations run simultaneously).

Method 1b: Sequential Automated Deployment (Alternative)

If you prefer sequential deployment or encounter parallel execution issues:

cd /home/intlc/projects/smom-dbis-138
source .env  # Ensure .env is loaded

# Sequential deployment (safer, slower)
./scripts/deployment/deploy-contracts-ordered.sh

This script:

Deploys all contracts in correct order (one at a time)
Automatically updates .env with deployed addresses
Handles dependencies between contracts
Provides deployment summary

Method 2: Manual Step-by-Step Deployment

Step 1: Load Environment

cd /home/intlc/projects/smom-dbis-138
source .env  # Load all variables from .env

Step 2: Deploy Independent Contracts in Parallel

Deploy Multicall, WETH9, and WETH10 simultaneously (they have no dependencies):

# Parallel deployment of independent contracts
forge script script/DeployMulticall.s.sol:DeployMulticall \
  --rpc-url "$RPC_URL" \
  --broadcast \
  --private-key "$PRIVATE_KEY" \
  --verify &
MULTICALL_PID=$!

forge script script/DeployWETH.s.sol:DeployWETH \
  --rpc-url "$RPC_URL" \
  --broadcast \
  --private-key "$PRIVATE_KEY" \
  --verify &
WETH9_PID=$!

forge script script/DeployWETH10.s.sol:DeployWETH10 \
  --rpc-url "$RPC_URL" \
  --broadcast \
  --private-key "$PRIVATE_KEY" \
  --verify &
WETH10_PID=$!

# Wait for all to complete
wait $MULTICALL_PID
wait $WETH9_PID
wait $WETH10_PID

# Extract addresses and update .env (scripts handle this automatically)
source .env  # Reload to get new addresses

Step 3: Deploy CCIP Router (if needed)

# If deploying custom CCIP Router
if [ -z "$CCIP_ROUTER" ] || [ "$CCIP_ROUTER" = "0x0000000000000000000000000000000000000000" ]; then
    forge script script/DeployCCIPRouter.s.sol:DeployCCIPRouter \
      --sig "run(address,uint256,uint256)" \
      "${CCIP_FEE_TOKEN:-0x0000000000000000000000000000000000000000}" \
      "1000000000000000" \
      "1000000000" \
      --rpc-url "$RPC_URL" \
      --broadcast \
      --private-key "$PRIVATE_KEY" \
      --verify
    # Update .env with deployed address (use deploy script's auto-update feature)
fi

source .env  # Reload

Note: If using Chainlink's official CCIP Router, set CCIP_ROUTER in .env to the official address.

Step 4: Deploy CCIP Bridges in Parallel

Deploy both bridges simultaneously (they depend on CCIP_ROUTER and WETH addresses):

# Ensure dependencies are in .env
source .env

# Parallel bridge deployment
forge script script/DeployCCIPWETH9Bridge.s.sol:DeployCCIPWETH9Bridge \
  --rpc-url "$RPC_URL" \
  --broadcast \
  --private-key "$PRIVATE_KEY" \
  --verify &
BRIDGE9_PID=$!

forge script script/DeployCCIPWETH10Bridge.s.sol:DeployCCIPWETH10Bridge \
  --rpc-url "$RPC_URL" \
  --broadcast \
  --private-key "$PRIVATE_KEY" \
  --verify &
BRIDGE10_PID=$!

wait $BRIDGE9_PID
wait $BRIDGE10_PID

source .env  # Reload addresses

Step 5: Deploy Oracle and MultiSig in Parallel

Deploy Oracle and MultiSig simultaneously (they are independent):

source .env

# Deploy Oracle and MultiSig in parallel
forge script script/DeployOracle.s.sol:DeployOracle \
  --rpc-url "$RPC_URL" \
  --broadcast \
  --private-key "$PRIVATE_KEY" \
  --verify &
ORACLE_PID=$!

if [ -n "$MULTISIG_OWNERS" ]; then
    forge script script/DeployMultiSig.s.sol:DeployMultiSig \
      --rpc-url "$RPC_URL" \
      --broadcast \
      --private-key "$PRIVATE_KEY" \
      --verify &
    MULTISIG_PID=$!
    wait $ORACLE_PID $MULTISIG_PID
else
    echo "⚠️  MULTISIG_OWNERS not set in .env. Skipping MultiSig deployment."
    wait $ORACLE_PID
fi

source .env  # Reload addresses

Step 7: Deploy CCIP Sender/Receiver (if needed)

source .env

# If deploying custom CCIP endpoints
forge script script/DeployCCIPSender.s.sol:DeployCCIPSender \
  --rpc-url "$RPC_URL" \
  --broadcast \
  --private-key "$PRIVATE_KEY" \
  --verify

Note: All addresses are automatically saved to .env by the deployment scripts. Manual .env updates are only needed if using raw forge script commands.

Method 3: Individual Contract Scripts

For deploying single contracts (can run multiple in parallel manually):

# Load .env first
source .env

# WETH9 only
make deploy-weth
# or
./scripts/deployment/deploy-weth.sh

# WETH10 only
make deploy-weth10
# or
./scripts/deployment/deploy-weth10.sh

# Deploy multiple contracts in parallel manually:
make deploy-weth &
make deploy-weth10 &
wait

# All WETH contracts with CCIP bridges (uses parallel internally where possible)
make deploy-weth-ccip
# or
./scripts/deployment/deploy-weth-with-ccip.sh

# Individual bridges (can deploy in parallel)
make deploy-ccip-weth9-bridge &
make deploy-ccip-weth10-bridge &
wait

Configuration & Integration

1. Configure CCIP Bridges

After deploying bridges, configure them:

# Configure WETH9 Bridge
./scripts/deployment/configure-weth9-bridge.sh

# Configure WETH10 Bridge
./scripts/deployment/configure-weth10-bridge.sh

Configuration includes:

Setting trusted destination chains
Configuring fee tokens
Setting up cross-chain message routing
Whitelisting approved senders/receivers

2. Initialize Oracle

# Set up price feed
cast send $ORACLE_PROXY_ADDRESS \
  "submit(uint256)" \
  <price_in_wei> \
  --rpc-url $RPC_URL \
  --private-key $PRIVATE_KEY

# Example: Submit $2000 ETH/USD price (2000 * 10^8 = 200000000000)
cast send $ORACLE_PROXY_ADDRESS \
  "submit(uint256)" \
  200000000000 \
  --rpc-url $RPC_URL \
  --private-key $PRIVATE_KEY

3. Configure MultiSig

# Add owners
cast send $MULTISIG_ADDRESS \
  "addOwner(address)" \
  <owner_address> \
  --rpc-url $RPC_URL \
  --private-key $PRIVATE_KEY

# Set threshold (e.g., 2 of 3)
cast send $MULTISIG_ADDRESS \
  "changeThreshold(uint256)" \
  2 \
  --rpc-url $RPC_URL \
  --private-key $PRIVATE_KEY

4. Integrate with FireFly

Update FireFly configuration to use deployed contracts:

# FireFly configuration
smart_contracts:
  weth9: "<WETH9_ADDRESS>"
  weth10: "<WETH10_ADDRESS>"
  oracle: "<ORACLE_PROXY_ADDRESS>"
  multisig: "<MULTISIG_ADDRESS>"

5. Configure Chainlink CCIP

If using Chainlink CCIP nodes, configure them:

# Update Chainlink node configuration
# Point to deployed CCIP Router
# Configure fee tokens
# Set up destination chains

Testing & Verification

1. Verify Contract Deployments (Parallel)

Use parallel verification for faster results:

# Load .env first
source .env

# Verify all contracts in parallel (recommended - fastest)
./scripts/deployment/verify-contracts-parallel.sh

# Sequential verification (alternative)
./scripts/deployment/verify-on-chain-deployments.sh

# Check specific contracts (can run in parallel manually)
cast code "$WETH9_ADDRESS" --rpc-url "$RPC_URL" &
cast code "$WETH10_ADDRESS" --rpc-url "$RPC_URL" &
cast code "$CCIPWETH9BRIDGE_ADDRESS" --rpc-url "$RPC_URL" &
wait

2. Test WETH Contracts

# Test WETH9 deposit
cast send $WETH9_ADDRESS \
  "deposit()" \
  --value 1ether \
  --rpc-url $RPC_URL \
  --private-key $PRIVATE_KEY

# Test WETH9 withdrawal
cast send $WETH9_ADDRESS \
  "withdraw(uint256)" \
  1ether \
  --rpc-url $RPC_URL \
  --private-key $PRIVATE_KEY

3. Test CCIP Bridges

# Test cross-chain WETH9 transfer
# (Requires destination chain configuration)
cast send $CCIPWETH9BRIDGE_ADDRESS \
  "bridgeTokens(uint256,uint64,bytes)" \
  <amount> \
  <destination_chain_selector> \
  <recipient_address_bytes> \
  --rpc-url $RPC_URL \
  --private-key $PRIVATE_KEY \
  --value <ccip_fee>

4. Test Oracle

# Read latest price
cast call $ORACLE_PROXY_ADDRESS \
  "latestRoundData()" \
  --rpc-url $RPC_URL

# Submit price update
cast send $ORACLE_PROXY_ADDRESS \
  "submit(uint256)" \
  <price> \
  --rpc-url $RPC_URL \
  --private-key $PRIVATE_KEY

5. End-to-End Testing

# Run comprehensive tests
forge test --fork-url $RPC_URL -vvv

# Run integration tests
npm test  # If TypeScript/JavaScript tests exist

6. Monitor Contract Events

# Watch for deployment events
cast logs --from-block 0 \
  --address $WETH9_ADDRESS \
  --rpc-url $RPC_URL

# Watch CCIP bridge events
cast logs --from-block 0 \
  --address $CCIPWETH9BRIDGE_ADDRESS \
  --rpc-url $RPC_URL

Production Readiness Checklist

Infrastructure ✅

Phase 1 VMs deployed and accessible
Phase 2 docker-compose services running
All 5 regions operational (cus, eus, eus2, wus, wus2)
Network connectivity verified
Monitoring stack operational (Prometheus, Grafana, Loki)
Logging operational (Promtail shipping logs)

Smart Contracts ✅

All contracts deployed
Contract addresses saved to .env
Contract source code verified (if applicable)
CCIP Router configured
WETH9 & WETH10 deployed and tested
CCIP bridges deployed and configured
Oracle deployed and receiving price updates
MultiSig deployed and configured
All contract permissions set correctly

Integration ✅

FireFly configured with contract addresses
Cacti configured for cross-chain monitoring
Chainlink nodes configured (if applicable)
Cross-chain routes configured
Fee tokens configured

Security ✅

Private keys secured (use Key Vault)
MultiSig owners configured
Access control verified
Security audit completed (if applicable)
Emergency pause mechanisms tested

Monitoring & Observability ✅

Prometheus scraping metrics
Grafana dashboards configured
Alerts configured in Alertmanager
Logs centralized in Loki
Contract event monitoring set up

Documentation ✅

Contract addresses documented
Deployment process documented
Configuration documented
Operations runbooks created
API documentation updated

Testing ✅

Unit tests passing
Integration tests passing
End-to-end tests passing
Load testing completed
Security testing completed

Quick Reference Commands

Phase 2 Management

# Generate Phase 2 config from Phase 1 outputs and .env
./scripts/deployment/generate-phase2-tfvars.sh

# Deploy Phase 2 (all regions in parallel)
cd terraform/phases/phase2 && terraform apply

# Start services (all regions in parallel)
./terraform/phases/phase2/scripts/start-services.sh all

# Stop services (all regions in parallel)
./terraform/phases/phase2/scripts/stop-services.sh all

# Check status (all regions in parallel)
./terraform/phases/phase2/scripts/status.sh all

Contract Deployment

# Load .env first
source .env

# Parallel deployment (recommended - fastest)
./scripts/deployment/deploy-contracts-parallel.sh

# Sequential deployment (alternative)
./scripts/deployment/deploy-contracts-ordered.sh

# Individual contracts (can run multiple in parallel manually)
make deploy-weth &
make deploy-weth10 &
wait

make deploy-weth-ccip
./scripts/deployment/deploy-multicall.sh
./scripts/deployment/deploy-multisig.sh

Verification

# Load .env first
source .env

# Verify deployments in parallel (recommended - fastest)
./scripts/deployment/verify-contracts-parallel.sh

# Sequential verification (alternative)
./scripts/deployment/verify-on-chain-deployments.sh
./scripts/deployment/verify-deployment.sh

# Check contract code in parallel (uses .env RPC_URL)
cast code "$WETH9_ADDRESS" --rpc-url "$RPC_URL" &
cast code "$WETH10_ADDRESS" --rpc-url "$RPC_URL" &
cast code "$CCIPWETH9BRIDGE_ADDRESS" --rpc-url "$RPC_URL" &
wait

Testing

# Load .env first
source .env

# Run tests (uses .env RPC_URL)
forge test
forge test --fork-url "$RPC_URL"

# Integration tests
npm test

# Run tests in parallel (faster)
forge test --fork-url "$RPC_URL" -j $(nproc)

Troubleshooting

Environment Configuration

Problem: Variables not found / scripts fail with "not set" errors
Solution:

Ensure .env file exists in project root: ls -la .env
Load .env before running scripts: source .env
Check variables are set: grep PRIVATE_KEY .env
Use helper script to generate Phase 2 config: ./scripts/deployment/generate-phase2-tfvars.sh

Problem: Duplicate variable definitions
Solution:

All configuration should be in .env only - don't duplicate in scripts or command line
Remove hardcoded values from scripts
Use ${VAR:-default} syntax for optional variables
Scripts automatically load .env - don't manually export variables

Phase 2 Issues

Problem: Cannot SSH to VMs
Solution:

Verify VPN/ExpressRoute/Cloudflare Tunnel connectivity
Check NSG rules allow SSH from your IP
Verify SSH_PRIVATE_KEY_PATH in .env: grep SSH_PRIVATE_KEY_PATH .env
Regenerate terraform.tfvars: ./scripts/deployment/generate-phase2-tfvars.sh

Problem: Docker compose services not starting
Solution:

Check logs: docker compose logs on VM
Verify volumes exist: ls -la /opt/*
Check permissions: sudo chown -R besuadmin:besuadmin /opt/*
All regions deploy in parallel - check individual region: ./status.sh <region>

Contract Deployment Issues

Problem: Deployment fails with "insufficient funds"
Solution: Fund deployer address with native tokens

Problem: CCIP Router deployment fails
Solution:

Verify CCIP_FEE_TOKEN in .env: grep CCIP_FEE_TOKEN .env
Use zero address for native token: CCIP_FEE_TOKEN=0x0000000000000000000000000000000000000000
Check fee parameters (baseFee, dataFeePerByte) in deployment script
Reload .env: source .env

Problem: Bridge deployment fails
Solution:

Verify CCIP_ROUTER is set in .env: grep CCIP_ROUTER .env
Ensure WETH9_ADDRESS and WETH10_ADDRESS are in .env: grep WETH.*ADDRESS .env
Check CCIP_FEE_TOKEN configuration in .env
Deploy dependencies first (use parallel script which handles order automatically)

Problem: Parallel deployment failures
Solution:

Check individual contract deployments sequentially first
Verify .env has all required addresses before parallel bridge deployment
Use sequential script if parallel fails: ./scripts/deployment/deploy-contracts-ordered.sh

Support & Resources

Documentation: docs/ directory
Terraform Phase 1: terraform/phases/phase1/README.md
Terraform Phase 2: terraform/phases/phase2/README.md
Contract Documentation: contracts/README.md
Deployment Scripts: scripts/deployment/README.md
Environment Configuration: .env file (create from .env.example if exists)

Key Points: Using .env & Full Parallel Mode

Single Source of Truth: All configuration is in .env - no duplication
Automatic Loading: All scripts automatically source .env
Auto-Updates: Deployment scripts automatically update .env with deployed addresses
Full Parallel Execution: All independent operations run simultaneously:
- Phase 2: All 5 regions deploy/start/stop/check in parallel
- Contracts: Independent contracts deploy in parallel (Multicall, WETH9, WETH10, Oracle, MultiSig)
- Bridges: Both bridge contracts deploy in parallel
- Verification: All contracts verified in parallel
- Testing: Forge tests use parallel execution (-j $(nproc))
No Manual Exports: Don't manually export variables - scripts handle it
Performance: ~3-4x faster than sequential execution

Quick .env Checklist

# Required variables
grep -E "^(PRIVATE_KEY|RPC_URL|CHAIN_ID|SSH_PRIVATE_KEY_PATH)=" .env

# Optional but recommended
grep -E "^(CCIP_ROUTER|CCIP_FEE_TOKEN|MULTISIG_OWNERS|ENVIRONMENT|VM_ADMIN_USERNAME)=" .env

# Verify .env is valid
source .env && echo "✅ .env loaded successfully"

Complete Parallel Deployment (All-in-One)

Master Script: Deploy Phase 2 + Contracts in Parallel

For the fastest deployment, use the master parallel script:

cd /home/intlc/projects/smom-dbis-138
source .env  # Ensure .env is loaded

# Deploy Phase 2 and contracts in full parallel mode
./scripts/deployment/deploy-phase2-and-contracts-parallel.sh

This script:

Generates Phase 2 configuration from Phase 1 outputs and .env
Deploys Phase 2 docker-compose to all 5 regions in parallel
Starts Phase 2 services in parallel (all regions)
Deploys all contracts in parallel (independent contracts simultaneously)
Verifies both Phase 2 and contracts in parallel

Performance: Complete deployment in ~10-15 minutes (vs ~40 minutes sequential)

Individual Parallel Operations

If you prefer step-by-step control:

# 1. Generate Phase 2 config (reads .env + Phase 1)
./scripts/deployment/generate-phase2-tfvars.sh

# 2. Deploy Phase 2 (all regions parallel)
cd terraform/phases/phase2 && terraform apply

# 3. Start services (all regions parallel)
./terraform/phases/phase2/scripts/start-services.sh all

# 4. Deploy contracts (parallel where possible)
source .env && ./scripts/deployment/deploy-contracts-parallel.sh

# 5. Verify everything (parallel)
./terraform/phases/phase2/scripts/status.sh all &
source .env && ./scripts/deployment/verify-contracts-parallel.sh &
wait

Last Updated: $(date)
Status: Complete Deployment Guide with Full Parallel Execution & .env Integration

24 KiB Raw Blame History

Complete Next Steps Guide - Phase 2 & Smart Contract Deployment

Overview

Quick Start (Full Parallel)

Table of Contents

Phase 2 Deployment Completion

Prerequisites: Load .env Configuration

Step 1: Verify Phase 1 Completion

Step 2: Generate Phase 2 Configuration (Automated)

Step 3: Deploy Phase 2 Docker Compose Files (Parallel)

Step 4: Start Phase 2 Services (Full Parallel)

Step 5: Verify Phase 2 Deployment (Full Parallel)

Prerequisites for Contract Deployment

1. Environment Setup

2. Fund Deployer Address

3. Verify RPC Connection

4. Compile Contracts

Smart Contract Deployment Sequence

Deployment Order (Critical - Must Follow This Sequence)

Method 1: Parallel Automated Deployment (Recommended)

Method 1b: Sequential Automated Deployment (Alternative)

Method 2: Manual Step-by-Step Deployment

Step 1: Load Environment

Step 2: Deploy Independent Contracts in Parallel

Step 3: Deploy CCIP Router (if needed)

Step 4: Deploy CCIP Bridges in Parallel

Step 5: Deploy Oracle and MultiSig in Parallel

Step 7: Deploy CCIP Sender/Receiver (if needed)

Method 3: Individual Contract Scripts

Configuration & Integration

1. Configure CCIP Bridges

2. Initialize Oracle

3. Configure MultiSig

4. Integrate with FireFly

5. Configure Chainlink CCIP

Testing & Verification

1. Verify Contract Deployments (Parallel)

2. Test WETH Contracts

3. Test CCIP Bridges

4. Test Oracle

5. End-to-End Testing

6. Monitor Contract Events

Production Readiness Checklist

Infrastructure ✅

Smart Contracts ✅

Integration ✅

Security ✅

Monitoring & Observability ✅

Documentation ✅

Testing ✅

Quick Reference Commands

Phase 2 Management

Contract Deployment

Verification

Testing

Troubleshooting

Environment Configuration

Phase 2 Issues

Contract Deployment Issues

Support & Resources

Key Points: Using .env & Full Parallel Mode

Quick .env Checklist

Complete Parallel Deployment (All-in-One)

Master Script: Deploy Phase 2 + Contracts in Parallel

Individual Parallel Operations

24 KiB

Raw Blame History