Build with Otomate

npm install viem

import {
  createPublicClient, createWalletClient, custom, http, erc20Abi,
  encodeAbiParameters, encodeFunctionData, getAbiItem, keccak256,
  stringToHex, toHex, parseUnits, parseEventLogs,
  type Address, type Hex, type EIP1193Provider,
  type ContractFunctionArgs, type WalletClient, type Account, parseAbi,
  BaseError, ContractFunctionRevertedError,
} from 'viem';
import { ink } from 'viem/chains';
import { LaunchConfigurationAbi105 as configurationAbi } from './abis/LaunchConfiguration';
import { LocalStockQuoteRegistryAbi105 as registryAbi } from './abis/LocalStockQuoteRegistry';
import { LauncherMarketCoordinator035Abi105 as marketAbi } from './abis/LauncherMarketCoordinator035';
import { LauncherProjectFactory037Abi105 as factoryAbi }
  from './abis/LauncherProjectFactory037';
import { ILauncherProjectFactory105Abi105 as creationAbi }
  from './abis/ILauncherProjectFactory105';
import { LauncherProjectEntitlement105Abi105 as entitlementAbi }
  from './abis/LauncherProjectEntitlement105';

const curveAbi = parseAbi([
  "function buyNativeWithFeePolicy103(uint256 minimum, uint256 deadline, address recipient, bytes32 expected, uint16 maximumOrdinaryBps) payable returns ((uint256 grossQuoteUsed, uint256 grossQuoteRefund, uint256 principalIn, uint256 feeAmount, uint256 tokensOut))",
  "function buyWithFeePolicy103(uint256 gross, uint256 minimum, uint256 deadline, address recipient, bytes32 expected, uint16 maximumOrdinaryBps) returns ((uint256 grossQuoteUsed, uint256 grossQuoteRefund, uint256 principalIn, uint256 feeAmount, uint256 tokensOut))",
  "function currentFeeWitness103() view returns (bytes32 hash, uint64 version, uint16 totalBps)",
  "function graduated() view returns (bool)",
  "function launchActive104() view returns (bool active)",
  "function quoteAsset() view returns (address)",
  "function quoteBuyFor(uint256 gross, address recipient) view returns ((uint256 grossQuoteUsed, uint256 grossQuoteRefund, uint256 principalIn, uint256 feeAmount, uint256 tokensOut))",
  "function quoteSell(uint256 amount) view returns ((uint256 tokensIn, uint256 grossQuoteOut, uint256 feeAmount, uint256 netQuoteOut))",
  "function sellNativeWithFeePolicy103(uint256 amount, uint256 minimum, uint256 deadline, address recipient, bytes32 expected, uint16 maximumOrdinaryBps) returns ((uint256 tokensIn, uint256 grossQuoteOut, uint256 feeAmount, uint256 netQuoteOut))",
  "function sellWithFeePolicy103(uint256 amount, uint256 minimum, uint256 deadline, address recipient, bytes32 expected, uint16 maximumOrdinaryBps) returns ((uint256 tokensIn, uint256 grossQuoteOut, uint256 feeAmount, uint256 netQuoteOut))",
  "function token() view returns (address)",
  "event TokensBought(address indexed payer, address indexed recipient, uint256 grossQuoteUsed, uint256 feeAmount, uint256 tokensOut, uint256 realQuoteReserve, uint256 tokenReserve)",
  "event TokensSold(address indexed seller, address indexed recipient, uint256 tokensIn, uint256 grossQuoteOut, uint256 feeAmount, uint256 netQuoteOut, uint256 realQuoteReserve, uint256 tokenReserve)"
]);

