Cross-chain Portfolio Rebalancer

npm install -g @human.tech/waap-cli@2.2.0
waap-cli signup
waap-cli policy set --daily-spend-limit 10
waap-cli squid init
waap-cli squid addresses

quote({ fromChain, toChain, fromToken, toToken, fromAmount, fromAddress, toAddress })
  // → { tool, feeUSD, toAmount, transactionRequest }
 
settle({ ...same })
  // → { quote, srcTxHash, bridge: { destTxHash, status, elapsedMs } }

// cross-chain-rebalancer/agent.ts
import { CHAINS, decimalsFor, squidAddresses, squidSendTx, nativeBalance, type Chain } from '../lib/squid'
import { settle, NATIVE_TOKEN } from '../lib/lifi'
 
const TAG = '[cross-chain-rebalancer]'
const POLL_MS = Number(process.env.POLL_INTERVAL_MS ?? '60000')
const MAX_TICKS = Number(process.env.MAX_TICKS ?? '0')
/** How far a leg may drift from its target share before we act, in percentage points. */
const DRIFT_TOLERANCE_PP = Number(process.env.DRIFT_TOLERANCE_PP ?? '5')
/**
 * `bridge` moves value between legs through LI.FI; `same-chain` self-sends on one leg and
 * proves signing only. Default stays `same-chain` — crossing chains with real money is opt-in,
 * never inherited from a default.
 */
const SETTLE_MODE = process.env.SETTLE_MODE ?? 'same-chain'
 
const log = (level: string, event: string, data?: Record<string, unknown>) =>
  console.log(JSON.stringify({ ts: new Date().toISOString(), level, agent: TAG, event, ...data }))
 
interface Leg {
  name: string
  chain: Chain
  address: string
  /** Target share of the portfolio, 0..1. Shares across all legs must sum to 1. */
  target: number
  balance: bigint
  price: number
}
 
/** Replace with a real oracle read. Kept explicit so the recipe never hides its price source. */
async function priceOf(leg: string): Promise<number> {
  const env = process.env[`PRICE_${leg.toUpperCase()}`]
  if (!env) throw new Error(`No price source for ${leg} — set PRICE_${leg.toUpperCase()} or wire an oracle`)
  return Number(env)
}
 
async function readLegs(): Promise<Leg[]> {
  const a = await squidAddresses()
  // Chains come from env so the same runner drives testnet and mainnet. Hardcoding them means a
  // mainnet run silently reads empty testnet legs and reports a portfolio worth zero — a failure
  // that looks exactly like a funding problem.
  const evmChain = (process.env.LEG_EVM_CHAIN as Chain) ?? CHAINS.baseSepolia
  const solChain = (process.env.LEG_SOL_CHAIN as Chain) ?? CHAINS.solanaDevnet
  const defs = [
    { name: 'evm', chain: evmChain, address: a.evm!, target: Number(process.env.TARGET_EVM ?? '0.5') },
    // The Solana and Sui legs share sqd2 — one ed25519 dWallet, two networks. Their balance
    // reads go through their own RPCs.
    { name: 'sol', chain: solChain, address: a.sol!, target: Number(process.env.TARGET_SOL ?? '0.5') },
    // A Sui leg is one more entry here: `{ name: 'sui', chain: CHAINS.suiTestnet, address: a.sui!, target }`
    // with a PRICE_SUI source and targets that still sum to 1. Two things then change below: the
    // src/dst pairing in tick() must pick the most over- and under-weight rows rather than "the other
    // leg", and LI.FI only routes Sui on mainnet. The verified run at the bottom of this page did
    // not exercise a Sui leg.
  ]
  const legs: Leg[] = []
  for (const d of defs) {
    const balance = await nativeBalance(d.address, d.chain)
    legs.push({ ...d, balance, price: await priceOf(d.name) })
  }
  return legs
}
 
