@pickhooks/sdk 0.2.0 → 0.5.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,8 @@ 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 { comboModeAbi, drandBeaconAbi, forwardModeAbi, sticky3FactoryAbi, sticky3TokenAbi, sticky3ValidatorAbi, } from "./abis/sticky3.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 +28,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.",
@@ -71,6 +84,21 @@ const BAD = {
     "pot needs a drop": "A pot needs a drop row that pays it out.",
     every: "Every n-th buy: n from 2 to 1,000,000.",
     idle: "Time since the last buy: at most 30 days.",
+    // sticky 3: the factory, the validator, the modes
+    mode: "That mode is not open for launches (or it launches another way).",
+    "mode data": "Settings for a mode, but no mode.",
+    "game take": "The rows' burns and pots and the mode's share are over 10 % of a buy together.",
+    bps: "The mode's share of buys is outside its bounds.",
+    min: "The mode's minimum size is outside its bounds (0.001 to 0.1 % of the supply).",
+    registered: "This coin is registered with the mode already.",
+    "no play": "This mode has nothing to play.",
+    "no poke": "This mode has nothing to nudge.",
+    "no action": "Say what to do (the action first).",
+    action: "This mode does not know that action.",
+    player: "The creator (and the coin's pools) cannot play this.",
+    "too small": "Too small: below the mode's minimum.",
+    size: "A size is out of its bounds.",
+    "not yet": "Not yet: the reveal round is not out.",
 };
 /** every other error of the pickhooks contracts, by name */
 const BY_NAME = {
@@ -80,6 +108,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 +197,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.",
@@ -176,6 +249,12 @@ const BY_NAME = {
     NothingToProtect: "No coins arrived to protect.",
     Swap: "The swap through PancakeSwap failed.",
     Target: "The executor only calls PancakeSwap's own routers.",
+    // sticky 3: the coin
+    Busy: "The coin is busy with its mode. Try again.",
+    NoMode: "This coin has no mode.",
+    LowGas: "Too little gas for the coin's mode: send it with more gas (estimate again).",
+    BadOrder: "The mode answered with an order the coin refuses.",
+    BadSignature: "That is not drand's signature on this round.",
 };
 /** PancakeSwap's own errors that a trade can run into */
 const PANCAKE = [
@@ -192,6 +271,13 @@ const ABIS = [
     stickyFactoryAbi,
     stickyValidatorAbi,
     stickyTokenAbi,
+    sticky2FactoryAbi,
+    sticky2ValidatorAbi,
+    sticky2TokenAbi,
+    coverDeskAbi,
+    ruleAuctionAbi,
+    darkRoundAbi,
+    launchDeskAbi,
     anyTaxFactoryAbi,
     anyTaxHookAbi,
     v1FactoryAbi,
@@ -218,6 +304,15 @@ const ABIS = [
     hooksExecutorAbi,
     hooksFloorAbi,
     hooksFloorFactoryAbi,
+    agentsFactoryAbi,
+    agentsHookAbi,
+    agentsDeskAbi,
+    sticky3FactoryAbi,
+    sticky3ValidatorAbi,
+    sticky3TokenAbi,
+    drandBeaconAbi,
+    comboModeAbi,
+    forwardModeAbi,
 ];
 /** 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,22 @@
 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 StickyModule, type StickyLaunch } from "./sticky.js";
+import { type ModesModule } from "./modes.js";
+import { type SimulateModule } from "./simulate.js";
+import { type TextRead, understandLaunch } from "./text-launch.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 +24,33 @@ 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">;
+    /**
+     * sticky 3: the sticky 2 coin with a mode (a game, like combo), fixed at launch: launch with `mode` and
+     * `modeSettings`; fromText reads a sentence into a launch. Off until the factory is on mainnet (the zero address).
+     */
+    sticky3: StickyModule & {
+        fromText: (text: string, o?: {
+            reader?: Parameters<typeof understandLaunch>[1];
+            metadata?: string;
+        }) => Promise<TextRead & {
+            by: "parser" | "reader" | null;
+            launch: StickyLaunch | null;
+        }>;
+    };
+    /** the games of sticky 3 coins: each mode's state and actions, custody, the catalog */
+    modes: ModesModule;
+    /** every buy, sell, send or play tried first against the chain as it is (eth_simulateV1): what arrives, burns, pays, or which rule stops it */
+    simulate: SimulateModule;
+    /** 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 +63,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 +86,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 });
@@ -55,19 +99,30 @@ export type Pickhooks = {
  *   const r = await ph.any.buy({ pool, bnbIn: parseEther("0.05") });
  */
 export declare function createPickhooks(options?: PickhooksOptions): Pickhooks;
-export { BSC_MAINNET, LIMITS, NATIVE, ZERO_ADDRESS, type Addresses } from "./addresses.js";
+export { BSC_MAINNET, LIMITS, MODE_NAMES, NATIVE, ZERO_ADDRESS, type Addresses, type ModeName } from "./addresses.js";
 export { CHECK_TEXT, PickhooksError, decodeRevert, errorText, explain, findRevertData } from "./errors.js";
 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 { MODES, MODE_LIST, encodeModeData, modeBps, type ModeAction, type ModeInfo, type ModeSettings } from "./modes-catalog.js";
+export { type Custody, type ModesModule } from "./modes.js";
+export { eventText, shadowOf, type SimResult, type SimulateModule } from "./simulate.js";
+export { NOT_POSSIBLE, readLaunch, understandLaunch, type TextDraft, type TextPick, type TextRead } from "./text-launch.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,31 @@
+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 { modesModule } from "./modes.js";
+import { simulateModule } from "./simulate.js";
+import { understandLaunch } from "./text-launch.js";
+import { PickhooksError } from "./errors.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,37 +34,102 @@ 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 sticky3 = stickyModule(ctx, 3);
+    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 },
+        sticky3: {
+            ...sticky3,
+            /**
+             * A sentence ("CAT Cat, combo, dev lock 7 days, sniper jail, dev buy 0.05") read into a sticky 3 launch. `launch` is
+             * ready for ph.sticky3.launch once there are no unknown clauses (add `metadata`); the factory and the mode check it
+             * again on chain. Pass a reader (your model, your key) for what the parser does not understand.
+             */
+            fromText: async (text, o = {}) => {
+                const r = await understandLaunch(text, o.reader);
+                const d = r.draft;
+                if (!d || r.unknown.length || r.refusals.length)
+                    return { ...r, launch: null };
+                const launch = {
+                    name: d.name,
+                    symbol: d.symbol,
+                    metadata: o.metadata ?? "",
+                    picks: d.picks,
+                    devBuy: BigInt(Math.round(d.devBuyBnb * 1e6)) * 10n ** 12n,
+                    ...(d.mode ? { mode: d.mode, modeSettings: d.modeSettings } : {}),
+                };
+                const table = (() => {
+                    try {
+                        return sticky3.table(launch);
+                    }
+                    catch (e) {
+                        return e instanceof PickhooksError ? e.message : String(e);
+                    }
+                })();
+                if (typeof table === "string")
+                    return { ...r, notes: [...r.notes, table], launch: null };
+                return { ...r, launch };
+            },
+        },
+        modes: modesModule(ctx),
+        simulate: simulateModule(ctx),
+        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),
         sendAll: (txs, o) => sendAll(ctx, txs, o),
     };
 }
