UPDATE: This is the old method of running bots. There is a lot of good information in these blog posts but they may differ from the new bot code. See the Cabana docs for the latest on G9’s PoolTogether bots:

https://docs.cabana.fi/protocol/bots

What is the Draw Auction bot?

The hyperstructure — PoolTogether’s latest protocol update introduces a new way to ensure the protocol lasts for generations to come. Built-in to the protocol is the ability for you to make profit by running core functions necessary for PoolTogether to operate day-to-day.

We’ve learned about the Arbitrage Liquidator bot in Part 1, and the Prize Claiming bot in Part 2. This tutorial is about the Draw Auction bot, which does two things:

1. Requests the RNG (random number generator) to create a random number — used to determine the prizes — every day, and

2. Bridges the provably fair and verifiable random number obtained in step 1 to the various chain’s prize pools.

Similar to the Prize Claiming in Part 2 of this tutorial series, the Draw Auctions use a gradual dutch auction to ramp up the rewards you can earn in exchange for assisting with the RNG flow over time. More info on how the auction works behind the scenes can be found in the docs here: https://dev.pooltogether.com/protocol/next/design/draw-auction

This tutorial will go over the steps required to create profitable RNG Request and Relay (bridge) transactions.

—

Note: We have created a bot (which runs on OpenZeppelin Defender, but you can use whichever cron/relay service you like) which you can use as a reference here: https://github.com/GenerationSoftware/pt-v5-autotasks-monorepo/tree/main/packages/draw-auction

These tutorials expect you have intermediate knowledge of programming concepts and JavaScript/TypeScript. We’ll use ethers.js, but you could write these bots using web3.js, Web3.py, etc.

Also, there is a JavaScript utils library for interacting with the PrizePool and associated contracts here: https://github.com/GenerationSoftware/pt-v5-utils-js

RNG Service

The RNG service used in Step 1 is currently set to Chainlink’s VRF, however any other random number source (such as RANDAO) could be plugged in at a later date.

Steps:

1. Create a main() function and get setup

2. Gather information about the state of the RNG and Relay Auctions

3. Compare RNG service fee and gas costs against the current reward you could earn to determine profitability

4. Execute transaction (when profitable) to start the RNG request or relay (bridge) the number to other chain’s prize pools

Caveat: The term relay in this tutorial is referencing the RngRelayAuction contract and function, not the OpenZeppelin Defender Relayer unless otherwise stated.

1. Create a main() and do setup

Working with the RNG and Relay contracts requires us to initialize a bunch of ethers.js Contract objects, as well as work across multiple chains.

During the first RngAuctionphase we will need to run startRngRequest to get a random number. The RNG currently uses Chainlink’s VRF on the Ethereum L1 chain. Therefore, the RngAuction, the RngAuctionRelayerRemoteOwnerand the ChainlinkVRFV2DirectRngAuctionHelpercontracts all live on Ethereum.

In the second phase RngRelayAuction, the random number needs to be broadcast from the L1 (Ethereum) to the prize pool on the L2 (currently Optimism, but could be a number of prize pools on various L2 chains). This is also initiated on the L1 using the RngAuctionRelayerRemoteOwner contract.

We will use the following contracts to query data from for finding out the state of the auctions: PrizePoolContract, RngAuctionContract, and RngRelayAuctionContract.

As well, we’ll need these two helper contracts for sending transactions: ChainlinkVRFV2DirectRngAuctionHelper and RngAuctionRelayerRemoteOwner.

These contract objects are all collected in the code below:

import { ethers, Contract } from 'ethers';
import { Provider } from '@ethersproject/providers';
import {
  ContractsBlob,
  downloadContractsBlob,
  getContract,
} from '@generationsoftware/pt-v5-utils-js';

export interface AuctionContracts {
  prizePoolContract: Contract;
  chainlinkVRFV2DirectRngAuctionHelperContract: Contract;
  remoteOwnerContract: Contract;
  rngAuctionContract: Contract;
  rngRelayAuctionContract: Contract;
  rngAuctionRelayerRemoteOwnerContract: Contract;
}

const CONTRACTS_VERSION = {
  major: 1,
  minor: 0,
  patch: 0,
};

const ERC_5164_MESSAGE_DISPATCHER_ADDRESS = {
  1: '0xa8f85bab964d7e6be938b54bf4b29a247a88cd9d', // mainnet -> optimism
};

const RNG_CHAIN_ID = 1; // eth mainnet
const RELAY_CHAIN_ID = 10; // optimism
const RNG_JSON_RPC_URI = ''; // your Alchemy, Infura, etc. RPC URI for target RNG chain
const RELAY_JSON_RPC_URI = ''; // your Alchemy, Infura, etc. RPC URI for target RELAY chain

const REWARD_RECIPIENT = '' // address the rewards should be sent to

const main = async () => {
  const helpers = await getHelpers();
  const context = await getDrawAuctionContext(helpers);

  if (!context.state) {
    console.warn(`Currently no Rng or RngRelay auctions to complete. Exiting ...`);
    return;
  }

  if (context.state === DrawAuctionState.RngStartVrfHelper) {
    await checkBalance(context);
    await increaseRngFeeAllowance(signer, context, helpers.auctionContracts);
  }

  // Get estimate for gas cost ...

  const profitable = await calculateProfit(gasCostUsd, context);

  if (profitable) {
    // We can simply pass the rngRelayer and rngReadProvider here since
    // both transactions we create will be on the L1
    await sendTransaction(rngRelayer, auctionContracts, context);
  }
};
main();

const getHelpers = async () => {
  const rngReadProvider = new ethers.providers.JsonRpcProvider(RNG_JSON_RPC_URI, RNG_CHAIN_ID);
  const relayReadProvider = new ethers.providers.JsonRpcProvider(
    RELAY_JSON_RPC_URI,
    RELAY_CHAIN_ID,
  );

  const rngContracts = await downloadContractsBlob(RNG_CHAIN_ID);
  const relayContracts = await downloadContractsBlob(RELAY_CHAIN_ID);

  const auctionContracts = getAuctionContracts(
    rngReadProvider,
    relayReadProvider,
    rngContracts,
    relayContracts,
  );

  return { auctionContracts, rngReadProvider, relayReadProvider };
};

const getAuctionContracts = (
  rngReadProvider: Provider,
  relayReadProvider: Provider,
  rngContractsBlob: ContractsBlob,
  relayContractsBlob: ContractsBlob,
): AuctionContracts => {
  const rngContracts = getRngContracts(rngReadProvider, rngContractsBlob);
  const relayContracts = getRelayContracts(relayReadProvider, relayContractsBlob);

  return {
    ...rngContracts,
    ...relayContracts,
  };
};

