@ripplesdotrun/agent-sdk 0.1.0

package/dist/abi.js

@@ -0,0 +1,75 @@
+import { parseAbi } from "viem";
+const CHARTER = "(address operator,uint128 dailySpend,uint128 perCallSpend,uint128 dailySell,uint32 dailyMint,address[] payees)";
+const LAUNCH_PARAMS = "(string name,string symbol,uint256 curveSupply,uint256 lpTokenSupply,uint256 vQuoteInit,uint256 vTokenInit,uint256 graduationQuote,uint64 lpUnlockAt,uint96 creatorTaxBps,address quote,string logo,string description,string twitter,string telegram,string discord,string website,string farcaster)";
+const COLLECTION_PARAMS = "(string name,string symbol,uint256 priceQuote,uint256 maxSupply,uint256 perWalletCap,uint64 startTime,uint64 endTime,uint8 mode,string baseURI,string placeholderURI,uint96 royaltyBps,address quote)";
+const LINKED_PARAMS = "(uint96 nftAllocationBps,uint96 mintToCurveBps,uint64 vestDuration,uint64 vestCliff)";
+const DEV_BUY = "(uint256 initialBuy,uint256 minTokensOut,address[] snipeExempt)";
+export const AGENT_FACTORY_ABI = parseAbi([
+    `function createAndLaunch(${CHARTER} charter,${LAUNCH_PARAMS} tp,${COLLECTION_PARAMS} np,${LINKED_PARAMS} lp,${DEV_BUY} d,uint256 runway) returns (address treasury,address token,address locker,address collection,address vesting)`,
+    `function create(${CHARTER} charter) returns (address)`,
+    "function isFromFactory(address treasury) view returns (bool)",
+    "function treasuryCount() view returns (uint256)",
+    "function treasuries(uint256 offset,uint256 limit) view returns (address[])",
+    "function RUNWAY_ASSET() view returns (address)",
+    "function TOKEN_FACTORY() view returns (address)",
+    "event AgentTreasuryCreated(address indexed creator,address indexed treasury,address indexed operator)",
+    "error DuplicatePayee()",
+    "error InvalidSpendLimits()",
+    "error NoRunway()",
+    "error NotAContract()",
+    "error TooManyPayees()",
+    "error WrongPayment()",
+    "error ZeroAddress()",
+]);
+export const AGENT_TREASURY_ABI = parseAbi([
+    "function buy(uint256 amountIn,uint256 minAmountOut,uint256 deadline) returns (uint256 spent,uint256 received)",
+    "function sell(uint256 amountIn,uint256 minAmountOut,uint256 deadline) returns (uint256 sold,uint256 received)",
+    "function mint(uint256 quantity,uint256 minRoutedTotal)",
+    "function pay(address to,uint256 amount)",
+    "function note(bytes32 digest,string uri)",
+    "function claimFees() returns (uint256 quoteAmount,uint256 tokenAmount)",
+    "function claimVested() returns (uint256 amount)",
+    "function setCollectionBaseURI(string uri)",
+    "function setCollectionPlaceholderURI(string uri)",
+    "function freezeCollectionMetadata()",
+    "function charter() view returns (address operator,uint128 dailySpend,uint128 perCallSpend,uint128 dailySell,uint32 dailyMint,address[] payees)",
+    "function remainingToday() view returns (uint256 spend,uint256 sellable,uint256 mintable)",
+    "function payees() view returns (address[])",
+    "function CREATOR() view returns (address)",
+    "function OPERATOR() view returns (address)",
+    "function QUOTE() view returns (address)",
+    "function token() view returns (address)",
+    "function locker() view returns (address)",
+    "function collection() view returns (address)",
+    "function vesting() view returns (address)",
+    "event Launched(address indexed token,address indexed locker,address collection,address vesting)",
+    "event Bought(uint256 spent,uint256 received)",
+    "event Sold(uint256 sold,uint256 received)",
+    "event Minted(uint256 quantity,uint256 cost)",
+    "event Paid(address indexed to,uint256 amount)",
+    "event FeesClaimed(uint256 quoteAmount,uint256 tokenAmount)",
+    "event VestedClaimed(uint256 amount)",
+    "event Noted(bytes32 indexed digest,string uri)",
+    "error AlreadyLaunched()",
+    "error AmountTooLarge()",
+    "error NotCreator()",
+    "error NotLaunched()",
+    "error NotOperator()",
+    "error NotPayee(address to)",
+    "error NoVenue()",
+    "error OverCallSpend(uint256 requested,uint256 limit)",
+    "error OverDailyMint(uint256 requested,uint256 limit)",
+    "error OverDailySell(uint256 requested,uint256 limit)",
+    "error OverDailySpend(uint256 requested,uint256 limit)",
+    "error QuoteMismatch()",
+    "error UnexpectedBalance()",
+    "error ZeroAmount()",
+]);
+export const ERC20_ABI = parseAbi([
+    "function approve(address spender,uint256 value) returns (bool)",
+    "function allowance(address owner,address spender) view returns (uint256)",
+    "function balanceOf(address account) view returns (uint256)",
+    "function decimals() view returns (uint8)",
+    "function symbol() view returns (string)",
+]);
+export const LAUNCH_FACTORY_ABI = parseAbi(["function launchFee() view returns (uint256)"]);

