@pickhooks/sdk 0.0.0-stage → 0.4.0

package/dist/sticky-rules.d.ts

@@ -0,0 +1,179 @@
+/**
+ * sticky rules: the rule table of a sticky coin, the same encoding as src/sticky/StickyRules.sol.
+ * A row is one uint256: on (bits 0..7), act (8..15), arg (16..31), then four conditions of 56 bits (var, op, value).
+ * The launcher offers templates; each template is one or two rows. The chain is the truth: the validator checks every
+ * table at launch and the coin checks every transfer. POT rows fill the coin's pot from buys, DROP rows pay it out to
+ * buyers (at most the coins of the buy, never to the creator).
+ */
+export declare const ON: {
+    readonly BUY: 1;
+    readonly SELL: 2;
+    readonly SEND: 4;
+};
+export declare const ACT: {
+    readonly DENY: 1;
+    readonly FLAG: 2;
+    readonly LOCK: 3;
+    readonly BURN: 4;
+    readonly POT: 5;
+    readonly DROP: 6;
+};
+export declare const VAR: {
+    readonly AGE: 1;
+    readonly LAUNCH: 2;
+    readonly BLOCKS: 3;
+    readonly AMOUNT: 4;
+    readonly BALANCE: 5;
+    readonly PRICE: 6;
+    readonly DIP: 7;
+    readonly SOLD: 8;
+    readonly HOUR: 9;
+    readonly WEEKDAY: 10;
+    readonly FLAGS: 11;
+    readonly BUYS: 12;
+    readonly HOLDERS: 13;
+    readonly IDLE: 14;
+    readonly POTSIZE: 15;
+};
+export declare const OP: {
+    readonly LT: 1;
+    readonly GE: 2;
+    readonly HAS: 3;
+    readonly NOT: 4;
+    readonly MODLT: 5;
+    readonly MODGE: 6;
+};
+export declare const FLAG: {
+    readonly SNIPER: 1;
+    readonly MARK: 2;
+    readonly DEV: 4;
+};
+/** answers of token.check(): allowed, and "no row stops it but the coins are still locked" */
+export declare const NONE = 255;
+export declare const LOCKED = 254;
+export declare const STICKY_LIMITS: {
+    readonly maxRows: 8;
+    readonly maxLots: 8;
+    readonly exitDays: 30;
+    readonly maxBurnPct: 10;
+    /** burn and pot together, per buy */
+    readonly maxTakePct: 10;
+    readonly maxHoldDays: 7;
+    readonly minReleaseMinutes: 10;
+    readonly maxReleaseDays: 30;
+};
+export type Cond = {
+    v: number;
+    op: number;
+    val: bigint;
+};
+export type Row = {
+    on: number;
+    act: number;
+    arg: number;
+    conds: Cond[];
+};
+export declare function encodeRow(r: Row): bigint;
+export declare function decodeRow(x: bigint): Row;
+export type TemplateId = "hold" | "sniper" | "devlock" | "drip" | "maxbuy" | "maxwallet" | "window" | "hours" | "burn" | "dipdrop" | "lucky" | "wakeup";
+export type Param = {
+    key: string;
+    label: string;
+    unit: string;
+    min: number;
+    max: number;
+    step: number;
+    def: number;
+    hint: string;
+};
+export type Template = {
+    id: TemplateId;
+    name: string;
+    line: string;
+    /** true when the rule moves with the coins (the point of sticky rules) */
+    sticky: boolean;
+    /** true when the rule gives buyers something (the pot templates) */
+    gives?: boolean;
+    /** how scanners see it: green nothing, yellow a warning, red a refused test sell at times */
+    scanner: "green" | "yellow" | "red";
+    scannerNote?: string;
+    params: Param[];
+    rows: (p: Record<string, number>) => Row[];
+    /** the coin's release time in seconds when this template locks coins */
+    release?: (p: Record<string, number>) => number;
+};
+/** every n-th buy: the buys before it are n-1, 2n-1, ... (buys % n >= n - 1) */
+export declare const every: (n: number) => bigint;
+export declare const TEMPLATES: Template[];
+export declare const TEMPLATE_BY_ID: Map<TemplateId, Template>;
+export declare function defaults(t: Template): Record<string, number>;
+/** Problems of a template's numbers, as sentences (the validator has the same bounds). */
+export declare function paramProblems(t: Template, p: Record<string, number>): string[];
+export type Pick = {
+    id: TemplateId;
+    params: Record<string, number>;
+};
+/** The rows and release time of the picked templates (and the creator's own rows after them), and the problems that
+ *  keep the table from launching. The own rows' single checks are rowProblems; the table checks run over everything. */
+export declare function compile(picks: Pick[], own?: Row[]): {
+    rows: bigint[];
+    release: number;
+    problems: string[];
+};
+/** How the editor shows a variable: its unit and how a typed number becomes the on chain value. */
+export type VarDef = {
+    v: number;
+    label: string;
+    unit: string;
+    toChain: (x: number) => number;
+    fromChain: (x: number) => number;
+    lotOnly?: boolean;
+};
+export declare const VARS: VarDef[];
+export declare const VAR_BY_ID: Map<number, VarDef>;
+/** One condition as the editor holds it: numbers in the editor's units. A window holds its period and open time. */
+export type EditCond = {
+    v: number;
+    op: number;
+    x: number;
+    period?: number;
+};
+export type EditRow = {
+    on: number;
+    act: number;
+    arg: number;
+    conds: EditCond[];
+};
+export declare function emptyEditRow(): EditRow;
+/** The editor's row as an on chain row. A window (MODLT / MODGE on the launch time) packs period << 20 | minutes. */
+export declare function editToRow(e: EditRow): Row;
+/** How long a row can refuse, the validator's way: it lets go by itself (ends), or it closes only by the clock. */
+export type Hold = {
+    ends: boolean;
+    window: boolean;
+    hasHour: boolean;
+    hours: number;
+    hasDay: boolean;
+    days: number;
+};
+export declare const HOLD_LIMITS: {
+    readonly maxAgeDays: 7;
+    readonly maxHoldBlocks: 1000000;
+    readonly minSellCapPpm: 500;
+};
+/**
+ * A drop row that pays on every buy: no condition, or only ones every buy meets (the coins of a buy are 0 seconds old,
+ * a stranger's coins are not the creator's). Bots then buy small again and again and empty the pot.
+ */
+export declare function dropOnEveryBuy(r: Row): boolean;
+export declare function holdOf(r: Row): Hold;
+/** The validator's checks for one row, as sentences (the chain checks again at launch). */
+export declare function rowProblems(r: Row): string[];
+/** Checks of the whole table that no single row shows: burn and pot together, a pot without a drop. */
+export declare function tableProblems(rows: Row[]): string[];
+/** One row as a sentence, for the coin page and the API. */
+export declare function rowText(r: Row, release: number): string;
+/** Which template a row belongs to, by its shape (null for a custom row). */
+export declare function templateOf(r: Row): TemplateId | null;
+/** Scanner color of a whole table: the worst of its templates. */
+export declare function scannerOf(rows: Row[]): "green" | "yellow" | "red";