const getRngContracts = (provider: Provider, contracts: ContractsBlob) => {
  const chainId = RNG_CHAIN_ID;
  const version = CONTRACTS_VERSION;

  const rngAuctionContract = getContract('RngAuction', chainId, provider, contracts, version);
  const chainlinkVRFV2DirectRngAuctionHelperContract = getContract(
    'ChainlinkVRFV2DirectRngAuctionHelper',
    chainId,
    provider,
    contracts,
    version,
  );
  const rngAuctionRelayerRemoteOwnerContract = getContract(
    'RngAuctionRelayerRemoteOwner',
    chainId,
    provider,
    contracts,
    version,
  );

  return {
    chainlinkVRFV2DirectRngAuctionHelperContract,
    rngAuctionContract,
    rngAuctionRelayerRemoteOwnerContract,
  };
};

const getRelayContracts = (provider: Provider, contracts: ContractsBlob) => {
  const chainId = RELAY_CHAIN_ID;
  const version = CONTRACTS_VERSION;

  const prizePoolContract = getContract('PrizePool', chainId, provider, contracts, version);
  const rngRelayAuctionContract = getContract(
    'RngRelayAuction',
    chainId,
    provider,
    contracts,
    version,
  );
  const remoteOwnerContract = getContract('RemoteOwner', chainId, provider, contracts, version);

  return {
    prizePoolContract,
    remoteOwnerContract,
    rngRelayAuctionContract,
  };
};

2. Gather Contract State

Once we have our main function set up, and the various AuctionContracts collected we can gain intel on the current auction state.

We start with the basic get function getDrawAuctionContext, this will call both getRng and getRelay as well, then combine that data into the contextobject:

import { BigNumber, ethers } from 'ethers';
import { formatUnits } from '@ethersproject/units';
import { Provider } from '@ethersproject/providers';
import {
  AuctionContracts,
  DrawAuctionContext,
  DrawAuctionRelayerContext,
  RelayDrawAuctionContext,
  RngDrawAuctionContext,
  TokenWithRate,
} from '@generationsoftware/pt-v5-autotasks-library';

export enum DrawAuctionState {
  RngStartVrfHelper = 'RngVrfHelper',
  RngRelayBridge = 'RngRelayBridge',
}

import { ERC20Abi } from '../abis/ERC20Abi';
import { VrfRngAbi } from '../abis/VrfRngAbi';

const RELAYER_ADDRESS = ''; // account address of your signer / relayer
const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';

const RNG_FEE_TOKEN_MARKET_RATE_USD = 6.14
const REWARD_TOKEN_MARKET_RATE_USD = 0.62
const ETH_MARKET_RATE_USD = 1636.27

const getDrawAuctionContext = async (
  rngReadProvider: Provider,
  relayReadProvider: Provider,
  auctionContracts: AuctionContracts,
): Promise<DrawAuctionContext> => {
  const prizePoolReserve = await auctionContracts.prizePoolContract.reserve();
  const prizePoolReserveForOpenDraw = await auctionContracts.prizePoolContract.reserveForOpenDraw();
  const reserve = prizePoolReserve.add(prizePoolReserveForOpenDraw);

  const rngContext = await getRng(rngReadProvider, auctionContracts, reserve);
  const relayContext = await getRelay(relayReadProvider, auctionContracts, rngContext);

  const rngNativeTokenMarketRateUsd = await getNativeTokenMarketRateUsd(RNG_CHAIN_ID);
  const relayNativeTokenMarketRateUsd = await getNativeTokenMarketRateUsd(RELAY_CHAIN_ID);

  const rngExpectedRewardUsd = rngContext.rngExpectedReward * relayContext.rewardToken.assetRateUsd;

  const context = {
    ...rngContext,
    ...relayContext,
    rngNativeTokenMarketRateUsd,
    relayNativeTokenMarketRateUsd,
    rngExpectedRewardUsd,
  };

  return {
    ...context,
    state: getState(context),
  };
};

const getState = (context: DrawAuctionContext): DrawAuctionState => {
  if (context.rngIsAuctionOpen && context.rngFeeTokenIsSet && context.rngFeeUsd > 0) {
    return DrawAuctionState.RngStartVrfHelper;
  } else if (context.rngRelayIsAuctionOpen) {
    return DrawAuctionState.RngRelayBridge;
  }
};

getRng will collect all of the info necessary to determine if the startRngRequest function can be run, the fee we need to pay when requesting a random number, and the reward we could earn by requesting it:

