Write a multi chain bash script that will be used in all protocols

[andreivladbrg]

During my last Flow deployments, I wrote this bash script (inspired by @smol-ninja), which should be project-neutral, as it requires you to pass the script path.

To make the bash script work in the child protocols, we’d also need another TS/Python script that temporarily copies it to the root of the child protocol from which it’s being run.

bash script

Note: ran this and it worked smoothly (deployed to all chains)

./multi-deploy.sh \
 --target "scripts/solidity/DeployDeterministicProtocol.s.sol:DeployDeterministicProtocol" \
 --sender 0xb1bEF51ebCA01EB12001a639bDBbFF6eEcA12B9F \
 --chains "abstract,arbitrum,avalanche,base,berachain,blast,chiliz,core_dao,ethereum,gnosis,lightlink,mode,morph,optimism,polygon,scroll,sei,sonic,sophon,superseed,unichain,zksync" \
 --out "./deployment.ts" \
 --sdk-root "../sdk" \
 --profile optimized

Missing features & issues:

• Issues writing the correct block number to the deployments.ts file for some chains (for those that are using blockscout), because they return the receipt’s contractAddress as null.
  • We’d need to look up for "returns" (and also "libraries" in case of lockup) to map them correctly.
• Flag for broadcast or not.
• Testnet/mainnet chain separation, so I can write to the correct type in the deployments.ts file (currently aggregating to a common chain).
• Print at the end which chains failed the script (currently, if a Forge script CLI run fails, it’s ignored and only prints a warning, which gets buried in long logs).
• When the broadcast file is moved to sdk, use - instead of _ in case of some chain names (also sepolia -> testnet, where needed).
• Not all contract verification worked (which is normal)
  • for the blockscout ones, which i think we should split the command run into: 1. forge script 2. forge verify

#!/usr/bin/env bash
set -euo pipefail

# ------------------------------------------------------------------------------
# Multi-chain Foundry deploy + verify + SDK copy + docs deployment.ts generator
# ------------------------------------------------------------------------------

# Usage:
#   ./multi_deploy.sh \
#     --target "scripts/solidity/<ScriptName>.s.sol:ContractName" \
#     --sender 0xYourDeployerAddress \
#     [--chains "ethereum,base,arbitrum"] \
#     [--out ./deployment.ts] \
#     [--sdk-root ../sdk] \
#     [--profile optimized]
#
# Notes:
# - PRIVATE_KEY and ETHERSCAN_API_KEY must be exported in your env.
# - --chains defaults to ALL supported chains listed below.
# - --target must be the fully-qualified script (path + :ContractName).
# - Foundry must have RPC aliases in foundry.toml that match the chain names.
# - Requires: jq
# ------------------------------------------------------------------------------

# ---- Load .env (if present) --------------------------------------------------
# Exports every var in .env into the environment (so $PRIVATE_KEY, $ETHERSCAN_API_KEY, etc.)
if [[ -f .env ]]; then
  set -a            # auto-export all variables
  # shellcheck disable=SC1091
  source .env
  set +a
fi

# -------- Parse args -----------------------------------------------------------
TARGET=""
SENDER=""
CHAINS_CSV=""
OUT_FILE="./deployment.ts"
SDK_ROOT="../sdk"
FOUNDRY_PROFILE="optimized"

while [[ $# -gt 0 ]]; do
  case "$1" in
    --target) TARGET="$2"; shift 2 ;;
    --sender) SENDER="$2"; shift 2 ;;
    --chains) CHAINS_CSV="$2"; shift 2 ;;
    --out) OUT_FILE="$2"; shift 2 ;;
    --sdk-root) SDK_ROOT="$2"; shift 2 ;;
    --profile) FOUNDRY_PROFILE="$2"; shift 2 ;;
    -h|--help)
      sed -n '1,60p' "$0"; exit 0 ;;
    *) echo "Unknown arg: $1" >&2; exit 1 ;;
  esac
done

if [[ -z "${TARGET}" || -z "${SENDER}" ]]; then
  echo "ERROR: --target and --sender are required." >&2
  exit 1
fi

if [[ -z "${PRIVATE_KEY:-}" ]]; then
  echo "ERROR: PRIVATE_KEY env var must be set." >&2
  exit 1
fi

if ! command -v jq >/dev/null 2>&1; then
  echo "ERROR: jq is required." >&2
  exit 1
fi

# -------- Config from your prompt ---------------------------------------------

