@0block.io/sdk 0.4.1 → 0.5.1

package/dist/fetch.d.ts

@@ -19,7 +19,19 @@ export declare function resolveTokenProgram(fetcher: AccountFetcher, mint: Addre
 export declare function fetchPumpfunGlobalFeeRecipient(fetcher: AccountFetcher, globalAccount: web3.PublicKey): Promise<web3.PublicKey>;
 /** Non-zero entries of Global.buyback_fee_recipients ([Pubkey; 8]). */
 export declare function fetchPumpfunBuybackFeeRecipients(fetcher: AccountFetcher, globalAccount: web3.PublicKey): Promise<web3.PublicKey[]>;
-/** BondingCurve.creator (offset: discriminator + 5×u64 + bool). */
+/**
+ * BondingCurve.creator (offset: discriminator + 5×u64 + bool), with tradeability
+ * preflight. Throws a PRECISE error instead of letting an untradeable market
+ * fail on-chain (where the user would still pay the tx fee + tip):
+ *
+ * - `complete == true` → the token GRADUATED off the bonding curve (liquidity
+ *   moved to an AMM — PumpSwap/Raydium); the pump.fun program rejects both
+ *   buys and sells on a complete curve.
+ * - 49-byte legacy layout (pre-creator-fee, curve untouched since the mid-2025
+ *   pump.fun upgrade) → needs the program's extend_account before any modern
+ *   swap can even deserialize it. In practice these are dead tokens: anything
+ *   actively traded has long been extended.
+ */
 export declare function fetchPumpfunBondingCurveCreator(fetcher: AccountFetcher, bondingCurve: web3.PublicKey): Promise<web3.PublicKey>;
 /**
  * Resolve everything a pump.fun swap needs for one mint. Run this server-side

package/dist/fetch.js

@@ -55,17 +55,38 @@ export async function fetchPumpfunBuybackFeeRecipients(fetcher, globalAccount) {
     }
     return recipients;
 }
-/** BondingCurve.creator (offset: discriminator + 5×u64 + bool). */
+/**
+ * BondingCurve.creator (offset: discriminator + 5×u64 + bool), with tradeability
+ * preflight. Throws a PRECISE error instead of letting an untradeable market
+ * fail on-chain (where the user would still pay the tx fee + tip):
+ *
+ * - `complete == true` → the token GRADUATED off the bonding curve (liquidity
+ *   moved to an AMM — PumpSwap/Raydium); the pump.fun program rejects both
+ *   buys and sells on a complete curve.
+ * - 49-byte legacy layout (pre-creator-fee, curve untouched since the mid-2025
+ *   pump.fun upgrade) → needs the program's extend_account before any modern
+ *   swap can even deserialize it. In practice these are dead tokens: anything
+ *   actively traded has long been extended.
+ */
 export async function fetchPumpfunBondingCurveCreator(fetcher, bondingCurve) {
     const info = await fetcher.getAccountInfo(bondingCurve);
     if (!info) {
         throw new Error(`pump.fun bonding curve not found: ${bondingCurve.toBase58()}`);
     }
-    const offset = 8 + 5 * 8 + 1;
-    if (info.data.length < offset + 32) {
+    const legacyLen = 8 + 5 * 8 + 1; // ..= complete flag (pre-creator layout)
+    if (info.data.length < legacyLen) {
         throw new Error("pump.fun bonding curve data too short");
     }
-    return new web3.PublicKey(info.data.slice(offset, offset + 32));
+    const complete = info.data[legacyLen - 1] === 1;
+    if (complete) {
+        throw new Error("pump.fun bonding curve is complete — the token graduated to an AMM " +
+            "(PumpSwap/Raydium); it cannot be traded on the bonding curve");
+    }
+    if (info.data.length < legacyLen + 32) {
+        throw new Error("legacy pump.fun bonding curve (pre-creator layout, never extended) — " +
+            "the account needs pump.fun extend_account before modern swaps can run");
+    }
+    return new web3.PublicKey(info.data.slice(legacyLen, legacyLen + 32));
 }
 /**
  * Resolve everything a pump.fun swap needs for one mint. Run this server-side

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from "./types.js";
 export { createContext, type CreateContextParams, type TenantInit, type ZeroBlockContext, } from "./context.js";
 export { buildSendTransactionRequest, createLandingClient, withLandingTip, type LandingClient, type LandingServiceConfig, type SendTransactionOptions, } from "./landing.js";
 export { fetchRecentBlockhash, type FetchBlockhashOptions, type RecentBlockhash, } from "./blockhash.js";
+export { zeroblockFetcher, fetchTokenBalanceViaZeroblock, fetchLookupTableViaZeroblock, type ZeroblockReadOptions, type ZeroblockTokenBalance, } from "./zeroblock.js";
 export { toPk, deriveAta, deriveOrderMarker, deriveWrapperConfig, deriveRouterGlobalConfig, deriveRouterTenantConfig, derivePumpfunGlobal, derivePumpfunBondingCurve, derivePumpfunBondingCurveV2, derivePumpfunEventAuthority, derivePumpfunCreatorVault, derivePumpfunGlobalVolumeAccumulator, derivePumpfunUserVolumeAccumulator, derivePumpfunFeeConfig, } from "./pda.js";
 export { type AccountFetcher, connectionFetcher, resolveTokenProgram, resolvePumpfunMarketContext, fetchPumpfunGlobalFeeRecipient, fetchPumpfunBondingCurveCreator, fetchPumpfunBuybackFeeRecipients, } from "./fetch.js";
 export { buildPumpfunRemainingAccounts, type PumpfunRemainingAccountsParams, } from "./venues/pumpfun.js";

package/dist/index.js

@@ -16,6 +16,7 @@ export * from "./types.js";
 export { createContext, } from "./context.js";
 export { buildSendTransactionRequest, createLandingClient, withLandingTip, } from "./landing.js";
 export { fetchRecentBlockhash, } from "./blockhash.js";
+export { zeroblockFetcher, fetchTokenBalanceViaZeroblock, fetchLookupTableViaZeroblock, } from "./zeroblock.js";
 export { toPk, deriveAta, deriveOrderMarker, deriveWrapperConfig, deriveRouterGlobalConfig, deriveRouterTenantConfig, derivePumpfunGlobal, derivePumpfunBondingCurve, derivePumpfunBondingCurveV2, derivePumpfunEventAuthority, derivePumpfunCreatorVault, derivePumpfunGlobalVolumeAccumulator, derivePumpfunUserVolumeAccumulator, derivePumpfunFeeConfig, } from "./pda.js";
 export { connectionFetcher, resolveTokenProgram, resolvePumpfunMarketContext, fetchPumpfunGlobalFeeRecipient, fetchPumpfunBondingCurveCreator, fetchPumpfunBuybackFeeRecipients, } from "./fetch.js";
 export { buildPumpfunRemainingAccounts, } from "./venues/pumpfun.js";

package/dist/zeroblock.d.ts

@@ -0,0 +1,31 @@
+import type { AccountFetcher } from "./fetch.js";
+import type { Address, LookupTableData } from "./types.js";
+export interface ZeroblockReadOptions {
+    /** Injectable fetch (tests / non-standard runtimes). Defaults to global fetch. */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * An {@link AccountFetcher} backed by 0Block's read gateway instead of a
+ * web3.js Connection. Coalesces every getAccountInfo issued in the same
+ * microtask into ONE getMultipleAccounts round-trip (the market resolver reads
+ * ~4 accounts concurrently → a single request), and dedupes repeated addresses.
+ */
+export declare function zeroblockFetcher(apiBaseUrl: string, opts?: ZeroblockReadOptions): AccountFetcher;
+export interface ZeroblockTokenBalance {
+    /** Raw base-unit balance (summed across the owner's token accounts), integer string. */
+    amountBaseUnits: string;
+    decimals: number;
+}
+/**
+ * The SPL token balance of `owner` for `mint`, via 0Block's
+ * getTokenAccountsByOwner proxy. Returns a ZERO balance (not an error) when the
+ * owner holds no token account for the mint — a legitimate "nothing to sell"
+ * state. Sums across multiple token accounts (rare multi-ATA case).
+ */
+export declare function fetchTokenBalanceViaZeroblock(apiBaseUrl: string, owner: Address, mint: Address, opts?: ZeroblockReadOptions): Promise<ZeroblockTokenBalance>;
+/**
+ * Fetch and decode an Address Lookup Table via 0Block's accounts proxy —
+ * returns the table key + its stored addresses (base58), ready to pass as a
+ * {@link LookupTableData}. Returns null when the table account does not exist.
+ */
+export declare function fetchLookupTableViaZeroblock(apiBaseUrl: string, tableAddress: Address, opts?: ZeroblockReadOptions): Promise<LookupTableData | null>;

package/dist/zeroblock.js

@@ -0,0 +1,131 @@
+// 0Block READ GATEWAY client. Lets a browser build swap transactions with NO
+// Solana RPC of its own: 0Block proxies the handful of read methods a swap
+// needs (getMultipleAccounts, getTokenAccountsByOwner) to its OWN upstream RPC
+// node and returns the standard JSON-RPC `result` verbatim. This module speaks
+// that gateway and adapts it to the SDK's AccountFetcher seam, so the pump.fun
+// market resolver, ALT decode, and balance reads all work unchanged — just
+// sourced from 0Block instead of web3.js.
+//
+// Endpoints (all public, no API key — the data is public on-chain):
+//   POST {base}/api/v1/accounts        { addresses:[<b58>...] } -> RPC getMultipleAccounts result
+//   GET  {base}/api/v1/token-accounts?owner=<b58>&mint=<b58>    -> RPC getTokenAccountsByOwner result
+import * as web3 from "@solana/web3.js";
+import { toPk } from "./pda.js";
+/** Strip trailing slashes so `${base}/api/v1/...` is always well-formed. */
+function normalizeBase(apiBaseUrl) {
+    return apiBaseUrl.replace(/\/+$/, "");
+}
+/**
+ * Fetch raw account infos for `addresses` (order-preserving) via 0Block's
+ * getMultipleAccounts proxy. Missing accounts come back as null.
+ */
+async function fetchAccountsRaw(base, addresses, fetchImpl) {
+    const res = await fetchImpl(`${base}/api/v1/accounts`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ addresses }),
+    });
+    if (!res.ok) {
+        throw new Error(`0Block accounts unavailable (HTTP ${res.status})`);
+    }
+    const body = (await res.json());
+    if (body.error) {
+        throw new Error(`0Block accounts error: ${body.error.message ?? "unknown"}`);
+    }
+    const value = body.value ?? [];
+    return addresses.map((_, i) => {
+        const acct = value[i];
+        if (!acct || acct.data === undefined)
+            return null;
+        const b64 = Array.isArray(acct.data) ? acct.data[0] : acct.data;
+        return {
+            data: new Uint8Array(Buffer.from(b64, "base64")),
+            owner: new web3.PublicKey(acct.owner ?? web3.PublicKey.default.toBase58()),
+        };
+    });
+}
+/**
+ * An {@link AccountFetcher} backed by 0Block's read gateway instead of a
+ * web3.js Connection. Coalesces every getAccountInfo issued in the same
+ * microtask into ONE getMultipleAccounts round-trip (the market resolver reads
+ * ~4 accounts concurrently → a single request), and dedupes repeated addresses.
+ */
+export function zeroblockFetcher(apiBaseUrl, opts) {
+    const base = normalizeBase(apiBaseUrl);
+    const fetchImpl = opts?.fetchImpl ?? fetch;
+    let queue = [];
+    let scheduled = false;
+    const flush = async () => {
+        const batch = queue;
+        queue = [];
+        scheduled = false;
+        const unique = [...new Set(batch.map((p) => p.address.toBase58()))];
+        try {
+            const infos = await fetchAccountsRaw(base, unique, fetchImpl);
+            const byAddr = new Map(unique.map((a, i) => [a, infos[i]]));
+            for (const p of batch)
+                p.resolve(byAddr.get(p.address.toBase58()) ?? null);
+        }
+        catch (err) {
+            for (const p of batch)
+                p.reject(err);
+        }
+    };
+    return {
+        getAccountInfo(address) {
+            return new Promise((resolve, reject) => {
+                queue.push({ address, resolve, reject });
+                if (!scheduled) {
+                    scheduled = true;
+                    queueMicrotask(() => void flush());
+                }
+            });
+        },
+    };
+}
+/**
+ * The SPL token balance of `owner` for `mint`, via 0Block's
+ * getTokenAccountsByOwner proxy. Returns a ZERO balance (not an error) when the
+ * owner holds no token account for the mint — a legitimate "nothing to sell"
+ * state. Sums across multiple token accounts (rare multi-ATA case).
+ */
+export async function fetchTokenBalanceViaZeroblock(apiBaseUrl, owner, mint, opts) {
+    const base = normalizeBase(apiBaseUrl);
+    const fetchImpl = opts?.fetchImpl ?? fetch;
+    const ownerB58 = toPk(owner).toBase58();
+    const mintB58 = toPk(mint).toBase58();
+    const res = await fetchImpl(`${base}/api/v1/token-accounts?owner=${ownerB58}&mint=${mintB58}`);
+    if (!res.ok) {
+        throw new Error(`0Block token balance unavailable (HTTP ${res.status})`);
+    }
+    const body = (await res.json());
+    if (body.error) {
+        throw new Error(`0Block token balance error: ${body.error.message ?? "unknown"}`);
+    }
+    let total = 0n;
+    let decimals = 0;
+    for (const acct of body.value ?? []) {
+        const tokenAmount = acct.account?.data?.parsed?.info?.tokenAmount;
+        if (!tokenAmount || typeof tokenAmount.amount !== "string")
+            continue;
+        total += BigInt(tokenAmount.amount);
+        if (typeof tokenAmount.decimals === "number")
+            decimals = tokenAmount.decimals;
+    }
+    return { amountBaseUnits: total.toString(), decimals };
+}
+/**
+ * Fetch and decode an Address Lookup Table via 0Block's accounts proxy —
+ * returns the table key + its stored addresses (base58), ready to pass as a
+ * {@link LookupTableData}. Returns null when the table account does not exist.
+ */
+export async function fetchLookupTableViaZeroblock(apiBaseUrl, tableAddress, opts) {
+    const base = normalizeBase(apiBaseUrl);
+    const fetchImpl = opts?.fetchImpl ?? fetch;
+    const keyB58 = toPk(tableAddress).toBase58();
+    const [info] = await fetchAccountsRaw(base, [keyB58], fetchImpl);
+    if (!info)
+        return null;
+    const state = web3.AddressLookupTableAccount.deserialize(info.data);
+    return { key: keyB58, addresses: state.addresses.map((a) => a.toBase58()) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0block.io/sdk",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "Client-side transaction builder for the 0Block DEX router. Builds unsigned v0 swap transactions entirely offline \u2014 tenant-wrapped or direct \u2014 with shared address lookup tables, gateway tips, and on-chain fee-event decoding for accounting.",
   "keywords": [
     "solana",