export const getRng = async (
  rngReadProvider: Provider,
  auctionContracts: AuctionContracts,
  reserve: BigNumber,
): Promise<RngDrawAuctionContext> => {
  // RNG Auction Service Info
  const rngService = await auctionContracts.rngAuctionContract.getNextRngService();
  const rngServiceContract = new ethers.Contract(rngService, VrfRngAbi, rngReadProvider);
  const rngServiceRequestFee = await rngServiceContract.getRequestFee();

  const rngFeeTokenAddress = rngServiceRequestFee[0];

  // RNG Estimated Fee from VrfHelper
  const gasPrice = await rngReadProvider.getGasPrice();
  const requestGasPriceWei = gasPrice;

  const chainlinkVRFV2DirectRngAuctionHelperContract =
    await auctionContracts.chainlinkVRFV2DirectRngAuctionHelperContract;
  const vrfHelperRequestFee = await chainlinkVRFV2DirectRngAuctionHelperContract.estimateRequestFee(
    requestGasPriceWei,
  );
  const rngFeeAmount = vrfHelperRequestFee._requestFee;

  const rngFeeTokenIsSet = rngFeeTokenAddress !== ZERO_ADDRESS;

  let rngFeeTokenBalance = BigNumber.from(0);
  let rngFeeTokenAllowance = BigNumber.from(0);
  let rngFeeTokenContract;

  if (rngFeeTokenIsSet) {
    rngFeeTokenContract = new ethers.Contract(rngFeeTokenAddress, ERC20Abi, rngReadProvider);

    rngFeeTokenBalance = await rngFeeTokenContract.balanceOf(RELAYER_ADDRESS);
    rngFeeTokenAllowance = await rngFeeTokenContract.allowance(
      RELAYER_ADDRESS,
      auctionContracts.chainlinkVRFV2DirectRngAuctionHelperContract.address,
    );
  }

  // RNG Auction info
  const rngIsAuctionOpen = await auctionContracts.rngAuctionContract.isAuctionOpen();
  const rngIsRngComplete = await auctionContracts.rngAuctionContract.isRngComplete();
  const rngCurrentFractionalReward =
    await auctionContracts.rngAuctionContract.currentFractionalReward();

  // RNG Auction Service
  let rngFeeToken: TokenWithRate;
  if (rngFeeTokenIsSet) {
    const rngFeeTokenSymbol = await rngFeeTokenContract.symbol();
    rngFeeTokenContract = new ethers.Contract(rngFeeTokenAddress, ERC20Abi, rngReadProvider);

    rngFeeToken = {
      address: rngFeeTokenAddress,
      decimals: await rngFeeTokenContract.decimals(),
      name: await rngFeeTokenContract.name(),
      symbol: rngFeeTokenSymbol,
      assetRateUsd: RNG_FEE_TOKEN_MARKET_RATE_USD,
    };
  }

  const rngCurrentFractionalRewardString = ethers.utils.formatEther(rngCurrentFractionalReward);

  // TODO: Assuming 18 decimals. May need to format using rewardToken's decimals instead
  const reserveStr = ethers.utils.formatEther(reserve);
  const rngExpectedReward = Number(reserveStr) * Number(rngCurrentFractionalRewardString);

  // RNG Fee
  let relayer: DrawAuctionRelayerContext;
  if (rngFeeTokenIsSet) {
    relayer = {
      rngFeeTokenBalance,
      rngFeeTokenAllowance,
    };
  }

  let rngFeeUsd = 0;
  if (rngFeeTokenIsSet) {
    rngFeeUsd =
      parseFloat(formatUnits(rngFeeAmount, rngFeeToken.decimals)) * rngFeeToken.assetRateUsd;
  }

  return {
    rngFeeTokenIsSet,
    rngFeeToken,
    rngFeeAmount,
    rngFeeUsd,
    rngIsAuctionOpen,
    rngIsRngComplete,
    rngExpectedReward,
    relayer,
  };
};

getRelay takes information from getRng and determines if relay()(the bridging of the random number) can be run and how much we can earn by running that function:

export const getRelay = async (
  readProvider: Provider,
  auctionContracts: AuctionContracts,
  rngContext: RngDrawAuctionContext,
): Promise<RelayDrawAuctionContext> => {
  // Prize Pool Info
  const prizePoolOpenDrawEndsAt = await auctionContracts.prizePoolContract.openDrawEndsAt();

  const rewardTokenAddress = await auctionContracts.prizePoolContract.prizeToken();
  const rewardTokenContract = new ethers.Contract(rewardTokenAddress, ERC20Abi, readProvider);

  // Reward Token
  const rewardTokenSymbol = await rewardTokenContract.symbol();

  const rewardToken: TokenWithRate = {
    address: rewardTokenAddress,
    decimals: await rewardTokenContract.decimals(),
    name: await rewardTokenContract.name(),
    symbol: rewardTokenSymbol,
    assetRateUsd: REWARD_TOKEN_MARKET_RATE_USD,
  };

  // Relay Auction Info
  const rngRelayLastSequenceId = auctionContracts.rngAuctionContract.lastSequenceId();

  const lastSequenceCompleted = await auctionContracts.rngRelayAuctionContract.isSequenceCompleted(
    rngRelayLastSequenceId,
  );

  const rngRelayIsAuctionOpen =
    rngRelayLastSequenceId > 0 && rngContext.rngIsRngComplete && !lastSequenceCompleted;

  // Relayer Reward
  let rngRelayExpectedReward, rngRelayExpectedRewardUsd;
  if (rngRelayIsAuctionOpen) {
    const [randomNumber, completedAt] =
      await auctionContracts.rngAuctionContract.callStatic.getRngResults();
    const rngLastAuctionResult = await auctionContracts.rngAuctionContract.getLastAuctionResult();
    const elapsedTime = Math.floor(Date.now() / 1000) - Number(completedAt.toString());

    const rngRelayRewardFraction =
      await auctionContracts.rngRelayAuctionContract.computeRewardFraction(elapsedTime);

    const auctionResult = {
      rewardFraction: rngRelayRewardFraction,
      recipient: RELAYER_ADDRESS,
    };

    const auctionResults = [];
    auctionResults[0] = rngLastAuctionResult;
    auctionResults[1] = auctionResult;

    const rngRelayExpectedRewardResult =
      await auctionContracts.rngRelayAuctionContract.callStatic.computeRewards(auctionResults);
    rngRelayExpectedReward = rngRelayExpectedRewardResult[1];

    rngRelayExpectedRewardUsd =
      parseFloat(formatUnits(rngRelayExpectedReward.toString(), rewardToken.decimals)) *
      rewardToken.assetRateUsd;
  }

  return {
    prizePoolOpenDrawEndsAt,
    rewardToken,
    rngRelayIsAuctionOpen,
    rngRelayExpectedReward,
    rngRelayExpectedRewardUsd,
    rngRelayLastSequenceId,
  };
};

3. Calculating Profitability

Now that we have all of that information about the state of the auctions and the cost of the RNG fee we can figure out how much could be earned by starting and completing the RNG process.

If the first phase RngAuction#startRngRequest is open, we will need to check if we can afford the RNG Fee (denominated in LINK), and if we have provided enough allowance to the contract to spend our relayer’s LINK. If the allowance is not high enough it will set it to maximum (as we trust the security of this contract. You may not want to set yours to max):

const checkBalance = (context: DrawAuctionContext) => {
  const cannotAffordRngFee = context.relayer.rngFeeTokenBalance.lt(context.rngFeeAmount);
  if (cannotAffordRngFee) {
    console.warn(
      `Need to increase relayer/bot's balance of '${context.rngFeeToken.symbol}' to pay RNG fee.`,
    );
  } else {
    console.log('Sufficient balance ✔');
  }
};

const increaseRngFeeAllowance = async (
  signer,
  context: DrawAuctionContext,
  auctionContracts: AuctionContracts,
) => {
  const rngFeeTokenContract = new ethers.Contract(context.rngFeeToken.address, ERC20Abi, signer);

  const allowance = context.relayer.rngFeeTokenAllowance;

  if (allowance.lt(context.rngFeeAmount)) {
    const tx = await rngFeeTokenContract.approve(
      auctionContracts.chainlinkVRFV2DirectRngAuctionHelperContract.address,
      ethers.constants.MaxInt256,
    );
    await tx.wait();
  }
};

