@solard/sdk 0.2.37 → 0.2.40

package/dist/types/browser/client.d.ts

@@ -0,0 +1,129 @@
+import { Connection, PublicKey, VersionedTransaction } from "@solana/web3.js";
+import { type PumpLaunchPairInput } from "@solard/core";
+import { type TokenHolderSnapshotOptions } from "@solard/core";
+import { type SubscribeTokenEventsOptions, type TokenEventSubscription } from "@solard/core";
+import { PumpPairService } from "@solard/core";
+import { BrowserSolardStore } from "./storage.js";
+import type { BrowserConfirmedTransaction, BrowserTransactionSubmission, BrowserPortfolio, BrowserPumpDeploymentBuild, BrowserPumpDeploymentResult, BrowserSolardOptions, BrowserTradeBuild, BrowserTradeResult, BrowserWalletSigner } from "./types.js";
+export declare const SOL_MINT = "So11111111111111111111111111111111111111112";
+export declare const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+export declare const TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+export declare const TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+export declare class BrowserSolard {
+    readonly options: BrowserSolardOptions;
+    readonly connection: Connection;
+    readonly store: BrowserSolardStore;
+    readonly contacts: {
+        list: () => import("./types.js").BrowserContact[];
+        add: (name: string, address: string, addOptions?: {
+            overwrite?: boolean;
+        }) => import("./types.js").BrowserContact;
+        find: (ref: string) => import("./types.js").BrowserContact | null;
+        remove: (ref: string) => import("./types.js").BrowserContact;
+        resolve: (ref: string) => string;
+    };
+    readonly tokens: {
+        list: () => import("./types.js").BrowserTokenAlias[];
+        register: (alias: string, mint: string, registerOptions?: {
+            overwrite?: boolean;
+        }) => import("./types.js").BrowserTokenAlias;
+        resolve: (ref: string) => string;
+    };
+    readonly pump: PumpPairService;
+    readonly events: {
+        subscribeToken: (token: string, options?: SubscribeTokenEventsOptions) => Promise<TokenEventSubscription>;
+    };
+    private wallet;
+    constructor(options: BrowserSolardOptions);
+    setWallet(wallet: BrowserWalletSigner | null): void;
+    get publicKey(): PublicKey | null;
+    private signer;
+    connectWallet(): Promise<PublicKey>;
+    resolveDestination(ref: string): string;
+    resolveToken(ref: string): string;
+    private resolveTokenOrMint;
+    private inspectPumpToken;
+    /** Complete holder snapshot suitable for reward allocation. */
+    snapshotHolders(token: string, options?: Omit<TokenHolderSnapshotOptions, "token">): Promise<import("@solard/core").TokenHolderSnapshot>;
+    /** Typed Pump/PumpSwap swap and mint-mentioned transfer stream. */
+    subscribeTokenEvents(token: string, options?: SubscribeTokenEventsOptions): Promise<TokenEventSubscription>;
+    getPortfolio(address?: string | PublicKey): Promise<BrowserPortfolio>;
+    submitTransaction(transaction: VersionedTransaction, strategy: {
+        blockhash: string;
+        lastValidBlockHeight: number;
+        skipPreflight?: boolean;
+    }): Promise<BrowserTransactionSubmission>;
+    confirmSubmission(submission: BrowserTransactionSubmission): Promise<BrowserConfirmedTransaction>;
+    private submitAndConfirm;
+    sendSol(destinationRef: string, amountSol: string | number): Promise<BrowserConfirmedTransaction>;
+    /**
+     * Build a Pump create_v2 transaction for the connected wallet without asking
+     * it to sign and without broadcasting. The generated mint signature is already
+     * present; the connected wallet remains the missing payer signature.
+     */
+    buildPumpDeployment(args: {
+        name: string;
+        symbol: string;
+        uri: string;
+        pair?: PumpLaunchPairInput;
+        beneficiary?: string | PublicKey;
+        mayhemMode?: boolean;
+        cashback?: boolean;
+        cuLimit?: number;
+        priorityMicroLamports?: number;
+    }): Promise<BrowserPumpDeploymentBuild>;
+    /** Build, request the wallet signature, broadcast, and confirm a Pump launch. */
+    deployPump(args: {
+        name: string;
+        symbol: string;
+        uri: string;
+        pair?: PumpLaunchPairInput;
+        beneficiary?: string | PublicKey;
+        mayhemMode?: boolean;
+        cashback?: boolean;
+        cuLimit?: number;
+        priorityMicroLamports?: number;
+        skipPreflight?: boolean;
+    }): Promise<BrowserPumpDeploymentResult>;
+    buildBuy(args: {
+        token: string;
+        sol: string | number;
+        slippageBps?: number;
+        cuLimit?: number;
+        priorityMicroLamports?: number;
+    }): Promise<BrowserTradeBuild>;
+    buildSell(args: {
+        token: string;
+        amountRaw: bigint;
+        slippageBps?: number;
+        cuLimit?: number;
+        priorityMicroLamports?: number;
+    }): Promise<BrowserTradeBuild>;
+    buy(args: {
+        token: string;
+        sol: string | number;
+        slippageBps?: number;
+        cuLimit?: number;
+        priorityMicroLamports?: number;
+        skipPreflight?: boolean;
+    }): Promise<BrowserTradeResult>;
+    sell(args: {
+        token: string;
+        amountRaw: bigint;
+        slippageBps?: number;
+        cuLimit?: number;
+        priorityMicroLamports?: number;
+        skipPreflight?: boolean;
+    }): Promise<BrowserTradeResult>;
+    buyWithSol(args: {
+        outputMint: string;
+        sol: string | number;
+        slippageBps?: number;
+    }): Promise<BrowserTradeResult>;
+    sellToSol(args: {
+        inputMint: string;
+        amountRaw: bigint;
+        slippageBps?: number;
+    }): Promise<BrowserTradeResult>;
+}
+export declare function createBrowserSolard(options: BrowserSolardOptions): BrowserSolard;

