304 lines
9.5 KiB
Bash
Executable File
304 lines
9.5 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
set -euo pipefail
|
|
|
|
ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
|
|
CONTRACTS_DIR="$ROOT/MEV_Bot/mev-platform/contracts"
|
|
CONFIG_PATH_DEFAULT="$ROOT/MEV_Bot/mev-platform/config.toml"
|
|
OUTPUT_DEFAULT="$ROOT/reports/status/mev_execution_deploy_$(date +%Y%m%d_%H%M%S).json"
|
|
|
|
RPC_URL="${RPC_URL:-}"
|
|
PRIVATE_KEY="${PRIVATE_KEY:-}"
|
|
FLASH_LOAN_PROVIDER="${FLASH_LOAN_PROVIDER:-}"
|
|
AAVE_POOL="${AAVE_POOL:-}"
|
|
TREASURY="${TREASURY:-}"
|
|
EXECUTOR_OWNER="${EXECUTOR_OWNER:-}"
|
|
PAUSE_ON_DEPLOY="${PAUSE_ON_DEPLOY:-1}"
|
|
CONFIG_PATH="${MEV_CONFIG_PATH:-$CONFIG_PATH_DEFAULT}"
|
|
OUTPUT_PATH="${MEV_EXECUTION_DEPLOY_OUTPUT:-$OUTPUT_DEFAULT}"
|
|
DRY_RUN=0
|
|
|
|
usage() {
|
|
cat <<'EOF'
|
|
Usage: deploy-mev-execution-contracts.sh [options]
|
|
|
|
Deploys the MEV ArbitrageExecutor and UniswapV2Adapter using the Foundry script
|
|
already present in the MEV contracts workspace, then captures the deployed
|
|
addresses into a JSON artifact and prints the exact config values that should be
|
|
updated afterward.
|
|
|
|
Required env or options:
|
|
RPC_URL Target chain RPC URL
|
|
PRIVATE_KEY Deployer private key
|
|
FLASH_LOAN_PROVIDER Non-zero generic provider address compatible with the executor
|
|
AAVE_POOL Aave V3 pool address; deploys the wrapper and uses it as provider
|
|
|
|
Optional env or options:
|
|
TREASURY Treasury address; defaults to deployer in Foundry script
|
|
EXECUTOR_OWNER Optional final owner; deploy initiates 2-step ownership transfer
|
|
PAUSE_ON_DEPLOY 1/true to pause immediately after deploy (default: 1)
|
|
MEV_CONFIG_PATH Config file to inspect for current values
|
|
MEV_EXECUTION_DEPLOY_OUTPUT Output JSON path
|
|
|
|
Options:
|
|
--rpc-url URL
|
|
--private-key KEY
|
|
--flash-loan-provider ADDRESS
|
|
--aave-pool ADDRESS
|
|
--treasury ADDRESS
|
|
--executor-owner ADDRESS
|
|
--pause-on-deploy BOOL
|
|
--config PATH
|
|
--output PATH
|
|
--dry-run
|
|
-h, --help
|
|
EOF
|
|
}
|
|
|
|
while [[ $# -gt 0 ]]; do
|
|
case "$1" in
|
|
--rpc-url)
|
|
RPC_URL="$2"
|
|
shift 2
|
|
;;
|
|
--private-key)
|
|
PRIVATE_KEY="$2"
|
|
shift 2
|
|
;;
|
|
--flash-loan-provider)
|
|
FLASH_LOAN_PROVIDER="$2"
|
|
shift 2
|
|
;;
|
|
--aave-pool)
|
|
AAVE_POOL="$2"
|
|
shift 2
|
|
;;
|
|
--treasury)
|
|
TREASURY="$2"
|
|
shift 2
|
|
;;
|
|
--executor-owner)
|
|
EXECUTOR_OWNER="$2"
|
|
shift 2
|
|
;;
|
|
--pause-on-deploy)
|
|
PAUSE_ON_DEPLOY="$2"
|
|
shift 2
|
|
;;
|
|
--config)
|
|
CONFIG_PATH="$2"
|
|
shift 2
|
|
;;
|
|
--output)
|
|
OUTPUT_PATH="$2"
|
|
shift 2
|
|
;;
|
|
--dry-run)
|
|
DRY_RUN=1
|
|
shift
|
|
;;
|
|
-h|--help)
|
|
usage
|
|
exit 0
|
|
;;
|
|
*)
|
|
echo "Unknown argument: $1" >&2
|
|
usage >&2
|
|
exit 2
|
|
;;
|
|
esac
|
|
done
|
|
|
|
require_cmd() {
|
|
command -v "$1" >/dev/null 2>&1 || {
|
|
echo "Required command missing: $1" >&2
|
|
exit 2
|
|
}
|
|
}
|
|
|
|
require_cmd forge
|
|
require_cmd jq
|
|
require_cmd python3
|
|
require_cmd cast
|
|
|
|
if [[ -z "$RPC_URL" ]]; then
|
|
echo "RPC_URL is required" >&2
|
|
exit 2
|
|
fi
|
|
|
|
if [[ -z "$PRIVATE_KEY" && "$DRY_RUN" -eq 0 ]]; then
|
|
echo "PRIVATE_KEY is required unless --dry-run is used" >&2
|
|
exit 2
|
|
fi
|
|
|
|
if [[ -z "$FLASH_LOAN_PROVIDER" && -z "$AAVE_POOL" ]]; then
|
|
echo "Either FLASH_LOAN_PROVIDER or AAVE_POOL is required" >&2
|
|
exit 2
|
|
fi
|
|
|
|
if [[ ! -d "$CONTRACTS_DIR" ]]; then
|
|
echo "Contracts directory not found: $CONTRACTS_DIR" >&2
|
|
exit 2
|
|
fi
|
|
|
|
mkdir -p "$(dirname "$OUTPUT_PATH")"
|
|
|
|
CHAIN_ID="$(cast chain-id --rpc-url "$RPC_URL")"
|
|
BROADCAST_PATH="$CONTRACTS_DIR/broadcast/Deploy.s.sol/$CHAIN_ID/run-latest.json"
|
|
DEPLOYER_ADDRESS=""
|
|
if [[ -n "$PRIVATE_KEY" ]]; then
|
|
DEPLOYER_ADDRESS="$(cast wallet address --private-key "$PRIVATE_KEY")"
|
|
fi
|
|
|
|
cat <<EOF
|
|
MEV execution contract deployment
|
|
contracts: $CONTRACTS_DIR
|
|
config target: $CONFIG_PATH
|
|
output artifact: $OUTPUT_PATH
|
|
chain id: $CHAIN_ID
|
|
flash loan provider: ${FLASH_LOAN_PROVIDER:-"(derived from AAVE_POOL wrapper if set)"}
|
|
aave pool: ${AAVE_POOL:-"(not used)"}
|
|
treasury: ${TREASURY:-"(defaults to deployer)"}
|
|
executor owner: ${EXECUTOR_OWNER:-"(deployer remains owner)"}
|
|
pause on deploy: $PAUSE_ON_DEPLOY
|
|
deployer address: ${DEPLOYER_ADDRESS:-"(not resolved in dry-run without private key)"}
|
|
mode: $( [[ "$DRY_RUN" -eq 1 ]] && echo "dry-run" || echo "broadcast" )
|
|
EOF
|
|
|
|
if [[ "$DRY_RUN" -eq 1 ]]; then
|
|
echo ""
|
|
echo "Planned forge command:"
|
|
printf 'cd %q && ' "$CONTRACTS_DIR"
|
|
if [[ -n "$AAVE_POOL" ]]; then
|
|
printf 'AAVE_POOL=%q ' "$AAVE_POOL"
|
|
else
|
|
printf 'FLASH_LOAN_PROVIDER=%q ' "$FLASH_LOAN_PROVIDER"
|
|
fi
|
|
if [[ -n "$TREASURY" ]]; then
|
|
printf 'TREASURY=%q ' "$TREASURY"
|
|
fi
|
|
if [[ -n "$EXECUTOR_OWNER" ]]; then
|
|
printf 'EXECUTOR_OWNER=%q ' "$EXECUTOR_OWNER"
|
|
fi
|
|
printf 'PAUSE_ON_DEPLOY=%q ' "$PAUSE_ON_DEPLOY"
|
|
printf 'forge script script/Deploy.s.sol --rpc-url %q --private-key %q --broadcast\n' "$RPC_URL" '${PRIVATE_KEY}'
|
|
exit 0
|
|
fi
|
|
|
|
(
|
|
cd "$CONTRACTS_DIR"
|
|
if [[ -n "$AAVE_POOL" ]]; then
|
|
export AAVE_POOL
|
|
else
|
|
export FLASH_LOAN_PROVIDER
|
|
fi
|
|
export PAUSE_ON_DEPLOY
|
|
if [[ -n "$TREASURY" ]]; then
|
|
export TREASURY
|
|
fi
|
|
if [[ -n "$EXECUTOR_OWNER" ]]; then
|
|
export EXECUTOR_OWNER
|
|
fi
|
|
forge script script/Deploy.s.sol --rpc-url "$RPC_URL" --private-key "$PRIVATE_KEY" --broadcast
|
|
)
|
|
|
|
if [[ ! -f "$BROADCAST_PATH" ]]; then
|
|
echo "Expected broadcast artifact not found: $BROADCAST_PATH" >&2
|
|
exit 1
|
|
fi
|
|
|
|
EXECUTOR_CONTRACT="$(jq -r '.transactions[] | select(.contractName=="ArbitrageExecutor") | .contractAddress' "$BROADCAST_PATH" | tail -1)"
|
|
UNISWAP_V2_ADAPTER="$(jq -r '.transactions[] | select(.contractName=="UniswapV2Adapter") | .contractAddress' "$BROADCAST_PATH" | tail -1)"
|
|
AAVE_WRAPPER="$(jq -r '.transactions[] | select(.contractName=="AaveV3FlashLoanProviderAdapter") | .contractAddress' "$BROADCAST_PATH" | tail -1)"
|
|
|
|
if [[ -z "$EXECUTOR_CONTRACT" || "$EXECUTOR_CONTRACT" == "null" || -z "$UNISWAP_V2_ADAPTER" || "$UNISWAP_V2_ADAPTER" == "null" ]]; then
|
|
echo "Could not extract deployed contract addresses from broadcast artifact" >&2
|
|
exit 1
|
|
fi
|
|
|
|
if [[ "$AAVE_WRAPPER" == "null" ]]; then
|
|
AAVE_WRAPPER=""
|
|
fi
|
|
|
|
if [[ -n "$AAVE_POOL" ]]; then
|
|
EFFECTIVE_PROVIDER="$AAVE_WRAPPER"
|
|
else
|
|
EFFECTIVE_PROVIDER="$FLASH_LOAN_PROVIDER"
|
|
fi
|
|
|
|
ONCHAIN_OWNER="$(cast call "$EXECUTOR_CONTRACT" "owner()(address)" --rpc-url "$RPC_URL" 2>/dev/null || true)"
|
|
ONCHAIN_PENDING_OWNER="$(cast call "$EXECUTOR_CONTRACT" "pendingOwner()(address)" --rpc-url "$RPC_URL" 2>/dev/null || true)"
|
|
ONCHAIN_PAUSED="$(cast call "$EXECUTOR_CONTRACT" "paused()(bool)" --rpc-url "$RPC_URL" 2>/dev/null || true)"
|
|
ONCHAIN_PROVIDER="$(cast call "$EXECUTOR_CONTRACT" "flashLoanProvider()(address)" --rpc-url "$RPC_URL" 2>/dev/null || true)"
|
|
ONCHAIN_TREASURY="$(cast call "$EXECUTOR_CONTRACT" "treasury()(address)" --rpc-url "$RPC_URL" 2>/dev/null || true)"
|
|
|
|
python3 - "$OUTPUT_PATH" "$CONFIG_PATH" "$BROADCAST_PATH" "$CHAIN_ID" "$EXECUTOR_CONTRACT" "$UNISWAP_V2_ADAPTER" "$EFFECTIVE_PROVIDER" "$TREASURY" "$DEPLOYER_ADDRESS" "$EXECUTOR_OWNER" "$PAUSE_ON_DEPLOY" "$ONCHAIN_OWNER" "$ONCHAIN_PENDING_OWNER" "$ONCHAIN_PAUSED" "$ONCHAIN_PROVIDER" "$ONCHAIN_TREASURY" "$AAVE_POOL" "$AAVE_WRAPPER" <<'PY'
|
|
import json
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
output_path = Path(sys.argv[1])
|
|
config_path = Path(sys.argv[2])
|
|
broadcast_path = Path(sys.argv[3])
|
|
chain_id = int(sys.argv[4])
|
|
executor_contract = sys.argv[5]
|
|
uniswap_v2_adapter = sys.argv[6]
|
|
flash_loan_provider = sys.argv[7]
|
|
treasury = sys.argv[8] or None
|
|
deployer_address = sys.argv[9] or None
|
|
executor_owner = sys.argv[10] or None
|
|
pause_on_deploy = sys.argv[11]
|
|
onchain_owner = sys.argv[12] or None
|
|
onchain_pending_owner = sys.argv[13] or None
|
|
onchain_paused = sys.argv[14] or None
|
|
onchain_provider = sys.argv[15] or None
|
|
onchain_treasury = sys.argv[16] or None
|
|
aave_pool = sys.argv[17] or None
|
|
aave_wrapper = sys.argv[18] or None
|
|
|
|
artifact = {
|
|
"chain_id": chain_id,
|
|
"broadcast_artifact": str(broadcast_path),
|
|
"config_path": str(config_path),
|
|
"executor_contract": executor_contract,
|
|
"uniswap_v2_adapter": uniswap_v2_adapter,
|
|
"flash_loan_provider": flash_loan_provider,
|
|
"treasury": treasury,
|
|
"deployer_address": deployer_address,
|
|
"requested_executor_owner": executor_owner,
|
|
"pause_on_deploy": pause_on_deploy,
|
|
"aave_pool": aave_pool,
|
|
"aave_wrapper": aave_wrapper,
|
|
"onchain": {
|
|
"owner": onchain_owner,
|
|
"pending_owner": onchain_pending_owner,
|
|
"paused": onchain_paused,
|
|
"flash_loan_provider": onchain_provider,
|
|
"treasury": onchain_treasury,
|
|
},
|
|
}
|
|
output_path.write_text(json.dumps(artifact, indent=2) + "\n")
|
|
|
|
print("")
|
|
print("captured deployment artifact:")
|
|
print(output_path)
|
|
print("")
|
|
print(json.dumps(artifact, indent=2))
|
|
print("")
|
|
print("next config values:")
|
|
print(f'chains.{chain_id}.execution.executor_contract = "{executor_contract}"')
|
|
print(f'chains.{chain_id}.execution.flash_loan_provider = "{flash_loan_provider}"')
|
|
if aave_pool:
|
|
print(f'# Aave pool behind wrapper: {aave_pool}')
|
|
print("")
|
|
print("next operator checks:")
|
|
print(f"- verify code exists at {executor_contract}")
|
|
if aave_wrapper:
|
|
print(f"- verify code exists at provider wrapper {aave_wrapper}")
|
|
print(f"- verify owner(): {onchain_owner}")
|
|
if onchain_pending_owner and onchain_pending_owner.lower() != "0x0000000000000000000000000000000000000000":
|
|
print(f"- pendingOwner() is set to {onchain_pending_owner}; that address must call acceptOwnership()")
|
|
print(f"- verify paused(): {onchain_paused}")
|
|
print("- set router addresses for every V2-style dex used by execution")
|
|
print("- keep MEV_SUBMIT_DISABLED=1 until signer/config readiness is green")
|
|
PY
|