—

Note: We’ll leave out how to get the gas cost in USD for the chain you’re working on. You can view the reference implementation to see how this is done using eth_gasPrice, gasEstimate on contract calls from ethers.js and the USD value of the native gas token (ie. ETH on Optimism) from a price feed such as Coingecko or Covalent, etc.

Now we can find out if we will make profit on this transaction:

const calculateProfit = async (
  gasCostUsd: number,
  context: DrawAuctionContext,
): Promise<boolean> => {
  const grossProfitUsd =
    context.state === DrawAuctionState.RngStartVrfHelper
      ? context.rngExpectedRewardUsd
      : context.rngRelayExpectedRewardUsd;

  let netProfitUsd;
  if (context.state === DrawAuctionState.RngStartVrfHelper) {
    netProfitUsd = grossProfitUsd - gasCostUsd - context.rngFeeUsd;
  } else {
    netProfitUsd = grossProfitUsd - gasCostUsd;
  }

  const profitable = netProfitUsd > MIN_PROFIT_THRESHOLD_USD;

  return profitable;
};

4. Executing Transactions

Last but not least, we need to determine which contract we want to transact with using the DrawAuctionState, and then send the transaction.

The reason we use the ChainlinkVRFV2DirectRngAuctionHelper is that it takes care of transferring the ERC20 RNG fee token, making it easier for bots to interact with the RngAuctioncontract.

The RngAuctionRelayerRemoteOwnerContract is used when the RNG is on one chain and needs to be relayed to a prize pool on another chain. Otherwise we could use the RngAuctionRelayerDirect#relay function directly.

const sendTransaction = async (
  relayer: Relayer,
  auctionContracts: AuctionContracts,
  context: DrawAuctionContext,
) => {
  let populatedTx: PopulatedTransaction;
  if (context.drawAuctionState === DrawAuctionState.RngStartVrfHelper) {
    const chainlinkRngAuctionHelper = auctionContracts.chainlinkVRFV2DirectRngAuctionHelperContract;
    populatedTx = await chainlinkRngAuctionHelper.populateTransaction.transferFeeAndStartRngRequest(
      REWARD_RECIPIENT,
    );
  } else {
    populatedTx =
      await auctionContracts.rngAuctionRelayerRemoteOwnerContract.populateTransaction.relay(
        ERC_5164_MESSAGE_DISPATCHER_ADDRESS[RNG_CHAIN_ID],
        RELAY_CHAIN_ID,
        auctionContracts.remoteOwnerContract.address,
        auctionContracts.rngRelayAuctionContract.address,
        REWARD_RECIPIENT,
      );
  }

  const tx = await relayer.sendTransaction({
    data: populatedTx.data,
    to: populatedTx.to,
    gasLimit: 8000000,
  });

  console.log('Transaction hash:', tx.hash);
};

Finishing Up

That wraps up Part 3 and this series of tutorials on the new PoolTogether hyperstructure bots.

Just in case you missed it: in Part 1 we looked at making profit with Liquidation bots — whose job is to liquidate interest-bearing (yield) tokens for POOL to supply the prize pool with.

In Part 2 we looked at Prize Claiming bots — a way to earn POOL while automating the claiming of prizes every day on behalf of winners.

If you have any questions don’t hesitate to ask anyone in the PoolTogether Discord community. The #developers channel is your best bet!

UPDATE: This is the old method of running bots. There is a lot of good information in these blog posts but they may differ from the new bot code. See the Cabana docs for the latest on G9’s PoolTogether bots:

https://docs.cabana.fi/protocol/bots

What is a prize claiming bot for?

The upcoming PoolTogether Hyperstructure automates prize claiming using incentives. You can earn fees by claiming prizes for winners. You earn money, and they get their prizes automatically.

New prizes are released in daily draws. Winners must first be computed, then the prizes can be claimed. The reward for claiming a prize is priced according to a variable rate gradual dutch auction (VRGDA for short). In a nutshell, this means that the reward increases if prizes aren’t claimed fast enough.

In this tutorial we will create a bot which will run every few minutes and check if there are prizes to claim on behalf of winners. If there are prizes to claim and the reward they will earn for claiming is worth the cost, the bot will send a transaction to claim.

—

Note: We have created a bot (which runs on OpenZeppelin Defender, but you can use whichever cron/relay service you like) which you can use as a reference here: https://github.com/GenerationSoftware/pt-v5-autotasks-monorepo/tree/main/packages/prize-claimer

These tutorials expect you have intermediate knowledge of programming concepts and JavaScript/TypeScript. We’ll use ethers.js, but you could write these bots using web3.js, Web3.py, etc.

Also, there is a JavaScript utils library for interacting with the PrizePool and associated contracts here: https://github.com/GenerationSoftware/pt-v5-utils-js

Rewards & Prize Expiry

Prizes will expire every day to incentivize claiming. The rewards for claiming increase exponentially during the course of the auction. Rewards are taken from the prize itself. A basic example of this is:

• a depositor wins 10 POOL

• 15 hours later (if the prize hasn’t been claimed yet) the reward for claiming would be 2 POOL

• the winner would receive 8 POOL

• the bot who claims the prize would earn the 2 POOL reward

Thankfully the system has been designed so that a bot can send one transaction to claim multiple prizes in one go. Being able to claim multiple prizes in one transaction ensures it will be profitable to claim prizes soon after a draw, reducing the amount of claim fees taken from the prize itself.

The first prize claim transaction fee is about 220,000 wei worth of gas, and each subsequent prize claim is about 120,000 wei gas. During the time this article was written, on Optimism gas for 1 prize claimed was $0.08, and gas for 7 prizes claimed was $0.20.

Claim Prizes Subgraph

There is a subgraph live at https://api.studio.thegraph.com/query/41211/pt-v5-optimism-prize-pool/v0.0.1 which you can use for querying which prizes have previously been claimed for which draws. The pt-v5-utils-js library also has getSubgraphClaimedPrizes function for easily fetching claimed prizes.

And with that, let’s get into it:

Steps to claiming prizes:

1. Write main() function

2. Find all active depositor accounts and compute prizes won for each account

3. Check the optimal number of prizes to claim per tier to maximize rewards (called fees)

4. If the fees are sufficiently profitable, execute prize claims

5. Periodically withdraw the fees you have earned from the Prize Pool

1. main() Function

Let’s start by importing the various library functions and types (if using TypeScript) we will need to use, then setting up an async function that we will call right away:

