Sarcophagus

import { createPublicClient, createWalletClient, http, parseAbi } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'

const robinhood = {
  id: 4663,
  name: 'Robinhood Chain',
  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
  rpcUrls: {
    default: { http: ['https://rpc.mainnet.chain.robinhood.com'] },
  },
} as const

const SARCOPHAGUS = '0x712567e71a93Fb111510A790cAf3469677aAba3e'

const sarcophagusAbi = parseAbi([
  'function R33() view returns (address)',
  'function nonce() view returns (uint256)',
  'function exchangeAmountThreshold() view returns (uint256)',
  'function maxTokenClaim() view returns (uint256)',
  'function bury(uint256 nonce, address[] tokens, uint256[] minAmountsOut)',
])

const erc20Abi = parseAbi([
  'function balanceOf(address) view returns (uint256)',
  'function allowance(address,address) view returns (uint256)',
])

const publicClient = createPublicClient({
  chain: robinhood,
  transport: http(),
})

const account = privateKeyToAccount(process.env.SEARCHER_KEY as `0x${string}`)
const walletClient = createWalletClient({
  account,
  chain: robinhood,
  transport: http(),
})

// Supply addresses discovered from trusted fee configuration or indexed logs.
const tokens: readonly `0x${string}`[] = [
  // '0x...',
]

const blockNumber = await publicClient.getBlockNumber()
const read = { address: SARCOPHAGUS, abi: sarcophagusAbi, blockNumber } as const

const [r33, nonce, threshold, maxTokenClaim] = await Promise.all([
  publicClient.readContract({ ...read, functionName: 'R33' }),
  publicClient.readContract({ ...read, functionName: 'nonce' }),
  publicClient.readContract({ ...read, functionName: 'exchangeAmountThreshold' }),
  publicClient.readContract({ ...read, functionName: 'maxTokenClaim' }),
])

if (tokens.length === 0 || BigInt(tokens.length) > maxTokenClaim) {
  throw new Error('Invalid token count')
}

const balances = await Promise.all(
  tokens.map((token) =>
    publicClient.readContract({
      address: token,
      abi: erc20Abi,
      functionName: 'balanceOf',
      args: [SARCOPHAGUS],
      blockNumber,
    }),
  ),
)

// Raw token units. Choose policy based on each token's behavior and latency.
const minAmountsOut = balances.map((balance) => (balance * 995n) / 1000n)

const allowance = await publicClient.readContract({
  address: r33,
  abi: erc20Abi,
  functionName: 'allowance',
  args: [account.address, SARCOPHAGUS],
})

if (allowance < threshold) {
  throw new Error('Approve the r33 threshold, then rebuild the quote from a new block')
}

const { request } = await publicClient.simulateContract({
  account,
  address: SARCOPHAGUS,
  abi: sarcophagusAbi,
  functionName: 'bury',
  args: [nonce, [...tokens], minAmountsOut],
})

// Re-evaluate profitability and freshness before signing.
const hash = await walletClient.writeContract(request)
const receipt = await publicClient.waitForTransactionReceipt({ hash })
if (receipt.status !== 'success') throw new Error(`bury reverted: ${hash}`)

function bury(
    uint256 _nonce,
    address[] calldata _tokens,
    uint256[] calldata _minAmountsOut
) external

function rescue(address token, address to, uint256 amount) external onlyOwner
function setExchangeAmountThreshold(uint256 threshold) external onlyOwner
function setMaxTokenClaim(uint256 maxTokenClaim) external onlyOwner

event Buried(
    uint256 indexed nonce,
    address indexed user,
    address[] tokensClaimed
)