package/dist/agent.d.ts

@@ -0,0 +1,157 @@
+import { type Account, type Address, type Hash, type Transport } from "viem";
+import { type RipplesDeployment, type RipplesNetwork } from "./chains.js";
+import { LINKED_DEFAULTS } from "./defaults.js";
+/**
+ * What the agent may do with its own money, fixed when its treasury is deployed.
+ *
+ * Amounts are written the way a person writes them: `"0.05"` is 0.05 of the settlement asset,
+ * and `dailySell` is in the launch's own token. There is no setter for any of this, so these
+ * are the limits for the life of the launch.
+ */
+export type Charter = {
+    /** The key that works the agent. The only address that can spend, and only the five ways. */
+    operator: Address;
+    /** Everything it spends counts against this: buying, minting and paying share one budget. */
+    dailySpend: string;
+    /** At most the daily figure, so a day's budget cannot leave in one transaction. */
+    perCallSpend: string;
+    /** In the launch's own token. Omit it and the agent can never sell what it launched. */
+    dailySell?: string;
+    /** Pieces it may mint from its own collection each day. Omit it and it never mints. */
+    dailyMint?: number;
+    /** Where its running costs go. It can pay these addresses and no others, ever. */
+    payees?: readonly Address[];
+};
+export type TokenPlan = {
+    name: string;
+    symbol: string;
+    /** A public image URL. The token carries it on chain, which is what terminals read. */
+    image: string;
+    description?: string;
+    website?: string;
+    twitter?: string;
+    telegram?: string;
+    discord?: string;
+    farcaster?: string;
+};
+export type CollectionPlan = {
+    name: string;
+    symbol: string;
+    /** Price per piece, in the settlement asset. */
+    price: string;
+    supply: number;
+    /** Where the finished artwork lives, with a trailing slash. */
+    baseUri: string;
+    placeholderUri?: string;
+    /** Secondary-sale royalty, in basis points. At most 1000. */
+    royaltyBps?: number;
+    perWalletCap?: number;
+    /** Unix seconds. Omit for a mint that never closes. */
+    endTime?: number;
+};
+export type LaunchPlan = {
+    charter: Charter;
+    token: TokenPlan;
+    collection: CollectionPlan;
+    /** What goes into the treasury. It has to cover the launch fee. */
+    runway: string;
+    /** The coupling, if the defaults are not wanted. Frozen at create either way. */
+    linked?: Partial<typeof LINKED_DEFAULTS>;
+};
+export type LaunchResult = {
+    treasury: Address;
+    token: Address;
+    market: Address;
+    collection: Address;
+    vesting: Address;
+    transaction: Hash;
+};
+export type AgentCharter = {
+    operator: Address;
+    dailySpend: string;
+    perCallSpend: string;
+    dailySell: string;
+    dailyMint: number;
+    payees: readonly Address[];
+};
+export type Budget = {
+    spend: string;
+    sellable: string;
+    mintable: number;
+};
+export type Activity = {
+    kind: "launched" | "bought" | "sold" | "minted" | "paid" | "claimed" | "vested" | "noted";
+    block: bigint;
+    transaction: Hash;
+    detail: string;
+};
+export type RipplesAgentOptions = {
+    network?: RipplesNetwork;
+    /** Signs. Omit for a read-only client. */
+    account?: Account;
+    /** Overrides the network's public endpoint. */
+    rpcUrl?: string;
+    transport?: Transport;
+    /** An existing treasury to work. `launch` fills this in when it creates one. */
+    treasury?: Address;
+};
+export declare class RipplesAgentError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export type AgentClient = ReturnType<typeof createRipplesAgent>;
+export declare function createRipplesAgent(options?: RipplesAgentOptions): {
+    network: RipplesNetwork;
+    deployment: RipplesDeployment;
+    readonly treasury: Address | undefined;
+    /**
+     * Create the agent, its market and its collection, in one transaction.
+     *
+     * Two wallet requests: a spending permission for the runway, then the launch itself. The
+     * factory deploys the treasury, moves the runway in, and has the treasury open the launch,
+     * so the treasury is the launch's creator of record and the creator's share of every trade
+     * fee is the agent's working capital. A failure anywhere unwinds all of it.
+     */
+    launch(plan: LaunchPlan): Promise<LaunchResult>;
+    /** Buy the agent's own token on its own market, into the treasury. */
+    buy(amount: string, options?: {
+        minReceived?: string;
+        deadline?: number;
+    }): Promise<`0x${string}`>;
+    /** Sell it back, against the charter's daily ceiling. Refused outright when that is zero. */
+    sell(amount: string, options?: {
+        minReceived?: string;
+        deadline?: number;
+    }): Promise<`0x${string}`>;
+    /** Mint from its own collection. The pieces stay with the treasury. */
+    mint(quantity: number, options?: {
+        minRouted?: string;
+    }): Promise<`0x${string}`>;
+    /** Pay one of the charter's published addresses. */
+    pay(to: Address, amount: string): Promise<`0x${string}`>;
+    /** Write an entry in the agent's public run log. */
+    note(text: string, uri?: string): Promise<`0x${string}`>;
+    /** Take in the creator's share of every trade and the collection's share of every mint. */
+    claim(): Promise<`0x${string}`>;
+    /** Take in the token slice the agent's own mints earned it, once the market has graduated. */
+    claimVested(): Promise<`0x${string}`>;
+    /** The limits, as published. None of them can change. */
+    charter(): Promise<AgentCharter>;
+    /** What is left of each ceiling today. The window is the UTC day. */
+    budget(): Promise<Budget>;
+    /** Everything the agent has done, newest first. */
+    activity(limit?: number): Promise<readonly Activity[]>;
+    /** The launch this treasury opened. */
+    launched(): Promise<{
+        token: `0x${string}`;
+        market: `0x${string}`;
+        collection: `0x${string}`;
+        vesting: `0x${string}`;
+    }>;
+};
+/** Whether this chain's factory deployed `treasury`, which is what makes its charter worth reading. */
+export declare function readAgent(treasury: Address, options?: {
+    network?: RipplesNetwork;
+    rpcUrl?: string;
+}): Promise<boolean>;

