@solard/sdk 0.2.15 → 0.2.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solard/sdk",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "description": "Public Solard SDK for wallets, transactions, trading and token launches.",
   "type": "module",
   "main": "./src/index.ts",
@@ -22,7 +22,7 @@
   "license": "MIT",
   "dependencies": {
     "@solana/web3.js": "^1.98.4",
-    "@solard/core": "0.2.15"
+    "@solard/core": "0.2.17"
   },
   "scripts": {
     "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.browser.json",

package/src/browser/client.ts

@@ -9,26 +9,29 @@ import {
 import {
   buildPumpExternalDeployment,
   type PumpLaunchPairInput,
-} from "@solard/core/launches/pump/external-deployment.ts";
+} from "@solard/core";
 
 import {
   snapshotTokenHolders,
   type TokenHolderSnapshotOptions,
-} from "@solard/core/chain/holders.ts";
-import { readMint } from "@solard/core/chain/state.ts";
+} from "@solard/core";
+import { readMint } from "@solard/core";
 import {
   subscribeTokenEvents,
   type SubscribeTokenEventsOptions,
-} from "@solard/core/events/token-events.ts";
-import type { TokenRow } from "@solard/core/db/schema.ts";
-import { PumpCurveVenue } from "@solard/core/venues/pump/pump-curve-venue.ts";
-import { PumpSwapVenue } from "@solard/core/venues/pump/pumpswap-venue.ts";
-import { VenueRegistry } from "@solard/core/venues/route-resolver.ts";
+  type TokenEventSubscription,
+} from "@solard/core";
+import type { TokenRow } from "@solard/core";
+import { PumpCurveVenue } from "@solard/core";
+import { PumpSwapVenue } from "@solard/core";
+import { VenueRegistry } from "@solard/core";
+import { PumpPairService } from "@solard/core";
 
 import { BrowserSolardStore, defaultBrowserStorage } from "./storage.ts";
 import { buildLocalPumpBuy, buildLocalPumpSell } from "./pump.ts";
 import type {
-  BrowserBroadcastResult,
+  BrowserConfirmedTransaction,
+  BrowserTransactionSubmission,
   BrowserPortfolio,
   BrowserPumpDeploymentBuild,
   BrowserPumpDeploymentResult,
@@ -43,7 +46,7 @@ export const SOL_MINT = "So11111111111111111111111111111111111111112";
 export const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
 export const TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 export const TOKEN_2022_PROGRAM_ID =
-  "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHn5qCXEpPxuEb";
+  "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
 
 const CANONICAL_LABELS: Record<string, string> = {
   [SOL_MINT]: "WSOL",
@@ -114,6 +117,13 @@ export class BrowserSolard {
   readonly store: BrowserSolardStore;
   readonly contacts;
   readonly tokens;
+  readonly pump: PumpPairService;
+  readonly events: {
+    subscribeToken: (
+      token: string,
+      options?: SubscribeTokenEventsOptions,
+    ) => Promise<TokenEventSubscription>;
+  };
   private wallet: BrowserWalletSigner | null;
 
   constructor(readonly options: BrowserSolardOptions) {
@@ -127,6 +137,11 @@ export class BrowserSolard {
       fetch: rpcFetch,
     });
     this.wallet = options.wallet ?? null;
+    this.pump = new PumpPairService(() => this.connection);
+    this.events = {
+      subscribeToken: (token, eventOptions = {}) =>
+        this.subscribeTokenEvents(token, eventOptions),
+    };
     this.store = new BrowserSolardStore(
       options.storage ?? defaultBrowserStorage(),
       options.storageNamespace ?? "solard:browser:v1",
@@ -330,14 +345,14 @@ export class BrowserSolard {
     };
   }
 
-  async signAndBroadcast(
+  async submitTransaction(
     transaction: VersionedTransaction,
     strategy: {
       blockhash: string;
       lastValidBlockHeight: number;
       skipPreflight?: boolean;
     },
-  ): Promise<BrowserBroadcastResult> {
+  ): Promise<BrowserTransactionSubmission> {
     const signed = await this.signer().signTransaction(transaction);
     if (!(signed instanceof VersionedTransaction))
       throw new Error("Browser wallet did not return a VersionedTransaction.");
@@ -349,30 +364,48 @@ export class BrowserSolard {
         maxRetries: 0,
       },
     );
+    return {
+      signature,
+      blockhash: strategy.blockhash,
+      lastValidBlockHeight: strategy.lastValidBlockHeight,
+    };
+  }
+
+  async confirmSubmission(
+    submission: BrowserTransactionSubmission,
+  ): Promise<BrowserConfirmedTransaction> {
     const confirmation = await this.connection.confirmTransaction(
       {
-        signature,
-        blockhash: strategy.blockhash,
-        lastValidBlockHeight: strategy.lastValidBlockHeight,
+        signature: submission.signature,
+        blockhash: submission.blockhash,
+        lastValidBlockHeight: submission.lastValidBlockHeight,
       },
       "confirmed",
     );
     if (confirmation.value.err)
       throw new Error(
-        `Transaction ${signature} failed: ${JSON.stringify(confirmation.value.err)}`,
+        `Transaction ${submission.signature} failed: ${JSON.stringify(confirmation.value.err)}`,
       );
-    return {
-      signature,
-      confirmed: true,
-      blockhash: strategy.blockhash,
-      lastValidBlockHeight: strategy.lastValidBlockHeight,
-    };
+    return { ...submission, status: "confirmed" };
+  }
+
+  private async submitAndConfirm(
+    transaction: VersionedTransaction,
+    strategy: {
+      blockhash: string;
+      lastValidBlockHeight: number;
+      skipPreflight?: boolean;
+    },
+  ): Promise<BrowserConfirmedTransaction> {
+    return await this.confirmSubmission(
+      await this.submitTransaction(transaction, strategy),
+    );
   }
 
   async sendSol(
     destinationRef: string,
     amountSol: string | number,
-  ): Promise<BrowserBroadcastResult> {
+  ): Promise<BrowserConfirmedTransaction> {
     const wallet = this.signer();
     const destination = new PublicKey(
       this.store.resolveDestination(destinationRef),
@@ -392,7 +425,7 @@ export class BrowserSolard {
         }),
       ],
     }).compileToV0Message();
-    return await this.signAndBroadcast(
+    return await this.submitAndConfirm(
       new VersionedTransaction(message),
       latest,
     );
@@ -437,7 +470,7 @@ export class BrowserSolard {
     skipPreflight?: boolean;
   }): Promise<BrowserPumpDeploymentResult> {
     const build = await this.buildPumpDeployment(args);
-    const receipt = await this.signAndBroadcast(build.transaction, {
+    const receipt = await this.submitAndConfirm(build.transaction, {
       blockhash: build.blockhash,
       lastValidBlockHeight: build.lastValidBlockHeight,
       skipPreflight: args.skipPreflight,
@@ -497,7 +530,7 @@ export class BrowserSolard {
     skipPreflight?: boolean;
   }): Promise<BrowserTradeResult> {
     const build = await this.buildBuy(args);
-    const receipt = await this.signAndBroadcast(build.transaction, {
+    const receipt = await this.submitAndConfirm(build.transaction, {
       blockhash: build.blockhash,
       lastValidBlockHeight: build.lastValidBlockHeight,
       skipPreflight: args.skipPreflight,
@@ -522,7 +555,7 @@ export class BrowserSolard {
     skipPreflight?: boolean;
   }): Promise<BrowserTradeResult> {
     const build = await this.buildSell(args);
-    const receipt = await this.signAndBroadcast(build.transaction, {
+    const receipt = await this.submitAndConfirm(build.transaction, {
       blockhash: build.blockhash,
       lastValidBlockHeight: build.lastValidBlockHeight,
       skipPreflight: args.skipPreflight,

package/src/browser/index.ts

@@ -20,34 +20,40 @@ export {
 } from "./storage.ts";
 export { BrowserKeyVault, KeypairBrowserSigner } from "./wallet.ts";
 export { buildLocalPumpBuy, buildLocalPumpSell } from "./pump.ts";
+export { getSupportedPumpPairs, PumpPairService } from "@solard/core";
+export type { PumpSupportedPair } from "@solard/core";
 export {
   PUMP_USDC_MINT,
   buildPumpExternalDeployment,
   resolvePumpQuoteAsset,
-} from "@solard/core/launches/pump/external-deployment.ts";
+} from "@solard/core";
 export type {
   PumpExternalDeploymentBuild,
   PumpCustomPairSelection,
   PumpLaunchPairInput,
-} from "@solard/core/launches/pump/external-deployment.ts";
-export { snapshotTokenHolders } from "@solard/core/chain/holders.ts";
+} from "@solard/core";
+export { snapshotTokenHolders } from "@solard/core";
 export type {
   TokenHolder,
   ExcludedTokenHolder,
   TokenHolderSnapshot,
   TokenHolderSnapshotOptions,
-} from "@solard/core/chain/holders.ts";
-export { subscribeTokenEvents } from "@solard/core/events/token-events.ts";
+} from "@solard/core";
+export { subscribeTokenEvents } from "@solard/core";
 export type {
+  SolardTokenCreateEvent,
   SolardTokenEvent,
   SolardTokenSwapEvent,
   SolardTokenTransferEvent,
+  SolardTokenTransferMovement,
+  SolardTokenTransferSource,
   SubscribeTokenEventsOptions,
   TokenEventSubscription,
-} from "@solard/core/events/token-events.ts";
+} from "@solard/core";
 
 export type {
-  BrowserBroadcastResult,
+  BrowserConfirmedTransaction,
+  BrowserTransactionSubmission,
   BrowserContact,
   BrowserPortfolio,
   BrowserPumpDeploymentBuild,

package/src/browser/pump.ts

@@ -7,12 +7,12 @@ import {
   type TransactionInstruction,
 } from "@solana/web3.js";
 
-import { readMint } from "@solard/core/chain/state.ts";
-import { rawAmount } from "@solard/core/core/amounts.ts";
-import type { TokenRow } from "@solard/core/db/schema.ts";
-import { PumpCurveVenue } from "@solard/core/venues/pump/pump-curve-venue.ts";
-import { PumpSwapVenue } from "@solard/core/venues/pump/pumpswap-venue.ts";
-import { VenueRegistry } from "@solard/core/venues/route-resolver.ts";
+import { readMint } from "@solard/core";
+import { rawAmount } from "@solard/core";
+import type { TokenRow } from "@solard/core";
+import { PumpCurveVenue } from "@solard/core";
+import { PumpSwapVenue } from "@solard/core";
+import { VenueRegistry } from "@solard/core";
 
 import type { BrowserTradeBuild } from "./types.ts";
 

package/src/browser/types.ts

@@ -1,3 +1,4 @@
+import type { PumpExternalDeploymentBuild } from "@solard/core";
 import type {
   PublicKey,
   Transaction,
@@ -55,13 +56,16 @@ export type BrowserPortfolio = {
   tokenBalances: BrowserTokenBalance[];
 };
 
-export type BrowserBroadcastResult = {
+export type BrowserTransactionSubmission = {
   signature: string;
-  confirmed: boolean;
   blockhash: string;
   lastValidBlockHeight: number;
 };
 
+export type BrowserConfirmedTransaction = BrowserTransactionSubmission & {
+  status: "confirmed";
+};
+
 export type BrowserTradeSide = "buy" | "sell";
 
 export type BrowserTradeBuild = {
@@ -79,7 +83,7 @@ export type BrowserTradeBuild = {
   serializedSize: number;
 };
 
-export type BrowserTradeResult = BrowserBroadcastResult & {
+export type BrowserTradeResult = BrowserConfirmedTransaction & {
   side: BrowserTradeSide;
   venue: string;
   mint: string;
@@ -97,10 +101,9 @@ export type BrowserSolardOptions = {
   rpcMaxRps?: number;
   fetch?: typeof globalThis.fetch;
 };
-export type BrowserPumpDeploymentBuild =
-  import("@solard/core/launches/pump/external-deployment.ts").PumpExternalDeploymentBuild;
+export type BrowserPumpDeploymentBuild = PumpExternalDeploymentBuild;
 
-export type BrowserPumpDeploymentResult = BrowserBroadcastResult & {
+export type BrowserPumpDeploymentResult = BrowserConfirmedTransaction & {
   mint: string;
   beneficiary: string;
   quoteMint: string;

package/src/client.ts

@@ -0,0 +1,141 @@
+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 TokenHolderSnapshot,
+  type TokenHolderSnapshotOptions,
+  type TokenRef,
+  type WalletRef,
+} from "@solard/core";
+
+export type SolardOptions = {
+  rpcUrl?: 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 Solard = {
+  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"];
+  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"];
+  samplePrice(token: TokenRef): Promise<MarketPrice>;
+  buy(
+    token: TokenRef,
+    wallet: WalletRef,
+    amount: HumanAmount,
+    options?: Parameters<ReturnType<typeof createCoreSolard>["buy"]>[3],
+  ): ReturnType<ReturnType<typeof createCoreSolard>["buy"]>;
+  sell: ReturnType<typeof createCoreSolard>["sell"];
+};
+
+export function createSolard(options: SolardOptions = {}): Solard {
+  const core = createCoreSolard(options);
+  const history: SolardHistoryApi = Object.freeze({
+    replay: (token, replayOptions) => core.history.replay(token, replayOptions),
+    market: (token, marketOptions) => core.history.market(token, marketOptions),
+    merge: core.history.merge,
+  });
+  const events = Object.assign(
+    (token: TokenRef, eventOptions: ReplayEventsOptions = {}) =>
+      core.events(token, eventOptions),
+    { merge: core.events.merge },
+  ) as SolardEventsApi;
+  return Object.freeze({
+    close: core.close.bind(core),
+    history,
+    events: Object.freeze(events),
+    claims: Object.freeze({
+      creatorFees: Object.freeze({
+        claim: core.claims.creatorFees.claim,
+        status: core.claims.creatorFees.status,
+      }),
+    }),
+    distributions: Object.freeze({
+      plan: core.distributions.plan,
+      execute: core.distributions.execute,
+      status: core.distributions.status,
+    }),
+    createWallet: core.createWallet.bind(core),
+    createVanityWallet: core.createVanityWallet.bind(core),
+    importWallet: core.importWallet.bind(core),
+    listWallets: core.listWallets.bind(core),
+    addToken: core.addToken.bind(core),
+    resolveToken: core.resolveToken.bind(core),
+    tokenAccounts: core.tokenAccounts.bind(core),
+    snapshotHolders: core.snapshotHolders.bind(core),
+    walletBalances: core.walletBalances.bind(core),
+    samplePrice: core.samplePrice.bind(core),
+    buy: core.buy.bind(core),
+    sell: core.sell.bind(core),
+  });
+}
+
+export const createTraderSolard = createSolard;

package/src/export-surface.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const source = readFileSync(join(import.meta.dir, "index.ts"), "utf8");
+const client = readFileSync(join(import.meta.dir, "client.ts"), "utf8");
+
+function exportedNames(value: string) {
+  const values: string[] = [];
+  const types: string[] = [];
+  const pattern = /export\s+(type\s+)?\{([\s\S]*?)\}\s+from\s+["'][^"']+["'];/g;
+  for (const match of value.matchAll(pattern)) {
+    const target = match[1] ? types : values;
+    for (const raw of match[2]!.split(",")) {
+      const name =
+        raw.trim().split(/\s+as\s+/)[1] ?? raw.trim().split(/\s+as\s+/)[0];
+      if (name) target.push(name.trim());
+    }
+  }
+  return {
+    values: [...new Set(values)].sort(),
+    types: [...new Set(types)].sort(),
+  };
+}
+
+describe("sdk membrane", () => {
+  test("has an exact curated root export surface", () => {
+    expect(exportedNames(source)).toEqual({
+      values: [
+        "createSolard",
+        "createTraderSolard",
+        "formatRaw",
+        "sol",
+        "tokenAmount",
+      ].sort(),
+      types: [
+        "ClaimCreatorRewardsOptions",
+        "CreatorRewardClaimPayout",
+        "CreatorRewardClaimResult",
+        "CumulativeDistributionExecuteOptions",
+        "CumulativeDistributionInput",
+        "CumulativeDistributionPlan",
+        "CumulativeDistributionRecipient",
+        "CumulativeDistributionState",
+        "CumulativeEntitlement",
+        "HumanAmount",
+        "MarketHistory",
+        "MarketHistoryOptions",
+        "MarketPrice",
+        "MergedReplayEventStream",
+        "QuoteAsset",
+        "ReplayCoverage",
+        "ReplayEventSubscription",
+        "ReplayEventsOptions",
+        "ReplayHistory",
+        "ReplayItem",
+        "ReplayOptions",
+        "ReplayPayout",
+        "ReplayTransaction",
+        "SendReceipt",
+        "SenderId",
+        "SimulationResult",
+        "Solard",
+        "SolardCanonicalEvent",
+        "SolardClaimAttribution",
+        "SolardClaimEvent",
+        "SolardEventsApi",
+        "SolardHistoryApi",
+        "SolardOptions",
+        "ExcludedTokenHolder",
+        "TokenHolder",
+        "TokenHolderSnapshot",
+        "TokenHolderSnapshotOptions",
+        "TokenEventHistoryProgress",
+        "TokenRef",
+        "TokenRow",
+        "WalletInfo",
+        "WalletRef",
+      ].sort(),
+    });
+  });
+
+  test("does not wildcard-export or deep-import core", () => {
+    expect(source).not.toContain('export * from "@solard/core"');
+    expect(source).not.toMatch(/\.\.\/\.\.\/core\/src|@solard\/core\//);
+    expect(client).not.toMatch(/\.\.\/\.\.\/core\/src|@solard\/core\//);
+  });
+
+  test("does not create persistence at module import", () => {
+    expect(source).not.toMatch(/createCoreSolard|createTraderSolard\(\)/);
+    expect(client.indexOf("createCoreSolard(options)")).toBeGreaterThan(
+      client.indexOf("export function createSolard"),
+    );
+  });
+
+  test("does not expose core repositories or secret-bearing handles", () => {
+    expect(client).not.toMatch(
+      /\b(?:db|wallets|tokens|groups|executions|positions|prices|alts|senders|venues|claimSources|launches|launchpads|connection|signer)\s*:/,
+    );
+  });
+});

package/src/index.ts

@@ -1,53 +1,50 @@
-/**
- * Public Solard SDK.
- *
- * All stateful behavior lives in @solard/core so the SDK and CLI share exactly
- * the same wallet store, transaction engine, venues, senders and database.
- */
-export * from "@solard/core";
-
-// Explicit source-level re-export for the generic Jupiter swap helpers.
-// This avoids depending on the @solard/core package barrel resolution when the
-// monorepo CLI is executed directly from source with Bun.
-export {
-  executeJupiterSwap,
-  quoteJupiterSwap,
-  executeJupiterTokenToSol,
-  quoteJupiterTokenToSol,
-} from "../../core/src/chain/jupiter-swap.ts";
+export { createSolard, createTraderSolard } from "./client.ts";
 export type {
-  JupiterSwapExecuteResult,
-  JupiterSwapOrder,
-  JupiterSwapQuote,
-} from "../../core/src/chain/jupiter-swap.ts";
+  Solard,
+  SolardEventsApi,
+  SolardHistoryApi,
+  SolardOptions,
+} from "./client.ts";
+
+export { formatRaw, sol, tokenAmount } from "@solard/core";
 
-// Direct source re-exports used by the source-executed CLI.
-export { readMint } from "../../core/src/chain/state.ts";
-export { transferTokenIxs } from "../../core/src/tx/spl.ts";
-// Direct source re-exports for the target-weight portfolio controller and
-// backtester. Keeping these explicit lets the source-executed CLI/examples use
-// the new strategy without requiring a root @solard/core barrel replacement.
-export {
-  normalizeTargetWeightPolicy,
-  planTargetWeightRebalance,
-  targetWeightGapPct,
-} from "../../core/src/strategy/target-weight.ts";
-export type {
-  TargetWeightCandle,
-  TargetWeightGapMode,
-  TargetWeightGapPolicy,
-  TargetWeightPolicy,
-  TargetWeightRebalancePlan,
-} from "../../core/src/strategy/target-weight.ts";
-export { simulateTargetWeightStrategy } from "../../core/src/backtest/target-weight-sim.ts";
 export type {
-  TargetWeightBacktestExecution,
-  TargetWeightBacktestResult,
-  TargetWeightBacktestSummary,
-  TargetWeightDecision,
-} from "../../core/src/backtest/target-weight-sim.ts";
-export {
-  backtestTargetWeightToken,
-  backtestTargetWeightTokenWithDependencies,
-} from "../../core/src/backtest/token-backtest.ts";
-export type { TokenTargetWeightBacktestResult } from "../../core/src/backtest/token-backtest.ts";
+  ClaimCreatorRewardsOptions,
+  CreatorRewardClaimPayout,
+  CreatorRewardClaimResult,
+  CumulativeDistributionExecuteOptions,
+  CumulativeDistributionInput,
+  CumulativeDistributionPlan,
+  CumulativeDistributionRecipient,
+  CumulativeDistributionState,
+  CumulativeEntitlement,
+  HumanAmount,
+  MarketHistory,
+  MarketHistoryOptions,
+  MarketPrice,
+  MergedReplayEventStream,
+  QuoteAsset,
+  ReplayCoverage,
+  ReplayEventSubscription,
+  ReplayEventsOptions,
+  ReplayHistory,
+  ReplayItem,
+  ReplayOptions,
+  ReplayPayout,
+  ReplayTransaction,
+  SendReceipt,
+  SenderId,
+  SimulationResult,
+  SolardCanonicalEvent,
+  SolardClaimAttribution,
+  SolardClaimEvent,
+  TokenEventHistoryProgress,
+  TokenHolder,
+  ExcludedTokenHolder,
+  TokenHolderSnapshot,
+  TokenHolderSnapshotOptions,
+  TokenRef,
+  TokenRow,
+  WalletInfo,
+  WalletRef,
+} from "@solard/core";