Run a DCA strategy

// run-dca-strategy.ts. Run: node run-dca-strategy.ts
import { Contract, JsonRpcProvider, Wallet, formatUnits, getAddress, parseUnits } from "ethers";
import { olympexRequest } from "./sign-request.ts"; // /authentication/sign-requests

// The Olympex order contract: the spender that limit orders and DCA draw on. See /concepts/order-authorization.
const ORDER_CONTRACTS: Record<number, string> = {
  1: "0xef636bca438D030Cead0AaBD74447Bdf85872F6B", // Ethereum
  10: "0xfc07731BE06D93afbfA66E2072B5188A35b93077", // Optimism
  56: "0xA95ccc6f0A561206dd1D0260C1ceE279CB4245A2", // BNB Chain
  137: "0x50186B03dc7315271FB58da0d3b9f2c65A51dA76", // Polygon
  8453: "0x0eE148d16beB83B08905Db4ad3c9c62d569153f0", // Base
  42161: "0x31B15abf6F2c924919605d7ccbc5FB41C8A56Bc1", // Arbitrum One
  43114: "0x1a362443D22a481867e1a20C16711f14102D3CB3", // Avalanche C-Chain
  59144: "0x0eE148d16beB83B08905Db4ad3c9c62d569153f0", // Linea
};

const CHAIN_ID = 137; // Polygon
const USDC = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"; // the token you spend
const WETH = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619"; // the token you buy
const plan = { totalAmount: 100, iterations: 10, frequency: 86_400, slippage: 1 }; // 10 orders of 10 USDC, one a day, 1% slippage

const provider = new JsonRpcProvider(process.env.POLYGON_RPC_URL);
const wallet = new Wallet(process.env.WALLET_PRIVATE_KEY!, provider);
const maker = getAddress(wallet.address); // EIP-55 checksummed

const { chainIds } = await olympexRequest<{ chainIds: number[] }>("GET", "/chains");
const orderContract = ORDER_CONTRACTS[CHAIN_ID];
if (!chainIds.includes(CHAIN_ID) || !orderContract) throw new Error(`No DCA on chain ${CHAIN_ID}`);

type Token = { address: string; symbol: string; name: string; decimals: number };

const { tokens } = await olympexRequest<{ chainId: number; tokens: Token[] }>("GET", `/tokens?chainId=${CHAIN_ID}`);
const findToken = (address: string): Token => {
  const token = tokens.find((t) => t.address.toLowerCase() === address.toLowerCase());
  // Unlisted tokens can be traded too: this example stops on them only to stay short.
  if (!token) throw new Error(`${address} isn't listed on chain ${CHAIN_ID}`);
  // Listed symbols can carry a suffix that tells duplicates apart ("STRK_1") or stray spaces: keep the plain symbol.
  return { ...token, symbol: token.symbol.trim().replace(/_\d+$/, "") };
};
const from = findToken(USDC); // symbol "USDC", decimals 6
const to = findToken(WETH); // symbol "WETH", decimals 18

/** Converts a human-readable amount to base units, rounding up digits beyond the token's decimals. */
const toBaseUnitsUp = (value: string | number, decimals: number): bigint => {
  const text = typeof value === "number" ? value.toLocaleString("en-US", { useGrouping: false, maximumFractionDigits: 20 }) : value;
  const [whole, fraction = ""] = text.split(".");
  const units = parseUnits(`${whole}.${fraction.slice(0, decimals) || "0"}`, decimals);
  return /[1-9]/.test(fraction.slice(decimals)) ? units + 1n : units;
};

const ERC20_ABI = [
  "function allowance(address owner, address spender) view returns (uint256)",
  "function approve(address spender, uint256 value) returns (bool)",
  "function balanceOf(address account) view returns (uint256)",
];
const fromToken = new Contract(from.address, ERC20_ABI, wallet);
const RESET_BEFORE_APPROVE = false; // true for tokens, such as USDT, that revert when one non-zero allowance replaces another

/** Sets the order contract's allowance on the token spent to exactly `value`. */
const setAllowance = async (value: bigint): Promise<void> => {
  const current: bigint = await fromToken.allowance(maker, orderContract);
  if (current === value) return;
  if (RESET_BEFORE_APPROVE && current > 0n && value > 0n) await (await fromToken.approve(orderContract, 0n)).wait();
  await (await fromToken.approve(orderContract, value)).wait(); // wait() throws if the approval reverts
};

