@solard/sdk 0.2.27 → 0.2.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solard/sdk",
-  "version": "0.2.27",
+  "version": "0.2.29",
   "description": "Public Solard SDK for wallets, trading, history, live market subscriptions and token metadata.",
   "type": "module",
   "main": "./src/index.ts",
@@ -27,7 +27,7 @@
   "license": "MIT",
   "dependencies": {
     "@solana/web3.js": "^1.98.4",
-    "@solard/core": "0.2.27"
+    "@solard/core": "0.2.29"
   },
   "scripts": {
     "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.browser.json",

package/src/client.trade-fees.test.ts

@@ -0,0 +1,60 @@
+import { expect, spyOn, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Keypair } from "@solana/web3.js";
+import { Solard } from "../../core/src/core/solard.ts";
+import { TransactionComposer } from "../../core/src/tx/composer.ts";
+import type { PlannedTransaction, TransactionDraft } from "../../core/src/tx/types.ts";
+import { createSolard } from "./client.ts";
+
+test("SDK buy rebuild and sell preserve custom fees in immediate submitted results", async () => {
+  const directory = mkdtempSync(join(tmpdir(), "solard-sdk-fees-"));
+  const drafts: Array<TransactionDraft> = [];
+  // A sentinel plan is never compiled, signed, or broadcast in this test.
+  const payer = Keypair.generate();
+  const plan = { payer: payer.publicKey } as PlannedTransaction;
+  const build = spyOn(TransactionComposer.prototype, "build").mockImplementation(async function (this: TransactionComposer) {
+    drafts.push(this.snapshot());
+    return { ...plan, draft: this.snapshot() };
+  });
+  const signer = spyOn(Solard.prototype, "signer").mockImplementation(() => payer);
+  const compile = spyOn(Solard.prototype, "compile").mockImplementation(async (_payer, draft) => ({ ...plan, draft }));
+  let submissions = 0;
+  const submit = spyOn(Solard.prototype, "submitPlan").mockImplementation(async () => {
+    submissions += 1;
+    if (submissions === 1) {
+      throw new Error("Simulation failed: BuySlippageBelowMinBaseAmountOut");
+    }
+    return { signature: "test-signature", sender: "rpc", executionId: 42, plan };
+  });
+  const settle = spyOn(Solard.prototype, "settleSubmission").mockImplementation(async () => {
+    throw new Error("Immediate submission must not wait for confirmation");
+  });
+  const sdk = createSolard({ dbPath: join(directory, "test.sqlite") });
+  try {
+    const options = {
+      priorityFee: { cuLimit: 300_000, microLamports: 0 },
+      waitForConfirmation: false,
+    };
+    const buy = await sdk.buy({ token: "token", wallet: "wallet", amount: 0.1 }, options);
+    const sell = await sdk.sell({ token: "token", wallet: "wallet" }, options);
+    expect(drafts).toHaveLength(3);
+    for (const draft of drafts) {
+      expect(draft.cuLimit).toBe(300_000);
+      expect(draft.cuPriceMicroLamports).toBe(0);
+    }
+    expect(buy.status).toBe("submitted");
+    expect(sell.status).toBe("submitted");
+    expect(buy.executionId).toBe(42);
+    expect(settle).not.toHaveBeenCalled();
+  } finally {
+    sdk.close();
+    build.mockRestore();
+    signer.mockRestore();
+    compile.mockRestore();
+    submit.mockRestore();
+    settle.mockRestore();
+    rmSync(directory, { recursive: true, force: true });
+  }
+});

package/src/client.ts

@@ -1,285 +1,279 @@
-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,
+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 SendReceipt,
-  type SenderId,
-  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";
-
-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 SolardBuyInput = {
-  wallet: WalletRef;
-  token: TokenRef;
-  amount: HumanAmount | string | number;
-  slippageBps?: number;
-};
-
-export type SolardSellInput = {
-  wallet: WalletRef;
-  token: TokenRef;
-  amount?: "all" | { bps: number };
-  slippageBps?: number;
-};
-
+  type TradeLandingPolicy,
+  type SenderId,
+  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";
+
+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 SolardBuyInput = {
+  wallet: WalletRef;
+  token: TokenRef;
+  amount: HumanAmount | string | number;
+  slippageBps?: number;
+};
+
+export type SolardSellInput = {
+  wallet: WalletRef;
+  token: TokenRef;
+  amount?: "all" | { bps: number };
+  slippageBps?: number;
+};
+
 export type SolardTradeExecutionOptions = {
-  waitForConfirmation?: boolean;
-  via?: SenderId;
-  skipSimulation?: boolean;
-  skipPreflight?: boolean;
-};
-
+  landing?: TradeLandingPolicy;
+  waitForConfirmation?: boolean;
+  priorityFee?: { cuLimit?: number; microLamports?: number };
+  via?: SenderId;
+  skipSimulation?: boolean;
+  skipPreflight?: boolean;
+};
+
 export type SolardTradeExecutionResult = {
-  executionId: number;
-  signature: string;
-  sender: string;
-  status: SendReceipt["status"];
-  slot: number | null;
-  error: string | null;
-  feeLamports?: number;
-  computeUnitsConsumed?: number;
-};
-
-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"];
-  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>;
-};
-
-function tradeAmount(value: HumanAmount | string | number): HumanAmount {
-  return typeof value === "string" || typeof value === "number"
-    ? { sol: value }
-    : value;
-}
-
-function sellBps(value: SolardSellInput["amount"]): number {
-  if (value == null || value === "all") return 10_000;
-  const bps = Math.trunc(value.bps);
-  if (!(bps > 0 && bps <= 10_000))
-    throw new Error("sell amount.bps must be between 1 and 10000");
-  return bps;
-}
-
-function pumpSwap6040(error: unknown): boolean {
-  const message = error instanceof Error ? error.message : String(error);
-  return (
-    message.includes("Simulation failed") &&
-    (message.includes("BuySlippageBelowMinBaseAmountOut") ||
-      message.includes("Error Number: 6040") ||
-      /["']?Custom["']?\s*[:=]\s*6040/.test(message))
-  );
-}
-
-async function executeTrade(
-  core: ReturnType<typeof createCoreSolard>,
-  side: "buy" | "sell",
-  input: SolardBuyInput | SolardSellInput,
-  options: SolardTradeExecutionOptions = {},
-): Promise<SolardTradeExecutionResult> {
-  const via = options.via ?? "rpc";
-  const buildAndSubmit = async () => {
-    const composer = core.tx(input.wallet);
+  attempts?: Array<{ executionId: number; signature: string; priorityMicroLamports: number }>;
+  executionId: number;
+  signature: string;
+  sender: string;
+  status: SendReceipt["status"];
+  slot: number | null;
+  error: string | null;
+  feeLamports?: number;
+  computeUnitsConsumed?: number;
+  /** Signed economic SOL delta excluding network fee and token-account rent. */
+  solPrincipalDeltaLamports?: bigint;
+  /** Signed target-token delta for the confirmed atomic route. */
+  targetTokenDeltaRaw?: bigint;
+  /** Confirmed transaction network fee. */
+  networkFeeLamports?: bigint;
+};
+
+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"];
+  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>;
+};
+
+function tradeAmount(value: HumanAmount | string | number): HumanAmount {
+  return typeof value === "string" || typeof value === "number"
+    ? { sol: value }
+    : value;
+}
+
+function sellBps(value: SolardSellInput["amount"]): number {
+  if (value == null || value === "all") return 10_000;
+  const bps = Math.trunc(value.bps);
+  if (!(bps > 0 && bps <= 10_000))
+    throw new Error("sell amount.bps must be between 1 and 10000");
+  return bps;
+}
+
+
+async function executeTrade(
+  core: ReturnType<typeof createCoreSolard>,
+  side: "buy" | "sell",
+  input: SolardBuyInput | SolardSellInput,
+  options: SolardTradeExecutionOptions = {},
+): Promise<SolardTradeExecutionResult> {
+  const { submission, receipt, attempts } = await core.executeTradePlan(input.wallet, async () => {
+    const composer = core.tx(input.wallet).priorityFee(options.priorityFee ?? {});
     if (side === "buy") {
       const buy = input as SolardBuyInput;
-      composer.buy(buy.token, tradeAmount(buy.amount), {
-        slippageBps: buy.slippageBps,
-      });
+      composer.buy(buy.token, tradeAmount(buy.amount), { slippageBps: buy.slippageBps });
     } else {
       const sell = input as SolardSellInput;
-      composer.sell(sell.token, {
-        bps: sellBps(sell.amount),
-        slippageBps: sell.slippageBps,
-      });
+      composer.sell(sell.token, { bps: sellBps(sell.amount), slippageBps: sell.slippageBps });
     }
-    const plan = await composer.build();
-    return await core.submitPlan(plan, via, side, {
-      skipSimulation: options.skipSimulation,
-      skipPreflight: options.skipPreflight,
-    });
-  };
-  let submission;
-  try {
-    submission = await buildAndSubmit();
-  } catch (error) {
-    if (side !== "buy" || options.skipSimulation || !pumpSwap6040(error))
-      throw error;
-    submission = await buildAndSubmit();
-  }
-  if (options.waitForConfirmation === false) {
-    return {
-      executionId: submission.executionId,
-      signature: submission.signature,
-      sender: submission.sender,
-      status: "submitted",
-      slot: null,
-      error: null,
-    };
-  }
-  const receipt = await core.settleSubmission(submission);
-  return {
-    executionId: submission.executionId,
-    signature: receipt.signature,
-    sender: receipt.sender,
-    status: receipt.status,
-    slot: receipt.slot,
-    error: receipt.error ?? null,
-    feeLamports: receipt.feeLamports,
+    return await composer.build();
+  }, options.via ?? "rpc", side, options);
+  const confirmedTrade =
+    receipt.status === "confirmed"
+      ? (
+          await core.trades({
+            wallet: input.wallet,
+            token: input.token,
+            side,
+            status: "confirmed",
+            limit: 32,
+          })
+        ).find((trade) => trade.signature === receipt.signature) ?? null
+      : null;
+  return {
+    executionId: submission.executionId,
+    signature: receipt.signature,
+    sender: receipt.sender,
+    status: receipt.status,
+    slot: receipt.slot,
+    error: receipt.error ?? null,
+    feeLamports: receipt.feeLamports,
     computeUnitsConsumed: receipt.computeUnitsConsumed,
-  };
-}
-
-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),
-    walletAddress: core.walletAddress.bind(core),
-    exportPrivateKey: core.exportWalletPrivateKey.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),
-    recordConfirmedTrade: core.recordConfirmedTrade.bind(core),
-    trades: core.trades.bind(core),
-    position: core.position.bind(core),
-    getTransaction: core.getTransaction.bind(core),
-    samplePrice: core.samplePrice.bind(core),
-    buy: (input, executionOptions) =>
-      executeTrade(core, "buy", input, executionOptions),
-    sell: (input, executionOptions) =>
-      executeTrade(core, "sell", input, executionOptions),
-  });
-}
+    attempts,
+    ...(confirmedTrade?.solDeltaLamports != null
+      ? { solPrincipalDeltaLamports: confirmedTrade.solDeltaLamports }
+      : {}),
+    ...(confirmedTrade?.tokenDeltaRaw != null
+      ? { targetTokenDeltaRaw: confirmedTrade.tokenDeltaRaw }
+      : {}),
+    ...(confirmedTrade?.networkFeeLamports != null
+      ? { networkFeeLamports: confirmedTrade.networkFeeLamports }
+      : {}),
+  };
+}
+
+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),
+    walletAddress: core.walletAddress.bind(core),
+    exportPrivateKey: core.exportWalletPrivateKey.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),
+    recordConfirmedTrade: core.recordConfirmedTrade.bind(core),
+    trades: core.trades.bind(core),
+    position: core.position.bind(core),
+    getTransaction: core.getTransaction.bind(core),
+    samplePrice: core.samplePrice.bind(core),
+    buy: (input, executionOptions) =>
+      executeTrade(core, "buy", input, executionOptions),
+    sell: (input, executionOptions) =>
+      executeTrade(core, "sell", input, executionOptions),
+  });
+}