// reserve must atomically insert a unique key and commit before returning true.
// Keep failed/uncertain attempts until their transaction has been reconciled.
export type AttemptStore = {
  reserve(key: string, transaction: { to: Address; data: Hex; value: string }): Promise<boolean>;
  submitted(key: string, hash: Hex): Promise<void>;
  confirmed(key: string, hash: Hex): Promise<void>;
};
export type Context = {
  client: ReturnType<typeof createPublicClient<ReturnType<typeof http>, typeof ink>>;
  wallet: WalletClient;
  account: Address;
  signer: Account | Address;
  attempts: AttemptStore;
};
export async function connectOtomate(provider: EIP1193Provider, rpcUrl: string,
  attempts: AttemptStore): Promise<Context> {
  const client = createPublicClient({ chain: ink, transport: http(rpcUrl) });
  const wallet = createWalletClient({ chain: ink, transport: custom(provider) });
  await wallet.switchChain({ id: ink.id });
  const [account] = await wallet.requestAddresses();
  if (!account || await client.getChainId() !== ink.id) throw new Error('Connect to Ink');
  return { client, wallet, account, signer: account, attempts };
}
export async function connectBot(signer: Account, rpcUrl: string,
  attempts: AttemptStore): Promise<Context> {
  const client = createPublicClient({ chain: ink, transport: http(rpcUrl) });
  if (await client.getChainId() !== ink.id) throw new Error('Wrong RPC chain');
  const wallet = createWalletClient({ account: signer, chain: ink, transport: http(rpcUrl) });
  return { client, wallet, account: signer.address, signer, attempts };
}
type Transaction = { to: Address; data: Hex; value: bigint };

// A persistent attempt ID prevents this example from blindly sending twice.
// Keep the same ID when inspecting or recovering the same attempted action.
async function sendOnce(ctx: Context, attemptId: string, tx: Transaction) {
  const key = `otomate:${ink.id}:${ctx.account}:${attemptId}`;
  const [selected] = await ctx.wallet.getAddresses();
  if (selected?.toLowerCase() !== ctx.account.toLowerCase()
      || await ctx.wallet.getChainId() !== ink.id
      || await ctx.client.getChainId() !== ink.id) {
    throw new Error('Wallet or network changed');
  }
  await ctx.client.call({ ...tx, account: ctx.account });
  const estimate = await ctx.client.estimateGas({ ...tx, account: ctx.account });
  const gas = (estimate * 120n + 99n) / 100n;
  const block = await ctx.client.getBlock();
  if (gas > 10_000_000n || gas > block.gasLimit) {
    throw new Error('Transaction exceeds the normal gas budget');
  }
  if (!await ctx.attempts.reserve(key, {
    to: tx.to, data: tx.data, value: tx.value.toString(),
  })) throw new Error('Reconcile the existing attempt');
  const hash = await ctx.wallet.sendTransaction({ ...tx, account: ctx.signer, chain: ink, gas });
  await ctx.attempts.submitted(key, hash);
  const receipt = await ctx.client.waitForTransactionReceipt({ hash, confirmations: 2 });
  if (receipt.status !== 'success') throw new Error(`Transaction reverted: ${hash}`);
  const canonical = await ctx.client.getBlock({ blockNumber: receipt.blockNumber });
  if (canonical.hash !== receipt.blockHash) throw new Error('Receipt was reorganized');
  await ctx.attempts.confirmed(key, hash);
  return receipt;
}

async function approveExact(ctx: Context, token: Address, spender: Address,
  amount: bigint, attemptId: string) {
  const allowance = await ctx.client.readContract({ address: token,
    abi: erc20Abi, functionName: 'allowance', args: [ctx.account, spender] });
  if (allowance >= amount) return;
  // Supports admitted tokens that require clearing a nonzero allowance first.
  if (allowance > 0n) await sendOnce(ctx, `${attemptId}:reset`, {
    to: token, data: encodeFunctionData({ abi: erc20Abi,
      functionName: 'approve', args: [spender, 0n] }), value: 0n,
  });
  await sendOnce(ctx, `${attemptId}:approve`, {
    to: token, data: encodeFunctionData({ abi: erc20Abi,
      functionName: 'approve', args: [spender, amount] }), value: 0n,
  });
}

