Quickstart

export TARGET_ADDRESS="0xF143a9D93045474C2B573d21AC1CCe8dB2b06dbD"

cast call "$TARGET_ADDRESS" "supportsInterface(bytes4)(bool)" 0x93de4531 \
  --rpc-url "$RPC_URL"

import {GasKillerSDK} from "gas-killer-sdk/GasKillerSDK.sol";

contract Counter is GasKillerSDK {
    uint256 public total;

    constructor(address avs, address blsSigChecker) {
        _setAvsAddress(avs);
        _setBlsSignatureChecker(blsSigChecker);
    }

    function recompute(uint32 rounds) external trackState {
        // the expensive path operators reproduce off-chain
    }
}

ACCOUNT=$(cast wallet address --private-key "$PRIVATE_KEY")
BLOCK=$(cast block-number --rpc-url "$RPC_URL")

# call_data is a JSON array of byte values, so expand the ABI-encoded calldata.
CALLDATA=$(cast calldata "sum(uint256[])" "[1,2,3]")
BYTES=$(printf '%s' "${CALLDATA#0x}" | xxd -r -p \
  | od -An -tu1 -v | tr -s ' ' '\n' | grep . | paste -sd, -)

TASK_ID=$(curl -s -X POST "$ROUTER_URL/tasks" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"body\": {
      \"target_address\": \"$TARGET_ADDRESS\",
      \"from_address\": \"$ACCOUNT\",
      \"call_data\": [$BYTES],
      \"value\": \"0x0\",
      \"block_height\": $BLOCK
    }
  }" | jq -r .task_id)

echo "$TASK_ID"

import { createPublicClient, encodeFunctionData, http, parseAbi } from "viem"
import { privateKeyToAccount } from "viem/accounts"
import { sepolia } from "viem/chains"

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`)
const publicClient = createPublicClient({
  chain: sepolia,
  transport: http(process.env.RPC_URL),
})

const blockHeight = await publicClient.getBlockNumber()

const callData = encodeFunctionData({
  abi: parseAbi(["function sum(uint256[] indexes)"]),
  functionName: "sum",
  args: [[1n, 2n, 3n]],
})

const res = await fetch(`${process.env.ROUTER_URL}/tasks`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    body: {
      target_address: process.env.TARGET_ADDRESS,
      from_address: account.address,
      // call_data is a byte array, not a hex string.
      call_data: Array.from(Buffer.from(callData.slice(2), "hex")),
      value: "0x0",
      block_height: Number(blockHeight),
    },
  }),
})

const { task_id } = await res.json()
console.log(task_id)

# Poll every 2s until the task leaves the queue.
while :; do
  TASK=$(curl -s "$ROUTER_URL/tasks/$TASK_ID" -H "Authorization: Bearer $API_KEY")
  STATUS=$(echo "$TASK" | jq -r .status)
  echo "status: $STATUS"
  [ "$STATUS" = "ready" ] && break
  case "$STATUS" in failed|expired) echo "$TASK" | jq .error; exit 1;; esac
  sleep 2
done

echo "$TASK" | jq .payload

async function pollUntilReady(taskId: string) {
  while (true) {
    const res = await fetch(`${process.env.ROUTER_URL}/tasks/${taskId}`, {
      headers: { Authorization: `Bearer ${process.env.API_KEY}` },
    })
    if (!res.ok) {
      const { error } = await res.json()
      throw new Error(`${error.code}: ${error.message}`)
    }
    const task = await res.json()
    if (task.status === "ready") return task.payload
    if (task.status === "failed" || task.status === "expired") {
      throw new Error(`task ${task.status}: ${task.error}`)
    }
    await new Promise((r) => setTimeout(r, 2000))
  }
}

const payload = await pollUntilReady(task_id)

TO=$(echo "$TASK" | jq -r .payload.to)
DATA=$(echo "$TASK" | jq -r .payload.data)
VALUE=$(echo "$TASK" | jq -r .payload.value)

cast send "$TO" "$DATA" \
  --value "$VALUE" \
  --rpc-url "$RPC_URL" \
  --private-key "$PRIVATE_KEY"

import { createWalletClient, http } from "viem"
import { privateKeyToAccount } from "viem/accounts"
import { sepolia } from "viem/chains"

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`)

const walletClient = createWalletClient({
  account,
  chain: sepolia,
  transport: http(process.env.RPC_URL),
})

const hash = await walletClient.sendTransaction({
  to: payload.to as `0x${string}`,
  data: payload.data as `0x${string}`,
  value: BigInt(payload.value),
  gas: BigInt(payload.estimated_gas),
})

console.log("submitted:", hash)