madeonsol-x402 2.4.0 → 2.6.0

package/dist/types.d.ts

@@ -475,6 +475,17 @@ export interface WebhookTestResult {
     status_code?: number;
     response_time_ms: number;
     error?: string;
+    /** Which event type the sample delivery used. Returned by servers from 2026-09-25 on. */
+    event?: string;
+}
+/** Options for `testWebhook`. */
+export interface WebhookTestOptions {
+    /**
+     * Which of the webhook's subscribed events to sample (sent as `event`).
+     * Omit it to sample the first subscribed event. An event the webhook is not
+     * subscribed to is answered with 400.
+     */
+    event?: WebhookEvent | (string & {});
 }
 export interface StreamToken {
     token: string;
@@ -1253,20 +1264,58 @@ export interface CopyTradeSubscription {
     sizing_amount: number;
     delivery_mode: CopyTradeDeliveryMode;
     webhook_url: string | null;
+    /** Market-cap band (USD) on the source trade; `null` = no bound. */
+    min_mc_usd: number | null;
+    max_mc_usd: number | null;
     is_active: boolean;
     created_at: string;
     updated_at?: string;
+    /**
+     * Source wallets that are tracked KOL wallets (can produce signals), read at
+     * response time. `null` when the tracking lookup failed (see `warnings`).
+     * Returned by servers from 2026-09-25 on; absent on older ones.
+     */
+    source_wallets_tracked?: string[] | null;
+    /** Source wallets that are NOT tracked KOL wallets: they never produce a signal. */
+    source_wallets_untracked?: string[] | null;
+    /** Present when at least one wallet is untracked, or tracking could not be determined. */
+    warnings?: CopyTradeRuleWarning[];
+}
+/** A non-fatal note on a copy-trade rule. The rule is saved unchanged. */
+export interface CopyTradeRuleWarning {
+    code: "untracked_source_wallets" | "source_wallet_tracking_unavailable" | (string & {});
+    message: string;
 }
+/**
+ * Create body for POST /copytrade/subscriptions.
+ *
+ * `source_wallets`: the per-rule limit is set by your tier and enforced by the
+ * server (Pro 5, Ultra 50, Business and Enterprise 250; `GET /me` reports
+ * yours as `copytrade_wallets_per_rule`). Signals fire only for trades by
+ * wallets MadeOnSol tracks as KOLs (`GET /kol/wallets`). Any valid Solana
+ * address is accepted into a rule, but an untracked wallet never produces a signal.
+ */
 export interface CopyTradeCreateParams {
     name?: string;
     source_wallets: string[];
     min_trade_sol?: number;
+    /** Default `"buy"` (server side) when omitted. */
     only_action?: CopyTradeAction;
+    /** `proportional` and `percent_source` are the same maths: source size × `sizing_amount`. */
     sizing_mode?: CopyTradeSizingMode;
+    /** SOL when `fixed`; otherwise a multiplier / fraction (0.25 = a quarter of the source size), never a percent. */
     sizing_amount: number;
     delivery_mode?: CopyTradeDeliveryMode;
     webhook_url?: string;
+    /**
+     * Market-cap band (USD, 0 to 1e12, min ≤ max) on the source trade's market
+     * cap at trade time. When either bound is set, trades with an unknown market
+     * cap are dropped.
+     */
+    min_mc_usd?: number | null;
+    max_mc_usd?: number | null;
 }
+/** PATCH body. Omit a field to leave it unchanged; pass `null` to clear an MC bound. */
 export interface CopyTradeUpdateParams {
     name?: string | null;
     source_wallets?: string[];
@@ -1277,12 +1326,30 @@ export interface CopyTradeUpdateParams {
     delivery_mode?: CopyTradeDeliveryMode;
     webhook_url?: string | null;
     is_active?: boolean;
+    min_mc_usd?: number | null;
+    max_mc_usd?: number | null;
 }
 export interface CopyTradeCreateResponse {
     subscription: CopyTradeSubscription;
     /** Returned ONCE on creation when `webhook_url` is set — store it to verify HMAC signatures. */
     webhook_secret: string | null;
     note?: string;
+    /** Same as `subscription.warnings`, repeated at top level when present. */
+    warnings?: CopyTradeRuleWarning[];
+}
+/** Response of PATCH /copytrade/subscriptions/{id} (and GET of one rule). */
+export interface CopyTradeUpdateResponse {
+    subscription: CopyTradeSubscription;
+    /** Same as `subscription.warnings`, repeated at top level when present. */
+    warnings?: CopyTradeRuleWarning[];
+    /**
+     * Returned ONCE, only when this PATCH set a `webhook_url` on a rule that had
+     * no signing secret yet (for example a websocket-only rule). Store it. An
+     * existing secret is never rotated or re-shown.
+     */
+    webhook_secret?: string;
+    /** Explains the one-time `webhook_secret` when it is present. */
+    note?: string;
 }
 export interface CopyTradeSignal {
     id: number;
@@ -1313,6 +1380,10 @@ export interface CopyTradeSignalsParams {
     since?: string;
     /** 1–500, default 50. */
     limit?: number;
+    /** Keep signals whose source trade's market cap (USD) was at least this. Drops unknown-MC signals. */
+    min_mc_usd?: number;
+    /** Keep signals whose source trade's market cap (USD) was at most this. Drops unknown-MC signals. */
+    max_mc_usd?: number;
 }
 export interface WalletTrackerEntry {
     wallet_address: string;
@@ -1333,34 +1404,72 @@ export interface WalletTrackerUpdateResponse {
     updated: boolean;
     watchlist: WalletTrackerEntry;
 }
-export type WalletTrackerAction = "buy" | "sell" | "transfer_in" | "transfer_out";
+/**
+ * The `action` filter and field. Swaps only: a swap is `buy` or `sell`.
+ * Transfers carry `action: null` (their direction is not stored), so select
+ * them with `event_type: "transfer"`. The API answers any other value with 400.
+ * Before 2.6.0 this union also listed `transfer_in` / `transfer_out`, which the
+ * API never accepted.
+ */
+export type WalletTrackerAction = "buy" | "sell";
 export type WalletTrackerEventType = "swap" | "transfer";
 export interface WalletTrackerTradesParams {
     wallet?: string;
+    /** Swaps only; see {@link WalletTrackerAction}. */
     action?: WalletTrackerAction;
     event_type?: WalletTrackerEventType;
     /** 1–200, default 50. */
     limit?: number;
-    /** Pagination cursor — block_time of the last event from previous page. */
+    /**
+     * Sort column. `slot` = on-chain position (the default on a first page).
+     * `block_time` = our INGEST clock (the default when you pass the legacy
+     * `before` cursor). An explicit value always wins.
+     */
+    order?: "slot" | "block_time";
+    /** Cursor for `order: "block_time"`: the previous page's `next_cursor`. */
     before?: number;
+    /** Cursor for `order: "slot"`: the previous page's `next_cursor_slot`. */
+    before_slot?: number;
 }
+/** One event of GET /wallet-tracker/trades. The field set mirrors the route. */
 export interface WalletTrackerTrade {
-    block_time: number;
-    wallet: string;
-    action: WalletTrackerAction;
+    wallet_address: string;
+    label: string | null;
     event_type: WalletTrackerEventType;
-    token_mint?: string;
-    token_symbol?: string;
-    sol_amount?: number;
-    token_amount?: number;
-    tx_signature?: string;
+    /** `buy` / `sell` on swaps, `null` on transfers. */
+    action: WalletTrackerAction | null;
+    token_mint: string | null;
+    token_symbol: string | null;
+    token_name: string | null;
+    sol_amount: number | null;
+    token_amount: number | null;
+    /** Present only when a counterparty was matched (the key is absent otherwise). */
     counterparty?: string;
-    label?: string | null;
+    tx_signature: string;
+    /** Unix seconds on the tracker's INGEST clock, not chain time. Use `slot` for chain order. */
+    block_time: number;
+    /** On-chain slot. `null` on rows written before slot tracking existed. */
+    slot: number | null;
+    /** `true` when the row arrived through a replay (reconnect or restart recovery), not live delivery. */
+    replayed: boolean;
+    /** ISO 8601 form of `block_time` (ingest time). */
+    ingested_at: string;
+    /** Alias of `ingested_at`, kept for older consumers. It never meant chain time. */
+    timestamp: string;
 }
+/**
+ * Response of GET /wallet-tracker/trades. Before 2.6.0 this type declared
+ * `trades` / `has_more` / `next`, which the API never returned.
+ */
 export interface WalletTrackerTradesResponse {
-    trades: WalletTrackerTrade[];
-    has_more: boolean;
-    next?: number;
+    events: WalletTrackerTrade[];
+    count: number;
+    /** Which column this page was ordered by. */
+    ordered_by: "slot" | "block_time";
+    /** `block_time` cursor for the next page (`before`); `null` on the last page. */
+    next_cursor: number | null;
+    /** Slot cursor for the next page (`before_slot`); `null` on the last page or on a page of pre-slot rows. */
+    next_cursor_slot: number | null;
 }
 export interface WalletTrackerSummaryParams {
     /** "24h" | "7d" | "30d" — default "7d" */
@@ -1742,7 +1851,9 @@ export interface MeResponse {
             limit: number;
             used: number;
         };
+        /** `limit` = the watchlist cap POST /wallet-tracker/watchlist enforces (servers from 2026-09-25 on). */
         wallet_tracker_watchlist: {
+            limit?: number;
             used: number;
         };
     };
@@ -2964,6 +3075,257 @@ export interface TokenUnlockScheduleEvent extends TokenLockLifecycleBase {
 }
 /** Any lifecycle payload on `token:locks` — narrow on the frame's `event`. */
 export type TokenLockLifecycleEvent = TokenLockClaimedEvent | TokenLockCancelledEvent | TokenLockClosedEvent | TokenLockUpdatedEvent | TokenUnlockScheduleEvent;
+/**
+ * `token:candles` subscribe filters (PRO+). `mints` is REQUIRED (base58) and
+ * capped per CONNECTION across named subscriptions — PRO 25 / ULTRA 100 /
+ * BUSINESS 250, a budget separate from `token:prices`. Over the cap, a missing
+ * scope or a non-boolean `updates` rejects the channel, never truncates.
+ */
+export interface TokenCandlesFilters {
+    mints: string[];
+    /** Also receive the in-progress minute as `candle:update` (a state stream). Default false. */
+    updates?: boolean;
+}
+/**
+ * `candle:closed` frame `data` on `token:candles` — the STORED 1-minute row
+ * (`token_ohlc_1m`), identical live and on a durable resume. Every key is
+ * always present (null when unknown). Frame id =
+ * `candle:solana:<mint>:<bucket_start epoch s>` (not event-prefixed). A fully
+ * flat zero-trade candle (o = h = l = c, trades 0) is never emitted.
+ */
+export interface TokenCandleClosedEvent {
+    chain: "solana";
+    mint: string;
+    bucket_start: string;
+    /** bucket_start + 60 s. */
+    bucket_end: string;
+    /** When the row was first written (≈ ≤ 25 s after bucket_end). */
+    closed_at: string | null;
+    open_price_usd: number | null;
+    high_price_usd: number | null;
+    low_price_usd: number | null;
+    close_price_usd: number | null;
+    open_mc_usd: number | null;
+    high_mc_usd: number | null;
+    low_mc_usd: number | null;
+    close_mc_usd: number | null;
+    open_liquidity_usd: number | null;
+    close_liquidity_usd: number | null;
+    close_supply: number | null;
+    volume_usd: number | null;
+    volume_mev_usd: number | null;
+    buy_volume_usd: number | null;
+    sell_volume_usd: number | null;
+    trades: number | null;
+    buy_count: number | null;
+    sell_count: number | null;
+    dex: string | null;
+    pool_address: string | null;
+    write_id: string | null;
+    final: true;
+    source: "token_ohlc_1m";
+}
+/**
+ * `candle:update` frame `data` (only with `filters.updates: true`) — the
+ * producer's in-progress minute, ≤ 1 per mint per second. A state stream: no
+ * id / seq, never replayed, no snapshot on subscribe.
+ */
+export interface TokenCandleUpdateEvent {
+    chain: "solana";
+    mint: string;
+    bucket_start: string;
+    bucket_end: string;
+    open_price_usd: number | null;
+    high_price_usd: number | null;
+    low_price_usd: number | null;
+    close_price_usd: number | null;
+    close_mc_usd: number | null;
+    volume_usd: number | null;
+    trades: number | null;
+    final: false;
+    /** The producer's timestamp of this state (ISO). */
+    as_of: string | null;
+    source: "mc-tracker:open_candle";
+}
+/** Event types on `token:risk`. */
+export type TokenRiskEventName = "risk:authority_changed" | "risk:supply_inflated";
+/**
+ * `token:risk` subscribe filters (PRO+). `mints` is REQUIRED (base58), capped
+ * per connection PRO 25 / ULTRA 100 / BUSINESS 250. Invalid values reject the
+ * channel (`channels_rejected`) or the whole update (`invalid_filters`).
+ */
+export interface TokenRiskFilters {
+    mints: string[];
+    /** Non-empty subset of the channel's event types. */
+    risk_events?: TokenRiskEventName[];
+    /** Send one `risk:inputs` snapshot per mint on subscribe / scope change / resume. Default true. */
+    risk_snapshot?: boolean;
+}
+/**
+ * `risk:authority_changed` — the stored mint / freeze authority went from not
+ * revoked to revoked (once per mint + field, ever), or the Token-2022 transfer
+ * fee changed with both values known. Never a re-enable, never a first
+ * observation. Frame id = `risk:authority_changed:<event_key>`.
+ */
+export interface TokenRiskAuthorityChangedEvent {
+    chain: "solana";
+    mint: string;
+    /** `<mint>:mint_authority:revoked` | `<mint>:freeze_authority:revoked` | `<mint>:transfer_fee:<before>><after>:<observed_at ms>`. */
+    event_key: string;
+    field: "mint_authority" | "freeze_authority" | "transfer_fee";
+    /** `{revoked}` for the authorities, `{transfer_fee_bps}` for the fee. */
+    before: {
+        revoked: boolean;
+    } | {
+        transfer_fee_bps: number;
+    };
+    after: {
+        revoked: boolean;
+    } | {
+        transfer_fee_bps: number;
+    };
+    /** The full picture after the change. */
+    mint_authority_revoked: boolean | null;
+    freeze_authority_revoked: boolean | null;
+    transfer_fee_bps: number | null;
+    is_token_2022: boolean | null;
+    /** When mc-tracker parsed the mint account that showed the change. */
+    observed_at: string | null;
+    /** The parse before: the change happened on chain in between. */
+    previous_observed_at: string | null;
+    written_at: string;
+    slot: null;
+    source: "token_prices";
+}
+/**
+ * `risk:supply_inflated` — the first `supply_drift_events` row for the mint
+ * reaching a level (warn 0.5 % / danger 5 %). Per-observation drift, not a
+ * cumulative inflation. Frame id = `risk:supply_inflated:<event_key>`.
+ */
+export interface TokenRiskSupplyInflatedEvent {
+    chain: "solana";
+    mint: string;
+    /** `<mint>:supply_inflated:warn` | `<mint>:supply_inflated:danger`. */
+    event_key: string;
+    level: "warn" | "danger";
+    /** 0.5 (warn) | 5 (danger). */
+    threshold_pct: number;
+    /** drift / expected of one drift row, in percent, 4 dp. */
+    inflation_pct: number;
+    /** Integer strings. */
+    expected_supply_raw: string;
+    onchain_supply_raw: string;
+    drift_raw: string;
+    detected_at: string;
+    drift_event_id: number;
+    window_days: 30;
+    written_at: string;
+    slot: null;
+    source: "supply_drift_events";
+}
+/**
+ * `risk:inputs` snapshot frame `data` (frame `snapshot: true`, no id / seq):
+ * the CURRENT stored risk inputs of one scoped mint. Not the score or band —
+ * `GET /tokens/{mint}/risk` computes those.
+ */
+export interface TokenRiskInputsSnapshot {
+    chain: "solana";
+    mint: string;
+    /** false = the mint is not in the price table (every input null). */
+    tracked: boolean;
+    mint_authority_revoked: boolean | null;
+    freeze_authority_revoked: boolean | null;
+    transfer_fee_bps: number | null;
+    is_token_2022: boolean | null;
+    authority_observed_at: string | null;
+    /** Worst positive supply drift in the last 30 days; null when none. `level` null below 0.5 %. */
+    supply_inflation: {
+        inflation_pct: number;
+        level: "warn" | "danger" | null;
+        detected_at: string | null;
+        window_days: 30;
+    } | null;
+    source: "token_prices+supply_drift_events";
+}
+/** Any event payload on `token:risk` — narrow on the frame's `event`. */
+export type TokenRiskEvent = TokenRiskAuthorityChangedEvent | TokenRiskSupplyInflatedEvent;
+/** Event types on `wallet:scores`. */
+export type WalletScoreEventName = "deployer:tier_changed" | "kol:score_state_changed";
+/**
+ * `wallet:scores` subscribe filters (PRO+). `wallets` is REQUIRED — base58
+ * deployer or KOL wallets — capped per connection per chain PRO 25 / ULTRA 100
+ * / BUSINESS 250. A subscription that also holds `rhc:wallet_scores` may mix
+ * in 0x addresses; an entry of a chain the subscription does not hold is refused.
+ */
+export interface WalletScoresFilters {
+    wallets: string[];
+    /** Optional subset of the held channels' event types (e.g. `"rhc:deployer_tier_changed"` when mixing chains). */
+    score_events?: Array<WalletScoreEventName | "rhc:deployer_tier_changed">;
+}
+/**
+ * Where a score event came from. `computed_at` means "recomputed at T", not
+ * "changed at T": `live_write` = a bond / deploy re-classified the deployer
+ * (real time); `scheduled_recompute` = the 6-hourly stats worker (can lag the
+ * stats by hours); `matview_refresh` = the KOL diff after each 10-min refresh.
+ */
+export type WalletScoreSource = "live_write" | "scheduled_recompute" | "matview_refresh";
+/** Solana deployer tier values on `deployer:tier_changed`. */
+export type DeployerTierChangeValue = "elite" | "good" | "rising" | "moderate" | "cold" | "unranked";
+/**
+ * `deployer:tier_changed` — `deployers.tier` changed. Frame id =
+ * `deployer:tier_changed:<event_key>`. A wallet appearing is not an event;
+ * entering a ranked tier is (`entered_ranking: true`, `tier_before: "unranked"`).
+ */
+export interface DeployerTierChangedEvent {
+    /** `<wallet>:<tier_before>><tier_after>:<txid>`. */
+    event_key: string;
+    chain: "solana";
+    wallet: string;
+    tier_before: DeployerTierChangeValue | null;
+    tier_after: DeployerTierChangeValue | null;
+    entered_ranking: boolean;
+    is_tracked: boolean | null;
+    /** As of the write. */
+    stats: {
+        total_tokens_deployed: number | null;
+        total_bonded: number | null;
+        instant_bonds: number | null;
+        bonding_rate: number | null;
+        recent_bond_rate: number | null;
+        recent_outcomes: string | null;
+    };
+    computed_at: string;
+    source: WalletScoreSource;
+}
+/** The categorical KOL score fields diffed on `kol:score_state_changed`. */
+export interface KolScoreState {
+    is_cold: boolean | null;
+    is_heating_up: boolean | null;
+    auto_strategy_tag: KolStrategy | null;
+}
+/**
+ * `kol:score_state_changed` — one event per KOL per `mv_kol_scores` refresh
+ * where `is_cold`, `is_heating_up` or `auto_strategy_tag` differs (fields never
+ * split). Frame id = `kol:score_state_changed:<event_key>`.
+ */
+export interface KolScoreStateChangedEvent {
+    /** `<wallet>:<computed_at epoch ms>`. */
+    event_key: string;
+    chain: "solana";
+    wallet: string;
+    kol_wallet_id: string | null;
+    kol_name: string | null;
+    /** All three for a KOL first seen after the seed. */
+    changed: Array<keyof KolScoreState>;
+    /** null for a first appearance. */
+    before: KolScoreState | null;
+    after: KolScoreState;
+    computed_at: string;
+    source: "matview_refresh";
+    matview: "mv_kol_scores";
+}
+/** Any event payload on `wallet:scores` — narrow on the frame's `event`. */
+export type WalletScoreEvent = DeployerTierChangedEvent | KolScoreStateChangedEvent;
 /** pump.fun fee event types (`creator_claim` is excluded from the feed unless requested via `type=`). */
 export type TokenFeeEventType = "shares_created" | "shares_updated" | "shares_reset" | "distribution" | "social_pda_created" | "social_claim" | "creator_transferred" | "creator_claim";
 /** A shareholder on a SharingConfig: `{ address, share_bps }` (bps of the creator fee). */