function minimumAfterSlippage(output: bigint, slippageBps: bigint) {
  if (slippageBps < 0n || slippageBps >= 10_000n) throw new Error('Invalid slippage');
  const minimum = output * (10_000n - slippageBps) / 10_000n;
  if (minimum <= 0n) throw new Error('Output is too small');
  return minimum;
}

export async function readLaunchConfigurations(ctx: Context, factory: Address,
  fromBlock: bigint, toBlock: bigint) {
  if (fromBlock < 0n || toBlock < fromBlock) throw new Error('Invalid block range');
  const infrastructure = await ctx.client.readContract({ address: factory,
    abi: factoryAbi, functionName: 'infrastructure', blockNumber: toBlock });
  const registry = await ctx.client.readContract({ address: infrastructure.market,
    abi: marketAbi, functionName: 'stockRegistry', blockNumber: toBlock });
  const recipes = new Map<bigint, Hex>();
  for (let from = fromBlock; from <= toBlock; from += 1_000n) {
    const end = from + 999n < toBlock ? from + 999n : toBlock;
    const logs = await ctx.client.getContractEvents({ address: factory,
      abi: factoryAbi, eventName: 'RecipeAdded', fromBlock: from, toBlock: end,
      strict: true });
    for (const log of logs) recipes.set(log.args.version, log.args.recipeHash);
  }
  const availableRecipes = [];
  for (const [id, expectedHash] of recipes) {
    const enabled = await ctx.client.readContract({ address: factory,
      abi: factoryAbi, functionName: 'recipeEnabled', args: [id], blockNumber: toBlock });
    if (!enabled) continue;
    const hash = await ctx.client.readContract({ address: factory,
      abi: factoryAbi, functionName: 'recipeHash', args: [id], blockNumber: toBlock });
    if (hash !== expectedHash) throw new Error('Recipe identity mismatch');
    const config = await ctx.client.readContract({ address: factory,
      abi: configurationAbi, functionName: 'recipeConfig103', args: [id], blockNumber: toBlock });
    availableRecipes.push({ id, hash, config });
  }
  const count = await ctx.client.readContract({ address: registry,
    abi: registryAbi, functionName: 'presetCount', blockNumber: toBlock });
  const block = await ctx.client.getBlock({ blockNumber: toBlock });
  const presets = [];
  for (let id = 1n; id <= count; id++) {
    const hash = await ctx.client.readContract({ address: registry,
      abi: registryAbi, functionName: 'configHash', args: [id], blockNumber: toBlock });
    // A contract revert marks an unavailable preset. RPC failures must propagate.
    try {
      const [asset, economics] = await ctx.client.readContract({ address: registry,
        abi: registryAbi, functionName: 'validateCreation',
        args: [id, hash, block.timestamp + 300n], blockNumber: toBlock });
      presets.push({ id, hash, quote: asset.quote, asset, economics });
    } catch (error) {
      if (error instanceof BaseError && error.walk(e => e instanceof ContractFunctionRevertedError)
        instanceof ContractFunctionRevertedError) continue;
      throw error;
    }
  }
  const wrappedNative = await ctx.client.readContract({ address: registry,
    abi: registryAbi, functionName: 'weth', blockNumber: toBlock });
  return { market: infrastructure.market, registry, wrappedNative, recipes: availableRecipes, presets };
}

export function createLaunchNonce(): Hex {
  let nonce: Hex;
  do { nonce = toHex(crypto.getRandomValues(new Uint8Array(32))); }
  while (nonce === `0x${'0'.repeat(64)}`);
  return nonce;
}

export function tokenOnlyEconomics(owner: Address, approvedTrading: {
  totalBps: number;
  allocationBps: readonly [number, number, number, number, number, number];
}): Economics {
  const recipients = [owner, owner, owner, owner, owner, owner] as const;
  return {
    trading: { ...approvedTrading, creatorWeights: [10_000, 0, 0],
      recipients, companions: false },
    royalty: { totalBps: 0, allocationBps: [0, 0, 0, 0, 0, 0],
      creatorWeights: [10_000, 0, 0], recipients, companions: false },
    creatorExtraBps: 0, creatorExtraBuybackBps: 0,
    baseCreatorBuybackBps: 0, creationMode: 0,
  };
}