# Chain name -> chain id
declare -A CHAIN_IDS=(
  [abstract]=2741
  [arbitrum]=42161
  [avalanche]=43114
  [base]=8453
  [berachain]=80094
  [blast]=81457
  [bsc]=56
  [chiliz]=88888
  [core_dao]=1116
  [ethereum]=1
  [gnosis]=100
  [hyperevm]=999
  [lightlink]=1890
  [linea]=59144
  [mode]=34443
  [morph]=2818
  [optimism]=10
  [polygon]=137
  [scroll]=534352
  [sei]=1329
  [sonic]=146
  [sophon]=50104
  [superseed]=5330
  [unichain]=130
  [xdc]=50
  [zksync]=324
  [arbitrum_sepolia]=421614
  [base_sepolia]=84532
  [mode_sepolia]=919
  [optimism_sepolia]=11155420
  [sepolia]=11155111
)

# Etherscan-supported chains (set truthy)
declare -A IS_ETHERSCAN=(
  [abstract]=1
  [arbitrum]=1
  [base]=1
  [berachain]=1
  [blast]=1
  [bsc]=1
  [ethereum]=1
  [gnosis]=1
  [hyperevm]=1
  [linea]=1
  [optimism]=1
  [polygon]=1
  [scroll]=1
  [sonic]=1
  [unichain]=1
  [xdc]=1 # not worked
  [zksync]=1
  [arbitrum_sepolia]=1
  [base_sepolia]=1
  [optimism_sepolia]=1
  [sepolia]=1
)

# Blockscout chains → verifier URL
declare -A BLOCKSCOUT_URL=(
  [avalanche]="https://api.snowtrace.io/"
  [chiliz]="https://api.routescan.io/v2/network/mainnet/evm/88888/"
  [core_dao]="https://openapi.coredao.org/api/"
  [lightlink]="https://phoenix.lightlink.io/api/"
  [mode]="https://explorer.mode.network/api/"
  [morph]="https://explorer-api.morphl2.io/api/"
  [sei]="https://sei.explorer.zenscan.io/api/"
  [sophon]="https://explorer.sophon.xyz/api/"
  [superseed]="https://explorer.superseed.xyz/api/"
  [mode_sepolia]="https://sepolia.explorer.mode.network/api/"
)

# Chains requiring --legacy
declare -A NEEDS_LEGACY=(
  [abstract]=1
  [chiliz]=1
  [core_dao]=1
  [lightlink]=1
  [xdc]=1
)

# Chiliz special gas flags
CHILIZ_GAS_FLAGS=(--with-gas-price 10000000000000 --priority-gas-price 1000000000)

# --------- Chain selection -----------------------------------------------------
ALL_CHAINS=("${!CHAIN_IDS[@]}")
IFS=$'\n' ALL_CHAINS=($(sort <<<"${ALL_CHAINS[*]}")); unset IFS

if [[ -n "${CHAINS_CSV}" ]]; then
  IFS=',' read -r -a SELECTED_CHAINS <<< "${CHAINS_CSV}"
else
  SELECTED_CHAINS=("${ALL_CHAINS[@]}")
fi

# --------- Derive package.json info (protocol + version) ----------------------
if [[ ! -f package.json ]]; then
  echo "ERROR: package.json not found in current directory." >&2
  exit 1
fi

PKG_NAME="$(jq -r '.name' package.json)"
PKG_VERSION_FULL="$(jq -r '.version' package.json)"   # e.g. "2.0.0" or "2.1.3-beta.1"