-export { BSC_MAINNET, LIMITS, NATIVE, ZERO_ADDRESS } from "./addresses.js";
+export { BSC_MAINNET, LIMITS, MODE_NAMES, NATIVE, ZERO_ADDRESS } from "./addresses.js";
 export { CHECK_TEXT, PickhooksError, decodeRevert, errorText, explain, findRevertData } from "./errors.js";
 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 { MODES, MODE_LIST, encodeModeData, modeBps } from "./modes-catalog.js";
+export {} from "./modes.js";
+export { eventText, shadowOf } from "./simulate.js";
+export { NOT_POSSIBLE, readLaunch, understandLaunch } from "./text-launch.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/modes-catalog.d.ts

@@ -0,0 +1,59 @@
+import { type Hex } from "viem";
+import type { ModeName } from "./addresses.js";
+/**
+ * The modes of sticky 3, offline: what each one is, its line, its share of buys and the bounds of its settings, the
+ * actions holders play, and whether it draws with drand. The chain is the truth: a mode's own quote() refuses settings
+ * outside its bounds, and the coin's guardrails hold whatever a mode does.
+ */
+export type ModeSettings = {
+    /** the mode's share of every buy into the game pot, basis points */
+    bps?: number;
+    /** the smallest trade (or bid, try, join) that counts, millionths of the supply */
+    minPpm?: number;
+};
+export type ModeAction = {
+    name: string;
+    who: "holder" | "creator" | "anyone" | "dev";
+    text: string;
+};
+export type ModeInfo = {
+    name: ModeName;
+    title: string;
+    /** the line as the launcher and the posts say it */
+    line: string;
+    /** how it plays, sentence by sentence */
+    how: string[];
+    /** the share of every buy into the game pot, basis points: default and bounds (0: the mode takes nothing) */
+    bps: {
+        default: number;
+        min: number;
+        max: number;
+    };
+    /** the smallest trade that counts, millionths of the supply (null: the mode has no minimum setting) */
+    minPpm: {
+        default: number;
+        min: number;
+        max: number;
+    } | null;
+    /** the settings the launcher offers */
+    settings: (keyof ModeSettings)[];
+    actions: ModeAction[];
+    /** it waits for drand rounds (the keeper hands them in) */
+    drand: boolean;
+    /** coins can sit in custody in this mode (never more than 7 days; 14 for a dev bag locked at the launch) */
+    custody: boolean;
+    /** the keeper's part: what it settles, opens or drops */
+    keeper: string | null;
+    /** said plainly: what can look odd or be gamed, and the cap that holds it */
+    notes: string[];
+};
+export declare const MODES: Record<ModeName, ModeInfo>;
+/** The modes in the launcher's order. */
+export declare const MODE_LIST: ModeInfo[];
+/**
+ * A mode's settings as the factory passes them on (abi encoded; zeros mean the defaults, empty means all defaults). Throws
+ * for settings the mode does not have, or outside its bounds.
+ */
+export declare function encodeModeData(name: ModeName, s?: ModeSettings): Hex;
+/** The share of buys a mode takes with these settings (offline; the mode's quote() on chain is the truth). */
+export declare function modeBps(name: ModeName, s?: ModeSettings): number;