type CreateArgs = ContractFunctionArgs<typeof creationAbi, 'nonpayable', 'createReserved105'>;
type CreateRequest = CreateArgs[0];
type Economics = CreateArgs[1];
type LaunchInput = {
  factory: Address; entitlement: Address; recipeHash: Hex;
  request: Omit<CreateRequest, 'factoryRevision' | 'deadline'>;
  economics: Economics; maximumPlatformFee: bigint; attemptId: string;
  initialBuy?: { amount: string; native: boolean; wrappedNative: Address; slippageBps: bigint };
};

export async function launchToken(ctx: Context, input: LaunchInput) {
  const { client, account } = ctx;
  const { factory, entitlement } = input;
  let economics = input.economics;
  const quoteAsset = input.request.intent.quote;
  const firstBuy = input.initialBuy;
  let amount = 0n;
  if (firstBuy) {
    if (firstBuy.native && quoteAsset.toLowerCase() !== firstBuy.wrappedNative.toLowerCase()) {
      throw new Error('Selected quote asset does not support native funding');
    }
    const decimals = firstBuy.native ? 18 : await client.readContract({
      address: quoteAsset, abi: erc20Abi, functionName: 'decimals',
    });
    amount = parseUnits(firstBuy.amount, decimals);
    if (amount <= 0n) throw new Error('Initial purchase must be positive');
    if (!firstBuy.native) {
      const balance = await client.readContract({ address: quoteAsset,
        abi: erc20Abi, functionName: 'balanceOf', args: [account] });
      if (balance < amount) throw new Error('Insufficient initial-buy balance');
      // Atomic launch uses ENTITLEMENT as spender, not the future curve.
      await approveExact(ctx, quoteAsset, entitlement, amount, input.attemptId);
    }
  }
  const block = await client.getBlock();
  const factoryRead = { address: factory, abi: factoryAbi, blockNumber: block.number } as const;
  const entitlementRead = { address: entitlement, abi: entitlementAbi, blockNumber: block.number } as const;
  const [fee, feeVersion, allowed, enabled, recipeHash, factoryAdmission, entitlementAdmission] = await Promise.all([
    client.readContract({ ...entitlementRead, functionName: 'fee' }),
    client.readContract({ ...entitlementRead, functionName: 'feeVersion' }),
    client.readContract({ ...entitlementRead, functionName: 'factoryAllowed', args: [factory] }),
    client.readContract({ ...factoryRead, functionName: 'recipeEnabled', args: [input.request.intent.recipe] }),
    client.readContract({ ...factoryRead, functionName: 'recipeHash', args: [input.request.intent.recipe] }),
    client.readContract({ ...factoryRead, functionName: 'requireAdmission' }),
    client.readContract({ ...entitlementRead, functionName: 'requireAdmission' }),
  ]);
  if (!allowed || !enabled || recipeHash.toLowerCase() !== input.recipeHash.toLowerCase()) {
    throw new Error('Factory or recipe is not admitted');
  }
  if (fee > input.maximumPlatformFee) throw new Error('Platform fee exceeds your limit');
  const deadline = block.timestamp + 300n;
  const request: CreateRequest = { ...input.request, factoryRevision: factoryAdmission[0], deadline };
  const projectId = await client.readContract({ ...entitlementRead,
    functionName: 'entitlementId', args: [account, request.intent.nonce] });
  const receivers = await client.readContract({ address: factory, abi: creationAbi,
    functionName: 'predictedReceivers105',
    args: [projectId, economics.trading.recipients[0], economics.creationMode !== 0],
    blockNumber: block.number });
  economics = { ...economics,
    trading: { ...economics.trading, recipients: receivers },
    royalty: { ...economics.royalty,
      recipients: [economics.royalty.recipients[0], receivers[1], receivers[2],
        receivers[3], receivers[4], receivers[5]] },
  };
  const commitment = await client.readContract({ address: factory, abi: creationAbi,
    functionName: 'commitmentFor105', args: [account, request.intent, economics],
    blockNumber: block.number });
  const create = getAbiItem({ abi: creationAbi, name: 'createReserved105' });
  const creationData = encodeAbiParameters(
    [{ type: 'bytes32' }, ...create.inputs],
    [keccak256(stringToHex('OTOMATE_LAUNCHER_PROJECT_CREATE_105_V2')), request, economics],
  );
  const feeQuote = {
    nonce: request.intent.nonce, commitment, factory, feeVersion,
    factoryRevision: factoryAdmission[0], entitlementRevision: entitlementAdmission[0],
    maxFee: input.maximumPlatformFee, deadline,
  };
  let data: Hex;
  if (firstBuy) {
    const quote = await client.readContract({ address: factory, abi: creationAbi,
      functionName: 'quoteInitialBuy105',
      args: [account, request.intent, economics, amount, deadline], blockNumber: block.number,
    });
    if (quote.grossQuoteUsed <= 0n) throw new Error('No executable initial-buy quote');
    const minimum = minimumAfterSlippage(quote.tokensOut, firstBuy.slippageBps);
    data = encodeFunctionData({ abi: entitlementAbi, functionName: 'payAndCreateAndBuy',
      args: [feeQuote, creationData, {
        quoteAsset, amountIn: amount,
        minimumTokensOut: minimum * amount / quote.grossQuoteUsed,
        deadline, nativePayment: firstBuy.native,
      }],
    });
  } else {
    data = encodeFunctionData({ abi: entitlementAbi, functionName: 'payAndCreate',
      args: [feeQuote, creationData] });
  }
  const receipt = await sendOnce(ctx, `${input.attemptId}:launch`, {
    to: entitlement, data, value: fee + (firstBuy?.native ? amount : 0n),
  });
  const events = parseEventLogs({ abi: factoryAbi, eventName: 'ProjectCreated',
    logs: receipt.logs.filter(log => log.address.toLowerCase() === factory.toLowerCase()),
  });
  const event = events.find(item => item.args.entitlementId === projectId
    && item.args.owner.toLowerCase() === account.toLowerCase()
    && item.args.commitment === commitment);
  if (!event) throw new Error(`Inspect launch receipt ${receipt.transactionHash}`);
  const project = await client.readContract({ address: factory, abi: factoryAbi,
    functionName: 'project', args: [projectId], blockNumber: receipt.blockNumber });
  if (project.token.toLowerCase() !== event.args.token.toLowerCase()) {
    throw new Error('Created token does not match the project record');
  }
  return { hash: receipt.transactionHash, projectId, token: project.token,
    curve: project.curve, project };
}

