dgf-prototype/ethereum/scripts/automatic-staking.js

const { ethers } = require('hardhat');
const { getContractAddressByNetworkName } = require('./contract-config');
const readFromApi = require('./util/read-from-api');

const network = process.env.HARDHAT_NETWORK;

let dao;
let work1;
let onboarding;
let account;
let validationPools;
let reputation;
let posts;

const fetchReputation = async () => {
  reputation = await dao.balanceOf(account);
  console.log(`reputation: ${reputation}`);
};

const fetchPost = async (postIndex) => {
  const {
    id, sender, author, contentId,
  } = await dao.posts(postIndex);
  const { content } = await readFromApi(contentId);
  const post = {
    id,
    sender,
    author,
    contentId,
    content,
  };
  posts[postIndex] = post;
  return post;
};

const fetchValidationPool = async (poolIndex) => {
  const {
    id, postIndex, sender, stakeCount, fee, duration, endTime, resolved, outcome,
  } = await dao.validationPools(poolIndex);
  const pool = {
    id, postIndex, sender, stakeCount, fee, duration, endTime, resolved, outcome,
  };
  pool.post = await fetchPost(pool.postIndex);
  validationPools[poolIndex] = pool;
  return pool;
};

const fetchValidationPools = async () => {
  const count = await dao.validationPoolCount();
  console.log(`validation pool count: ${count}`);
  const promises = [];
  validationPools = [];
  for (let i = 0; i < count; i += 1) {
    promises.push(fetchValidationPool(i));
  }
  await Promise.all(promises);
};

const initialize = async () => {
  const getContract = (name) => ethers.getContractAt(
    name,
    getContractAddressByNetworkName(network, name),
  );
  dao = await getContract('DAO');
  work1 = await getContract('Work1');
  onboarding = await getContract('Onboarding');
  [account] = await ethers.getSigners();
  const address = await account.getAddress();
  console.log(`account: ${address}`);
  posts = [];
  await fetchReputation();
  await fetchValidationPools();
};

const poolIsActive = (pool) => {
  if (new Date() >= new Date(Number(pool.endTime) * 1000)) return false;
  if (pool.resolved) return false;
  return true;
};

const poolIsValid = async (pool) => {
  switch (pool.sender) {
    case getContractAddressByNetworkName(network, 'Work1'): {
      // TODO: Read content of post for this pool and verify that it conforms to protocol
      console.log(`post ${pool.post.id} content: ${pool.post.content}`);
      if (pool.post.content) return true;
      return true;
    }
    case getContractAddressByNetworkName(network, 'Onboarding'):
      // TODO: Read content of post for this pool and verify that it conforms to protocol
      return true;
    default:
      return false;
  }
};

const getPoolStatus = (pool) => {
  if (poolIsActive(pool)) return 'Active';
  if (!pool.resolved) return 'Ready to Evaluate';
  if (pool.outcome) return 'Accepted';
  return 'Rejected';
};

const stake = async (pool, amount, inFavor) => {
  console.log(`staking ${amount} ${inFavor ? 'in favor of' : 'against'} pool ${pool.id.toString()}`);
  await dao.stake(pool.id, amount, true);
  await fetchReputation();
};

const stakeEach = async (pools, amountPerPool) => {
  const promises = [];
  pools.forEach(async (pool) => {
    const inFavor = await poolIsValid(pool);
    promises.push(stake(pool, amountPerPool, inFavor));
  });
  await Promise.all(promises);
};

async function main() {
  await initialize();

  validationPools.forEach((pool) => {
    console.log(`pool ${pool.id.toString()}, status: ${getPoolStatus(pool)}, post content: ${pool.post?.content}`);
  });

  // Stake half of available reputation on any active pools
  const activePools = validationPools.filter(poolIsActive);
  if (activePools.length && reputation > 0) {
    const amountPerPool = reputation / BigInt(2) / BigInt(activePools.length);
    await stakeEach(activePools, amountPerPool);
  }

  // Listen for new validation pools
  dao.on('ValidationPoolInitiated', async (poolIndex) => {
    console.log(`pool ${poolIndex} started`);
    const pool = await fetchValidationPool(poolIndex);
    await fetchReputation();
    if (!reputation) return;
    const amountToStake = reputation / BigInt(2);
    if (await poolIsValid(pool)) {
    // Stake half of available reputation on this validation pool
      await stake(pool, amountToStake, true);
    } else {
      console.log(`pool sender ${pool.sender} is not recognized`);
      await stake(pool, amountToStake, false);
    }
  });

  dao.on('ValidationPoolResolved', async (poolIndex, votePasses) => {
    console.log(`pool ${poolIndex} resolved, status: ${votePasses ? 'accepted' : 'rejected'}`);
    fetchValidationPool(poolIndex);
    fetchReputation();
  });

  work1.on('AvailabilityStaked', async () => {
    fetchReputation();
  });

  onboarding.on('AvailabilityStaked', async () => {
    fetchReputation();
  });
}

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