skunk-net-e2e/bootstrap-solana-local.sh

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

ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
CAPITAL_STAKING_DIR="${CAPITAL_STAKING_DIR:-$(pwd)}"
CAPITAL_STAKING_REPO_REL="${CAPITAL_STAKING_REPO_REL:-$(realpath --relative-to "${ROOT_DIR}" "${CAPITAL_STAKING_DIR}")}"
ARTIFACTS_DIR="${ROOT_DIR}/.local/e2e"
ANCHOR_PROVIDER_URL="${ANCHOR_PROVIDER_URL:-http://solana-validator:8899}"
ANCHOR_WALLET="${ANCHOR_WALLET:-${CAPITAL_STAKING_DIR}/wallets/deploymentWallet/universalDeploymentWallet.json}"
WIRE_BATCH_SOL_RPC_URL="${WIRE_BATCH_SOL_RPC_URL:-http://solana-validator:8899}"
AIRDROP_AMOUNT="${AIRDROP_AMOUNT:-100}"
LOCAL_BOOTSTRAP_ROOT="${LOCAL_BOOTSTRAP_ROOT:-${ROOT_DIR}/.local/solana-bootstrap}"
LOCAL_CARGO_HOME="${LOCAL_CARGO_HOME:-${LOCAL_BOOTSTRAP_ROOT}/cargo-home}"
LOCAL_SOLANA_HOME="${LOCAL_SOLANA_HOME:-${LOCAL_BOOTSTRAP_ROOT}/home}"
LOCAL_RUSTUP_HOME="${LOCAL_RUSTUP_HOME:-${LOCAL_BOOTSTRAP_ROOT}/rustup-home}"
LOCAL_SBF_SDK_PATH="${LOCAL_SBF_SDK_PATH:-${LOCAL_SOLANA_HOME}/sdk/sbf}"
CAPITAL_STAKING_FEATURES="${CAPITAL_STAKING_FEATURES:-development}"
SOL_CLIENT_ID="${SOL_CLIENT_ID:-sol-local-1}"
SOL_PROVIDER_ID="${SOL_PROVIDER_ID:-sol-local-1}"
SOL_PROGRAM_ID="${SOL_PROGRAM_ID:-}"
SOL_IDL_FILE="/wire/${CAPITAL_STAKING_REPO_REL}/target/idl/liqsol_core.json"

prepare_sbf_sdk() {
  local default_sbf_sdk="/opt/solana/.local/share/solana/install/active_release/bin/sdk/sbf"

  mkdir -p "$(dirname "${LOCAL_SBF_SDK_PATH}")"
  if [[ ! -d "${LOCAL_SBF_SDK_PATH}" ]]; then
    cp -a "${default_sbf_sdk}" "${LOCAL_SBF_SDK_PATH}"
  fi

  export SBF_SDK_PATH="${LOCAL_SBF_SDK_PATH}"
}

prepare_rustup_home() {
  if [[ ! -d "${LOCAL_RUSTUP_HOME}/toolchains" ]]; then
    mkdir -p "${LOCAL_RUSTUP_HOME}"
    cp -a /opt/rustup/. "${LOCAL_RUSTUP_HOME}/"
  fi

  export RUSTUP_HOME="${LOCAL_RUSTUP_HOME}"
}

resolve_sol_program_id() {
  if [[ -n "${SOL_PROGRAM_ID}" ]]; then
    printf '%s\n' "${SOL_PROGRAM_ID}"
    return 0
  fi

  node <<'EOF'
const fs = require("fs");
const path = require("path");
const { Keypair } = require("@solana/web3.js");

const keypairPath = path.resolve("target/deploy/liqsol_core-keypair.json");
if (fs.existsSync(keypairPath)) {
  const secret = Uint8Array.from(JSON.parse(fs.readFileSync(keypairPath, "utf8")));
  console.log(Keypair.fromSecretKey(secret).publicKey.toBase58());
  process.exit(0);
}

const idlPath = path.resolve("target/idl/liqsol_core.json");
if (fs.existsSync(idlPath)) {
  const idl = JSON.parse(fs.readFileSync(idlPath, "utf8"));
  if (idl.address) {
    console.log(idl.address);
    process.exit(0);
  }
}

process.exit(1);
EOF
}

