@pickhooks/sdk 0.2.0 → 0.4.0

package/dist/errors.js

@@ -1,5 +1,6 @@
 import { decodeErrorResult, toFunctionSelector } from "viem";
 import { formatAbiItem } from "viem/utils";
+import { agentsDeskAbi, agentsFactoryAbi, agentsHookAbi } from "./abis/agents.js";
 import { any3FactoryAbi, any3HookAbi } from "./abis/any3.js";
 import { anyTaxFactoryAbi, anyTaxHookAbi } from "./abis/anytax.js";
 import { callsDeskAbi, callsFactoryAbi, callsHookAbi } from "./abis/calls.js";
@@ -9,6 +10,7 @@ import { leverEngineAbi, leverFactoryAbi, leverHookAbi, leverRouterAbi } from ".
 import { lever2EngineAbi, lever2FactoryAbi, lever2HookAbi } from "./abis/lever2.js";
 import { poolsFactoryAbi, poolsHookAbi } from "./abis/pools.js";
 import { stickyFactoryAbi, stickyTokenAbi, stickyValidatorAbi } from "./abis/sticky.js";
+import { coverDeskAbi, darkRoundAbi, launchDeskAbi, ruleAuctionAbi, sticky2FactoryAbi, sticky2TokenAbi, sticky2ValidatorAbi } from "./abis/sticky2.js";
 import { v1FactoryAbi, v1TokenAbi } from "./abis/v1.js";
 import { arenaAbi, floorVaultAbi, payrollBoxAbi, v2FactoryAbi, v2TokenAbi, voteBoxAbi } from "./abis/v2.js";
 /** sticky: what token.check() answers when no row stops a trade but the coins are not unlocked yet */