package/dist/types/browser/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Browser-safe Solard SDK.
+ *
+ * Trading uses the same local Pump/PumpSwap venue classes, quote math and
+ * instruction builders as the CLI/core engine. No external swap API is used.
+ */
+export { BrowserSolard, SOL_MINT, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID, USDC_MINT, createBrowserSolard, } from "./client.js";
+export { BrowserSolardStore, MemoryBrowserStorage, defaultBrowserStorage, } from "./storage.js";
+export { BrowserKeyVault, KeypairBrowserSigner } from "./wallet.js";
+export { buildLocalPumpBuy, buildLocalPumpSell } from "./pump.js";
+export { getSupportedPumpPairs, PumpPairService } from "@solard/core";
+export type { PumpSupportedPair } from "@solard/core";
+export { PUMP_USDC_MINT, buildPumpExternalDeployment, resolvePumpQuoteAsset, } from "@solard/core";
+export type { PumpExternalDeploymentBuild, PumpCustomPairSelection, PumpLaunchPairInput, } from "@solard/core";
+export { snapshotTokenHolders } from "@solard/core";
+export type { TokenHolder, ExcludedTokenHolder, TokenHolderSnapshot, TokenHolderSnapshotOptions, } from "@solard/core";
+export { subscribeTokenEvents } from "@solard/core";
+export type { SolardTokenCreateEvent, SolardTokenEvent, SolardTokenSwapEvent, SolardTokenTransferEvent, SolardTokenTransferMovement, SolardTokenTransferSource, SubscribeTokenEventsOptions, TokenEventSubscription, } from "@solard/core";
+export type { BrowserConfirmedTransaction, BrowserTransactionSubmission, BrowserContact, BrowserPortfolio, BrowserPumpDeploymentBuild, BrowserPumpDeploymentResult, BrowserSolardOptions, BrowserStorageLike, BrowserTokenAlias, BrowserTokenBalance, BrowserTradeBuild, BrowserTradeResult, BrowserTradeSide, BrowserWalletSigner, } from "./types.js";

package/dist/types/browser/pump.d.ts

@@ -0,0 +1,20 @@
+import { PublicKey, type Connection } from "@solana/web3.js";
+import type { BrowserTradeBuild } from "./types.js";
+export declare function buildLocalPumpBuy(args: {
+    connection: Connection;
+    user: PublicKey;
+    mint: string | PublicKey;
+    quoteInRaw: bigint;
+    slippageBps?: number;
+    cuLimit?: number;
+    priorityMicroLamports?: number;
+}): Promise<BrowserTradeBuild>;
+export declare function buildLocalPumpSell(args: {
+    connection: Connection;
+    user: PublicKey;
+    mint: string | PublicKey;
+    baseInRaw: bigint;
+    slippageBps?: number;
+    cuLimit?: number;
+    priorityMicroLamports?: number;
+}): Promise<BrowserTradeBuild>;