# Extract protocol: last segment after '/' if scoped (@org/protocol), else the whole name
if [[ "${PKG_NAME}" == *@*/* ]]; then
  PROTOCOL="${PKG_NAME##*/}"
else
  PROTOCOL="${PKG_NAME#@}"
fi

# Compute major.minor from SemVer (drop pre-release/build metadata)
VERSION_CLEAN="${PKG_VERSION_FULL%%[-+]*}"           # "2.1.3-beta" -> "2.1.3"
IFS='.' read -r VMAJOR VMINOR _ <<< "${VERSION_CLEAN}"
: "${VMAJOR:=0}"                                     # default if missing
: "${VMINOR:=0}"
PKG_VERSION_MM="${VMAJOR}.${VMINOR}"                 # "2.0"

# Use v<major>.<minor> in the SDK path
SDK_DEPLOY_DIR="${SDK_ROOT}/deployments/${PROTOCOL}/v${PKG_VERSION_MM}/broadcasts"
mkdir -p "${SDK_DEPLOY_DIR}"

# --------- Helpers ------------------------------------------------------------

# CamelCase to UPPER_SNAKE_CASE (handles groups like ERC20Mock → ERC20_MOCK)
upper_snake() {
  local s="$1"
  # Insert underscores between boundaries: AAAa -> AAA_a ; aA -> a_A
  s="$(sed -E 's/([A-Z]+)([A-Z][a-z])/\1_\2/g;s/([a-z0-9])([A-Z])/\1_\2/g' <<<"$s")"
  tr '[:lower:]' '[:upper:]' <<<"$s"
}

# Get script SOL path without :Contract suffix for broadcast folder
SCRIPT_PATH="${TARGET%%:*}"         # scripts/solidity/Foo.s.sol
SCRIPT_BASENAME="$(basename "${SCRIPT_PATH}")"  # Foo.s.sol

# Accumulator for deployment.ts content
TS_CONTENT="export const chains: Sablier.Deployment[] = ["

# Track whether we added at least one chain into TS
ADDED_ANY=0

# --------- Deploy per-chain ---------------------------------------------------
for CHAIN in "${SELECTED_CHAINS[@]}"; do
  CHAIN_ID="${CHAIN_IDS[$CHAIN]:-}"
  if [[ -z "${CHAIN_ID}" ]]; then
    echo "Skipping unknown chain '${CHAIN}'." >&2
    continue
  fi

  echo "==> Deploying to '${CHAIN}' (chain id ${CHAIN_ID})"

  # Build forge script command
  CMD=(forge script "${TARGET}" \
     --rpc-url "${CHAIN}" --broadcast --sig "run()" \
     --sender "${SENDER}" --private-key "${PRIVATE_KEY}")

  # Verifier selection
  if [[ -n "${IS_ETHERSCAN[$CHAIN]:-}" ]]; then
    if [[ -z "${ETHERSCAN_API_KEY:-}" ]]; then
      echo "WARNING: ETHERSCAN_API_KEY not set; verification may fail on ${CHAIN}." >&2
    fi
    CMD+=(--verify --verifier etherscan --etherscan-api-key "${ETHERSCAN_API_KEY:-}")
  elif [[ -n "${BLOCKSCOUT_URL[$CHAIN]:-}" ]]; then
    # (Following your provided command shape; Blockscout path includes '/api/' suffix)
    CMD+=(--verifier blockscout --verifier-url "${BLOCKSCOUT_URL[$CHAIN]}" --etherscan-api-key "verifyContract")
  else
    echo "Note: No verifier configured for ${CHAIN}; proceeding without verification flags."
  fi

  # Legacy flag?
  if [[ -n "${NEEDS_LEGACY[$CHAIN]:-}" ]]; then
    CMD+=(--legacy)
  fi

  # Chiliz gas flags?
  if [[ "${CHAIN}" == "chiliz" ]]; then
    CMD+=("${CHILIZ_GAS_FLAGS[@]}")
  fi

  # --- run forge but DO NOT abort the whole script on failure ---
  set +e
  FOUNDRY_PROFILE="${FOUNDRY_PROFILE}" "${CMD[@]}"
  rc=$?
  set -e

  if (( rc != 0 )); then
    echo "WARN: forge script exited with code ${rc} on ${CHAIN}. Continuing anyway."
  fi

  # Locate broadcast JSON
  # Foundry layout: broadcast/<script_path>/<chain_id>/run-latest.json
  BROADCAST_JSON="broadcast/${SCRIPT_PATH}/${CHAIN_ID}/run-latest.json"
  if [[ ! -f "${BROADCAST_JSON}" ]]; then
    # Some setups store only the basename path
    BROADCAST_JSON="broadcast/${SCRIPT_BASENAME}/${CHAIN_ID}/run-latest.json"
  fi

  if [[ ! -f "${BROADCAST_JSON}" ]]; then
    echo "ERROR: Broadcast JSON not found for ${CHAIN} at ${BROADCAST_JSON}" >&2
    exit 1
  fi

  # Copy to SDK
  DEST_JSON="${SDK_DEPLOY_DIR}/${CHAIN}.json"
  mkdir -p "$(dirname "${DEST_JSON}")"
  cp "${BROADCAST_JSON}" "${DEST_JSON}"

  # -------- Parse broadcast to build per-chain manifest entries --------------
  # Build address->blockNumber map (hex -> dec)
  # We'll read receipts, then iterate transactions to produce entries.
  mapfile -t RECEIPT_PAIRS < <(jq -r '.receipts[] | select(.contractAddress != null) | "\(.contractAddress|ascii_downcase) \(.blockNumber)"' "${DEST_JSON}")

  declare -A ADDR_TO_BLOCK=()
  for pair in "${RECEIPT_PAIRS[@]}"; do
    addr="${pair%% *}"
    hexbn="${pair##* }"
    hexbn="${hexbn#0x}"
    # Default to 0 if empty
    if [[ -z "${hexbn}" ]]; then
      decbn=0
    else
      decbn=$((16#${hexbn}))
    fi
    ADDR_TO_BLOCK["$addr"]="${decbn}"
  done

  # Collect contractName + contractAddress from transactions
  mapfile -t TX_LINES < <(jq -r '.transactions[] | select(.contractAddress != null) | "\(.contractName) \(.contractAddress|ascii_downcase) \(.contractAddress)"' "${DEST_JSON}" 2>/dev/null || true)

  # If no transactions (e.g., script only triggered receipts), skip TS generation for this chain
  if [[ ${#TX_LINES[@]} -eq 0 ]]; then
    echo "Note: No transactions with contractAddress found for ${CHAIN}; skipping docs entry."
    continue
  fi

  # Start chain block in TS
  TS_CONTENT+=$'\n  get(chains.'"${CHAIN}"'.id, {'
  ADDED_ANY=1

  # For each deployed contract, add [manifest.NAME]: ["addr", block]
  for line in "${TX_LINES[@]}"; do
    cname="${line%% *}"
    rest="${line#* }"
    addr_lc="${rest%% *}"
    addr_orig="${rest##* }"
    block="${ADDR_TO_BLOCK[$addr_lc]:-0}"

    NAME_UPPER_SNAKE="$(upper_snake "${cname}")"

    TS_CONTENT+=$'\n    [manifest.'"${NAME_UPPER_SNAKE}"']: ["'"${addr_orig}"'", '"${block}"'],'
  done

  # End chain block
  TS_CONTENT+=$'\n  }),'
done

# Close TS array
TS_CONTENT+=$'\n];\n'

# Write deployment.ts
mkdir -p "$(dirname "${OUT_FILE}")"
printf '%s' "${TS_CONTENT}" > "${OUT_FILE}"

# Final summary
echo
echo "-----------------------------------------------------------------"
echo " Done."
echo " - Copied broadcasts → ${SDK_DEPLOY_DIR}"
echo " - Generated docs file → ${OUT_FILE}"
echo " - Protocol: ${PROTOCOL} ; Version: ${PKG_VERSION_MM}"
echo "-----------------------------------------------------------------"

@sablier-labs/evm wdyt? if you like the idea, it can be improved, and made more robust

Note about multichain deployer

Regarding this: https://github.com/sablier-labs/multichain-utils/

I wanted to keep using it, but the maintenance cost of updating it isn’t worth it. And Rust isn’t the friendliest language for this kind of tasks.
If we want to take a similar approach for the project, we could vibe code a small app to make it more approachable, but again, not sure if it’s worth the time.

[PaulRBerg]

You haven't shared the link to the script so I'm not sure what it does.

Potentially related - take a look at execa to see if it makes it possible to use only TypeScript for the script (and no Bash).

[andreivladbrg]

You haven't shared the link to the script so I'm not sure what it does.

press on the details block

Potentially related - take a look at execa to see if it makes it possible to use only TypeScript for the script (and no Bash).

sure, if its gonna be easier & shorter, that would be even better

[smol-ninja]

IMO maintaining any deployment script isn't worth the efforts it takes to maintain it (add new chains when they are supported, sometimes manual explorer verifications, sometimes we need to use --legacy etc.). So, until chains are Ethereum copy (such as optimism, etc.), we will always have to maintain it.

My preference would be to keep these scripts at the personal level. I have mine (which I used for Airdrops and Comptroller deployment, and will use in the future too), you have written yours which you will always use. There will not be a third person (not until next few releases) making bulk deployments like this. Also, in the AI-era, re-writing these scripts from the scratch takes less time than reading someone else's scripts and learning to use it.

For custom deployment, its always good to use the forge script directly following the docs.

We have already refactored it from bash to rust and now to bash/typescript again.

Therefore, I believe until we have more people in the team making these deployments, we should refrain from writing such a script.

[PaulRBerg]

Agree with Shub - I won't be making deployments myself, it's only the two of you now. Better to keep the scripts separate.

Or maaaaybe in the scripts repo, but just that.

[andreivladbrg]

alright - closing