package/dist/modes-catalog.js

@@ -0,0 +1,77 @@
+import { encodeAbiParameters } from "viem";
+import { PickhooksError } from "./errors.js";
+const MIN = { default: 100, min: 10, max: 1000 };
+export const MODES = {
+    combo: {
+        name: "combo",
+        title: "combo",
+        line: "Buys build the combo. One sell breaks it.",
+        how: [
+            "Every buy of at least the minimum size adds one to the combo; every sell of that size breaks it to zero.",
+            "The buy that brings the combo to 10, 25 or 50 wins 10, 25 or 50 % of the pot, then every 25 more win 25 %.",
+            "A win is never more coins than the winning buy itself brings, and never goes to the creator.",
+        ],
+        bps: { default: 200, min: 100, max: 300 },
+        minPpm: MIN,
+        settings: ["bps", "minPpm"],
+        actions: [],
+        drand: false,
+        custody: false,
+        keeper: null,
+        notes: ["A bot can aim for the 10th buy: it buys, and the win stops at its own buy."],
+    },
+    forward: {
+        name: "forward",
+        title: "pay it forward",
+        line: "Your buy pays the last buyer. The next buy pays you.",
+        how: [
+            "A share of every buy (3 % by default) goes straight to the wallet that bought before, as fresh coins.",
+            "Never the same wallet twice in a row, never the creator, never more than that wallet's own buy brought.",
+            "What is not forwarded is burned: the mode keeps no pot.",
+        ],
+        bps: { default: 300, min: 100, max: 500 },
+        minPpm: MIN,
+        settings: ["bps", "minPpm"],
+        actions: [],
+        drand: false,
+        custody: false,
+        keeper: null,
+        notes: ["A game with a fixed share, not a return: two own wallets pay each other and lose the price and the fees."],
+    },
+};
+/** The modes in the launcher's order. */
+export const MODE_LIST = [
+    MODES.combo,
+    MODES.forward,
+];
+const u = (x) => BigInt(typeof x === "boolean" ? (x ? 1 : 0) : Math.round(x ?? 0));
+/**
+ * A mode's settings as the factory passes them on (abi encoded; zeros mean the defaults, empty means all defaults). Throws
+ * for settings the mode does not have, or outside its bounds.
+ */
+export function encodeModeData(name, s) {
+    const info = MODES[name];
+    if (!info)
+        throw new PickhooksError(`There is no mode "${name}".`, { code: "input" });
+    if (!s || Object.values(s).every((x) => x === undefined))
+        return "0x";
+    for (const k of Object.keys(s)) {
+        if (s[k] !== undefined && !info.settings.includes(k))
+            throw new PickhooksError(`${info.title} has no setting "${k}".`, { code: "input" });
+    }
+    if (s.bps !== undefined && (s.bps < info.bps.min || s.bps > info.bps.max)) {
+        throw new PickhooksError(`${info.title}: the share of buys is ${info.bps.min / 100} to ${info.bps.max / 100} %.`, { code: "input" });
+    }
+    if (s.minPpm !== undefined && info.minPpm && (s.minPpm < info.minPpm.min || s.minPpm > info.minPpm.max)) {
+        throw new PickhooksError(`${info.title}: the minimum size is ${info.minPpm.min / 1e4} to ${info.minPpm.max / 1e4} % of the supply.`, { code: "input" });
+    }
+    const two = [{ type: "uint256" }, { type: "uint256" }];
+    switch (name) {
+        default:
+            return encodeAbiParameters(two, [u(s.bps), u(s.minPpm)]);
+    }
+}
+/** The share of buys a mode takes with these settings (offline; the mode's quote() on chain is the truth). */
+export function modeBps(name, s) {
+    return s?.bps ?? MODES[name].bps.default;
+}