function drift(legs: Leg[]): { total: number; rows: Array<{ leg: Leg; share: number; delta: number }> } {
  // Per-chain decimals, not a flat 1e18.
  const values = legs.map((l) => (Number(l.balance) / 10 ** decimalsFor(l.chain)) * l.price)
  const total = values.reduce((a, b) => a + b, 0)
  const rows = legs.map((l, i) => ({
    leg: l,
    share: total ? values[i] / total : 0,
    delta: (total ? values[i] / total : 0) - l.target,
  }))
  return { total, rows }
}
 
async function tick(n: number) {
  const legs = await readLegs()
  const { total, rows } = drift(legs)
  log('info', 'portfolio', {
    tick: n, totalUsd: total.toFixed(2),
    legs: rows.map((r) => ({ leg: r.leg.name, share: (r.share * 100).toFixed(1) + '%', driftPp: (r.delta * 100).toFixed(1) })),
  })
 
  const worst = rows.slice().sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta))[0]
  if (!worst || Math.abs(worst.delta) * 100 < DRIFT_TOLERANCE_PP) {
    log('info', 'within_tolerance', { tick: n, tolerancePp: DRIFT_TOLERANCE_PP })
    return
  }
 
  // The over-weight leg funds the under-weight one. `worst` is the leg furthest from target:
  // positive delta = holding too much, so it is the source; negative = the destination.
  const other = rows.find((r) => r.leg.name !== worst.leg.name)!
  const [src, dst] = worst.delta > 0 ? [worst, other] : [other, worst]
 
  log('info', 'rebalance_signal', {
    tick: n, leg: worst.leg.name, driftPp: (worst.delta * 100).toFixed(1),
    from: src.leg.name, to: dst.leg.name, mode: SETTLE_MODE,
  })
 
  if (process.env.EXECUTE !== '1') { log('info', 'dry_run', { tick: n }); return }
 
  // A self-send on one leg. Proves signing and nothing else.
  if (SETTLE_MODE === 'same-chain') {
    const r = await squidSendTx({ to: worst.leg.address, chain: worst.leg.chain, value: process.env.REBALANCE_UNIT ?? '0.0001' })
    log('info', 'rebalanced', { tick: n, leg: worst.leg.name, txHash: r.txHash, mode: 'same-chain' })
    return
  }
 
  // SETTLE_MODE=bridge — value actually crosses chains.
  const moveUsd = Math.min(Math.abs(src.delta), Math.abs(dst.delta)) * total
  const srcUnits = BigInt(Math.floor((moveUsd / src.leg.price) * 10 ** decimalsFor(src.leg.chain)))
  log('info', 'settling', { tick: n, moveUsd: moveUsd.toFixed(2), from: src.leg.chain, to: dst.leg.chain })
 
  const out = await settle({
    fromChain: src.leg.chain,
    toChain: dst.leg.chain,
    fromToken: NATIVE_TOKEN[src.leg.chain],
    toToken: NATIVE_TOKEN[dst.leg.chain],
    fromAmount: srcUnits.toString(),
    fromAddress: src.leg.address,
    toAddress: dst.leg.address,
  })
  log('info', 'rebalanced', {
    tick: n, mode: 'bridge', tool: out.quote.tool,
    srcTxHash: out.srcTxHash, destTxHash: out.bridge.destTxHash,
    feeUsd: out.quote.feeUSD, bridgeStatus: out.bridge.status, elapsedMs: out.bridge.elapsedMs,
    note: 'a DONE status is not proof — confirm the destination balance over its own RPC',
  })
}
 
async function main() {
  const a = await squidAddresses()
  log('info', 'agent_start', { evm: a.evm, sui: a.sui, sol: a.sol, note: 'one account, two dWallets, three addresses' })
  let n = 0
  for (;;) {
    if (MAX_TICKS && n >= MAX_TICKS) break
    n++
    try { await tick(n) } catch (e) { log('error', 'tick_failed', { tick: n, message: (e as Error).message }) }
    await new Promise((r) => setTimeout(r, POLL_MS))
  }
  log('info', 'agent_stop', { ticks: n })
}
 
main().catch((e) => { log('error', 'fatal', { message: (e as Error).message }); process.exit(1) })