Relay a Safe transaction

import Safe from "@safe-global/protocol-kit";
import {
  createPublicClient,
  http,
  parseEther,
  zeroAddress,
  type Hex,
} from "viem";

const rpcUrl = process.env.RPC_URL;
const apiKey = process.env.RHINESTONE_API_KEY;
const safeAddress = process.env.SAFE_ADDRESS;
const ownerKeys = (process.env.SAFE_OWNER_PRIVATE_KEYS ?? "")
  .split(",")
  .filter(Boolean) as Hex[];

if (!rpcUrl || !apiKey || !safeAddress || ownerKeys.length === 0) {
  throw new Error(
    "RPC_URL, RHINESTONE_API_KEY, SAFE_ADDRESS, and SAFE_OWNER_PRIVATE_KEYS are required",
  );
}

const publicClient = createPublicClient({ transport: http(rpcUrl) });
const chainId = await publicClient.getChainId();

const protocolKit = await Safe.init({
  provider: rpcUrl,
  signer: ownerKeys[0],
  safeAddress,
});

let safeTransaction = await protocolKit.createTransaction({
  transactions: [
    {
      to: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
      value: parseEther("0.001").toString(),
      data: "0x",
    },
  ],
  options: {
    safeTxGas: "0",
    baseGas: "0",
    gasPrice: "0",
    gasToken: zeroAddress,
    refundReceiver: zeroAddress,
  },
});

for (const signer of ownerKeys) {
  const ownerKit = await protocolKit.connect({ signer });
  safeTransaction = await ownerKit.signTransaction(safeTransaction);
}

const threshold = await protocolKit.getThreshold();
if (safeTransaction.signatures.size < threshold) {
  throw new Error(`Safe requires ${threshold} owner signatures`);
}

const safeTxHash = await protocolKit.getTransactionHash(safeTransaction);
const data = await protocolKit.getEncodedTransaction(safeTransaction);

const apiBaseUrl = "https://v1.orchestrator.rhinestone.dev";

const response = await fetch(`${apiBaseUrl}/safe-transactions`, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
  },
  body: JSON.stringify({
    chainId,
    to: safeAddress,
    data,
    safeTxHash,
  }),
});

const result = (await response.json()) as {
  taskId?: string;
  error?: string;
};
if (!response.ok || !result.taskId) {
  throw new Error(
    `Safe relay rejected (${response.status}): ${JSON.stringify(result)}`,
  );
}

const taskId = result.taskId;

const terminalStatuses = new Set([200, 400, 500]);
let relayStatus: {
  taskId: string;
  status: number;
  transactionHash?: Hex;
};

while (true) {
  const response = await fetch(
    `${apiBaseUrl}/safe-transactions/${taskId}/status`,
    { headers: { "x-api-key": apiKey } },
  );
  relayStatus = (await response.json()) as typeof relayStatus;

  if (!response.ok) {
    throw new Error(
      `Status request failed (${response.status}): ${JSON.stringify(relayStatus)}`,
    );
  }
  if (terminalStatuses.has(relayStatus.status)) break;

  await new Promise((resolve) => setTimeout(resolve, 3_000));
}

if (relayStatus.status !== 200) {
  throw new Error(`Safe relay failed with status ${relayStatus.status}`);
}

console.log("Safe transaction included:", relayStatus.transactionHash);