const total = toBaseUnitsUp(plan.totalAmount, from.decimals); // 100 USDC is 100000000 base units
const balance: bigint = await fromToken.balanceOf(maker);
if (balance < total) console.warn(`The wallet holds ${formatUnits(balance, from.decimals)} ${from.symbol}: fund it before the later orders run`);

const allowanceBefore: bigint = await fromToken.allowance(maker, orderContract);
await setAllowance(allowanceBefore + total); // add to what other open orders need

import { signOrderPair } from "./sign-order-pair.ts";

const { accountTo, signature } = await signOrderPair(wallet, from.address, to.address);

type DcaStrategy = {
  id: string;
  status: string; // active, cancelled or finished
  tokenAddressFrom: string;
  tokenAddressTo: string;
  totalAmount: number;
  frequency: number;
  iterations: number;
  createdAt: string;
};

const sentAt = Date.now();
const created = await olympexRequest<DcaStrategy>("POST", "/dca-order/strategies", {
  accountTo,
  chainIdFrom: CHAIN_ID,
  chainIdTo: CHAIN_ID,
  tokenAddressFrom: getAddress(from.address),
  tokenAddressTo: getAddress(to.address),
  tokenSymbolFrom: from.symbol,
  tokenSymbolTo: to.symbol,
  pair: `${from.symbol}/${to.symbol}`, // "USDC/WETH"
  totalAmount: plan.totalAmount, // JSON numbers here, not strings
  frequency: plan.frequency,
  iterations: plan.iterations,
  slippage: plan.slippage,
  signature,
});
console.log(`Strategy ${created.id} is ${created.status}`); // store the ID now

const CLOCK_SKEW_MS = 60_000; // your tolerance for clock differences between your server and Olympex

/** After a timeout or 5xx on the create, look for the strategy before you send it again. */
const findCreatedStrategy = async (): Promise<DcaStrategy | undefined> =>
  (await olympexRequest<DcaStrategy[]>("GET", `/dca-order/strategies?accountTo=${accountTo}`)).find(
    (s) =>
      s.tokenAddressFrom === getAddress(from.address) &&
      s.tokenAddressTo === getAddress(to.address) &&
      s.totalAmount === plan.totalAmount &&
      s.iterations === plan.iterations &&
      s.frequency === plan.frequency &&
      Date.parse(s.createdAt) >= sentAt - CLOCK_SKEW_MS,
  );

type DcaOrder = {
  id: string;
  amount: number; // of the token spent, human-readable
  status: string;
  amountReceived?: number;
  executionPrice?: number;
  transactionHash?: string;
  errorMessage?: string;
};

/** Prints the strategy's status and each order's outcome, and returns the orders. */
const checkStrategy = async (id: string): Promise<DcaOrder[]> => {
  const strategy = await olympexRequest<DcaStrategy>("GET", `/dca-order/strategies/${id}`);
  const orders = await olympexRequest<DcaOrder[]>("GET", `/dca-order/strategies/${id}/orders`);
  console.log(`Strategy ${strategy.status}: ${orders.length} of ${strategy.iterations} orders created`);
  for (const o of orders) {
    if (o.status === "successful") console.log(`${o.amount} ${from.symbol} bought ${o.amountReceived} ${to.symbol} in ${o.transactionHash}`);
    else if (o.status === "error") console.log(`Order ${o.id} failed: ${o.errorMessage}`);
    else console.log(`Order ${o.id} is ${o.status}`);
  }
  return orders;
};

await checkStrategy(created.id);

const cancelled = await olympexRequest<DcaStrategy>("PATCH", `/dca-order/strategies/${created.id}`, { status: "cancelled" });
console.log(`Strategy ${cancelled.status}`); // cancelled

const orders = await olympexRequest<DcaOrder[]>("GET", `/dca-order/strategies/${created.id}/orders`);
// Successful orders have used their amount, and an executing order can still use it. Release the rest.
const used = orders
  .filter((o) => o.status === "successful" || o.status === "executing")
  .reduce((sum, o) => sum + toBaseUnitsUp(o.amount, from.decimals), 0n);
const unused = total > used ? total - used : 0n;

const current: bigint = await fromToken.allowance(maker, orderContract);
await setAllowance(current > unused ? current - unused : 0n);