package/dist/types/browser/storage.d.ts

@@ -0,0 +1,34 @@
+import type { BrowserContact, BrowserStorageLike, BrowserTokenAlias } from "./types.js";
+export declare class MemoryBrowserStorage implements BrowserStorageLike {
+    private readonly values;
+    get length(): number;
+    clear(): void;
+    getItem(key: string): string | null;
+    key(index: number): string | null;
+    removeItem(key: string): void;
+    setItem(key: string, value: string): void;
+}
+export declare function defaultBrowserStorage(): BrowserStorageLike;
+export declare class BrowserSolardStore {
+    readonly storage: BrowserStorageLike;
+    readonly namespace: string;
+    constructor(storage?: BrowserStorageLike, namespace?: string);
+    private key;
+    private readCollection;
+    private writeCollection;
+    listContacts(): BrowserContact[];
+    addContact(nameInput: string, addressInput: string, options?: {
+        overwrite?: boolean;
+    }): BrowserContact;
+    findContact(ref: string): BrowserContact | null;
+    removeContact(ref: string): BrowserContact;
+    listTokenAliases(): BrowserTokenAlias[];
+    registerToken(aliasInput: string, mintInput: string, options?: {
+        overwrite?: boolean;
+    }): BrowserTokenAlias;
+    resolveToken(ref: string): string;
+    setSetting<T>(name: string, value: T): void;
+    getSetting<T>(name: string, fallback: T): T;
+    removeSetting(name: string): void;
+    resolveDestination(ref: string): string;
+}

package/dist/types/browser/types.d.ts