package/src/export-surface.test.ts

@@ -35,6 +35,7 @@ describe("sdk membrane", () => {
         "fetchTokenMetadata",
         "formatRaw",
         "getSolUsdPrice",
+        "isDefinitivePreSubmissionError",
         "publicTokenMetadataUrl",
         "subscribeLaunches",
         "subscribeMigrations",
@@ -43,6 +44,7 @@ describe("sdk membrane", () => {
         "tokenAmount",
       ].sort(),
       types: [
+        "TradeLandingPolicy",
         "ClaimCreatorRewardsOptions",
         "CreatorRewardClaimPayout",
         "CreatorRewardClaimResult",

package/src/index.ts

@@ -1,106 +1,112 @@
-export { default } from "./default.ts";
-export { createSolard } from "./client.ts";
+export { default } from "./default.ts";
+export { createSolard } from "./client.ts";
 export type {
-  Solard,
-  SolardBuyInput,
-  SolardEventsApi,
-  SolardHistoryApi,
-  SolardOptions,
-  SolardSellInput,
-  SolardTradeExecutionOptions,
-  SolardTradeExecutionResult,
-} from "./client.ts";
-
-export { formatRaw, sol, tokenAmount } from "@solard/core";
-
+  Solard,
+  SolardBuyInput,
+  SolardEventsApi,
+  SolardHistoryApi,
+  SolardOptions,
+  SolardSellInput,
+  SolardTradeExecutionOptions,
+  SolardTradeExecutionResult,
+} from "./client.ts";
+
+export {
+  formatRaw,
+  sol,
+  tokenAmount,
+  isDefinitivePreSubmissionError,
+} from "@solard/core";
+
 export type {
   ClaimCreatorRewardsOptions,
-  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.ts";
-export type {
-  ListenTradesOptions,
-  SubscribeLaunchesOptions,
-  SubscribeMigrationsOptions,
-  TradeListener,
-} from "./live.ts";
-export type {
-  LaunchEvent,
-  LaunchSubscription,
-  LaunchVenue,
-  MigrationDestination,
-  MigrationEvent,
-  MigrationSubscription,
-  MigrationVenue,
-  GetSolUsdPriceOptions,
-  SolUsdPrice,
-  SolUsdSource,
-  TradeEvent,
-  TradeMarket,
-  TradeSide,
-  TradeVenue,
-  FetchTokenMetadataOptions,
-  TokenMetadata,
-  TokenMetadataHint,
-  TokenMetadataKind,
-  TokenMetadataMode,
-} from "@solard/core";
+  TradeLandingPolicy,
+  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.ts";
+export type {
+  ListenTradesOptions,
+  SubscribeLaunchesOptions,
+  SubscribeMigrationsOptions,
+  TradeListener,
+} from "./live.ts";
+export type {
+  LaunchEvent,
+  LaunchSubscription,
+  LaunchVenue,
+  MigrationDestination,
+  MigrationEvent,
+  MigrationSubscription,
+  MigrationVenue,
+  GetSolUsdPriceOptions,
+  SolUsdPrice,
+  SolUsdSource,
+  TradeEvent,
+  TradeMarket,
+  TradeSide,
+  TradeVenue,
+  FetchTokenMetadataOptions,
+  TokenMetadata,
+  TokenMetadataHint,
+  TokenMetadataKind,
+  TokenMetadataMode,
+} from "@solard/core";

package/src/live.ts

@@ -194,10 +194,10 @@ async function preflightWebSocket(endpoint: string): Promise<void> {
     socket.addEventListener(
       "open",
       () => {
+        finish();
         try {
           socket?.close(1000);
         } catch {}
-        finish();
       },
       { once: true },
     );

package/src/operator-api.architecture.test.ts

@@ -37,7 +37,7 @@ describe("operator api", () => {
   });
 
   test("default trades settle inside Solard rather than leaking submitted state", () => {
-    expect(client).toContain("core.settleSubmission(");
+    expect(client).toContain("core.executeTradePlan(");
     expect(core).toContain("async settleSubmission(");
     expect(core).toContain("submission.plan.lastValidBlockHeight");
   });