@oracle-agent/oracle 0.3.3 → 0.3.5

package/src/cards.mjs

@@ -0,0 +1,369 @@
+// Telegram card TEXT renderers.
+//
+// Implements skills/oracle-chain-graphs-telegram-cards/SKILL.md. That spec has
+// existed with no code behind it, so Oracle users were getting raw JSON instead
+// of readable alert cards. This module is the text half only: chart/image
+// rendering lives elsewhere and MUST NOT be required for a card to send.
+//
+// Contract for every exported renderer:
+//   - pure, synchronous, string in / string out
+//   - NO network, NO signing, NO filesystem, NO env reads, NO mutation of input
+//   - unknown data renders as the literal string UNKNOWN — never blank, never
+//     guessed, never interpolated from a neighbouring field
+//   - the only identifier (contract address / mint / market id) is NEVER
+//     truncated: a half-address is worse than no address because it still looks
+//     actionable
+//   - chart failure is cosmetic: the text card always returns
+//   - buy/sell affordances only when a valid local grant/session is supplied
+//
+// Markdown dialect: Telegram *legacy* Markdown. Values are escaped for `_`,
+// `*`, `[`, `]` and backtick; card chrome supplies its own markers. We never
+// emit `$` at all (the spec calls out repeated `$` spans as a formatting trap)
+// — amounts are suffixed with USD instead.
+
+import { chainById } from "./chains.mjs";
+
+/** The one and only stand-in for missing data. */
+export const UNKNOWN = "UNKNOWN";
+
+export const CARD_KINDS = Object.freeze(["token", "launch", "hip3", "hip4", "polymarket"]);
+
+const LEGACY_MD_SPECIALS = /[_*[\]`]/g;
+
+/**
+ * Escape Telegram legacy-Markdown control characters in a *value*.
+ * Card chrome (bold headers) is written unescaped by the renderers themselves.
+ * @param {unknown} value
+ * @returns {string} escaped text, or UNKNOWN when there is nothing to show
+ */
+export function escapeMd(value) {
+  if (!isPresent(value)) return UNKNOWN;
+  return String(value).replace(LEGACY_MD_SPECIALS, (c) => `\\${c}`);
+}
+
+function isPresent(value) {
+  if (value === null || value === undefined) return false;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value === "string") return value.trim() !== "";
+  return true;
+}
+
+/** A value that must survive verbatim (addresses, mints, market ids). */
+function code(value) {
+  if (!isPresent(value)) return UNKNOWN;
+  // Backticks would close the span; strip rather than truncate the identifier.
+  const raw = String(value).replace(/`/g, "");
+  return raw === "" ? UNKNOWN : `\`${raw}\``;
+}
+
+function num(value, { decimals = 2 } = {}) {
+  if (!isPresent(value)) return UNKNOWN;
+  const n = typeof value === "bigint" ? Number(value) : Number(value);
+  if (!Number.isFinite(n)) return UNKNOWN;
+  return n.toLocaleString("en-US", { minimumFractionDigits: 0, maximumFractionDigits: decimals });
+}
+
+/** Money. Deliberately no `$` — repeated dollar spans break Telegram parsing. */
+function usd(value, { decimals = 2 } = {}) {
+  const n = num(value, { decimals });
+  return n === UNKNOWN ? UNKNOWN : `${n} USD`;
+}
+
+function pct(value, { decimals = 2 } = {}) {
+  const n = num(value, { decimals });
+  return n === UNKNOWN ? UNKNOWN : `${n}%`;
+}
+
+function bps(value) {
+  const n = num(value, { decimals: 0 });
+  return n === UNKNOWN ? UNKNOWN : `${n} bps`;
+}
+
+/**
+ * Exact base-unit -> decimal string. BigInt only: a raw quote like
+ * 24325001237995579150138 loses precision the moment it touches a float.
+ */
+export function formatUnits(raw, decimals) {
+  if (!isPresent(raw)) return UNKNOWN;
+  const d = Number(decimals);
+  if (!Number.isInteger(d) || d < 0 || d > 77) return UNKNOWN;
+  let value;
+  try {
+    value = BigInt(typeof raw === "string" ? raw.trim() : raw);
+  } catch {
+    return UNKNOWN;
+  }
+  const neg = value < 0n;
+  const abs = neg ? -value : value;
+  const base = 10n ** BigInt(d);
+  const whole = (abs / base).toString();
+  const frac = (abs % base).toString().padStart(d, "0").replace(/0+$/, "");
+  return `${neg ? "-" : ""}${whole}${frac ? `.${frac}` : ""}`;
+}
+
+/** Normalize confidence to a stated band. Every card must state one. */
+export function normalizeConfidence(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    if (value < 0 || value > 1) return UNKNOWN;
+    if (value >= 0.75) return "HIGH";
+    if (value >= 0.4) return "MEDIUM";
+    return "LOW";
+  }
+  if (typeof value === "string") {
+    const v = value.trim().toUpperCase();
+    if (v === "HIGH" || v === "MEDIUM" || v === "LOW") return v;
+  }
+  return UNKNOWN;
+}
+
+function chainLine(data = {}) {
+  const id = data.chainId;
+  if (!isPresent(id) || !Number.isFinite(Number(id))) {
+    return isPresent(data.chain) ? escapeMd(data.chain) : UNKNOWN;
+  }
+  const known = chainById(id);
+  const name = known?.name || (isPresent(data.chain) ? String(data.chain) : UNKNOWN);
+  return `${escapeMd(name)} (chainId ${Number(id)})`;
+}
+
+function venueLine(data = {}) {
+  return escapeMd(data.venue ?? data.dex ?? data.pool?.venue);
+}
+
+/**
+ * Chart status. A graph is evidence, not a dependency — if the image failed we
+ * say so and the text card still stands.
+ */
+function chartLine(chart) {
+  if (chart === null || chart === undefined) return "NONE (text card only)";
+  if (typeof chart === "string") return chart.trim() ? code(chart) : "NONE (text card only)";
+  if (chart.error || chart.ok === false || chart.available === false) {
+    const why = isPresent(chart.error) ? ` — ${escapeMd(chart.error)}` : "";
+    return `UNAVAILABLE${why} (text card stands)`;
+  }
+  if (isPresent(chart.url)) return code(chart.url);
+  return "NONE (text card only)";
+}
+
+/**
+ * Buy/sell affordances are gated on a valid LOCAL grant or session. Absent or
+ * expired grant => prepare-only. This function is the single gate; renderers
+ * never decide on their own.
+ * @returns {{ allowed: boolean, reason: string, actions: string[] }}
+ */
+export function cardActions(data = {}, { now = Date.now() } = {}) {
+  const grant = data.grant ?? data.session ?? null;
+  if (!grant || typeof grant !== "object") {
+    return { allowed: false, reason: "no local grant/session", actions: [] };
+  }
+  if (grant.local === false) {
+    return { allowed: false, reason: "grant is not local", actions: [] };
+  }
+  if (grant.revoked === true) {
+    return { allowed: false, reason: "grant revoked", actions: [] };
+  }
+  const expiry = grant.expiresAt ?? grant.expiry;
+  if (isPresent(expiry)) {
+    const at = typeof expiry === "number" ? expiry : Date.parse(expiry);
+    if (!Number.isFinite(at)) return { allowed: false, reason: "grant expiry unreadable", actions: [] };
+    if (at <= now) return { allowed: false, reason: "grant expired", actions: [] };
+  }
+  const actions = Array.isArray(grant.actions) && grant.actions.length ? grant.actions.slice() : ["BUY", "SELL"];
+  return { allowed: true, reason: "valid local grant", actions };
+}
+
+function actionsLine(data) {
+  const gate = cardActions(data);
+  return gate.allowed
+    ? `${gate.actions.map((a) => escapeMd(a)).join(" / ")} (${escapeMd(gate.reason)})`
+    : `prepare-only — ${escapeMd(gate.reason)}`;
+}
+
+function build(title, rows, data = {}) {
+  const lines = [`*${title}*`];
+  for (const [label, value] of rows) {
+    // Labels are authored here and contain no markdown specials by construction.
+    lines.push(`${label}: ${value === undefined || value === null || value === "" ? UNKNOWN : value}`);
+  }
+  lines.push(`Chart: ${chartLine(data.chart)}`);
+  lines.push(`Actions: ${actionsLine(data)}`);
+  if (Array.isArray(data.warnings) && data.warnings.length) {
+    lines.push(`Warnings: ${data.warnings.map((w) => escapeMd(w)).join("; ")}`);
+  }
+  if (isPresent(data.source) || isPresent(data.fetchedAt)) {
+    lines.push(`Source: ${escapeMd(data.source)} at ${escapeMd(data.fetchedAt)}`);
+  }
+  return lines.join("\n");
+}
+
+function confidenceRow(data) {
+  return ["Confidence", normalizeConfidence(data.confidence)];
+}
+
+function quoteRows(data) {
+  const q = data.quote;
+  if (!q || typeof q !== "object") return [];
+  const human = isPresent(q.decimals) ? formatUnits(q.amountOutRaw ?? q.out ?? q.raw, q.decimals) : UNKNOWN;
+  return [
+    ["Quote out (raw)", code(q.amountOutRaw ?? q.out ?? q.raw)],
+    ["Quote out", human === UNKNOWN ? UNKNOWN : `${escapeMd(human)} ${escapeMd(q.symbol ?? "")}`.trim()],
+  ];
+}
+
+function slippageRow(data) {
+  const s = data.autoSlippage;
+  if (!s || typeof s !== "object") return ["Auto-slippage", UNKNOWN];
+  const sel = bps(s.selectedBps);
+  const cap = bps(s.capBps);
+  return ["Auto-slippage", sel === UNKNOWN && cap === UNKNOWN ? UNKNOWN : `${sel} selected, cap ${cap}`];
+}
+
+/** Per-chain token card: price, volume, liquidity, market cap, age, venue. */
+export function renderTokenCard(data = {}) {
+  const d = data || {};
+  return build(
+    `ORACLE TOKEN — ${escapeMd(d.symbol ?? d.token ?? d.name)}`,
+    [
+      ["Chain", chainLine(d)],
+      ["Venue", venueLine(d)],
+      ["Name", escapeMd(d.name)],
+      ["Address", code(d.address ?? d.mint ?? d.contract)],
+      ["Price", usd(d.priceUsd, { decimals: 8 })],
+      ["Market cap", usd(d.marketCapUsd)],
+      ["Liquidity", usd(d.liquidityUsd)],
+      ["Volume 24h", usd(d.volume24hUsd)],
+      ["Change 24h", pct(d.priceChange24h)],
+      ["Fee tier", isPresent(d.feeTier) ? `${bps(Number(d.feeTier) / 100)} (${num(d.feeTier, { decimals: 0 })})` : UNKNOWN],
+      ["Age", escapeMd(d.age)],
+      ...quoteRows(d),
+      slippageRow(d),
+      confidenceRow(d),
+    ],
+    d,
+  );
+}
+
+/** Launch/sniper card: route readiness, sellability, overlap, risk, ticket. */
+export function renderLaunchCard(data = {}) {
+  const d = data || {};
+  return build(
+    `ORACLE LAUNCH — ${escapeMd(d.symbol ?? d.token ?? d.name)}`,
+    [
+      ["Chain", chainLine(d)],
+      ["Venue", venueLine(d)],
+      ["Address", code(d.address ?? d.mint ?? d.contract)],
+      ["Pool", code(d.pool?.address ?? d.poolAddress ?? d.pool)],
+      ["Liquidity", usd(d.liquidityUsd)],
+      ["Route ready", escapeMd(d.routeReady)],
+      ["Sellable", escapeMd(d.sellable)],
+      ["Sell sim", escapeMd(d.sellSimulation ?? d.sellSim)],
+      ["Smart wallets", escapeMd(d.smartWalletOverlap)],
+      ["Risk", escapeMd(d.risk ?? d.riskStatus)],
+      ["Prepared ticket", escapeMd(d.preparedTicket ?? d.ticketStatus)],
+      slippageRow(d),
+      confidenceRow(d),
+    ],
+    d,
+  );
+}
+
+/** Hyperliquid HIP-3 builder-dex card. Requires perpDexs + metaAndAssetCtxs. */
+export function renderHip3Card(data = {}) {
+  const d = data || {};
+  return build(
+    `ORACLE HIP-3 — ${escapeMd(d.market ?? d.coin ?? d.name)}`,
+    [
+      ["Venue", `Hyperliquid builder-dex ${escapeMd(d.dex)}`],
+      ["Market", escapeMd(d.market ?? d.coin)],
+      ["Mark", usd(d.markPx, { decimals: 6 })],
+      ["Oracle", usd(d.oraclePx, { decimals: 6 })],
+      ["Funding", pct(d.funding, { decimals: 6 })],
+      ["Open interest", usd(d.openInterestUsd)],
+      ["Depth", escapeMd(d.depth)],
+      ["Liquidation notes", escapeMd(d.liquidationNotes ?? d.riskNotes)],
+      ["Account context", escapeMd(d.accountContext)],
+      confidenceRow(d),
+    ],
+    d,
+  );
+}
+
+/** Hyperliquid HIP-4 outcome-market card. Public reads are keyless. */
+export function renderHip4Card(data = {}) {
+  const d = data || {};
+  return build(
+    `ORACLE HIP-4 — ${escapeMd(d.event ?? d.market ?? d.name)}`,
+    [
+      ["Venue", `Hyperliquid HIP-4 ${escapeMd(d.dex ?? "outcome")}`],
+      ["Event", escapeMd(d.event)],
+      ["Outcome", escapeMd(d.outcome)],
+      ["Market id", code(d.marketId ?? d.market)],
+      ["Bid", usd(d.bid, { decimals: 6 })],
+      ["Ask", usd(d.ask, { decimals: 6 })],
+      ["Depth", escapeMd(d.depth)],
+      ["Edge", pct(d.edge)],
+      ["Position", escapeMd(d.position)],
+      confidenceRow(d),
+    ],
+    d,
+  );
+}
+
+/** Polymarket card. Public reads keyless; orders stay prepared/user-signed. */
+export function renderPolymarketCard(data = {}) {
+  const d = data || {};
+  return build(
+    `ORACLE POLYMARKET — ${escapeMd(d.event ?? d.market ?? d.name)}`,
+    [
+      ["Venue", "Polymarket CLOB"],
+      ["Event", escapeMd(d.event)],
+      ["Market", escapeMd(d.market)],
+      ["Market id", code(d.marketId ?? d.conditionId ?? d.tokenId)],
+      ["Yes", usd(d.yesPrice, { decimals: 4 })],
+      ["No", usd(d.noPrice, { decimals: 4 })],
+      ["Best bid / ask", `${usd(d.bestBid, { decimals: 4 })} / ${usd(d.bestAsk, { decimals: 4 })}`],
+      ["Volume", usd(d.volumeUsd)],
+      ["Resolution risk", escapeMd(d.resolutionRisk)],
+      ["Order intent", escapeMd(d.orderIntent)],
+      confidenceRow(d),
+    ],
+    d,
+  );
+}
+
+const RENDERERS = Object.freeze({
+  token: renderTokenCard,
+  launch: renderLaunchCard,
+  hip3: renderHip3Card,
+  hip4: renderHip4Card,
+  polymarket: renderPolymarketCard,
+});
+
+/**
+ * Dispatch by surface kind.
+ * @param {"token"|"launch"|"hip3"|"hip4"|"polymarket"} kind
+ */
+export function renderCard(kind, data = {}) {
+  const fn = RENDERERS[String(kind)];
+  if (!fn) throw new Error(`unknown card kind: ${kind} (expected one of ${CARD_KINDS.join(", ")})`);
+  return fn(data);
+}
+
+/**
+ * Total soft-fail wrapper. An alert that cannot render is still an alert the
+ * user needs to see, so a malformed payload degrades to a minimal card rather
+ * than throwing and dropping the notification.
+ */
+export function safeRenderCard(kind, data = {}) {
+  try {
+    return renderCard(kind, data);
+  } catch (error) {
+    return [
+      `*ORACLE CARD — DEGRADED*`,
+      `Kind: ${escapeMd(kind)}`,
+      `Chain: ${UNKNOWN}`,
+      `Confidence: ${UNKNOWN}`,
+      `Render error: ${escapeMd(error?.message)}`,
+    ].join("\n");
+  }
+}