deploy_local_cluster() {
  export HOME="${LOCAL_SOLANA_HOME}"
  export XDG_CACHE_HOME="${HOME}/.cache"
  export XDG_CONFIG_HOME="${HOME}/.config"
  npm ci
  export ANCHOR_PROVIDER_URL
  export ANCHOR_WALLET
  export AIRDROP_AMOUNT
  export CAPITAL_STAKING_FEATURES
  export CARGO_HOME="${LOCAL_CARGO_HOME}"
  export SOLANA_RPC="${ANCHOR_PROVIDER_URL}"
  mkdir -p "${HOME}" "${XDG_CACHE_HOME}" "${XDG_CONFIG_HOME}" "${CARGO_HOME}" "${LOCAL_BOOTSTRAP_ROOT}"
  prepare_rustup_home
  prepare_sbf_sdk
  solana config set --url "${ANCHOR_PROVIDER_URL}" --keypair "${ANCHOR_WALLET}" >/dev/null
  bash bash-scripts/local-deploy.sh --wait-for-cluster --features "${CAPITAL_STAKING_FEATURES}"
  SOL_PROGRAM_ID="$(resolve_sol_program_id)"
  export SOL_PROGRAM_ID
}

set_signature_weight() {
  ANCHOR_WALLET="${ANCHOR_WALLET}" \
  ANCHOR_PROVIDER_URL="${ANCHOR_PROVIDER_URL}" \
  SOL_PROGRAM_ID="${SOL_PROGRAM_ID}" \
  node <<'EOF'
const fs = require("fs");
const anchor = require("@coral-xyz/anchor");
const { Connection, Keypair, PublicKey } = require("@solana/web3.js");
const idl = require("./target/idl/liqsol_core.json");

const walletPath = process.env.ANCHOR_WALLET;
const providerUrl = process.env.ANCHOR_PROVIDER_URL;
const programId = new PublicKey(process.env.SOL_PROGRAM_ID || idl.address);
idl.address = programId.toBase58();
const secret = Uint8Array.from(JSON.parse(fs.readFileSync(walletPath, "utf8")));
const wallet = new anchor.Wallet(Keypair.fromSecretKey(secret));
const provider = new anchor.AnchorProvider(new Connection(providerUrl, "confirmed"), wallet, {
  commitment: "confirmed",
});
anchor.setProvider(provider);

const program = new anchor.Program(idl, provider);
const [globalConfig] = PublicKey.findProgramAddressSync([Buffer.from("global_config")], programId);
const [controllerState] = PublicKey.findProgramAddressSync([Buffer.from("stake_controller")], programId);

async function main() {
  await program.methods
    .updateConfigU16({ oppRequiredSignatureWeight: {} }, 1)
    .accounts({
      globalConfig,
      controllerState,
      authority: wallet.publicKey,
    })
    .rpc();
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});
EOF
}

write_artifacts() {
  local out_file="${ARTIFACTS_DIR}/solana.env"

  mkdir -p "${ARTIFACTS_DIR}"

  ANCHOR_WALLET="${ANCHOR_WALLET}" \
  SOL_PROVIDER_ID="${SOL_PROVIDER_ID}" \
  SOL_CLIENT_ID="${SOL_CLIENT_ID}" \
  WIRE_BATCH_SOL_RPC_URL="${WIRE_BATCH_SOL_RPC_URL}" \
  SOL_PROGRAM_ID="${SOL_PROGRAM_ID}" \
  SOL_IDL_FILE="${SOL_IDL_FILE}" \
  CAPITAL_STAKING_REPO_REL="${CAPITAL_STAKING_REPO_REL}" \
  node <<'EOF' >"${out_file}"
const fs = require("fs");
const bs58 = require("bs58");
const { Keypair } = require("@solana/web3.js");

const walletPath = process.env.ANCHOR_WALLET;
const providerId = process.env.SOL_PROVIDER_ID;
const clientId = process.env.SOL_CLIENT_ID;
const rpcUrl = process.env.WIRE_BATCH_SOL_RPC_URL;
const programId = process.env.SOL_PROGRAM_ID;
const idlFile = process.env.SOL_IDL_FILE;
const repoRel = process.env.CAPITAL_STAKING_REPO_REL;

const secret = Uint8Array.from(JSON.parse(fs.readFileSync(walletPath, "utf8")));
const keypair = Keypair.fromSecretKey(secret);
const secretBase58 = bs58.encode(Buffer.from(keypair.secretKey));

console.log(`LOCAL_SOL_CLIENT_ID=${clientId}`);
console.log(`LOCAL_SOL_PROVIDER_ID=${providerId}`);
console.log(`LOCAL_SOL_PROVIDER_SPEC=${providerId},solana,solana,${keypair.publicKey.toBase58()},KEY:${secretBase58}`);
console.log(`LOCAL_SOL_RPC_URL=${rpcUrl}`);
console.log(`LOCAL_SOL_PROGRAM_ID=${programId}`);
console.log(`LOCAL_SOL_IDL_FILE=${idlFile}`);
console.log(`LOCAL_SOL_REPO_DIR=${repoRel}`);
console.log(`LOCAL_SOL_OPP_REQUIRED_SIGNATURE_WEIGHT=1`);
EOF
}

main() {
  cd "${CAPITAL_STAKING_DIR}"
  deploy_local_cluster
  set_signature_weight
  write_artifacts
}

main "$@"