Agents that schedule themselves. Run forever. No babysitter.

// DCAAgent — a persistent, autonomous on-chain agent for AsentumChain.
//
// The pitch: on other chains an "agent" needs an off-chain script keeping
// it alive (a Lambda, a cron container, a laptop that must stay awake). On
// Asentum the agent IS the contract. It holds its own state, and the chain's
// own cron registry (ARC-21, system contract 0x…06) wakes it on a schedule —
// fired by consensus itself. Kill every server on earth; the agent keeps
// thinking, one `tick()` at a time, for as long as its gas escrow lasts.
//
// tick() is the agent's reasoning loop: observe → decide → act → (the cron
// registry) reschedules the next wake-up automatically. This reference agent
// keeps a heartbeat (tick count + last-seen block/time) so its liveness is
// visible on-chain; swap the body of tick() for any autonomous behaviour —
// a DCA buy on AuraSwap, a treasury rebalance, an oracle push.
//
// Wiring (the REAL cron API — note: absolute MILLISECOND timestamps, and
// cron is funded by a separate tx's value, since cross-contract calls don't
// forward value):
//
//   1. deploy this source                         (tx.to = 0x0…0, data = source)
//   2. agent.init()                               (one-shot)
//   3. cron.schedule(agent, 'tick', [], nextRunAtMs, intervalMs, 0, gasLimit)
//        on 0x…06, with tx.value = gas escrow      <- this is what makes it persistent
//
// chain.blockTimestamp is in MILLISECONDS on AsentumChain.

({
  // One-shot at deploy. Records the agent's birth block.
  init() {
    assert(!storage.get('born'), 'already initialised');
    storage.set('born', chain.blockNumber.toString());
    storage.set('ticks', '0');
    emit('AgentBorn', { block: chain.blockNumber.toString(), ts: chain.blockTimestamp.toString() });
    return true;
  },

  // The agent's reasoning loop — called by the cron registry on schedule.
  // Observe (block/time), decide + act (here: bump the heartbeat), and the
  // cron registry handles rescheduling the next wake-up. Open to any caller
  // so the chain's cron (msg.sender = 0x0…0) can fire it; on mainnet you'd
  // gate to the cron caller.
  tick() {
    const n = (BigInt(storage.get('ticks') || '0') + 1n).toString();
    storage.set('ticks', n);
    storage.set('lastBlock', chain.blockNumber.toString());
    storage.set('lastTs', chain.blockTimestamp.toString());
    emit('AgentTick', { n, block: chain.blockNumber.toString(), ts: chain.blockTimestamp.toString() });
    return n;
  },

  // ── views ───────────────────────────────────────────────────────────
  ticks() { return storage.get('ticks') || '0'; },

  status() {
    return {
      born: storage.get('born') || null,
      ticks: storage.get('ticks') || '0',
      lastBlock: storage.get('lastBlock') || null,
      lastTs: storage.get('lastTs') || null,
    };
  },
});

tick() is the agent's reasoning loop. It runs, decides whether to act, then schedules its own next call. The chain itself is the runtime — no Lambda, no cron container, no “is the bot still alive?” check. The contract is the agent.