@@ -0,0 +1,90 @@
+import type { PumpExternalDeploymentBuild } from "@solard/core";
+import type { PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
+export interface BrowserWalletSigner {
+    publicKey: PublicKey | null;
+    connect?: () => Promise<unknown>;
+    disconnect?: () => Promise<unknown>;
+    signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
+    signAllTransactions?<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<T[]>;
+}
+export interface BrowserStorageLike {
+    readonly length: number;
+    clear(): void;
+    getItem(key: string): string | null;
+    key(index: number): string | null;
+    removeItem(key: string): void;
+    setItem(key: string, value: string): void;
+}
+export type BrowserContact = {
+    name: string;
+    address: string;
+    createdAtMs: number;
+    updatedAtMs: number;
+};
+export type BrowserTokenAlias = {
+    alias: string;
+    mint: string;
+    createdAtMs: number;
+    updatedAtMs: number;
+};
+export type BrowserTokenBalance = {
+    mint: string;
+    amountRaw: bigint;
+    amountUi: string;
+    decimals: number;
+    program: "spl-token" | "token-2022";
+    label: string;
+    tokenAccounts: string[];
+};
+export type BrowserPortfolio = {
+    address: string;
+    solLamports: bigint;
+    tokenBalances: BrowserTokenBalance[];
+};
+export type BrowserTransactionSubmission = {
+    signature: string;
+    blockhash: string;
+    lastValidBlockHeight: number;
+};
+export type BrowserConfirmedTransaction = BrowserTransactionSubmission & {
+    status: "confirmed";
+};
+export type BrowserTradeSide = "buy" | "sell";
+export type BrowserTradeBuild = {
+    transaction: VersionedTransaction;
+    side: BrowserTradeSide;
+    venue: string;
+    mint: string;
+    inputRaw: bigint;
+    expectedOutputRaw: bigint;
+    minimumOutputRaw: bigint;
+    quoteMint: string;
+    quoteDecimals: number;
+    blockhash: string;
+    lastValidBlockHeight: number;
+    serializedSize: number;
+};
+export type BrowserTradeResult = BrowserConfirmedTransaction & {
+    side: BrowserTradeSide;
+    venue: string;
+    mint: string;
+    inputRaw: bigint;
+    expectedOutputRaw: bigint;
+    minimumOutputRaw: bigint;
+};
+export type BrowserSolardOptions = {
+    rpcUrl: string;
+    wallet?: BrowserWalletSigner | null;
+    storage?: BrowserStorageLike;
+    storageNamespace?: string;
+    commitment?: "processed" | "confirmed" | "finalized";
+    rpcMaxRps?: number;
+    fetch?: typeof globalThis.fetch;
+};
+export type BrowserPumpDeploymentBuild = PumpExternalDeploymentBuild;
+export type BrowserPumpDeploymentResult = BrowserConfirmedTransaction & {
+    mint: string;
+    beneficiary: string;
+    quoteMint: string;
+    quoteKind: "native-sol" | "spl-token";
+};

package/dist/types/browser/wallet.d.ts

@@ -0,0 +1,37 @@
+import { Keypair, Transaction, VersionedTransaction, type PublicKey } from "@solana/web3.js";
+import type { BrowserStorageLike, BrowserWalletSigner } from "./types.js";
+export declare class KeypairBrowserSigner implements BrowserWalletSigner {
+    private readonly keypair;
+    readonly publicKey: PublicKey;
+    constructor(keypair: Keypair);
+    signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
+    signAllTransactions<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<T[]>;
+}
+/**
+ * Optional local-key mode for browser-only apps.
+ *
+ * Secret bytes are AES-GCM encrypted before being written to localStorage.
+ * For user-facing trading apps, an injected wallet extension remains the
+ * preferred signer because XSS can access any origin's localStorage.
+ */
+export declare class BrowserKeyVault {
+    private readonly storage;
+    private readonly namespace;
+    constructor(storage?: BrowserStorageLike, namespace?: string);
+    private key;
+    list(): Array<{
+        name: string;
+        publicKey: string;
+        createdAtMs: number;
+    }>;
+    save(nameInput: string, keypair: Keypair, password: string, options?: {
+        overwrite?: boolean;
+        iterations?: number;
+    }): Promise<void>;
+    generate(name: string, password: string, options?: {
+        overwrite?: boolean;
+        iterations?: number;
+    }): Promise<KeypairBrowserSigner>;
+    unlock(nameInput: string, password: string): Promise<KeypairBrowserSigner>;
+    remove(name: string): void;
+}

package/dist/types/client.d.ts

@@ -0,0 +1,117 @@
+import { createTraderSolard as createCoreSolard, type ClaimCreatorRewardsOptions, type CreatorRewardClaimResult, type CumulativeDistributionExecuteOptions, type CumulativeDistributionInput, type CumulativeDistributionPlan, type CumulativeDistributionState, type HumanAmount, type MarketHistory, type MarketHistoryOptions, type MarketPrice, type MergedReplayEventStream, type ReplayEventSubscription, type ReplayHistory, type ReplayItem, type ReplayOptions, type ReplayEventsOptions, type RecordConfirmedTradeInput, type TradeResult, type TradeExecutionOptions, type LivePoolReserves, type SolardDecodedTransaction, type SolardTransactionOptions, type SolardPosition, type SolardPositionQuery, type SolardTrade, type SolardTradeQuery, type TokenHolderSnapshot, type TokenHolderSnapshotOptions, type TokenRef, type WalletRef, type WalletPrivateKeyExport, type WalletPrivateKeyFormat } from "@solard/core";
+import { type ListenTradesOptions, type TradeListener } from "./live.js";
+export type SolardOptions = {
+    transactionVersion?: 0 | 1;
+    rpcUrl?: string;
+    rpcUrls?: readonly string[];
+    websocketUrls?: readonly string[];
+    dbPath?: string;
+    cacheTtlMs?: number;
+};
+export type SolardHistoryApi = {
+    replay(token: TokenRef, options?: ReplayOptions): Promise<ReplayHistory>;
+    market(token: TokenRef, options?: MarketHistoryOptions): Promise<MarketHistory>;
+    merge(histories: readonly (ReplayHistory | Iterable<ReplayItem>)[]): ReplayItem[];
+};
+export type SolardEventsApi = {
+    (token: TokenRef, options?: ReplayEventsOptions): Promise<ReplayEventSubscription>;
+    merge(streams: readonly ReplayEventSubscription[]): MergedReplayEventStream;
+};
+export type SolardBuyInput = {
+    reserves?: LivePoolReserves;
+    maxPriceSol?: string | number;
+    wallet: WalletRef;
+    token: TokenRef;
+    amount: HumanAmount | string | number;
+    slippageBps?: number;
+    minOutputRaw?: bigint | string;
+};
+export type SolardSellInput = {
+    closeTokenAccount?: boolean;
+    reserves?: LivePoolReserves;
+    minPriceSol?: string | number;
+    wallet: WalletRef;
+    token: TokenRef;
+    amount?: "all" | {
+        bps: number;
+    } | {
+        raw: bigint | string;
+    };
+    /** Exact raw token units; mutually exclusive with amount. */
+    amountRaw?: bigint | string;
+    slippageBps?: number;
+    minOutputLamports?: bigint | string;
+};
+export type SolardTradeExecutionOptions = TradeExecutionOptions;
+export type SolardTradeExecutionResult = TradeResult;
+export type Solard = {
+    tx: ReturnType<typeof createCoreSolard>['tx'];
+    compileGroups: ReturnType<typeof createCoreSolard>['compileGroups'];
+    simulatePlan: ReturnType<typeof createCoreSolard>['simulatePlan'];
+    sendBatchPlans: ReturnType<typeof createCoreSolard>['sendBatchPlans'];
+    prepareFastTrade: ReturnType<typeof createCoreSolard>["prepareFastTrade"];
+    listenTrades(options?: Omit<ListenTradesOptions, "tokens"> & {
+        tokens?: readonly string[];
+    }): Promise<TradeListener>;
+    prepareUnsignedBuy: ReturnType<typeof createCoreSolard>["prepareUnsignedBuy"];
+    prepareUnsignedTokenDeployment: ReturnType<typeof createCoreSolard>["prepareUnsignedTokenDeployment"];
+    resolvePumpLaunchQuote: ReturnType<typeof createCoreSolard>["resolvePumpLaunchQuote"];
+    simulateUnsignedTokenDeployment: ReturnType<typeof createCoreSolard>["simulateUnsignedTokenDeployment"];
+    simulateUnsignedBuy: ReturnType<typeof createCoreSolard>["simulateUnsignedBuy"];
+    prepareUnsignedSell: ReturnType<typeof createCoreSolard>["prepareUnsignedSell"];
+    simulateUnsignedSell: ReturnType<typeof createCoreSolard>["simulateUnsignedSell"];
+    proposeUnsignedBuyLookupTable: ReturnType<typeof createCoreSolard>["proposeUnsignedBuyLookupTable"];
+    resolveCurrentMarket: ReturnType<typeof createCoreSolard>["resolveCurrentMarket"];
+    getClaimableCreatorFees: ReturnType<typeof createCoreSolard>["getClaimableCreatorFees"];
+    claimAllCreatorFees: ReturnType<typeof createCoreSolard>["claimAllCreatorFees"];
+    walletLedger: ReturnType<typeof createCoreSolard>["walletLedger"];
+    historicalTape: ReturnType<typeof createCoreSolard>["historicalTape"];
+    getSupportedPumpPairs: ReturnType<typeof createCoreSolard>["getSupportedPumpPairs"];
+    getSupportedLaunchLabPairs: ReturnType<typeof createCoreSolard>["getSupportedLaunchLabPairs"];
+    listVanityMints: ReturnType<typeof createCoreSolard>["listVanityMints"];
+    releaseVanityMint: ReturnType<typeof createCoreSolard>["releaseVanityMint"];
+    closeEmptyTokenAccounts: ReturnType<typeof createCoreSolard>["closeEmptyTokenAccounts"];
+    prepareTokenDeployment: ReturnType<typeof createCoreSolard>["prepareTokenDeployment"];
+    deployToken: ReturnType<typeof createCoreSolard>["deployToken"];
+    warmBlockhash: ReturnType<typeof createCoreSolard>["warmBlockhash"];
+    curveLiquidity: ReturnType<typeof createCoreSolard>["curveLiquidity"];
+    maxSendableSol: ReturnType<typeof createCoreSolard>["maxSendableSol"];
+    transferToken: ReturnType<typeof createCoreSolard>["transferToken"];
+    exitWallet: ReturnType<typeof createCoreSolard>["exitWallet"];
+    resumeTrade(intentKey: string): Promise<SolardTradeExecutionResult>;
+    reconcile(intentKey: string): Promise<SolardTradeExecutionResult>;
+    quote: ReturnType<typeof createCoreSolard>["quote"];
+    close(): void;
+    history: SolardHistoryApi;
+    events: SolardEventsApi;
+    claims: {
+        creatorFees: {
+            claim(token: TokenRef, wallet: WalletRef, options?: ClaimCreatorRewardsOptions): Promise<CreatorRewardClaimResult>;
+            status(id: string): ReturnType<ReturnType<typeof createCoreSolard>["claims"]["creatorFees"]["status"]>;
+        };
+    };
+    distributions: {
+        plan(options: CumulativeDistributionInput): Promise<CumulativeDistributionPlan>;
+        execute(options: CumulativeDistributionExecuteOptions): Promise<CumulativeDistributionState>;
+        status(id: string): CumulativeDistributionState | null;
+    };
+    createWallet: ReturnType<typeof createCoreSolard>["createWallet"];
+    createVanityWallet: ReturnType<typeof createCoreSolard>["createVanityWallet"];
+    importWallet: ReturnType<typeof createCoreSolard>["importWallet"];
+    listWallets: ReturnType<typeof createCoreSolard>["listWallets"];
+    walletAddress(wallet: WalletRef): string;
+    exportPrivateKey(wallet: WalletRef, format?: WalletPrivateKeyFormat): WalletPrivateKeyExport;
+    addToken: ReturnType<typeof createCoreSolard>["addToken"];
+    resolveToken: ReturnType<typeof createCoreSolard>["resolveToken"];
+    tokenAccounts: ReturnType<typeof createCoreSolard>["tokenAccounts"];
+    snapshotHolders(token: TokenRef, options?: Omit<TokenHolderSnapshotOptions, "token">): Promise<TokenHolderSnapshot>;
+    walletBalances: ReturnType<typeof createCoreSolard>["walletBalances"];
+    recordConfirmedTrade(input: RecordConfirmedTradeInput): Promise<SolardTrade>;
+    trades(options?: SolardTradeQuery): Promise<SolardTrade[]>;
+    position(options: SolardPositionQuery): Promise<SolardPosition>;
+    getTransaction(signature: string, options?: SolardTransactionOptions): Promise<SolardDecodedTransaction | null>;
+    samplePrice(token: TokenRef): Promise<MarketPrice>;
+    buy(input: SolardBuyInput, options?: SolardTradeExecutionOptions): Promise<SolardTradeExecutionResult>;
+    sell(input: SolardSellInput, options?: SolardTradeExecutionOptions): Promise<SolardTradeExecutionResult>;
+};
+export declare function createSolard(options?: SolardOptions): Solard;

package/dist/types/default.d.ts

@@ -0,0 +1,10 @@
+import { getSolUsdPrice } from "@solard/core";
+import { subscribeLaunches, subscribeMigrations } from "./live.js";
+import { type Solard } from "./client.js";
+type DefaultSolard = Solard & {
+    getSolUsdPrice: typeof getSolUsdPrice;
+    subscribeLaunches: typeof subscribeLaunches;
+    subscribeMigrations: typeof subscribeMigrations;
+};
+declare const slrd: DefaultSolard;
+export default slrd;

package/dist/types/index.d.ts

@@ -0,0 +1,16 @@
+export { default } from "./default.js";
+export { createSolard } from "./client.js";
+export { observeSolardRpc, withSolardRpcContext } from '@solard/core';
+export type { SolardRpcObservation, SolardRpcContext } from '@solard/core';
+export { createTraderSolard } from "@solard/core";
+export { normalizeValueBandPolicy, planValueBandDecision, valueBandThresholds, normalizeTargetWeightPolicy, planTargetWeightRebalance, buildHistoricalCandles, runHistoricalStrategy, sweepHistoricalStrategies, LAUNCHLAB_PLATFORM_PRESETS, resolveLaunchLabPlatform, } from "@solard/core";
+export type { SellEconomics, SupportedLaunchLabPair, ValueBandPolicy, ValueBandRuntimeState, ValueBandDecision, TargetWeightPolicy, TargetWeightRebalancePlan, HistoricalTradeTape, HistoricalCandle, HistoricalStrategy, HistoricalExecutionOptions, HistoricalStrategyResult, CreatorFeeDiscovery, CreatorFeeGroup, CreatorFeeItem, WalletLedger, WalletLedgerEntry, WalletLedgerOptions, CurrentMarket, PreparedTokenDeployment, PrepareDeploymentArgs, } from "@solard/core";
+export type { Solard, SolardBuyInput, SolardEventsApi, SolardHistoryApi, SolardOptions, SolardSellInput, SolardTradeExecutionOptions, SolardTradeExecutionResult, } from "./client.js";
+export { formatRaw, sol, tokenAmount, isDefinitivePreSubmissionError, } from "@solard/core";
+export type { ClaimCreatorRewardsOptions, TradeLandingPolicy, LivePoolReserves, CreatorRewardClaimPayout, CreatorRewardClaimResult, CumulativeDistributionExecuteOptions, CumulativeDistributionInput, CumulativeDistributionPlan, CumulativeDistributionRecipient, CumulativeDistributionState, CumulativeEntitlement, HumanAmount, MarketHistory, MarketHistoryOptions, MarketPrice, MergedReplayEventStream, QuoteAsset, ReplayCoverage, ReplayEventSubscription, ReplayEventsOptions, ReplayHistory, ReplayItem, ReplayOptions, ReplayPayout, ReplayTransaction, RecordConfirmedTradeInput, SendReceipt, SenderId, SimulationResult, SolardDecodedTransaction, SolardPosition, SolardPositionQuery, SolardTransactionNativeBalance, SolardTransactionOptions, SolardTransactionTokenBalance, SolardTrade, SolardTradeQuery, SolardTradeSide, SolardTradeStatus, SolardCanonicalEvent, SolardClaimAttribution, SolardClaimEvent, TokenEventHistoryProgress, TokenHolder, ExcludedTokenHolder, TokenHolderSnapshot, TokenHolderSnapshotOptions, TokenRef, TokenRow, WalletInfo, WalletPrivateKeyExport, WalletPrivateKeyFormat, WalletRef, } from "@solard/core";
+export { fetchTokenMetadata, getSolUsdPrice, publicTokenMetadataUrl, } from "@solard/core";
+export { listenTrades, subscribeLaunches, subscribeMigrations, } from "./live.js";
+export type { ListenTradesOptions, LiveEndpointOptions, FeedRecoveryVerification, RecoverableTradeSubscription, SubscribeLaunchesOptions, SubscribeMigrationsOptions, TradeListener, TradeListenerMigration, } from "./live.js";
+export type { LaunchEvent, LaunchSubscription, LaunchVenue, MigrationDestination, MigrationEvent, MigrationSubscription, MigrationVenue, GetSolUsdPriceOptions, SolUsdPrice, SolUsdSource, TradeEvent, TradeMarket, TradeSide, TradeVenue, FetchTokenMetadataOptions, TokenMetadata, TokenMetadataHint, TokenMetadataKind, TokenMetadataMode, } from "@solard/core";
+export { composeTransactionDrafts } from '@solard/core';
+export type { TransactionDraft, TransactionGroupInput, PlannedTransaction } from '@solard/core';

package/dist/types/live.d.ts

@@ -0,0 +1,60 @@
+import { Connection } from "@solana/web3.js";
+import { subscribeLaunches as subscribeCoreLaunches, subscribeMigrations as subscribeCoreMigrations, subscribeTrades as subscribeCoreTrades, type TradeEvent, type TradeSubscription, type MigrationEvent, type LiveTradeHistoryOptions } from "@solard/core";
+export type LiveEndpointOptions = {
+    /** Ordered endpoints on the same cluster; public RPC can be supplied last. */
+    rpcUrls?: readonly string[];
+    websocketUrls?: readonly string[];
+    /** Fresh HTTP and WebSocket readiness probes for pooled trade streams (default 30s). */
+    healthCheckIntervalMs?: number;
+};
+export type SubscribeLaunchesOptions = Omit<Parameters<typeof subscribeCoreLaunches>[0], "connection"> & LiveEndpointOptions;
+export type SubscribeMigrationsOptions = Omit<Parameters<typeof subscribeCoreMigrations>[0], "connection"> & LiveEndpointOptions;
+/** Applications must explicitly revalidate fresh on-chain pool/mint state.
+ * Returning true asserts current state only, not historical coverage. */
+export type FeedRecoveryVerification = (input: {
+    connection: Connection;
+    tokens: readonly string[];
+    signal: AbortSignal;
+}) => Promise<boolean>;
+export type RecoverableTradeSubscription = TradeSubscription & {
+    readonly feedVerified: boolean;
+    verifyAndResume(verify: FeedRecoveryVerification, timeoutMs?: number): Promise<boolean>;
+};
+export type SubscribeTradesOptions = Omit<Parameters<typeof subscribeCoreTrades>[0], "connection"> & LiveEndpointOptions;
+export type ListenTradesOptions = Omit<SubscribeTradesOptions, "onTrade"> & {
+    dbPath?: string;
+    /** Enabled by default; collected live history is partial and retains commitment. */
+    history?: false | Pick<LiveTradeHistoryOptions, "flushIntervalMs" | "batchSize" | "maxPending">;
+};
+export type TradeListener = {
+    add(tokens: string | readonly string[]): Promise<void>;
+    remove(tokens: string | readonly string[]): Promise<void>;
+    has(token: string): boolean;
+    list(): string[];
+    onTrade(callback: (event: TradeEvent) => void | Promise<void>): () => void;
+    onMigration(callback: (event: TradeListenerMigration) => void | Promise<void>): () => void;
+    close(): Promise<void>;
+    readonly closed: Promise<void>;
+    readonly feedVerified: boolean;
+    verifyAndResume(verify: FeedRecoveryVerification, timeoutMs?: number): Promise<boolean>;
+};
+export type TradeListenerMigration = MigrationEvent & {
+    oldPool: string | null;
+    newPool: string;
+};
+/** HTTP + a fresh WebSocket handshake must both succeed before choosing an endpoint. */
+export declare class LiveEndpointPool {
+    private readonly probe;
+    private active;
+    readonly endpoints: readonly string[];
+    constructor(endpoints: readonly string[], probe?: (endpoint: string) => Promise<void>);
+    get endpoint(): string;
+    select(skipCurrent?: boolean): Promise<string>;
+    check(): Promise<string>;
+}
+export declare function deriveWebSocketEndpoint(endpoint: string): string;
+export declare function redactRpcEndpoint(endpoint: string): string;
+export declare function subscribeTrades(options: SubscribeTradesOptions): Promise<RecoverableTradeSubscription>;
+export declare function subscribeLaunches(options: SubscribeLaunchesOptions): Promise<import("@solard/core").LaunchSubscription>;
+export declare function subscribeMigrations(options: SubscribeMigrationsOptions): Promise<import("@solard/core").MigrationSubscription>;
+export declare function listenTrades(options: ListenTradesOptions): Promise<TradeListener>;

package/dist/types/protocol.d.ts

@@ -0,0 +1,2 @@
+export { decodeProgramDataLogs, decodePumpProgramData, decodePumpSwapProgramData, decodeRaydiumLaunchLabProgramData, } from "@solard/core";
+export type { PumpDecodedEvent, PumpSwapDecodedEvent, RaydiumLaunchLabDecodedEvent, } from "@solard/core";

package/package.json

@@ -1,20 +1,24 @@
 {
   "name": "@solard/sdk",
-  "version": "0.2.37",
+  "version": "0.2.40",
   "description": "Public Solard SDK for wallets, trading, history, live market subscriptions and token metadata.",
   "type": "module",
   "main": "./src/index.ts",
   "module": "./src/index.ts",
-  "types": "./src/index.ts",
+  "types": "./dist/types/index.d.ts",
   "exports": {
-    ".": "./src/index.ts",
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
     "./browser": {
-      "types": "./src/browser/index.ts",
+      "types": "./dist/types/browser/index.d.ts",
       "import": "./src/browser/index.ts",
       "default": "./src/browser/index.ts"
     },
     "./protocol": {
-      "types": "./src/protocol.ts",
+      "types": "./dist/types/protocol.d.ts",
       "import": "./src/protocol.ts",
       "default": "./src/protocol.ts"
     }
@@ -22,15 +26,17 @@
   "files": [
     "src",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "dist/types"
   ],
   "license": "MIT",
   "dependencies": {
     "@solana/web3.js": "^1.98.4",
-    "@solard/core": "0.2.37"
+    "@solard/core": "0.2.40"
   },
   "scripts": {
     "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.browser.json",
-    "typecheck:browser": "tsc --noEmit -p tsconfig.browser.json"
+    "typecheck:browser": "tsc --noEmit -p tsconfig.browser.json",
+    "prepack": "bun run ../../scripts/build-declarations.mjs"
   }
 }