export async function launchFromYourApp(
  provider: EIP1193Provider, rpcUrl: string, attempts: AttemptStore, preparedLaunch: LaunchInput,
) {
  const ctx = await connectOtomate(provider, rpcUrl, attempts);
  const { hash, projectId, token, curve } = await launchToken(ctx, preparedLaunch);
  // Save these values in your project record and show the token to the user.
  return { hash, projectId, token, curve };
}

export function withInitialEthBuy(input: LaunchInput, wrappedNative: Address): LaunchInput {
  return { ...input, initialBuy: {
    amount: '0.01', native: true, wrappedNative, slippageBps: 100n,
  } };
}

export async function buyToken(ctx: Context, input: {
  curve: Address; recipient: Address; amount: string; native: boolean;
  wrappedNative: Address; slippageBps: bigint; attemptId: string;
}) {
  const { client } = ctx;
  const read = { address: input.curve, abi: curveAbi } as const;
  const quoteAsset = await client.readContract({ ...read, functionName: 'quoteAsset' });
  if (input.native && quoteAsset.toLowerCase() !== input.wrappedNative.toLowerCase()) {
    throw new Error('This pair does not accept native ETH');
  }
  const decimals = input.native ? 18 : await client.readContract({
    address: quoteAsset, abi: erc20Abi, functionName: 'decimals',
  });
  const amount = parseUnits(input.amount, decimals);
  if (amount <= 0n) throw new Error('Enter a positive amount');
  if (!input.native) {
    const balance = await client.readContract({ address: quoteAsset,
      abi: erc20Abi, functionName: 'balanceOf', args: [ctx.account] });
    if (balance < amount) throw new Error('Insufficient quote-asset balance');
    await approveExact(ctx, quoteAsset, input.curve, amount, input.attemptId);
  }
  // Quote AFTER approval: its transaction may have changed the current block.
  const block = await client.getBlock();
  const [graduated, active, quote, witness] = await Promise.all([
    client.readContract({ ...read, functionName: 'graduated', blockNumber: block.number }),
    client.readContract({ ...read, functionName: 'launchActive104', blockNumber: block.number }),
    client.readContract({ ...read, functionName: 'quoteBuyFor',
      args: [amount, input.recipient], blockNumber: block.number }),
    client.readContract({ ...read, functionName: 'currentFeeWitness103', blockNumber: block.number }),
  ]);
  if (graduated || !active) throw new Error('Curve trading is unavailable');
  if (quote.grossQuoteUsed <= 0n) throw new Error('No executable quote');
  const effectiveMinimum = minimumAfterSlippage(quote.tokensOut, input.slippageBps);
  // Raw 105 ABI minima are relative to the offered input, including partial fills.
  const minimum = effectiveMinimum * amount / quote.grossQuoteUsed;
  const deadline = block.timestamp + 300n;
  const [policyHash, , maximumOrdinaryBps] = witness;
  const data = input.native
    ? encodeFunctionData({ abi: curveAbi, functionName: 'buyNativeWithFeePolicy103',
        args: [minimum, deadline, input.recipient, policyHash, maximumOrdinaryBps] })
    : encodeFunctionData({ abi: curveAbi, functionName: 'buyWithFeePolicy103',
        args: [amount, minimum, deadline, input.recipient, policyHash, maximumOrdinaryBps] });
  const receipt = await sendOnce(ctx, `${input.attemptId}:buy`, {
    to: input.curve, data, value: input.native ? amount : 0n,
  });
  const fills = parseEventLogs({ abi: curveAbi, eventName: 'TokensBought',
    logs: receipt.logs.filter(log => log.address.toLowerCase() === input.curve.toLowerCase()),
  });
  if (fills.length !== 1 || fills[0].args.recipient.toLowerCase() !== input.recipient.toLowerCase()) {
    throw new Error(`Inspect purchase receipt ${receipt.transactionHash}`);
  }
  return { hash: receipt.transactionHash, quoted: quote, executed: fills[0].args };
}