package/dist/modes.d.ts

@@ -0,0 +1,71 @@
+import { type Address, type Hex } from "viem";
+import { type ModeName } from "./addresses.js";
+import { type ModeInfo, encodeModeData, modeBps } from "./modes-catalog.js";
+import { type Ctx, type SendOptions, type TxRequest } from "./tx.js";
+/**
+ * ph.modes: the games of sticky 3 coins. Every coin has one mode, fixed at launch; holders play it through the coin
+ * (`coin.play`), anyone nudges it (`coin.poke`), and the coin carries out what the mode answers inside its guardrails.
+ * Each mode here has its state (what the page shows) and its actions (build: the TxRequest; the plain name sends it).
+ * The modes that draw fetch drand's signature themselves (@pickhooks/sdk/tlock is loaded only then).
+ */
+export type Custody = {
+    amount: bigint;
+    dev: bigint;
+    until: number;
+    since: number;
+    shadow: Address;
+    releasable: boolean;
+};
+export declare function modesModule(ctx: Ctx): {
+    /** the modes: line, how they play, share of buys and bounds, actions (offline) */
+    catalog: Record<ModeName, ModeInfo>;
+    list: ModeInfo[];
+    info: (n: ModeName) => ModeInfo;
+    /** a mode's settings encoded for the launch (zeros: defaults) */
+    encode: typeof encodeModeData;
+    /** the share of buys a mode takes with these settings */
+    bps: typeof modeBps;
+    /** is the mode open for launches on the factory now */
+    listed: (n: ModeName) => Promise<boolean>;
+    of: (coin: Address) => Promise<{
+        name: ModeName | "other" | null;
+        address: Address;
+        gameBps: number;
+        gamePot: bigint;
+        info: ModeInfo | null;
+    }>;
+    custody: (coin: Address, who: Address) => Promise<Custody>;
+    build: {
+        release: (coin: Address, who: Address) => TxRequest;
+        play: (coin: Address, data: Hex, label: string) => TxRequest;
+        poke: (coin: Address, data: Hex, label: string) => TxRequest;
+    };
+    /** anyone: a holder's custody back to the wallet once its time is up */
+    release: (coin: Address, who: Address, s?: SendOptions) => Promise<import("./tx.js").Sent>;
+    /** a raw play or poke (data: abi.encode(action, ...)) for modes the SDK does not know */
+    play: (coin: Address, data: Hex, s?: SendOptions) => Promise<import("./tx.js").Sent>;
+    poke: (coin: Address, data: Hex, s?: SendOptions) => Promise<import("./tx.js").Sent>;
+    combo: {
+        state(coin: Address): Promise<{
+            combo: number;
+            best: number;
+            hits: number;
+            bps: number;
+            minPpm: number;
+            breaker: `0x${string}`;
+            brokeAt: number;
+            next: number;
+            nextSharePct: number;
+        }>;
+    };
+    forward: {
+        state(coin: Address): Promise<{
+            last: `0x${string}`;
+            lastGot: bigint;
+            bps: number;
+            minPpm: number;
+            forwards: number;
+        }>;
+    };
+};
+export type ModesModule = ReturnType<typeof modesModule>;