package/src/data/catalog.mjs

@@ -98,29 +98,6 @@ registerProvider({
   description: "RH agent local HTTP (unauthenticated read routes)",
 });
 
-registerProvider({
-  id: "portfolio",
-  venue: "multichain-wallet",
-  chainIds: [1, 10, 56, 137, 988, 999, 2741, 4663, 8453, 42161, 43114],
-  auth: "none",
-  ops: ["health", "balances", "snapshot", "history", "valueGraph"],
-  execution: "read-only",
-  description:
-    "Read-only balance aggregation across configured EVM chains, Solana, Bitcoin, and Hyperliquid, plus profile-local observation snapshots, history, and value graphs with explicit partial coverage.",
-});
-
-registerProvider({
-  id: "nft-portfolio",
-  venue: "multichain-nft-wallet",
-  chainIds: [1, 10, 137, 988, 999, 2741, 4663, 8453, 42161, 43114],
-  auth: "optionalApiKey",
-  ops: ["health", "inventory", "gallery", "pnl", "prepareList"],
-  execution: "prepare",
-  baseEnv: ["OPENSEA_API_KEY", "MAGICEDEN_API_KEY", "SATFLOW_API_KEY"],
-  description:
-    "Normalized EVM, Solana, and Bitcoin NFT inventory, static contact-sheet galleries, explicit PnL coverage, and user-confirmed unsigned listing preparation.",
-});
-
 registerProvider({
   id: "evm-rpc",
   venue: "evm",
@@ -404,12 +381,11 @@ registerProvider({
 registerProvider({
   id: "opensea-nft",
   venue: "nft",
-  chainIds: [1, 10, 137, 988, 999, 2741, 4663, 8453, 42161, 43114],
+  chainIds: [1],
   auth: "apiKey",
-  ops: ["health", "collection", "floor", "accountNfts", "accountPnl", "prepareList"],
-  execution: "prepare",
+  ops: ["health", "collection", "floor"],
   baseEnv: ["OPENSEA_API_KEY", "OPENSEA_ENV_FILE"],
-  description: "OpenSea multichain NFT inventory, estimated values, indexed account PnL, collection floors, and unsigned listing actions",
+  description: "OpenSea collection + floor (OPENSEA_API_KEY)",
 });
 
 registerProvider({

package/src/data/desk-data.mjs

@@ -40,9 +40,6 @@ import * as balancer from "./providers/balancer.mjs";
 import * as pendle from "./providers/pendle.mjs";
 import * as odos from "./providers/odos.mjs";
 import * as blockscout from "./providers/blockscout.mjs";
-import * as portfolio from "./providers/portfolio.mjs";
-import * as portfolioHistory from "./providers/portfolio-history.mjs";
-import * as nftPortfolio from "./providers/nft-portfolio.mjs";
 import * as paraswap from "./providers/paraswap.mjs";
 
 const OPS = {
@@ -93,20 +90,6 @@ const OPS = {
     erc20Balance: (o, a = {}) => rpc.erc20BalanceOf(a, o),
     transactionReceipt: (o, a = {}) => rpc.transactionReceipt(a, o),
   },
-  portfolio: {
-    health: (o) => portfolio.portfolioHealth(o),
-    balances: (o, a = {}) => portfolio.portfolioBalance(a, o),
-    snapshot: (o, a = {}) => portfolioHistory.portfolioSnapshot(a, o),
-    history: (o, a = {}) => portfolioHistory.portfolioHistory(a, o),
-    valueGraph: (o, a = {}) => portfolioHistory.portfolioValueGraph(a, o),
-  },
-  "nft-portfolio": {
-    health: (o) => nftPortfolio.nftHealth(o),
-    inventory: (o, a = {}) => nftPortfolio.nftInventory(a, o),
-    gallery: (o, a = {}) => nftPortfolio.nftPortfolioGallery(a, o),
-    pnl: (o, a = {}) => nftPortfolio.nftPnl(a, o),
-    prepareList: (o, a = {}) => nftPortfolio.nftPrepareList(a, o),
-  },
   "solana-rpc": {
     health: (o) => solana.solanaHealth(o),
     latestBlockhash: (o, a = {}) => solana.solanaLatestBlockhash(a, o),
@@ -230,9 +213,6 @@ const OPS = {
     health: (o) => osnft.openseaHealth(o),
     collection: (o, a = {}) => osnft.openseaCollection(a.slug, o),
     floor: (o, a = {}) => osnft.openseaFloor(a.slug, o),
-    accountNfts: (o, a = {}) => osnft.openseaAccountNfts(a, o),
-    accountPnl: (o, a = {}) => osnft.openseaAccountPnl(a, o),
-    prepareList: (o, a = {}) => osnft.openseaPrepareList(a, o),
   },
 
   "hl-outcome": {
@@ -590,20 +570,6 @@ export const data = {
     call: (chainId, method, params, o) =>
       dataCall("evm-rpc", "call", { chainId, method, params }, o),
   },
-  portfolio: {
-    balance: (a, o) => dataCall("portfolio", "balances", a || {}, o),
-    snapshot: (a, o) => dataCall("portfolio", "snapshot", a || {}, o),
-    history: (a, o) => dataCall("portfolio", "history", a || {}, o),
-    valueGraph: (a, o) => dataCall("portfolio", "valueGraph", a || {}, o),
-  },
-  nft: {
-    inventory: (a, o) => dataCall("nft-portfolio", "inventory", a || {}, o),
-    gallery: (a, o) => dataCall("nft-portfolio", "gallery", a || {}, o),
-    pnl: (a, o) => dataCall("nft-portfolio", "pnl", a || {}, o),
-    prepareList: (a, o) => dataCall("nft-portfolio", "prepareList", a || {}, o),
-    floor: (slug, o) => dataCall("opensea-nft", "floor", { slug }, o),
-    collection: (slug, o) => dataCall("opensea-nft", "collection", { slug }, o),
-  },
   solana: {
     health: (o) => dataCall("solana-rpc", "health", {}, o),
     latestBlockhash: (a, o) => dataCall("solana-rpc", "latestBlockhash", a || {}, o),
@@ -667,6 +633,10 @@ export const data = {
   cow: {
     quote: (a, o) => dataCall("cowswap", "quote", a || {}, o),
   },
+  nft: {
+    floor: (slug, o) => dataCall("opensea-nft", "floor", { slug }, o),
+    collection: (slug, o) => dataCall("opensea-nft", "collection", { slug }, o),
+  },
   hlWs: {
     allMids: (o) => dataCall("hl-ws", "allMids", {}, o),
     l2Book: (coin, o) => dataCall("hl-ws", "l2Book", { coin }, o),

package/src/data/providers/magiceden-sol.mjs

@@ -89,18 +89,6 @@ function lamports(sol) {
   return Math.round(positiveNumber(sol, "priceSol") * LAMPORTS_PER_SOL);
 }
 
-function listingExpiry(value) {
-  if (value == null || value === "") return null;
-  const expiry = Number(value);
-  if (!Number.isSafeInteger(expiry) || expiry < 0) {
-    throw new Error("magiceden: expiry must be a whole Unix timestamp in seconds or 0");
-  }
-  if (expiry !== 0 && expiry <= Math.floor(Date.now() / 1000)) {
-    throw new Error("magiceden: expiry must be in the future or 0 for no expiry");
-  }
-  return expiry;
-}
-
 export async function magicEdenSolHealth(opts = {}) {
   try {
     const stats = await magicEdenSolStats({ symbol: "mad_lads" }, opts);
@@ -268,26 +256,20 @@ export async function magicEdenSolPrepareList(args = {}, opts = {}) {
   const tokenATA = solanaPubkey(args.tokenATA || args.tokenAddress, "tokenATA");
   const auctionHouse = solanaPubkey(args.auctionHouse, "auctionHouse");
   const priceSol = positiveNumber(args.priceSol ?? args.price, "priceSol");
-  const expiry = listingExpiry(args.expiry);
   const url = new URL(`${base(opts)}/instructions/sell`);
   url.searchParams.set("seller", seller);
   url.searchParams.set("auctionHouseAddress", auctionHouse);
   url.searchParams.set("tokenMint", tokenMint);
   url.searchParams.set("tokenAccount", tokenATA);
   url.searchParams.set("price", String(priceSol));
-  if (args.sellerReferral) url.searchParams.set("sellerReferral", solanaPubkey(args.sellerReferral, "sellerReferral"));
-  if (expiry != null) url.searchParams.set("expiry", String(expiry));
   const raw = await httpJson(url.toString(), {
     headers: headers(opts),
     fetchImpl: opts.fetchImpl,
     timeoutMs: opts.timeoutMs ?? 15_000,
   });
   const data = raw?.v0?.tx?.data ?? raw?.tx?.data ?? null;
-  if (!Array.isArray(data)) {
-    if (raw?.txSigned) throw new Error("magiceden: refused a pre-signed transaction payload from the API");
-    throw new Error("magiceden: sell returned no unsigned transaction payload");
-  }
-  const transaction = Buffer.from(data).toString("base64");
+  const transaction = Array.isArray(data) ? Buffer.from(data).toString("base64") : null;
+  if (!transaction) throw new Error("magiceden: sell returned no transaction payload");
   return stampPrepared({
     provider: "magiceden-sol",
     chain: "solana-mainnet-beta",
@@ -300,7 +282,6 @@ export async function magicEdenSolPrepareList(args = {}, opts = {}) {
     seller,
     tokenMint,
     priceSol,
-    expiry,
     transaction,
     transactionEncoding: "base64",
     raw,