export async function buyFromYourApp(
  provider: EIP1193Provider, rpcUrl: string, attempts: AttemptStore,
  curve: Address, wrappedNative: Address, attemptId: string,
) {
  const ctx = await connectOtomate(provider, rpcUrl, attempts);
  const result = await buyToken(ctx, {
    curve,
    recipient: ctx.account,
    amount: '0.01',
    native: true,
    wrappedNative,
    slippageBps: 100n,
    attemptId,
  });
  // Use the hash for your explorer link and the fill for the success screen.
  return result;
}

export async function sellToken(ctx: Context, input: {
  curve: Address; recipient: Address; amount: string; native: boolean;
  wrappedNative: Address; slippageBps: bigint; attemptId: string;
}) {
  const { client } = ctx;
  const read = { address: input.curve, abi: curveAbi } as const;
  const [token, quoteAsset] = await Promise.all([
    client.readContract({ ...read, functionName: 'token' }),
    client.readContract({ ...read, functionName: 'quoteAsset' }),
  ]);
  if (input.native && quoteAsset.toLowerCase() !== input.wrappedNative.toLowerCase()) {
    throw new Error('This pair cannot return native ETH');
  }
  const [decimals, balance] = await Promise.all([
    client.readContract({ address: token, abi: erc20Abi, functionName: 'decimals' }),
    client.readContract({ address: token, abi: erc20Abi,
      functionName: 'balanceOf', args: [ctx.account] }),
  ]);
  const amount = parseUnits(input.amount, decimals);
  if (amount <= 0n || amount > balance) throw new Error('Invalid token amount');
  await approveExact(ctx, token, input.curve, amount, input.attemptId);
  const block = await client.getBlock();
  const [graduated, active, quote, witness] = await Promise.all([
    client.readContract({ ...read, functionName: 'graduated', blockNumber: block.number }),
    client.readContract({ ...read, functionName: 'launchActive104', blockNumber: block.number }),
    client.readContract({ ...read, functionName: 'quoteSell', args: [amount], blockNumber: block.number }),
    client.readContract({ ...read, functionName: 'currentFeeWitness103', blockNumber: block.number }),
  ]);
  if (graduated || !active) throw new Error('Curve trading is unavailable');
  const minimum = minimumAfterSlippage(quote.netQuoteOut, input.slippageBps);
  const [policyHash, , maximumOrdinaryBps] = witness;
  const data = encodeFunctionData({ abi: curveAbi,
    functionName: input.native ? 'sellNativeWithFeePolicy103' : 'sellWithFeePolicy103',
    args: [amount, minimum, block.timestamp + 300n, input.recipient, policyHash, maximumOrdinaryBps],
  });
  const receipt = await sendOnce(ctx, `${input.attemptId}:sell`, {
    to: input.curve, data, value: 0n,
  });
  const fills = parseEventLogs({ abi: curveAbi, eventName: 'TokensSold',
    logs: receipt.logs.filter(log => log.address.toLowerCase() === input.curve.toLowerCase()),
  });
  if (fills.length !== 1 || fills[0].args.recipient.toLowerCase() !== input.recipient.toLowerCase()) {
    throw new Error(`Inspect sale receipt ${receipt.transactionHash}`);
  }
  return { hash: receipt.transactionHash, quoted: quote, executed: fills[0].args };
}