package/dist/agent.js

@@ -0,0 +1,383 @@
+import { createPublicClient, createWalletClient, formatUnits, http, keccak256, parseUnits, toHex, } from "viem";
+import { AGENT_FACTORY_ABI, AGENT_TREASURY_ABI, ERC20_ABI, LAUNCH_FACTORY_ABI } from "./abi.js";
+import { chainOf, DEPLOYMENTS } from "./chains.js";
+import { LINKED_DEFAULTS, LINKED_RESERVES, MAX_PAYEES, PREGEN } from "./defaults.js";
+const DAY = 86400n;
+const ZERO = "0x0000000000000000000000000000000000000000";
+export class RipplesAgentError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "RipplesAgentError";
+    }
+}
+export function createRipplesAgent(options = {}) {
+    const network = options.network ?? "robinhood";
+    const record = DEPLOYMENTS[network];
+    const chain = chainOf(network);
+    const transport = options.transport ?? http(options.rpcUrl ?? record.rpcUrl);
+    const publicClient = createPublicClient({ chain, transport });
+    const wallet = options.account
+        ? createWalletClient({ account: options.account, chain, transport })
+        : undefined;
+    let treasury = options.treasury;
+    const quote = (value) => parseUnits(value, record.quoteDecimals);
+    const showQuote = (value) => formatUnits(value, record.quoteDecimals);
+    const token = (value) => parseUnits(value, 18);
+    const showToken = (value) => formatUnits(value, 18);
+    function signer() {
+        if (!wallet || !options.account) {
+            throw new RipplesAgentError("This client is read-only. Pass an `account` to send transactions.");
+        }
+        return { wallet, account: options.account };
+    }
+    function held() {
+        if (!treasury) {
+            throw new RipplesAgentError("No treasury. Call `launch` first, or pass `treasury` when you create the client.");
+        }
+        return treasury;
+    }
+    async function send(request) {
+        const { wallet } = signer();
+        const hash = await wallet.writeContract(request);
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+        if (receipt.status !== "success") {
+            throw new RipplesAgentError(`The transaction reverted. ${record.explorer}/tx/${hash}`);
+        }
+        return hash;
+    }
+    return {
+        network,
+        deployment: record,
+        get treasury() {
+            return treasury;
+        },
+        /**
+         * Create the agent, its market and its collection, in one transaction.
+         *
+         * Two wallet requests: a spending permission for the runway, then the launch itself. The
+         * factory deploys the treasury, moves the runway in, and has the treasury open the launch,
+         * so the treasury is the launch's creator of record and the creator's share of every trade
+         * fee is the agent's working capital. A failure anywhere unwinds all of it.
+         */
+        async launch(plan) {
+            const { account } = signer();
+            const runway = quote(plan.runway);
+            const fee = await publicClient.readContract({
+                address: record.tokenLaunchFactory,
+                abi: LAUNCH_FACTORY_ABI,
+                functionName: "launchFee",
+            });
+            if (runway < fee) {
+                throw new RipplesAgentError(`The runway has to cover the ${showQuote(fee)} ${record.quoteSymbol} launch fee.`);
+            }
+            const charter = chartered(plan.charter, quote, token);
+            const balance = await publicClient.readContract({
+                address: record.quote,
+                abi: ERC20_ABI,
+                functionName: "balanceOf",
+                args: [account.address],
+            });
+            if (balance < runway) {
+                throw new RipplesAgentError(`This wallet holds ${showQuote(balance)} ${record.quoteSymbol} and the runway is ${plan.runway}.`);
+            }
+            const allowance = await publicClient.readContract({
+                address: record.quote,
+                abi: ERC20_ABI,
+                functionName: "allowance",
+                args: [account.address, record.agentTreasuryFactory],
+            });
+            if (allowance < runway) {
+                await send({
+                    address: record.quote,
+                    abi: ERC20_ABI,
+                    functionName: "approve",
+                    args: [record.agentTreasuryFactory, runway],
+                    account,
+                    chain,
+                });
+            }
+            const linked = { ...LINKED_DEFAULTS, ...plan.linked };
+            const request = {
+                address: record.agentTreasuryFactory,
+                abi: AGENT_FACTORY_ABI,
+                functionName: "createAndLaunch",
+                args: [
+                    charter,
+                    {
+                        name: plan.token.name,
+                        symbol: plan.token.symbol,
+                        ...LINKED_RESERVES,
+                        creatorTaxBps: 0n,
+                        quote: ZERO,
+                        logo: plan.token.image,
+                        description: plan.token.description ?? "",
+                        twitter: plan.token.twitter ?? "",
+                        telegram: plan.token.telegram ?? "",
+                        discord: plan.token.discord ?? "",
+                        website: plan.token.website ?? "",
+                        farcaster: plan.token.farcaster ?? "",
+                    },
+                    {
+                        name: plan.collection.name,
+                        symbol: plan.collection.symbol,
+                        priceQuote: quote(plan.collection.price),
+                        maxSupply: BigInt(plan.collection.supply),
+                        perWalletCap: BigInt(plan.collection.perWalletCap ?? 0),
+                        startTime: 0n,
+                        endTime: BigInt(plan.collection.endTime ?? 0),
+                        mode: PREGEN,
+                        baseURI: plan.collection.baseUri,
+                        placeholderURI: plan.collection.placeholderUri ?? "",
+                        royaltyBps: BigInt(plan.collection.royaltyBps ?? 500),
+                        quote: ZERO,
+                    },
+                    {
+                        nftAllocationBps: BigInt(linked.allocationBps),
+                        mintToCurveBps: BigInt(linked.mintToCurveBps),
+                        vestDuration: BigInt(linked.vestDurationDays) * DAY,
+                        vestCliff: BigInt(linked.vestCliffDays) * DAY,
+                    },
+                    { initialBuy: 0n, minTokensOut: 0n, snipeExempt: [] },
+                    runway,
+                ],
+                account,
+                chain,
+            };
+            const { result } = await publicClient.simulateContract(request);
+            const transaction = await send(request);
+            const [created, launchToken, market, collection, vesting] = result;
+            treasury = created;
+            return {
+                treasury: created,
+                token: launchToken,
+                market: market,
+                collection: collection,
+                vesting: vesting,
+                transaction,
+            };
+        },
+        /** Buy the agent's own token on its own market, into the treasury. */
+        async buy(amount, options = {}) {
+            const { account } = signer();
+            return send({
+                address: held(),
+                abi: AGENT_TREASURY_ABI,
+                functionName: "buy",
+                args: [
+                    quote(amount),
+                    options.minReceived ? token(options.minReceived) : 0n,
+                    BigInt(options.deadline ?? Math.floor(Date.now() / 1000) + 300),
+                ],
+                account,
+                chain,
+            });
+        },
+        /** Sell it back, against the charter's daily ceiling. Refused outright when that is zero. */
+        async sell(amount, options = {}) {
+            const { account } = signer();
+            return send({
+                address: held(),
+                abi: AGENT_TREASURY_ABI,
+                functionName: "sell",
+                args: [
+                    token(amount),
+                    options.minReceived ? quote(options.minReceived) : 0n,
+                    BigInt(options.deadline ?? Math.floor(Date.now() / 1000) + 300),
+                ],
+                account,
+                chain,
+            });
+        },
+        /** Mint from its own collection. The pieces stay with the treasury. */
+        async mint(quantity, options = {}) {
+            const { account } = signer();
+            return send({
+                address: held(),
+                abi: AGENT_TREASURY_ABI,
+                functionName: "mint",
+                args: [BigInt(quantity), options.minRouted ? quote(options.minRouted) : 0n],
+                account,
+                chain,
+            });
+        },
+        /** Pay one of the charter's published addresses. */
+        async pay(to, amount) {
+            const { account } = signer();
+            return send({
+                address: held(),
+                abi: AGENT_TREASURY_ABI,
+                functionName: "pay",
+                args: [to, quote(amount)],
+                account,
+                chain,
+            });
+        },
+        /** Write an entry in the agent's public run log. */
+        async note(text, uri = "") {
+            const { account } = signer();
+            return send({
+                address: held(),
+                abi: AGENT_TREASURY_ABI,
+                functionName: "note",
+                args: [keccak256(toHex(text)), uri],
+                account,
+                chain,
+            });
+        },
+        /** Take in the creator's share of every trade and the collection's share of every mint. */
+        async claim() {
+            const { account } = signer();
+            return send({
+                address: held(),
+                abi: AGENT_TREASURY_ABI,
+                functionName: "claimFees",
+                args: [],
+                account,
+                chain,
+            });
+        },
+        /** Take in the token slice the agent's own mints earned it, once the market has graduated. */
+        async claimVested() {
+            const { account } = signer();
+            return send({
+                address: held(),
+                abi: AGENT_TREASURY_ABI,
+                functionName: "claimVested",
+                args: [],
+                account,
+                chain,
+            });
+        },
+        /** The limits, as published. None of them can change. */
+        async charter() {
+            const [operator, dailySpend, perCallSpend, dailySell, dailyMint, payees] = await publicClient.readContract({
+                address: held(),
+                abi: AGENT_TREASURY_ABI,
+                functionName: "charter",
+            });
+            return {
+                operator,
+                dailySpend: showQuote(dailySpend),
+                perCallSpend: showQuote(perCallSpend),
+                dailySell: showToken(dailySell),
+                dailyMint: Number(dailyMint),
+                payees,
+            };
+        },
+        /** What is left of each ceiling today. The window is the UTC day. */
+        async budget() {
+            const [spend, sellable, mintable] = await publicClient.readContract({
+                address: held(),
+                abi: AGENT_TREASURY_ABI,
+                functionName: "remainingToday",
+            });
+            return { spend: showQuote(spend), sellable: showToken(sellable), mintable: Number(mintable) };
+        },
+        /** Everything the agent has done, newest first. */
+        async activity(limit = 50) {
+            return readActivity(publicClient, held(), { limit, showQuote, showToken });
+        },
+        /** The launch this treasury opened. */
+        async launched() {
+            const address = held();
+            const [launchToken, market, collection, vesting] = await Promise.all([
+                publicClient.readContract({ address, abi: AGENT_TREASURY_ABI, functionName: "token" }),
+                publicClient.readContract({ address, abi: AGENT_TREASURY_ABI, functionName: "locker" }),
+                publicClient.readContract({ address, abi: AGENT_TREASURY_ABI, functionName: "collection" }),
+                publicClient.readContract({ address, abi: AGENT_TREASURY_ABI, functionName: "vesting" }),
+            ]);
+            return { token: launchToken, market, collection, vesting };
+        },
+    };
+}
+/** Whether this chain's factory deployed `treasury`, which is what makes its charter worth reading. */
+export async function readAgent(treasury, options = {}) {
+    const network = options.network ?? "robinhood";
+    const record = DEPLOYMENTS[network];
+    const client = createPublicClient({
+        chain: chainOf(network),
+        transport: http(options.rpcUrl ?? record.rpcUrl),
+    });
+    return client.readContract({
+        address: record.agentTreasuryFactory,
+        abi: AGENT_FACTORY_ABI,
+        functionName: "isFromFactory",
+        args: [treasury],
+    });
+}
+function chartered(charter, quote, token) {
+    const payees = charter.payees ?? [];
+    if (payees.length > MAX_PAYEES) {
+        throw new RipplesAgentError(`A charter names at most ${MAX_PAYEES} payees.`);
+    }
+    const dailySpend = quote(charter.dailySpend);
+    const perCallSpend = quote(charter.perCallSpend);
+    if (perCallSpend > dailySpend) {
+        throw new RipplesAgentError("`perCallSpend` cannot be above `dailySpend`.");
+    }
+    if (dailySpend > 0n && perCallSpend === 0n) {
+        throw new RipplesAgentError("A per-transaction limit of zero stops every payment the agent could make, for good.");
+    }
+    return {
+        operator: charter.operator,
+        dailySpend,
+        perCallSpend,
+        dailySell: charter.dailySell ? token(charter.dailySell) : 0n,
+        dailyMint: charter.dailyMint ?? 0,
+        payees: [...payees],
+    };
+}
+async function readActivity(client, treasury, units) {
+    const logs = await client.getLogs({
+        address: treasury,
+        events: AGENT_TREASURY_ABI.filter((entry) => entry.type === "event"),
+        fromBlock: 0n,
+        toBlock: "latest",
+    });
+    const ordered = [...logs].sort((left, right) => left.blockNumber === right.blockNumber
+        ? Number((right.logIndex ?? 0n) - (left.logIndex ?? 0n))
+        : right.blockNumber > left.blockNumber
+            ? 1
+            : -1);
+    const out = [];
+    for (const log of ordered) {
+        const args = log.args ?? {};
+        const name = log.eventName;
+        const base = { block: log.blockNumber, transaction: log.transactionHash };
+        const q = (value) => units.showQuote((value ?? 0n));
+        const t = (value) => units.showToken((value ?? 0n));
+        switch (name) {
+            case "Launched":
+                out.push({ kind: "launched", ...base, detail: `Opened its launch, token ${args.token}` });
+                break;
+            case "Bought":
+                out.push({ kind: "bought", ...base, detail: `Bought ${t(args.received)} for ${q(args.spent)}` });
+                break;
+            case "Sold":
+                out.push({ kind: "sold", ...base, detail: `Sold ${t(args.sold)} for ${q(args.received)}` });
+                break;
+            case "Minted":
+                out.push({ kind: "minted", ...base, detail: `Minted ${args.quantity} for ${q(args.cost)}` });
+                break;
+            case "Paid":
+                out.push({ kind: "paid", ...base, detail: `Paid ${q(args.amount)} to ${args.to}` });
+                break;
+            case "FeesClaimed":
+                out.push({
+                    kind: "claimed",
+                    ...base,
+                    detail: `Took in ${q(args.quoteAmount)} and ${t(args.tokenAmount)} of income`,
+                });
+                break;
+            case "VestedClaimed":
+                out.push({ kind: "vested", ...base, detail: `Took in ${t(args.amount)} it had vested` });
+                break;
+            case "Noted":
+                out.push({ kind: "noted", ...base, detail: String(args.uri || "Wrote to its run log") });
+                break;
+            default:
+                break;
+        }
+    }
+    return out.slice(0, units.limit);
+}

