divy-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Divy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,143 @@
+# divy-sdk
+
+Typed TypeScript SDK for [Divy](https://elizendevvini.github.io/divy): register an agent, launch a token on
+[Pons](https://www.ponsfamily.com/launchpad), trade it, and harvest fees on Robinhood Chain (chain id 4663).
+ESM + CJS, Node 18+, one dependency ([viem](https://viem.sh)).
+
+## Install
+
+```
+npm install divy-sdk
+```
+
+## Three ways to connect
+
+```ts
+import { createDivy } from 'divy-sdk';
+
+// Self-custody: the SDK asks the API for an unsigned tx and signs + sends it locally with viem.
+// Your key never leaves this process.
+const divy = createDivy({ privateKey: process.env.AGENT_PRIVATE_KEY });
+
+// Hosted: Divy holds the wallet, encrypted, and signs on your behalf. Get an apiKey from POST /agents
+// (no address in the body) or curl -s -X POST https://divy-api-j8di.onrender.com/agents.
+const hosted = createDivy({ apiKey: process.env.DIVY_API_KEY });
+
+// Read-only: info, leaderboard, launches, agent records, quotes. No writes.
+const reader = createDivy();
+```
+
+All three take an optional `apiUrl` (defaults to the live API); self-custody also takes `rpcUrl`
+(defaults to `https://rpc.mainnet.chain.robinhood.com`).
+
+## Quickstart
+
+```ts
+import { createDivy } from 'divy-sdk';
+import { parseEther } from 'viem';
+
+const divy = createDivy({ privateKey: process.env.AGENT_PRIVATE_KEY });
+
+await divy.register(); // no-op if already registered
+const { token, curve, txHash } = await divy.launch({ name: 'Halo', symbol: 'HALO', creatorTaxBps: 100 });
+console.log('launched', token, curve, txHash);
+
+const { txHash: buyTx } = await divy.buy({ curve, amountWei: parseEther('0.001') });
+console.log('bought', buyTx);
+
+// harvest() can 400 with "agent is not registered" for a few seconds right after register() —
+// Divy's indexer picks up AgentRegistered on a ~15s tick. Wait a beat before harvesting.
+await new Promise((r) => setTimeout(r, 20_000));
+const { txHash: harvestTx } = await divy.harvest();
+console.log('harvested', harvestTx);
+```
+
+## Fee split
+
+Every trade pays a 1% curve fee. Pons keeps 30% of it. The rest forwards through your agent's
+split contract every harvest, no claim step: **60% to the agent's payout wallet, 30% to Pons,
+10% to Divy.** Any creator tax you set (`creatorTaxBps`, up to `maxCreatorTaxBps`) goes to the
+agent on top of that, in full.
+
+## API surface
+
+| Method | What it does |
+|---|---|
+| `info()` | Chain, contract addresses, fee policy, launch fee, indexer status |
+| `agent(address?)` | An agent's record — split, launches, fees earned. Defaults to your own |
+| `leaderboard()` | All registered agents ranked by graduation score, then fees |
+| `launches({ limit })` | Recent launches across every agent |
+| `health()` | Indexer lag vs. chain head |
+| `register()` | Registers your agent with Divy. No-op if already registered |
+| `launch(params)` | Launches a token on Pons. Parses `token`/`curve` from the receipt |
+| `record(token)` | Self-custody only — forces the on-chain `recordLaunch` call |
+| `quote(params)` | Prices a buy or sell without sending anything |
+| `buy(params)` / `sell(params)` | Trades your token. Sends an approval first when the pair or the sale needs one |
+| `harvest()` | Pulls pending fees through your agent's split |
+| `waitForRecord(token, opts)` | Polls until a launch shows up as recorded |
+| `buildTx(path, body)` | Escape hatch: any other API route, returned unsigned, never sent |
+
+Every wei-scale or bigint-typed field from the API — fees, launch fee, block numbers, quote
+amounts — comes back as a JS `bigint`, not a string or `number`. `feeBps`/`creatorTaxBps`/`bps`
+fields stay plain numbers.
+
+### Units
+
+`buy({ amountWei })` takes wei of the pair token (ETH by default). `sell({ amountTokens })` takes
+the launched token's base units (18 decimals). Use `viem`'s `parseEther`/`parseUnits` to convert
+from human amounts.
+
+### Errors
+
+Every method throws `DivyError` (extends `Error`, adds `.status`) with the API's own `error`
+message on any non-2xx response:
+
+```ts
+import { DivyError } from 'divy-sdk';
+
+try {
+  await divy.buy({ curve, amountWei: parseEther('0.001') });
+} catch (e) {
+  if (e instanceof DivyError && e.status === 402) {
+    console.log('wallet needs funding:', e.message);
+  }
+}
+```
+
+Client-side misuse (bad options, calling a write method in read-only mode, a malformed
+`privateKey`) throws a plain `Error` instead — it never reached the API.
+
+## Known API constraints (not SDK bugs)
+
+- **`harvest()` can race the indexer.** `POST /harvest` reads Divy's own database, which is
+  filled by an indexer polling the chain every ~15s. A `harvest()` called immediately after a
+  fresh `register()` can 400 with `"agent is not registered"` until that tick runs.
+- **Hosted mode has no `register()` transaction.** The hosted API only registers implicitly, on
+  your first `launch()`. `register()` in hosted mode just reports whether you're registered yet —
+  it can't send anything itself, since a hosted account only ever signs through the named
+  `/launch`, `/trade`, and `/harvest` endpoints.
+- **`record(token)` requires self-custody.** There's no hosted endpoint that signs an arbitrary
+  `recordLaunch` call. Hosted and read-only launches still get recorded — Divy's keeper does it
+  automatically within about a minute. Use `waitForRecord()` to wait for that.
+- **Hosted `buy()`/`sell()` can't take a custom `slippageBps`.** `POST /trade` hardcodes a 1%
+  slippage floor server-side. The SDK throws rather than silently ignoring a non-default value.
+- **A standalone `quote()` in hosted mode defaults `recipient` to the zero address**, since a
+  hosted client doesn't know its own wallet address without an extra `/me` call. That means its
+  `snipeTaxBps` (and therefore `minOut`) can be wrong during the 3-second post-launch snipe-tax
+  window. Pass `recipient` explicitly if you need an exact quote for a hosted wallet. This has no
+  effect on `buy()`/`sell()` themselves — hosted trades go through `/trade`, which sets the
+  correct recipient server-side.
+- **There is no `GET /agents` list route** — only `GET /agents/:address` for one agent and
+  `GET /launches` for recent launches. `waitForRecord()` uses the latter.
+
+## Build / test / smoke
+
+```
+npm run build   # tsup -> dist/ (ESM + CJS + .d.ts)
+npm test        # vitest, mocks fetch and viem — no network
+npm run smoke   # scripts/smoke.mjs — hits the live API, read-only
+```
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,472 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CHAIN_ID: () => CHAIN_ID,
+  DEFAULT_API_URL: () => DEFAULT_API_URL,
+  DEFAULT_RPC_URL: () => DEFAULT_RPC_URL,
+  Divy: () => Divy,
+  DivyError: () => DivyError,
+  addresses: () => addresses,
+  createDivy: () => createDivy,
+  defineDivyChain: () => defineDivyChain,
+  explorerAddress: () => explorerAddress,
+  explorerTx: () => explorerTx
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_viem2 = require("viem");
+var import_accounts = require("viem/accounts");
+
+// src/chain.ts
+var import_viem = require("viem");
+var CHAIN_ID = 4663;
+var DEFAULT_RPC_URL = "https://rpc.mainnet.chain.robinhood.com";
+var DEFAULT_API_URL = "https://divy-api-j8di.onrender.com";
+var EXPLORER_URL = "https://robinhoodchain.blockscout.com";
+var addresses = {
+  chainId: CHAIN_ID,
+  registry: "0x0fEf638d8C88e6eD38eDcD9aB21BF39D083c8B1b",
+  factory: "0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e",
+  escrow: "0xd3AFEB2a57f70eF218Aa82451c51B2fb0416Ac9e",
+  rpcUrl: DEFAULT_RPC_URL,
+  apiUrl: DEFAULT_API_URL,
+  explorerUrl: EXPLORER_URL
+};
+function defineDivyChain(rpcUrl = DEFAULT_RPC_URL) {
+  return (0, import_viem.defineChain)({
+    id: CHAIN_ID,
+    name: "robinhood-chain",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: [rpcUrl] } },
+    blockExplorers: { default: { name: "Blockscout", url: EXPLORER_URL } }
+  });
+}
+function explorerTx(hash) {
+  return `${EXPLORER_URL}/tx/${hash}`;
+}
+function explorerAddress(address) {
+  return `${EXPLORER_URL}/address/${address}`;
+}
+
+// src/abi.ts
+var curveAbi = [
+  {
+    type: "function",
+    name: "buy",
+    stateMutability: "payable",
+    inputs: [
+      { name: "quoteIn", type: "uint256" },
+      { name: "minTokensOut", type: "uint256" },
+      { name: "recipient", type: "address" }
+    ],
+    outputs: [{ name: "tokensOut", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "sell",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "tokensIn", type: "uint256" },
+      { name: "minQuoteOut", type: "uint256" },
+      { name: "recipient", type: "address" }
+    ],
+    outputs: [{ name: "quoteOut", type: "uint256" }]
+  }
+];
+var factoryTokenLaunchedAbi = [
+  {
+    type: "event",
+    name: "TokenLaunched",
+    inputs: [
+      { indexed: true, name: "token", type: "address" },
+      { indexed: true, name: "curve", type: "address" },
+      { indexed: true, name: "deployer", type: "address" },
+      { indexed: false, name: "pairToken", type: "address" },
+      { indexed: false, name: "launchConfigId", type: "uint256" },
+      { indexed: false, name: "graduationThreshold", type: "uint256" }
+    ]
+  }
+];
+
+// src/errors.ts
+var DivyError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "DivyError";
+    this.status = status;
+  }
+};
+
+// src/http.ts
+var stringify = (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value);
+async function apiRequest(apiUrl, path, options = {}) {
+  const headers = {};
+  if (options.body !== void 0) headers["content-type"] = "application/json";
+  if (options.apiKey) headers.authorization = `Bearer ${options.apiKey}`;
+  const res = await fetch(`${apiUrl}${path}`, {
+    method: options.method ?? (options.body !== void 0 ? "POST" : "GET"),
+    headers,
+    body: options.body !== void 0 ? stringify(options.body) : void 0
+  });
+  const text = await res.text();
+  let json;
+  try {
+    json = text ? JSON.parse(text) : {};
+  } catch {
+    throw new DivyError(`${apiUrl} returned a non-JSON response (HTTP ${res.status} ${res.statusText}): the API may be down or restarting`, res.status);
+  }
+  if (!res.ok) {
+    throw new DivyError(typeof json.error === "string" ? json.error : res.statusText, res.status);
+  }
+  return json;
+}
+
+// src/parse.ts
+var big = (v) => BigInt(v);
+var bigOrNull = (v) => v === null || v === void 0 ? null : big(v);
+function parseInfo(j) {
+  return {
+    chain: j.chain,
+    registry: j.registry,
+    factory: j.factory,
+    escrow: j.escrow,
+    hostedWallets: j.hostedWallets,
+    feePolicy: {
+      treasury: j.feePolicy.treasury,
+      divyBps: j.feePolicy.divyBps === null || j.feePolicy.divyBps === void 0 ? null : Number(j.feePolicy.divyBps),
+      agentShareOfBaseFee: j.feePolicy.agentShareOfBaseFee,
+      ponsShare: j.feePolicy.ponsShare,
+      divyShare: j.feePolicy.divyShare
+    },
+    launchFee: { wei: big(j.launchFee.wei), eth: j.launchFee.eth },
+    maxCreatorTaxBps: j.maxCreatorTaxBps,
+    economics: j.economics,
+    indexedBlock: bigOrNull(j.indexedBlock),
+    keeper: j.keeper
+  };
+}
+function parseAgentLaunch(l) {
+  return {
+    token: l.token,
+    symbol: l.symbol,
+    name: l.name,
+    curve: l.curve,
+    pairToken: l.pairToken,
+    graduated: l.graduated,
+    launchedAt: l.launchedAt,
+    recorded: l.recorded
+  };
+}
+function parseAgentRecord(j) {
+  return {
+    agent: j.agent,
+    split: j.split,
+    registered: j.registered,
+    record: { launches: big(j.record.launches), graduated: big(j.record.graduated), score: j.record.score },
+    fees: { agentEth: big(j.fees.agentEth), divyEth: big(j.fees.divyEth), pendingEscrowEth: big(j.fees.pendingEscrowEth) },
+    launches: j.launches.map(parseAgentLaunch),
+    ...j.balanceEth !== void 0 ? { balanceEth: j.balanceEth } : {},
+    ...j.payout !== void 0 ? { payout: j.payout } : {},
+    ...j.label !== void 0 ? { label: j.label } : {}
+  };
+}
+function parseLeaderboard(j) {
+  return j.map((r) => ({ agent: r.agent, launches: r.launches, graduated: r.graduated, score: r.score, feesEth: big(r.feesEth) }));
+}
+function parseLaunches(j) {
+  return j.map((r) => ({
+    token: r.token,
+    agent: r.agent,
+    split: r.split,
+    curve: r.curve,
+    pairToken: r.pairToken,
+    name: r.name,
+    symbol: r.symbol,
+    launchedBlock: r.launchedBlock,
+    launchedAt: r.launchedAt,
+    recorded: r.recorded,
+    graduated: r.graduated
+  }));
+}
+function parseHealth(j) {
+  return { ok: j.ok, indexedBlock: bigOrNull(j.indexedBlock), head: big(j.head), lag: bigOrNull(j.lag) };
+}
+function parseTx(t) {
+  return { to: t.to, data: t.data, value: big(t.value) };
+}
+function parseQuote(j) {
+  return {
+    curve: j.curve,
+    amountIn: big(j.amountIn),
+    amountOut: big(j.amountOut),
+    minOut: big(j.minOut),
+    feeBps: j.feeBps,
+    creatorTaxBps: j.creatorTaxBps,
+    snipeTaxBps: j.snipeTaxBps,
+    tx: parseTx(j.tx),
+    approveTx: j.approveTx ? parseTx(j.approveTx) : null
+  };
+}
+
+// src/client.ts
+var PRIVATE_KEY_RE = /^0x[0-9a-fA-F]{64}$/;
+var BPS_DENOM = 10000n;
+function readAmount(amount) {
+  return typeof amount === "bigint" ? amount : BigInt(amount);
+}
+var Divy = class {
+  mode;
+  apiUrl;
+  apiKey;
+  account;
+  // viem's client generics resist a clean stored type across the three constructor branches;
+  // both are only ever touched through sendLocal(), which fixes the call shape in one place.
+  wallet;
+  pub;
+  chain;
+  constructor(options) {
+    const hasPrivateKey = "privateKey" in options && options.privateKey !== void 0;
+    const hasApiKey = "apiKey" in options && options.apiKey !== void 0;
+    if (hasPrivateKey && hasApiKey) {
+      throw new Error("pass either privateKey or apiKey to createDivy, not both");
+    }
+    this.apiUrl = options.apiUrl ?? addresses.apiUrl;
+    if (hasPrivateKey) {
+      const { privateKey, rpcUrl } = options;
+      if (!PRIVATE_KEY_RE.test(privateKey)) {
+        throw new Error("privateKey must be a 0x-prefixed 32-byte hex string");
+      }
+      this.mode = "self-custody";
+      this.account = (0, import_accounts.privateKeyToAccount)(privateKey);
+      this.chain = defineDivyChain(rpcUrl ?? addresses.rpcUrl);
+      const transport = (0, import_viem2.http)(rpcUrl ?? addresses.rpcUrl);
+      this.wallet = (0, import_viem2.createWalletClient)({ account: this.account, chain: this.chain, transport });
+      this.pub = (0, import_viem2.createPublicClient)({ chain: this.chain, transport });
+    } else if (hasApiKey) {
+      const { apiKey } = options;
+      if (typeof apiKey !== "string" || apiKey.length === 0) {
+        throw new Error("apiKey must be a non-empty string");
+      }
+      this.mode = "hosted";
+      this.apiKey = apiKey;
+    } else {
+      this.mode = "read-only";
+    }
+  }
+  requireSigner(action) {
+    if (this.mode === "read-only") {
+      throw new Error(`${action} requires a privateKey (self-custody) or apiKey (hosted) \u2014 this client is read-only`);
+    }
+  }
+  async sendLocal(tx) {
+    if (!this.wallet || !this.pub || !this.account) throw new Error("self-custody wallet is not configured");
+    const hash = await this.wallet.sendTransaction({
+      account: this.account,
+      chain: this.chain,
+      to: tx.to,
+      data: tx.data,
+      value: tx.value
+    });
+    const receipt = await this.pub.waitForTransactionReceipt({ hash });
+    if (receipt.status !== "success") throw new Error(`transaction reverted on-chain: ${hash}`);
+    return receipt;
+  }
+  async buildTx(path, body) {
+    return apiRequest(this.apiUrl, path, { body: body ?? {} });
+  }
+  async info() {
+    return parseInfo(await apiRequest(this.apiUrl, "/"));
+  }
+  async agent(address) {
+    if (!address) {
+      if (this.mode === "hosted") {
+        return parseAgentRecord(await apiRequest(this.apiUrl, "/me", { apiKey: this.apiKey }));
+      }
+      if (this.mode === "self-custody" && this.account) {
+        address = this.account.address;
+      } else {
+        throw new Error("agent() requires an address in read-only mode");
+      }
+    }
+    return parseAgentRecord(await apiRequest(this.apiUrl, `/agents/${address}`));
+  }
+  async leaderboard() {
+    return parseLeaderboard(await apiRequest(this.apiUrl, "/leaderboard"));
+  }
+  async launches(options = {}) {
+    const qs = options.limit ? `?limit=${options.limit}` : "";
+    return parseLaunches(await apiRequest(this.apiUrl, `/launches${qs}`));
+  }
+  async health() {
+    return parseHealth(await apiRequest(this.apiUrl, "/health"));
+  }
+  async register() {
+    this.requireSigner("register");
+    if (this.mode === "hosted") {
+      const me = await apiRequest(this.apiUrl, "/me", { apiKey: this.apiKey });
+      if (me.registered) return { registered: true, split: me.split };
+      return { registered: false, split: null };
+    }
+    const address = this.account.address;
+    const first = await apiRequest(this.apiUrl, "/agents", {
+      body: { address }
+    });
+    if (first.registered) return { registered: true, split: first.split };
+    const receipt = await this.sendLocal({ to: first.tx.to, data: first.tx.data, value: BigInt(first.tx.value ?? 0) });
+    const after = await apiRequest(this.apiUrl, "/agents", { body: { address } });
+    return { registered: after.registered, split: after.split, txHash: receipt.transactionHash };
+  }
+  async quote(params) {
+    let recipient = params.recipient;
+    if (!recipient && this.mode === "self-custody" && this.account) recipient = this.account.address;
+    return parseQuote(
+      await apiRequest(this.apiUrl, "/quote", {
+        body: {
+          curve: params.curve,
+          token: params.token,
+          side: params.side,
+          amount: readAmount(params.amount).toString(),
+          recipient: recipient ?? import_viem2.zeroAddress
+        }
+      })
+    );
+  }
+  async launch(params) {
+    this.requireSigner("launch");
+    if (this.mode === "hosted") {
+      const out = await apiRequest(this.apiUrl, "/launch", {
+        apiKey: this.apiKey,
+        body: params
+      });
+      return { token: out.token, curve: out.curve, txHash: out.txHash };
+    }
+    const address = this.account.address;
+    const built = await apiRequest(this.apiUrl, "/launch", { body: { ...params, agent: address } });
+    const receipt = await this.sendLocal(built.tx);
+    let launched;
+    for (const log of receipt.logs) {
+      try {
+        const ev = (0, import_viem2.decodeEventLog)({ abi: factoryTokenLaunchedAbi, data: log.data, topics: log.topics });
+        if (ev.eventName === "TokenLaunched") {
+          launched = ev.args;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (!launched) throw new Error(`launch mined (${receipt.transactionHash}) but no TokenLaunched event was found`);
+    const result = { token: launched.token, curve: launched.curve, txHash: receipt.transactionHash };
+    try {
+      const recorded = await this.record(launched.token);
+      result.recordTxHash = recorded.txHash;
+    } catch (e) {
+      result.recordError = e instanceof Error ? e.message : String(e);
+    }
+    return result;
+  }
+  async record(token) {
+    if (this.mode !== "self-custody") {
+      throw new Error(
+        "record() requires self-custody (a privateKey): hosted and read-only launches are recorded automatically by Divy's keeper within about a minute \u2014 use waitForRecord() to wait for it"
+      );
+    }
+    const built = await apiRequest(this.apiUrl, "/record", { body: { token } });
+    const receipt = await this.sendLocal(built.tx);
+    return { txHash: receipt.transactionHash };
+  }
+  async buy(params) {
+    return this.trade("buy", readAmount(params.amountWei), params);
+  }
+  async sell(params) {
+    return this.trade("sell", readAmount(params.amountTokens), params);
+  }
+  async trade(side, amount, params) {
+    this.requireSigner(side);
+    const slippageBps = params.slippageBps ?? 100;
+    if (this.mode === "hosted") {
+      if (slippageBps !== 100) {
+        throw new Error("slippageBps is not configurable in hosted mode: /trade hardcodes a 1% (100bps) slippage floor");
+      }
+      const out = await apiRequest(this.apiUrl, "/trade", {
+        apiKey: this.apiKey,
+        body: { curve: params.curve, token: params.token, side, amount: amount.toString() }
+      });
+      return { txHash: out.txHash, amountOut: BigInt(out.amountOut) };
+    }
+    const address = this.account.address;
+    const q = await this.quote({ curve: params.curve, token: params.token, side, amount, recipient: address });
+    let tradeTx = q.tx;
+    if (slippageBps !== 100) {
+      const minOut = q.amountOut * (BPS_DENOM - BigInt(slippageBps)) / BPS_DENOM;
+      const data = (0, import_viem2.encodeFunctionData)({ abi: curveAbi, functionName: side, args: [q.amountIn, minOut, address] });
+      tradeTx = { ...q.tx, data };
+    }
+    if (q.approveTx) await this.sendLocal(q.approveTx);
+    const receipt = await this.sendLocal(tradeTx);
+    return { txHash: receipt.transactionHash, amountOut: q.amountOut };
+  }
+  async harvest() {
+    this.requireSigner("harvest");
+    if (this.mode === "hosted") {
+      const out = await apiRequest(this.apiUrl, "/harvest", { apiKey: this.apiKey, body: {} });
+      return { txHash: out.txHash };
+    }
+    const address = this.account.address;
+    const built = await apiRequest(this.apiUrl, "/harvest", { body: { agent: address } });
+    const receipt = await this.sendLocal(built.tx);
+    return { txHash: receipt.transactionHash };
+  }
+  async waitForRecord(token, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 6e4;
+    const intervalMs = options.intervalMs ?? 3e3;
+    const deadline = Date.now() + timeoutMs;
+    const wanted = token.toLowerCase();
+    for (; ; ) {
+      const rows = await this.launches({ limit: 200 });
+      const row = rows.find((r) => r.token.toLowerCase() === wanted);
+      if (row?.recorded) return row;
+      if (Date.now() >= deadline) {
+        throw new DivyError(`timed out waiting for ${token} to be recorded`, 408);
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+  }
+};
+function createDivy(options = {}) {
+  return new Divy(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CHAIN_ID,
+  DEFAULT_API_URL,
+  DEFAULT_RPC_URL,
+  Divy,
+  DivyError,
+  addresses,
+  createDivy,
+  defineDivyChain,
+  explorerAddress,
+  explorerTx
+});
+//# sourceMappingURL=index.cjs.map