tokensOut >= ceil(minimum * actualGrossQuoteUsed / offeredGross)

const graduatorAbi = parseAbi([
  'function poolKey(address curve) view returns ((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks))',
]);
export async function readGraduatedPool(ctx: Context, factory: Address, projectId: Hex) {
  const blockNumber = await ctx.client.getBlockNumber();
  const infrastructure = await ctx.client.readContract({ address: factory,
    abi: factoryAbi, functionName: 'infrastructure', blockNumber });
  const project = await ctx.client.readContract({ address: factory,
    abi: factoryAbi, functionName: 'project', args: [projectId], blockNumber });
  const market = infrastructure.market;
  const ready = await ctx.client.readContract({ address: market,
    abi: marketAbi, functionName: 'marketReady', args: [project.token], blockNumber });
  if (!ready) throw new Error('Pool is not ready');
  const graduator = await ctx.client.readContract({ address: market,
    abi: marketAbi, functionName: 'graduator', blockNumber });
  const key = await ctx.client.readContract({ address: graduator,
    abi: graduatorAbi, functionName: 'poolKey', args: [project.curve], blockNumber });
  const currencies = [key.currency0.toLowerCase(), key.currency1.toLowerCase()];
  if (!currencies.includes(project.token.toLowerCase())
    || !currencies.includes(project.quote.toLowerCase())) throw new Error('Pool asset mismatch');
  const poolId = keccak256(encodeAbiParameters([
    { type: 'address' }, { type: 'address' }, { type: 'uint24' },
    { type: 'int24' }, { type: 'address' },
  ], [key.currency0, key.currency1, key.fee, key.tickSpacing, key.hooks]));
  return { token: project.token, quote: project.quote, curve: project.curve, market, key, poolId };
}