@@ -25,6 +27,16 @@ export const CHECK_TEXT = {
 };
 /** hook any coin's factory and sticky's factory and validator: Bad(what) as a sentence */
 const BAD = {
+    // sticky 2 factory and dark round
+    tick: "The start price is not on the price ladder.",
+    drip: "The drip is at most an hour.",
+    ciphertext: "The sealed bid has the wrong shape.",
+    creator: "The creator address is empty.",
+    switcher: "The coin's switcher is not listed, or it has switch rows without one.",
+    round: "A round runs 2 to 60 minutes.",
+    allocation: "The round sells 10 to 30 % of the supply.",
+    raise: "The minimum raise is at least 0.05 BNB.",
+    step: "The step is 0 to 23.",
     // hook any coin, open()
     fee: "Pool fee: 0.2 to 1 % (feeBps 20 to 100).",
     holderFee: "The holder fee cannot be higher than the pool fee.",
@@ -80,6 +92,20 @@ const BY_NAME = {
     NoLiquidity: "That is too little to add any liquidity. Put in more.",
     FeeOnTransfer: "This coin takes a fee on transfers, so it cannot go into a pool.",
     Transfer: "The coin refused the transfer. Check the balance and the allowance.",
+    // agents: the desk and the hook
+    NotPilot: "Only the coin's pilot (its agent's wallet) can do that.",
+    NoPilot: "This coin has no pilot any more: the holders fired it.",
+    NoPending: "This coin has no pending change.",
+    NoLock: "This wallet has no coins locked at the desk for this coin.",
+    Closed: "That vote is over: the change landed or was cancelled, or the pilot is gone.",
+    Unsteady: "The pool's price moved in this block already. The run waits for the next block.",
+    BadBucket: "That bucket does not exist, or BNB cannot move there.",
+    Empty: "That bucket is empty.",
+    DeskSet: "The desk is set once.",
+    NotDesk: "Only the desk can do that.",
+    NotReady: "The factory is not initialised yet.",
+    Liquidity: "The launch could not place the curve.",
+    AlreadyRegistered: "This coin is registered already.",
     PriceMoved: "The coin's price moved more than allowed while the pool opened. Check again and open.",
     TooShallow: "Not enough liquidity: the pool must be at least as deep as the coin's main pool.",
     StillLocked: "This position is still locked. Each one stays 30 days after it went in.",
@@ -155,9 +181,40 @@ const BY_NAME = {
     Premium: "The premium is between 0.01 % and 50 % of what a floor covers.",
     Until: "The end of the bid has to be in the future.",
     Deposit: "A new bid locks at least 0.01 BNB, and at least its smallest floor.",
-    IsClosed: "That bid is closed.",
     BidOver: "That bid has ended: it takes no new floors.",
-    TooBig: "The bid has less BNB free than this floor covers. Protect fewer coins or pick another bid.",
+    TooBig: "That is more than this bid or offer has free. Ask for less or pick another one.",
+    // sticky 2 desks (dev cover, dark launch, rule auction, launch desk); TooBig and IsClosed above are shared with dip bids
+    IsClosed: "That bid or offer is closed.",
+    NotWriter: "Only the wallet that posted the offer can do that.",
+    NoOffer: "There is no cover offer with this id.",
+    NoPolicy: "There is no policy with this id.",
+    Mark: "The mark is 10, 25, 50 or 100 % of the creator's coins sold.",
+    Stop: "The stop share has to be at most the mark.",
+    OfferOver: "This offer has ended: it takes no new policies.",
+    MarkHit: "The creator already sold past this mark: no new policies on it.",
+    StopHit: "The creator already sold past this offer's stop share: no new policies.",
+    Creator: "The creator cannot cover its own coin.",
+    OverBag: "A policy can only cover what this wallet's coins are worth right now. Ask for less.",
+    NotTriggered: "The creator has not sold past the mark yet (or it happened inside the 10 minute warm up).",
+    NoRound: "There is no dark round with this id.",
+    NotOpen: "Not every bid is open yet and the opening window is still running.",
+    Over: "This round takes no more bids.",
+    Opened: "That bid is open already.",
+    Nothing: "Nothing left to claim for this bid.",
+    NotSwitcher: "Only the coin's switcher can turn a game on.",
+    AlreadyStarted: "The auction of this coin has started already.",
+    Length: "The coin has no switch rows for the auction.",
+    NotAGame: "That rule is not one of the coin's games.",
+    Zero: "Burn more than nothing.",
+    Burn: "The burn failed: check the balance and the approval to the auction.",
+    NothingToSettle: "There is no auction round to settle for this coin.",
+    NotOperator: "Only the pad's reply bot may launch from a launch desk balance.",
+    NotAllowed: "This wallet has not allowed the bot to launch for it.",
+    Limit: "Over this wallet's limit per launch or per day.",
+    Balance: "Not enough BNB on the launch desk for this.",
+    GasFee: "The gas refund asked for is over the cap of 0.002 BNB.",
+    FeeTooHigh: "That fee is over the contract's cap.",
+    ZeroAddress: "That address is empty.",
     Ended: "That floor has run out or was already handed in.",
     NotOver: "Only the owner can end a floor before it runs out.",
     NotYours: "That floor belongs to another wallet.",
@@ -192,6 +249,13 @@ const ABIS = [
     stickyFactoryAbi,
     stickyValidatorAbi,
     stickyTokenAbi,
+    sticky2FactoryAbi,
+    sticky2ValidatorAbi,
+    sticky2TokenAbi,
+    coverDeskAbi,
+    ruleAuctionAbi,
+    darkRoundAbi,
+    launchDeskAbi,
     anyTaxFactoryAbi,
     anyTaxHookAbi,
     v1FactoryAbi,
@@ -218,6 +282,9 @@ const ABIS = [
     hooksExecutorAbi,
     hooksFloorAbi,
     hooksFloorFactoryAbi,
+    agentsFactoryAbi,
+    agentsHookAbi,
+    agentsDeskAbi,
 ];
 /** every error selector the pickhooks ABIs know, for errors that PancakeSwap wraps (WrappedError, the quoter's revert) */
 const SELECTORS = ABIS.flatMap((abi) => abi.filter((x) => x.type === "error").map((x) => ({ sel: toFunctionSelector(formatAbiItem(x)).slice(2).toLowerCase(), abi })));

package/dist/index.d.ts

@@ -1,15 +1,19 @@
 import type { PublicClient } from "viem";
 import type { Addresses } from "./addresses.js";
+import { type AgentsModule } from "./agents.js";
 import { type AnyModule } from "./any.js";
 import { type ApiModule } from "./api.js";
 import { type Block, type BlocksCatalog } from "./blocks.js";
 import { type CoinsModule } from "./coins.js";
+import { type DesksModule } from "./desks.js";
 import { type DipsModule } from "./dips.js";
 import { type InfraModule } from "./infra.js";
 import { type Lever2Module, type LeverModule } from "./lever.js";
 import { type CallsModule, type PoolsModule } from "./pools.js";
 import { type StickyModule } from "./sticky.js";
 import { type PickhooksOptions, type SendOptions, type Sent, type TxRequest } from "./tx.js";
+import { type WalletModule } from "./wallet.js";
+import { type WatchModule } from "./watch.js";
 export type Pickhooks = {
     addresses: Addresses;
     publicClient: PublicClient;
@@ -17,6 +21,16 @@ export type Pickhooks = {
     any: AnyModule;
     /** sticky rules: rules that stick to the coins */
     sticky: StickyModule;
+    /** sticky 2: the same coins from the second factory, plus what the creator sold and the switch rows (off until it is on mainnet) */
+    sticky2: StickyModule & Pick<DesksModule, "devCounters" | "switches">;
+    /** dev cover and dev bond: cover against the creator selling, paid out of the desk when the creator's sold share reaches the mark */
+    cover: DesksModule["cover"];
+    /** the rule auction: holders burn coins to pick the game of the next round */
+    auction: DesksModule["auction"];
+    /** the dark launch: sealed bids before the coin exists, one price for everyone, born with BNB on both sides */
+    dark: DesksModule["dark"];
+    /** the launch desk of launch per reply: a wallet's balance the pad's bot may launch with, for that wallet only */
+    launchDesk: DesksModule["desk"];
     /** coins with their rules in the coin (v1 and v2, also find the dev and CZ mode coins) */
     coins: CoinsModule;
     /** pools: coins with their rules in a PancakeSwap Infinity pool hook */
@@ -29,8 +43,14 @@ export type Pickhooks = {
     leverV1: LeverModule;
     /** dip bids: floors at a strike */
     dips: DipsModule;
-    /** HOOKS infra: BNB floors under coins and the protected buy (off while their addresses are zero) */
+    /** HOOKS infra: BNB floors under coins and the protected buy */
     infra: InfraModule;
+    /** agents: coins run by an agent that rewrites their rules live, inside limits the chain checks; be the agent yourself (brief, act) */
+    agents: AgentsModule;
+    /** live events: every launch on the pad, every trade of a coin, everything that happens to an agent coin */
+    watch: WatchModule;
+    /** one address: everything it holds on pickhooks, what it can sell now, what it can claim */
+    wallet: WalletModule;
     /** the building blocks: sticky rules' ready blocks with their numbers and rows, the hook script grammar, the rule book (offline; ph.api.blocks() asks the site) */
     blocks: {
         catalog: () => BlocksCatalog;
@@ -46,8 +66,12 @@ export type Pickhooks = {
  * The pickhooks SDK. One client, a part per product:
  *   any      hook any coin: quotes, trades with the recapture room, opening a pool with a partner, the payouts
  *   sticky   sticky rules: launching from templates, checking a trade against the coin's table, trading, lifting
+ *   sticky2  sticky 2 (the same, plus what the creator sold); cover: dev cover and dev bond; auction: the rule auction;
+ *            dark: the dark launch (sealed bids, @pickhooks/sdk/tlock seals them); launchDesk: launch per reply's balance
  *   coins    coins with rules in the coin (v1, v2): rules as sentences, the rule that would refuse a trade, launches
  *   pools    rules in the pool; calls: curve calls; lever: Lever longs and shorts (leverV1 the first lever); dips: dip bids
+ *   agents   coins run by an agent: read the program, brief any model, act as the pilot, veto and fire as a holder
+ *   watch    live events (launches, trades, agent changes); wallet: one address, everything it holds and can claim
  *   api      pickhooks.com's public JSON API (launch feed, board, activity)
  *
  *   const ph = createPickhooks({ walletClient });
@@ -60,14 +84,21 @@ export { CHECK_TEXT, PickhooksError, decodeRevert, errorText, explain, findRever
 export { DEFAULT_RPC, deadlineIn, minusBps, type PickhooksOptions, type SendOptions, type Sent, type TxRequest } from "./tx.js";
 export { blockedKind, buildInfiSwap, infiPriceBnb, infiQuote, infiSwapInput, permit2Approvals, poolIdOf, toKey, type PoolKey } from "./infinity.js";
 export { approvalFor, buildV3Buy, buildV3Sell, receivedOf, v3PriceBnb, v3Quote } from "./v3.js";
+export { type Venue, bestVenue, buildV2Buy, buildV2Sell, v2Quote, v2RouterAbi } from "./v2.js";
 export { MAX_TICK, MIN_TICK, TAX_QUOTE_MARK, afterTax, depthNeeds, fitLadder, partnerLink, rangeFor, tickOf, type AnyLine, type AnyModule, type AnyPool, type AnyQuote, type CoinCheck, type Earnings, type OpenOptions, type OpenParams, type PoolConfig, type PoolPosition, type PoolRef, type RangeKind, type Recapture, type TaxLive, type TradeResult, } from "./any.js";
-export { describeRows, type StickyCheck, type StickyCoin, type StickyLaunch, type StickyLot, type StickyModule, type StickyRow, type StickyTerms, } from "./sticky.js";
+export { describeRows, stickyTable, stickyTestRun, testRunText, type StickyTestRun, type StickyCheck, type StickyCoin, type StickyLaunch, type StickyLot, type StickyModule, type StickyRow, type StickyTerms, } from "./sticky.js";
+export { CURVE, SUPPLY, simulate, type SimReport } from "./sticky-sim.js";
 export { ruleText, type CoinRule, type CoinsModule, type RuleCheck, type RuleCoin, type RuleCoinVersion, type RuleLaunch } from "./coins.js";
 export { type CallRow, type CallStep, type CallsModule, type HookCoin, type HookLaunch, type PoolsModule } from "./pools.js";
 export { LEVER2_REASON, type Lever2CloseQuote, type Lever2Module, type Lever2OpenQuote, type Lever2Row, type Lever2State, type LeverCoin, type LeverMarket, type LeverModule, type LeverPosition, } from "./lever.js";
 export { coinsFor, coverOf, strikeFromPrice, type DipBid, type DipFloor, type DipPost, type DipsModule } from "./dips.js";
 export { type ApiModule, type Launch, type LaunchFeed } from "./api.js";
+export { type AuctionState, type CoverOffer, type CoverPolicy, type CoverPost, type DarkBid, type DarkRoundState, type DesksModule, type DevCounters, } from "./desks.js";
 export { type FloorState, type InfraModule, type ProtectOffer } from "./infra.js";
+export { type AgentCoin, type AgentLaunch, type AgentLock, type AgentLook, type AgentPending, type AgentsModule, type JournalEntry } from "./agents.js";
+export { AGENT_LIMITS, AGENT_RULES, AGENT_RULE_BY_ID, AGENT_RULE_BY_KIND, ALLOWED_MASK, ANSWER_SCHEMA, BUCKETS, ENVELOPE_TUPLE, OBJECTIVES, PERSONALITIES, PROGRAM_TUPLE, agentKindsOf, decodeProgram, describeProgram, encodeProgram, noteHash, parseAnswer, readPlan, starterEnvelope, starterProgram, systemPrompt, toPlan, toProgram, userPrompt, type AgentAnswer, type AgentProfile, type AgentRule, type AgentRuleField, type Bucket, type Envelope, type Plan, type Program, } from "./agents-catalog.js";
+export { type AgentEvent, type WatchMode, type WatchOptions, type WatchModule, type WatchedLaunch, type WatchedTrade } from "./watch.js";
+export { type WalletCoin, type WalletModule, type WalletView } from "./wallet.js";
 export { BLOCKS_VERSION, BLOCK_ACTIONS, BLOCK_CHECKS, BLOCK_MARKS, BLOCK_OPERATORS, BLOCK_TRIGGERS, blockLineVars, blocksCatalog, type Block, type BlockAction, type BlockParam, type BlockVariable, type BlocksCatalog, type CoinRuleBlock, type CoinRuleField, type GrammarItem, } from "./blocks.js";
 export { ACT, FLAG, LOCKED, NONE, ON, OP, STICKY_LIMITS, TEMPLATES, TEMPLATE_BY_ID, VAR, VARS, VAR_BY_ID, compile, decodeRow, defaults, editToRow, emptyEditRow, encodeRow, paramProblems, rowProblems, rowText, scannerOf, tableProblems, templateOf, type Cond, type EditCond, type EditRow, type Pick, type Row, type Template, type TemplateId, } from "./sticky-rules.js";
 export { GROUPS, RULES, RULE_BY_ID, RULE_BY_KIND, buildRules, emptyExtras, emptyRules, fieldProblem, kindsOf, refusal, selectionProblem, v2Costs, worstScanner, defaults as ruleDefaults, type Picked, type R as CoinRules, type RuleDef, type X as CoinExtras, } from "./coin-rules.js";

package/dist/index.js

@@ -1,19 +1,27 @@
+import { agentsModule } from "./agents.js";
 import { anyModule } from "./any.js";
 import { apiModule } from "./api.js";
 import { blocksCatalog } from "./blocks.js";
 import { coinsModule } from "./coins.js";
+import { desksModule } from "./desks.js";
 import { dipsModule } from "./dips.js";
 import { infraModule } from "./infra.js";
 import { lever2Module, leverModule } from "./lever.js";
 import { callsModule, poolsModule } from "./pools.js";
 import { stickyModule } from "./sticky.js";
 import { makeCtx, sendAll, sendTx } from "./tx.js";
+import { walletModule } from "./wallet.js";
+import { watchModule } from "./watch.js";
 /**
  * The pickhooks SDK. One client, a part per product:
  *   any      hook any coin: quotes, trades with the recapture room, opening a pool with a partner, the payouts
  *   sticky   sticky rules: launching from templates, checking a trade against the coin's table, trading, lifting
+ *   sticky2  sticky 2 (the same, plus what the creator sold); cover: dev cover and dev bond; auction: the rule auction;
+ *            dark: the dark launch (sealed bids, @pickhooks/sdk/tlock seals them); launchDesk: launch per reply's balance
  *   coins    coins with rules in the coin (v1, v2): rules as sentences, the rule that would refuse a trade, launches
  *   pools    rules in the pool; calls: curve calls; lever: Lever longs and shorts (leverV1 the first lever); dips: dip bids
+ *   agents   coins run by an agent: read the program, brief any model, act as the pilot, veto and fire as a holder
+ *   watch    live events (launches, trades, agent changes); wallet: one address, everything it holds and can claim
  *   api      pickhooks.com's public JSON API (launch feed, board, activity)
  *
  *   const ph = createPickhooks({ walletClient });
@@ -22,18 +30,36 @@ import { makeCtx, sendAll, sendTx } from "./tx.js";
  */
 export function createPickhooks(options = {}) {
     const ctx = makeCtx(options);
+    const d = desksModule(ctx);
+    const sticky = stickyModule(ctx);
+    const sticky2 = stickyModule(ctx, true);
+    const coins = coinsModule(ctx);
+    const pools = poolsModule(ctx);
+    const calls = callsModule(ctx);
+    const lever = lever2Module(ctx);
+    const dips = dipsModule(ctx);
+    const any = anyModule(ctx);
+    const agents = agentsModule(ctx);
     return {
         addresses: ctx.a,
         publicClient: ctx.pub,
-        any: anyModule(ctx),
-        sticky: stickyModule(ctx),
-        coins: coinsModule(ctx),
-        pools: poolsModule(ctx),
-        calls: callsModule(ctx),
-        lever: lever2Module(ctx),
+        any,
+        sticky,
+        sticky2: { ...sticky2, devCounters: d.devCounters, switches: d.switches },
+        cover: d.cover,
+        auction: d.auction,
+        dark: d.dark,
+        launchDesk: d.desk,
+        coins,
+        pools,
+        calls,
+        lever,
         leverV1: leverModule(ctx),
-        dips: dipsModule(ctx),
+        dips,
         infra: infraModule(ctx),
+        agents,
+        watch: watchModule(ctx, { sticky, sticky2, coins, pools, calls, agents, any }),
+        wallet: walletModule(ctx, { sticky, sticky2, coins, pools, calls, lever, agents, any, dips }),
         blocks: { catalog: blocksCatalog, block: (id) => blocksCatalog().sticky.blocks.find((b) => b.id === id) ?? null },
         api: apiModule(ctx),
         send: (tx, o) => sendTx(ctx, tx, o),
@@ -45,14 +71,21 @@ export { CHECK_TEXT, PickhooksError, decodeRevert, errorText, explain, findRever
 export { DEFAULT_RPC, deadlineIn, minusBps } from "./tx.js";
 export { blockedKind, buildInfiSwap, infiPriceBnb, infiQuote, infiSwapInput, permit2Approvals, poolIdOf, toKey } from "./infinity.js";
 export { approvalFor, buildV3Buy, buildV3Sell, receivedOf, v3PriceBnb, v3Quote } from "./v3.js";
+export { bestVenue, buildV2Buy, buildV2Sell, v2Quote, v2RouterAbi } from "./v2.js";
 export { MAX_TICK, MIN_TICK, TAX_QUOTE_MARK, afterTax, depthNeeds, fitLadder, partnerLink, rangeFor, tickOf, } from "./any.js";
-export { describeRows, } from "./sticky.js";
+export { describeRows, stickyTable, stickyTestRun, testRunText, } from "./sticky.js";
+export { CURVE, SUPPLY, simulate } from "./sticky-sim.js";
 export { ruleText } from "./coins.js";
 export {} from "./pools.js";
 export { LEVER2_REASON, } from "./lever.js";
 export { coinsFor, coverOf, strikeFromPrice } from "./dips.js";
 export {} from "./api.js";
+export {} from "./desks.js";
 export {} from "./infra.js";
+export {} from "./agents.js";
+export { AGENT_LIMITS, AGENT_RULES, AGENT_RULE_BY_ID, AGENT_RULE_BY_KIND, ALLOWED_MASK, ANSWER_SCHEMA, BUCKETS, ENVELOPE_TUPLE, OBJECTIVES, PERSONALITIES, PROGRAM_TUPLE, agentKindsOf, decodeProgram, describeProgram, encodeProgram, noteHash, parseAnswer, readPlan, starterEnvelope, starterProgram, systemPrompt, toPlan, toProgram, userPrompt, } from "./agents-catalog.js";
+export {} from "./watch.js";
+export {} from "./wallet.js";
 export { BLOCKS_VERSION, BLOCK_ACTIONS, BLOCK_CHECKS, BLOCK_MARKS, BLOCK_OPERATORS, BLOCK_TRIGGERS, blockLineVars, blocksCatalog, } from "./blocks.js";
 export { ACT, FLAG, LOCKED, NONE, ON, OP, STICKY_LIMITS, TEMPLATES, TEMPLATE_BY_ID, VAR, VARS, VAR_BY_ID, compile, decodeRow, defaults, editToRow, emptyEditRow, encodeRow, paramProblems, rowProblems, rowText, scannerOf, tableProblems, templateOf, } from "./sticky-rules.js";
 export { GROUPS, RULES, RULE_BY_ID, RULE_BY_KIND, buildRules, emptyExtras, emptyRules, fieldProblem, kindsOf, refusal, selectionProblem, v2Costs, worstScanner, defaults as ruleDefaults, } from "./coin-rules.js";

package/dist/sticky-sim.d.ts

@@ -0,0 +1,125 @@
+/**
+ * sticky rules in the browser: the coin's rule engine (src/sticky/StickyToken.sol) line for line, on bigints, and a test
+ * run of random trades on top. The engine is checked against the contract trade by trade (test/sticky/StickyTrace.t.sol
+ * writes a run, scripts/dev/sticky-sim-diff.mjs replays it here), so what the launcher shows is what the coin would do.
+ * The chain stays the truth: this only shows a creator what a table does before the launch.
+ */
+import { type Row } from "./sticky-rules.js";
+export declare const SUPPLY: bigint;
+/** The addresses the coin does not keep lots for. */
+export declare const POOL = "pool";
+export declare const POT = "pot";
+export declare const DEAD = "dead";
+export type Lot = {
+    amount: bigint;
+    lk: bigint;
+    since: number;
+    flags: number;
+};
+export type Stats = {
+    holders: number;
+    buys: number;
+    sells: number;
+    highAt: number;
+    lastBuy: number;
+    volume: bigint;
+    net: bigint;
+    peak: bigint;
+    high: bigint;
+};
+export type Now = {
+    t: number;
+    b: number;
+};
+export type CoinState = {
+    rows: Row[];
+    release: number;
+    off: number;
+    creator: string;
+    start: number;
+    startBlock: number;
+    curveSupply: bigint;
+    stats: Stats;
+    bal: Map<string, bigint>;
+    lots: Map<string, Lot[]>;
+};
+export type Result = {
+    ok: true;
+    burn: bigint;
+    toPot: bigint;
+    drop: bigint;
+} | {
+    ok: false;
+    why: number | "nope";
+};
+export declare function newCoin(rows: (bigint | Row)[], release: number, creator: string, curveSupply: bigint, start?: number, startBlock?: number): CoinState;
+/** A transfer as the coin runs it: out of POOL is a buy, into POOL a sell, anything else a send. */
+export declare function transfer(s: CoinState, from: string, to: string, amount: bigint, now: Now): Result;
+/** What `a` could sell right now (size rows left out, like the coin's view). */
+export declare function sellable(s: CoinState, a: string, now: Now): bigint;
+export declare function balanceOf(s: CoinState, a: string): bigint;
+export declare function lots(s: CoinState, a: string): Lot[];
+/** The curve as the coin prices it: x * y = k from the start price, so price / start = (supply / coins left)². */
+export declare const CURVE: {
+    supply: bigint;
+    startFdvBnb: number;
+};
+export type SimReport = {
+    trades: number;
+    hours: number;
+    buys: {
+        ok: number;
+        refused: number;
+    };
+    sells: {
+        ok: number;
+        refused: number;
+    };
+    sends: {
+        ok: number;
+        refused: number;
+    };
+    /** refusals by row (0 based) and LOCKED (254) */
+    refusals: {
+        row: number;
+        count: number;
+    }[];
+    /** longest a wallet that wanted to sell had to wait until a sell went through (seconds) */
+    longestWait: number;
+    /** wallets still unable to sell when the run ended */
+    stillWaiting: number;
+    /** after the run: seconds until every wallet can sell everything (null: longer than 31 days) */
+    allFreeAfter: number | null;
+    burnedPct: number;
+    pot: {
+        inPct: number;
+        drops: number;
+        paidPct: number;
+        biggestX: number;
+        leftPct: number;
+    };
+    snipers: {
+        count: number;
+        firstSellAfter: number | null;
+    };
+    splits: {
+        count: number;
+        refusedAfter: number;
+    };
+    /** a scanner's test: a tiny buy and an instant sell an hour after launch */
+    scanner: {
+        buy: number | null;
+        sell: number | null;
+    };
+};
+/**
+ * Random trades on a fresh coin with this table: the creator's first buy, three snipers in the first blocks, wallets
+ * that come, buy, hold for a while and sell (and try again when refused), some bags split to fresh wallets that then
+ * try to sell. The same seed gives the same run.
+ */
+export declare function simulate(rows: bigint[], release: number, opts?: {
+    seed?: number;
+    trades?: number;
+    devBuyBnb?: number;
+    start?: number;
+}): SimReport;