import { Contract, BigNumber } from 'ethers';
import { JsonRpcProvider } from '@ethersproject/providers'
import { formatUnits } from '@ethersproject/units';
import {
  computeDrawWinners,
  downloadContractsBlob,
  flagClaimedRpc,
  Claim,
  ContractsBlob,
} from '@generationsoftware/pt-v5-utils-js';
import groupBy from 'lodash.groupby';

// The params required by the `claimPrizes()` contract
// function on the Claimer.sol contract
interface ClaimPrizesParams {
  vault: string;
  tier: number;
  winners: string[];
  prizeIndices: number[][];
  feeRecipient: string;
  minVrgdaFeePerClaim: string;
}

const CONTRACTS_VERSION = {
  major: 1,
  minor: 0,
  patch: 0,
};

// the address you want earned fees to accrue to
const FEE_RECIPIENT = '0x0000000000000000000000000000000000000000'
const CHAIN_ID = 10; // Optimism

const readProvider = new JsonRpcProvider(YOUR_JSON_RPC_PROVIDER_URL);

const main = async () => {
  const claimerContract = getClaimerContract(chainId, readProvider, contracts)
  
  const claims: Claim[] = await getClaims();
  
  const unclaimedClaimsGrouped = await findAndGroupUnclaimed(claims)
  
  await loopUnclaimedGroups(unclaimedClaimsGrouped, claimerContract)
}
main()

const getClaimerContract = (chainId: number, readProvider: Provider, contracts: ContractsBlob): Contract => {
  const claimerContract = getContract(
    'Claimer',
    chainId,
    readProvider,
    contracts,
    CONTRACTS_VERSION,
  );
};
  

2. Find Winners

To collect a list of all active depositor addresses we can use the TwabController subgraph. We can then determine if they won in the previous draw by using RPC calls to the PrizePool contract’sisWinner().

You can use the handy computeDrawWinners()in the pt-v5-utils-jslibrary to find depositors, determine who won and if their prizes have been claimed already:

const getClaims = async (): Promise<Claim[]> { => {
  const contracts: ContractsBlob = await downloadContractsBlob(CHAIN_ID);

  // We have found this to be too heavy to use in our OpenZeppelin Defender autotasks.
  // Depending on the number of winners you may need to cache the results of this for
  // every draw in flat files that your bot then fetches later
  const claims: Claim[] = await computeDrawWinners(readProvider, contracts, CHAIN_ID);
  
  return claims;
}

// computeDrawWinners() returns:
[
  {
    vault: '0x06b36307e4da41f0c42efb7d7abc02df0c8b5c49',
    winner: '0x725e613f1816395dd453dc6394b1794a73152813',
    tier: 1,
    prizeIndex: 2,
    claimed: false
  },
  ...
]

Note: There is also thept-v5-clihelper library available which can be used to find depositors and cache data about their winnings to JSON flat files here: https://github.com/generationSoftware/pt-v5-cli

We get back an array containing info about each prize. One account can win multiple prizes in multiple vaults, tiers and indices.

Vaults — 4626-compatible prize vaults, hold user’s deposits, and in return gives the user a interest-bearing token as collateral.

Tiers — the various prize tiers which someone can win from. For instance, tier 0 prizes may be $1,000, while tier 1 prizes are $500, tier 2 $100, etc.

Indices — a method of allowing one account to win multiple prizes from the same tier. This allows for fairer winning odds based on the pooler’s deposit size.

Continuing on we check live data with RPC calls for prizes that have already been claimed (removing them with filter) and group the unclaimed claims by Vault and Tier:

const findAndGroupUnclaimed = async (claims: Claim[]) => {
  // Cross-reference claimed prizes to flag if a prize has been claimed or not
  claims = await flagClaimedRpc(readProvider, contracts, claims);

  let unclaimedClaims = claims.filter((claim) => !claim.claimed);
  console.log(`${unclaimedClaims.length} prizes remaining to be claimed...`);

  if (unclaimedClaims.length === 0) {
    console.log(`No prizes left to claim. Exiting ...`);
    return;
  }
  
  // Sort unclaimed claims by tier so largest prizes (with the largest rewards) are first
  unclaimedClaims = unclaimedClaims.sort((a, b) => a.tier - b.tier);

  // Group claims by vault & tier
  const unclaimedClaimsGrouped = groupBy(unclaimedClaims, (item) => [item.vault, item.tier]);
  
  return unclaimedClaimsGrouped;
};

3. Check For Profitable Claims

Now that we have a list of prizes grouped and sorted by Vault & Tier (stored in the unclaimedClaimsGrouped variable) let’s iterate through each to check how many we should claim (if any) to make us profit:

const loopUnclaimedGroups = async (unclaimedClaimsGrouped, claimerContract: Contract) => {
  for (let vaultTier of Object.entries(unclaimedClaimsGrouped)) {
    const [key, value] = vaultTier;
    const [vault, tier] = key.split(',');
    const groupedClaims: any = value;

    console.log(`Vault:       ${vault}`);
    console.log(`Tier Index:  #${tier}`);
    console.log(`# prizes:    ${groupedClaims.length}`);

    const claimPrizesParams = await calculateProfit(
      vault,
      Number(tier),
      claimerContract,
      groupedClaims,
    );

    // It's profitable if there is at least 1 claim to claim
    if (claimPrizesParams.winners.length > 0) {
      await executeTransaction(claimPrizesParams, claimerContract)
    }
};

—

Note: We’ll leave out how to get the gas cost in USD for the chain you’re working on. You can view the reference implementation to see how this is done using eth_gasPrice, gasEstimate on contract calls from ethers.js and the USD value of the native gas token (ie. ETH on Optimism) from a price feed such as Coingecko or Covalent, etc.

calculateProfit() will pass the claim data to getClaimInfo(), and in return receive information about how many claims in the array should be processed. It will then slice up the array to only include that number of claims, and build the params list that we will send to the contract function in executeTransaction():

const calculateProfit = async (
  vault: string,
  tierIndex: number,
  claimerContract: Contract,
  groupedClaims: any,
): Promise<ClaimPrizesParams> => {
  const { claimCount, claimFeesUsd, totalCostUsd, minVrgdaFeePerClaim } = 
    await getClaimInfo(
      claimerContract,
      tierIndex,
      groupedClaims,
    );

  const claimsSlice = groupedClaims.slice(0, claimCount);
  const claimPrizesParams = buildParams(
    vault,
    tierIndex,
    claimsSlice,
    minVrgdaFeePerClaim,
  );

  return claimPrizesParams;
};

const buildParams = (
  vault: string,
  tier: number,
  claims: Claim[],
  minVrgdaFeePerClaim: string,
): ClaimPrizesParams => {
  let winners: string[] = [];
  let prizeIndices: number[][] = [];

  claims.forEach((claim) => {
    winners.push(claim.winner);
    prizeIndices.push([claim.prizeIndex]);
  });

  return {
    vault,
    tier,
    winners,
    prizeIndices,
    feeRecipient: FEE_RECIPIENT,
    minVrgdaFeePerClaim,
  };
};

In getClaimInfo()below we go through each claim and call the Claimer contract’s computeTotalFees(uint8,uint256) function to get the amount we can earn.

On each loop, we will compare the amount we would earn against the previous fees, gas costs and MIN_PROFIT_USD. If we’re continuing to earn profit we’ll keep going, and if not we will break out of the loop.

getClaimInfo() will return an object of the ClaimInfo type. ClaimInfo includes the # of claims (which we’ll use to slice the original claims array) and the minVrgdaFeePerClaim— necessary to pass as an argument to the Claimer contract’s claimPrizes() function later:

const MIN_PROFIT_USD = 0.1;           // $0.10 per prize claimed
const FEE_TOKEN_ASSET_RATE_USD = 0.6; // $0.60 for prize token (likely POOL)
const FEE_TOKEN_DECIMALS = 18;

const GAS_ONE_CLAIM_USD = 0.08;            // $0.08 gas cost for one claim
const GAS_EACH_FOLLOWING_CLAIM_USD = 0.02; // $0.02 extra gas cost for each following claim

interface ClaimInfo {
  claimCount: number;
  minVrgdaFeePerClaim: string;
}

const getClaimInfo = async (
  claimerContract: Contract,
  tierIndex: number,
  claims: Claim[],
): Promise<ClaimInfo> => {
  let claimCount = 0;
  let claimFeesUsd = 0;
  let totalCostUsd = 0;
  let prevNetFeesUsd = 0;
  let claimFees = BigNumber.from(0);
  let minVrgdaFees: BigNumber[] = [];
  for (let numClaims = 1; numClaims <= claims.length; numClaims++) {
    const nextClaimFees = await claimerContract.functions'computeTotalFees(uint8,uint256)';

    const totalCostUsd =
      numClaims === 1
        ? GAS_ONE_CLAIM_USD
        : GAS_ONE_CLAIM_USD + GAS_EACH_FOLLOWING_CLAIM_USD * numClaims;

    const claimFeesFormatted = formatUnits(claimFees.toString(), FEE_TOKEN_DECIMALS);
    claimFeesUsd = parseFloat(claimFeesFormatted) * FEE_TOKEN_ASSET_RATE_USD;

    const nextClaimFeesFormatted = formatUnits(claimFees.toString(), FEE_TOKEN_DECIMALS);
    const nextClaimFeesUsd = parseFloat(nextClaimFeesFormatted) * FEE_TOKEN_ASSET_RATE_USD;

    const netFeesUsd = nextClaimFeesUsd - totalCostUsd;

    if (netFeesUsd > prevNetFeesUsd && netFeesUsd > MIN_PROFIT_USD) {
      prevNetFeesUsd = netFeesUsd;
      claimCount = numClaims;
      claimFees = nextClaimFees;
      claimFeesUsd = nextClaimFeesUsd;

      minVrgdaFees.push(nextClaimFees);
    } else {
      break;
    }
  }
  
  // Sort array of BigNumbers by comparing them using basic JS built-in sort()
  minVrgdaFees.sort((a: BigNumber, b: BigNumber) => (a.gt(b) ? 1 : -1));

  // Take the lowest BigNumber as the lowest fee we will accept
  const minVrgdaFeePerClaim = Boolean(minVrgdaFees[0]) ? minVrgdaFees[0].toString() : '0';
  
  console.log(`$${netProfitUsd} = ($${claimFeesUsd} - $${totalCostUsd})`);

  return { claimCount, minVrgdaFeePerClaim };
};

Whew!

On to the last step.

4. Execute Profitable Claims

Finally, we need to determine if there are any profitable claims based on the params list returned to us by the calculateProfit() function, and if there are use the OpenZeppelin relayer to send a transaction to the blockchain.

Of course, here you can swap out the OpenZeppelin relayer for whichever method you prefer for sending transactions:

const executeTransaction = async (claimPrizesParams, claimerContract: Contract) => {
  // It's profitable if there is at least 1 claim to claim
  if (claimPrizesParams.winners.length > 0) {
    const populatedTx = await claimerContract.populateTransaction.claimPrizes(
      ...Object.values(claimPrizesParams),
    );

    const tx = await relayer.sendTransaction({
      data: populatedTx.data,
      to: populatedTx.to,
      gasLimit: 8000000,
    });
    console.log('Transaction hash:', tx.hash);
  } else {
    console.log(`Not profitable to claim Draw #${context.drawId}, Tier Index: #${tier}`);
  }
}
  

5. Withdrawing Claim Rewards

Last but not least, every now and then you will need to withdraw the rewards you have earned from the PrizePool. There is an ancillary bot written to take care of that as well, which you can find a reference implementation of here.

Finishing Up

And with that, we have a bot that is capable of profiting from claiming prizes on behalf of PoolTogether v5 depositors. We’re impressed you made it this far! 👏

In Part 1, we looked at making liquidations with our bots. In Part 3 we will look at how to earn by helping with the RNG (random number generation) and relay (bridging the random number to other chains) Draw Auction bot.

If you have any questions feel free to reach out to anyone in the PoolTogether Discord community. The #developers channel is your best bet!

Tutorial duration: ~20 minutes

UPDATE: This is the old method of running bots. There is a lot of good information in these blog posts but they may differ from the new bot code. See the Cabana docs for the latest on G9’s PoolTogether bots:

https://docs.cabana.fi/protocol/bots

Why bots?

The new version of PoolTogether (called the hyperstructure) features incentivization in place of governance. This ensures that the protocol can exist and function for many generations to come without the need for any voters or admin staff.

In order for this to work, mechanism design was baked into the protocol so that those with technical know-how (or those interested in learning) of running bots are incentivized to do so.

In this tutorial we will be walking through creating and running a successful Arbitrage Swap bot — this bot will run every few minutes, find profitable trades, and autonomously submit those transactions.

Where this differs from other arbitrage bots is that it does not run transactions on a typical DEX (such as Uniswap), but instead only submits transactions to run on the new PoolTogether Liquidation contracts. The Liquidator exists simply to convert yield that a Prize Vault has accrued into Prize Tokens.

—

Note: We have created a bot (which runs on OpenZeppelin Defender, but you can use whichever cron/relay service you like) which you can use as a reference here: https://github.com/GenerationSoftware/pt-v5-autotasks-monorepo/tree/main/packages/arb-liquidator

These tutorials expect you have intermediate knowledge of programming concepts and JavaScript/TypeScript. We’ll use ethers.js, but you could write these bots using web3.js, Web3.py, etc.

Also, there is a JavaScript utils library for interacting with the PrizePool and associated contracts here: https://github.com/GenerationSoftware/pt-v5-utils-js

The Liquidator

Depositors in PoolTogether can deposit any ERC-20 crypto tokens so long as they have an EIP-4626 Vault to receive them. While the tokens are stored in the vault, they accrue yield (ie. when you deposit USDC to an Aave vault you receive Staked Aave DAI in return, an interest-bearing asset). This yield needs to be continually liquidated into prize tokens (currently the prize token is POOL), so that depositors who win prizes will be compensated in POOL instead of the interest-bearing asset.

The Liquidator has been designed so that anyone can run these swaps and profit from them. The bot sends POOL prize tokens and receives prize asset tokens in return.

Liquidation Pairs

Liquidation Pairs are the mechanism by which yield is liquidated. Each PoolTogether Vault will have one or more associated Liquidation Pairs. A Liquidation Pair is like a Uniswap pair, but it only supports swaps in a single direction.

To arbitrage yield, you would follow these steps:

1. Find Liquidation Pairs you would like to arb

2. Calculate most profitable swap

3. If profitable, execute swap

1. Finding Liquidation Pairs

All of the Liquidation Pairs are created by the Liquidation Pair Factory. We can use that factory to list and iterate through each Liquidation Pair:

const liquidationPairFactoryContract = new ethers.Contract(
  liquidationPairFactoryAddress,
  LiquidationPairFactoryAbi,
  readProvider
);
let liquidationPairContracts: Contract[] = [];

const numPairs = await liquidationPairFactoryContract.totalPairs();

for (let i = 0; i < numPairs; i++) {
  const liquidationPairAddress = 
        await liquidationPairFactoryContract.allPairs(i);
  const liquidationPairContract = new ethers.Contract(
    liquidationPairAddress,
    LiquidationPairAbi,
    readProvider
  );
  liquidationPairContracts.push(liquidationPairContract);
}

Note: When this was written everything was being run against the Beta contracts. The list of Beta contract addresses and ABIs can be found here: https://github.com/GenerationSoftware/pt-v5-beta/tree/main/deployments

2. Calculate Most Profitable Swap

In order to make the decision if we should execute the swap or not, and for how much of the input token we will need to find out the current available liquidity, the cost of the POOL we will be sending vs. the value of interest-bearing tokens we will receive in return, and the gas fee for the transaction.

To compare with Uniswap’s language, POOL (the prize token) is called tokenIn. The prize asset token (such as PTUSDC, PTWETH) is tokenOut. And the underlyingAssetToken is the original token deposited into the PoolTogether vault (the unwrapped interest-bearing token: eg. USDC, wETH, etc.).

—

Note: We’ll leave out how to get the gas cost and token values in USD for the chain you’re working on. You can view the reference implementation to see how this is done using eth_gasPrice, gasEstimate on contract calls from ethers.js and the USD value of the tokens from a price feed such as Coingecko or Covalent, etc.

The liquidator uses a CGDA (continuous gradual dutch auction) to auction off yield.

Let’s start by figuring out how much POOL we will need to supply. We can do this by making callStaticcalls (callStaticsimulates an external write function instead of actually sending a transaction) to the LiquidationPair’s maxAmountOut() (the maximum amount available to receive in return for POOL), andcomputeExactAmountIn()(how much POOL we need to supply):

const maxAmountOut = await liquidationPairContract.callStatic.maxAmountOut();

const exactAmountIn = await liquidationPairContract.callStatic.computeExactAmountIn(
  wantedAmountOut,
);

However, it’s not efficient or most profitable to always swap the maximum amount out for the maximum amount in, so we will want a way to calculate a more profitable swap. The easiest way to compute the best swap is to first get the maxAmountOut that we can receive right now, then split that up into many data points (we use 100 below) to find the optimal amountOut:

const { originalMaxAmountOut, wantedAmountsOut } = await calculateAmountOut(
  liquidationPairContract,
  context,
);

// Calculates necessary input parameters for the swap call based on current state
// of the contracts
const calculateAmountOut = async (
  liquidationPair: Contract,
  context: ArbLiquidatorContext,
): Promise<{
  originalMaxAmountOut: BigNumber;
  wantedAmountsOut: BigNumber[];
}> => {
  const wantedAmountsOut = [];
  const amountOut = await liquidationPair.callStatic.maxAmountOut();

  // Get multiple data points across the auction function to determine
  // the most amount of profitability (most amount out for least amount
  // of token in depending on the state of the gradual auction)
  for (let i = 1; i <= 100; i++) {
    const amountToSendPercent = i;
    const wantedAmountOut = amountOut
      .mul(ethers.BigNumber.from(amountToSendPercent))
      .div(100);

    wantedAmountsOut.push(wantedAmountOut);
  }

  return {
    originalMaxAmountOut: amountOut,
    wantedAmountsOut,
  };
};

We can then use the output from these 100 data points (stored in wantedAmountsOut) to find their corresponding wantedAmountsIn:

import { BigNumber, ethers } from 'ethers';
import { Contract } from 'ethers';
import { Provider } from '@ethersproject/providers';
import { getLiquidationPairComputeExactAmountInMulticall }
  from '@generationsoftware/pt-v5-autotasks-library';

const { amountIn, amountInMin, wantedAmountsIn } = await calculateAmountIn(
  readProvider,
  liquidationPairContract,
  originalMaxAmountOut,
  wantedAmountsOut,
);

// Calculates optimal input parameters for the swap call based on current
// state of the auction
const calculateAmountIn = async (
  readProvider: Provider,
  liquidationPairContract: Contract,
  originalMaxAmountOut: BigNumber,
  wantedAmountsOut: BigNumber[],
): Promise<{
  amountIn: BigNumber;
  amountInMin: BigNumber;
  wantedAmountsIn: BigNumber[];
}> => {
  let wantedAmountsIn = [];

  const amountIn: BigNumber = await liquidationPairContract
    .callStatic.computeExactAmountIn(originalMaxAmountOut);

  const amountInMin = ethers.constants.MaxInt256;

  wantedAmountsIn = await getLiquidationPairComputeExactAmountInMulticall(
    liquidationPairContract,
    wantedAmountsOut,
    readProvider,
  );

  return {
    amountIn,
    amountInMin,
    wantedAmountsIn,
  };
};

—

Note: This is using multicall reads to speed up network calls. Instead of doing 100 RPC calls, we can do 1 RPC call with 100 queries. See the implementation here.

Let’s now pass the arrays of amounts in and amounts out to the a calculateProfit helper function. This will create a new array with the gross profit of all 100 data points, which we can then compare (with Math.max()) to find the maximum profit:

import { ethers, BigNumber } from 'ethers';

const { profitable, selectedIndex } = await calculateProfit(wantedAmountsIn, wantedAmountsOut);

// Calculates the amount of profit the bot will make on this swap
// and if it's profitable or not
const calculateProfit = async (
  wantedAmountsIn: BigNumber[],
  wantedAmountsOut: BigNumber[],
): Promise<{ profitable: boolean; selectedIndex: number }> => {
  console.log('Gross profit = tokenOut - tokenIn');

  const grossProfitsUsd = [];
  for (let i = 0; i < wantedAmountsIn.length; i++) {
    const amountOut = wantedAmountsOut[i];
    const amountIn = wantedAmountsIn[i];

    const underlyingAssetTokenUsd =
      parseFloat(ethers.utils.formatUnits(amountOut, tokenOut.decimals)) *
      underlyingAssetToken.assetRateUsd;
    const tokenInUsd =
      parseFloat(ethers.utils.formatUnits(amountIn, tokenIn.decimals)) * tokenIn.assetRateUsd;

    const grossProfitUsd = underlyingAssetTokenUsd - tokenInUsd;

    console.log(`Index ${i}: $${grossProfitUsd} = $${underlyingAssetTokenUsd} - $${tokenInUsd}`);

    grossProfitsUsd.push(grossProfitUsd);
  }

  const getMaxGrossProfit = (grossProfitsUsd: number[]) => {
    const max = grossProfitsUsd.reduce((a, b) => Math.max(a, b), -Infinity);
    return { maxGrossProfit: max, selectedIndex: grossProfitsUsd.indexOf(max) };
  };

  const { selectedIndex, maxGrossProfit } = getMaxGrossProfit(grossProfitsUsd);
  console.log(`Selected Index ${selectedIndex} - $${maxGrossProfit}`);

  // Compare the profit with the gas costs to learn if transaction will be profitable
  const estimatedProfitUsd = maxGrossProfit - gasFeeUsd;
  const profitable = estimatedProfitUsd > 0;

  return { profitable, selectedIndex };
};

This will output something like the following:

Example console.log output of all the data point comparisons for finding the optimal profit.

In this case data point 21 (with index 20) was the most profitable. If we wanted to run it to earn the $0.11 of profit we could, but it would likely be best to wait until we are further along in the auction when the gross profit will be higher.

3. Executing Swaps

When we find a profitable swap, we can execute the swap using the Liquidation Router. The Router provides one function to do so: swapExactAmountOut() allows the caller to define the expected number of output tokens.

We have been using OpenZeppelin Defender to run our bots every n minutes, which is where our transactionrelayer instance comes from. However you could do this using ethers.js providers, a web3.js provider, Gelato, Chainlink Keepers, etc.

Next let’s check the relayer account’s POOL balance:

// Your Relayer (the EOA or "externally owned account") will be swapping POOL 
// tokens, so it will need to have a POOL balance.
const relayerAddress = '0x49ca801A80e31B1ef929eAB13Ab3FBbAe7A55e8F';

// Check if tokenIn balance for relayer (bot) account is sufficient
const tokenInContract = new ethers.Contract(tokenInAddress, ERC20Abi, writeProvider);
const tokenInBalance = await tokenInContract.balanceOf(relayerAddress);
const sufficientBalance = tokenInBalance.gt(exactAmountIn);

if (!sufficientBalance) {
  console.warn('Insufficient POOL balance.')
}

If the allowance of POOL for the relayer to the LiquidationRouter hasn’t been set previously, we will need to set that as well:

// Get allowance approval
const allowance = await tokenInContract.allowance(
  relayerAddress,
  liquidationRouterContract.address
);

// Note that we're setting it to the max allowance as we trust the security
// audits of the LiquidationRouter contract
if (allowance.lt(exactAmountIn)) {
  const tx = await tokenInContract.approve(
    liquidationRouterContract.address,
    ethers.constants.MaxInt256
  );
  await tx.wait();

  const newAllowanceResult = await tokenInContract.allowance(
    relayerAddress,
    liquidationRouterContract.address,
  );
  console.log('New allowance:', newAllowanceResult[0].toString());
} else {
  console.log('Sufficient allowance ✔');
}

With the allowance taken care of, we can create and send the transaction:

if (profitable) {
  const transactionPopulated = await 
    liquidationRouterContract.populateTransaction.swapExactAmountOut(
      liquidationPair.address,
      swapRecipient,
      wantedAmountsOut[selectedIndex],
      amountInMin,
      Math.floor(Date.now() / 1000) + 100 // deadline
    );

  const transactionSentToNetwork = await relayer.sendTransaction({
    data: transactionPopulated.data,
    to: transactionPopulated.to,
    gasLimit: 600000,
  });
  console.log('Transaction hash:', transactionSentToNetwork.hash);
}

Note: swapExactAmountOut() exists on both the LiquidationPair contracts and the LiquidationRouter, however for your swaps to be successful you will need to run it on the LiquidationRouter.

Finishing Up

Hopefully that gives you a good rundown of how to build an Arbitrage Liquidations swap bot with the new PoolTogether (hyperstructure) protocol.

In Part 2 we will look at Prize Claiming bots - another way to pocket profit while automating the claiming of prizes every day on behalf of winners.

In Part 3 we break down the Draw Auction bot, yet another way to profit by helping with the RNG (random number creation and bridging) process.

If you have any questions feel free to reach out to anyone in the PoolTogether Discord community. The #developers channel is your best bet!

Happy arbing!

* Profit is not guaranteed. Make sure to monitor and tweak your bot code and settings to nail your profit margins!