export async function discoverTokens(ctx: Context, factory: Address,
  fromBlock: bigint, toBlock: bigint) {
  if (toBlock < fromBlock || toBlock - fromBlock > 999n) {
    throw new Error('Read at most 1,000 blocks per request');
  }
  const events = await ctx.client.getContractEvents({
    address: factory, abi: factoryAbi, eventName: 'ProjectCreated',
    fromBlock, toBlock, strict: true,
  });
  const projects = [];
  for (const event of events) {
    const project = await ctx.client.readContract({
      address: factory, abi: factoryAbi, functionName: 'project',
      args: [event.args.entitlementId], blockNumber: toBlock,
    });
    projects.push({ projectId: event.args.entitlementId,
      token: project.token, curve: project.curve, quoteAsset: project.quote,
      transactionHash: event.transactionHash, blockHash: event.blockHash,
      logIndex: event.logIndex });
  }
  return projects;
}

import { LauncherWeightedRewards106Abi105 as rewardsAbi } from './abis/LauncherWeightedRewards106';
const nftAbi = parseAbi(['function ownerOf(uint256 tokenId) view returns (address)']);
export async function claimRewards(ctx: Context, factory: Address, projectId: Hex,
  asset: Address, tokenIds: bigint[], attemptId: string) {
  const ids = [...new Set(tokenIds)].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
  if (!ids.length || ids.length > 100 || ids.some(id => id < 0n)) throw new Error('Invalid NFT IDs');
  const blockNumber = await ctx.client.getBlockNumber();
  const project = await ctx.client.readContract({ address: factory, abi: factoryAbi,
    functionName: 'project', args: [projectId], blockNumber });
  if (project.rewards === '0x0000000000000000000000000000000000000000') throw new Error('No rewards contract');
  const read = { address: project.rewards, abi: rewardsAbi, blockNumber } as const;
  const companion = await ctx.client.readContract({ ...read, functionName: 'companion' });
  if (companion.toLowerCase() !== project.companion.toLowerCase()) throw new Error('Collection mismatch');
  const assets = await ctx.client.readContract({ ...read, functionName: 'assets106' });
  if (!assets.some(a => a.toLowerCase() === asset.toLowerCase())) throw new Error('Unsupported reward asset');
  let pending = 0n;
  for (const id of ids) {
    const owner = await ctx.client.readContract({ address: companion, abi: nftAbi,
      functionName: 'ownerOf', args: [id], blockNumber });
    if (owner.toLowerCase() !== ctx.account.toLowerCase()) throw new Error('NFT ownership changed');
    pending += await ctx.client.readContract({ ...read, functionName: 'pendingAsset106', args: [asset, id] });
  }
  if (pending === 0n) throw new Error('No claimable rewards');
  const receipt = await sendOnce(ctx, attemptId, { to: project.rewards, value: 0n,
    data: encodeFunctionData({ abi: rewardsAbi, functionName: 'claimAsset106',
      args: [asset, ids, ctx.account] }) });
  const claims = parseEventLogs({ abi: rewardsAbi, eventName: 'AssetClaimed106',
    logs: receipt.logs.filter(log => log.address.toLowerCase() === project.rewards.toLowerCase()), strict: true });
  return { hash: receipt.transactionHash, claims };
}

export async function readTradeFills(ctx: Context, curve: Address,
  fromBlock: bigint, toBlock: bigint) {
  if (fromBlock < 0n || toBlock < fromBlock || toBlock - fromBlock >= 1_000n) {
    throw new Error('Use a range of at most 1000 blocks');
  }
  const [buys, sells] = await Promise.all([
    ctx.client.getContractEvents({ address: curve, abi: curveAbi,
      eventName: 'TokensBought', fromBlock, toBlock, strict: true }),
    ctx.client.getContractEvents({ address: curve, abi: curveAbi,
      eventName: 'TokensSold', fromBlock, toBlock, strict: true }),
  ]);
  return [...buys, ...sells].sort((a, b) =>
    a.blockNumber < b.blockNumber ? -1 : a.blockNumber > b.blockNumber ? 1 : a.logIndex - b.logIndex);
}