package/dist/chains.d.ts

@@ -0,0 +1,17 @@
+import type { Address, Chain } from "viem";
+/** The networks an agent launch exists on. Robinhood Chain only; Solana takes a program upgrade. */
+export type RipplesNetwork = "robinhood" | "robinhood-testnet";
+export type RipplesDeployment = {
+    readonly chainId: number;
+    readonly rpcUrl: string;
+    readonly explorer: string;
+    /** Deploys treasuries and vouches for them. Every agent call starts here. */
+    readonly agentTreasuryFactory: Address;
+    readonly tokenLaunchFactory: Address;
+    /** What a treasury holds and meters, and what a launch settles in. */
+    readonly quote: Address;
+    readonly quoteSymbol: string;
+    readonly quoteDecimals: number;
+};
+export declare const DEPLOYMENTS: Readonly<Record<RipplesNetwork, RipplesDeployment>>;
+export declare function chainOf(network: RipplesNetwork): Chain;

package/dist/chains.js

@@ -0,0 +1,33 @@
+export const DEPLOYMENTS = {
+    robinhood: {
+        chainId: 4663,
+        rpcUrl: "https://rpc.mainnet.chain.robinhood.com",
+        explorer: "https://robinhoodchain.blockscout.com",
+        agentTreasuryFactory: "0xE284D60A8FCF55C72952454331A32ace0aBB5372",
+        tokenLaunchFactory: "0x149eB358fF19056c0952577fb248C7f7c861eCaF",
+        quote: "0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73",
+        quoteSymbol: "WETH",
+        quoteDecimals: 18,
+    },
+    "robinhood-testnet": {
+        chainId: 46630,
+        rpcUrl: "https://rpc.testnet.chain.robinhood.com",
+        explorer: "https://robinhoodchain-testnet.blockscout.com",
+        agentTreasuryFactory: "0xDA9a2E90A30056898C57Eba987B58AE80347AEBA",
+        tokenLaunchFactory: "0x0D39b557D154F2DD0D4231979FDbCFa5d667Ca76",
+        quote: "0x1F852eF3Afa13156b807204d838BbB46B4b452eb",
+        quoteSymbol: "WETH",
+        quoteDecimals: 18,
+    },
+};
+export function chainOf(network) {
+    const record = DEPLOYMENTS[network];
+    return {
+        id: record.chainId,
+        name: network === "robinhood" ? "Robinhood Chain" : "Robinhood Chain testnet",
+        nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+        rpcUrls: { default: { http: [record.rpcUrl] } },
+        blockExplorers: { default: { name: "Blockscout", url: record.explorer } },
+        testnet: network !== "robinhood",
+    };
+}