@oobe-protocol-labs/synapse-client-sdk 1.0.1 → 1.0.3

package/CHANGELOG.md

@@ -7,6 +7,66 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.0.3] — 2026-02-27
+
+### Added
+- **Native Solana account data decoders** (`src/decoders/`) — zero-dependency binary decoders
+  verified field-by-field against official Solana source code (`solana-program/token`, `anza-xyz/agave`).
+  - `AccountReader` — DataView-based binary reader with LE byte order, COption (C ABI) support.
+  - `decodeTokenAccount` — SPL Token Account (165 bytes): mint, owner, amount, delegate, state,
+    isNative, delegatedAmount, closeAuthority.
+  - `decodeMint` — SPL Token Mint (82 bytes): mintAuthority, supply, decimals, isInitialized,
+    freezeAuthority.
+  - `decodeToken2022Account` / `decodeToken2022Mint` — Token Extensions with TLV parser
+    (TransferFeeConfig, MintCloseAuthority, MetadataPointer, ImmutableOwner, MemoTransfer, etc.).
+  - `decodeStakeAccount` — Stake program (200 bytes): Meta (authorized + lockup) + Delegation
+    (voterPubkey, stake, activationEpoch, deactivationEpoch, warmupCooldownRate) + creditsObserved.
+  - `decodeNonceAccount` — Durable nonce (80 bytes): version, state, authority, blockhash,
+    lamportsPerSignature.
+  - `decodeLookupTable` — Address Lookup Table (56-byte header + N×32 addresses):
+    deactivationSlot, lastExtendedSlot, authority, addresses.
+  - `decodeMultisig` — SPL Multisig (355 bytes): m, n, isInitialized, signers[11].
+  - `encodeBase58` — self-contained base58 encoder (no external dependencies).
+- **Typed account fetchers** (`src/accounts/`) — high-level account fetching with automatic
+  decoding wired into `SynapseClient`.
+  - `AccountsClient` class accessible via `client.accounts`.
+  - `fetchTokenAccount` / `fetchMint` — auto-detects Token vs Token-2022 by program owner.
+  - `fetchTokenAccountsByOwner` — batch fetch all token accounts for a wallet.
+  - `fetchStakeAccount` / `fetchNonceAccount` / `fetchLookupTable`.
+  - `getDecodedAccount<T>` / `getDecodedAccounts<T>` generic helpers.
+- **Sub-path exports** — `./decoders` and `./accounts` added to `package.json` exports map.
+- **37 new unit tests** for all decoders with hand-crafted byte buffers (415 total, all passing).
+
+---
+
+## [1.0.2] — 2026-02-26
+
+### Added
+- **@solana/kit bridge module** (`src/kit/index.ts`) — curated re-exports and bridge utilities
+  between Synapse branded types and `@solana/kit` v6 native types.
+  - `toKitAddress` / `fromKitAddress` for `Pubkey` ↔ `Address` conversion.
+  - `toKitSignatureString` / `toKitLamports` for `Signature` & `Lamports`.
+  - Re-exports: `Address`, `KeyPairSigner`, `createSolanaRpc`, `pipe`, codecs, account helpers.
+- **`kitRpc` / `kitSubscriptions`** lazy accessors on `SynapseClient` — gives consumers direct
+  access to `@solana/kit`-native `Rpc<SolanaRpcApi>` and `RpcSubscriptions<SolanaRpcSubscriptionsApi>`
+  backed by the same endpoint.
+- **`./kit` sub-path export** in `package.json` — `import { Address, toKitAddress } from '@oobe-protocol-labs/synapse-client-sdk/kit'`.
+
+### Fixed
+- **Critical: `@/` path aliases leaking into compiled output** — TypeScript `paths` aliases were
+  not rewritten by `tsc`, causing `@/core/types` imports in `dist/cjs` and `dist/esm` that
+  Webpack, Next.js, Vite, and other bundlers could not resolve. Converted all 9 `@/` imports to
+  relative paths and removed the `paths` block from `tsconfig.json` to prevent regression.
+- **ESM directory imports broken** — the post-build `fix-esm-imports.mjs` script blindly appended
+  `.js` to all bare specifiers, producing `./tools.js` instead of `./tools/index.js` for directory
+  re-exports (`tools/`, `protocols/`, `zod/`, `jupiter/`, `raydium/`, `metaplex/`, `x402/`).
+  Rewrote the script with filesystem-aware resolution using `existsSync`.
+- **`@langchain/core` peer dependency too permissive** — the open-ended `>=0.3.0` range could
+  resolve `@langchain/core@1.x`, which is incompatible with `@langchain/openai@0.5.x`. Tightened
+  to `>=0.3.0 <0.4.0`. Also updated `zod` peerDep to `>=3.23.0 || >=4.0.0`.
+
+---
+
 ## [1.0.1] — 2025-07-15
 
 ### Added
@@ -56,5 +116,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+[1.0.2]: https://github.com/oobe-protocol-labs/synapse-client-sdk/compare/v1.0.1...v1.0.2
 [1.0.1]: https://github.com/oobe-protocol-labs/synapse-client-sdk/compare/v1.0.0-beta...v1.0.1
 [1.0.0-beta]: https://github.com/oobe-protocol-labs/synapse-client-sdk/releases/tag/v1.0.0-beta

package/dist/cjs/accounts/helpers.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Generic decoded account fetcher utilities.
+ *
+ * Provides a reusable pattern for fetching raw account data via RPC
+ * and decoding it with a typed decoder function.
+ *
+ * @module accounts/helpers
+ * @since 1.1.0
+ */
+import type { HttpTransport, CallOptions } from '../core/transport';
+import type { Pubkey, Commitment } from '../core/types';
+/** @internal Minimal account info from base64-encoded RPC response. */
+interface RawAccountInfo {
+    data: [string, string] | string;
+    executable: boolean;
+    lamports: number;
+    owner: string;
+    rentEpoch: number;
+    space: number;
+}
+/**
+ * Result of a decoded account fetch.
+ *
+ * @typeParam T - The decoded account type.
+ * @since 1.1.0
+ */
+export interface DecodedAccountResult<T> {
+    /** Decoded account data. */
+    decoded: T;
+    /** Raw account info as returned by the RPC (base64 encoding). */
+    raw: RawAccountInfo;
+    /** Slot at which the data was fetched. */
+    slot: number;
+}
+/**
+ * Base64-decode a Solana RPC account data field.
+ *
+ * The RPC returns account data as `[base64String, "base64"]` when
+ * `encoding: "base64"` is used.
+ *
+ * @param data - The raw data field from getAccountInfo.
+ * @returns Decoded Uint8Array.
+ * @since 1.1.0
+ */
+export declare function base64ToBytes(data: [string, string] | string | unknown): Uint8Array;
+/**
+ * Fetch a raw account and decode its data using the provided decoder.
+ *
+ * This is the core building block for all typed account fetchers.
+ * It handles the RPC call, base64 decoding, and applies the decoder.
+ *
+ * @typeParam T - The decoded account type.
+ * @param transport - HTTP transport for RPC calls.
+ * @param pubkey - Account public key to fetch.
+ * @param decoder - Function that decodes raw bytes into type T.
+ * @param opts - RPC options (commitment, call overrides).
+ * @returns Decoded result, or `null` if the account doesn't exist.
+ *
+ * @example
+ * ```ts
+ * import { getDecodedAccount } from '@oobe-protocol-labs/synapse-client-sdk/accounts';
+ * import { decodeTokenAccount } from '@oobe-protocol-labs/synapse-client-sdk/decoders';
+ *
+ * const result = await getDecodedAccount(transport, pubkey, decodeTokenAccount);
+ * if (result) console.log(`Amount: ${result.decoded.amount}`);
+ * ```
+ *
+ * @since 1.1.0
+ */
+export declare function getDecodedAccount<T>(transport: HttpTransport, pubkey: Pubkey, decoder: (data: Uint8Array) => T, opts?: {
+    commitment?: Commitment;
+} & CallOptions): Promise<DecodedAccountResult<T> | null>;
+/**
+ * Fetch multiple accounts and decode them in batch (single RPC call).
+ *
+ * @typeParam T - The decoded account type.
+ * @param transport - HTTP transport for RPC calls.
+ * @param pubkeys - Account public keys to fetch.
+ * @param decoder - Function that decodes raw bytes into type T.
+ * @param opts - RPC options.
+ * @returns Array of decoded results (null entries for non-existent accounts).
+ * @since 1.1.0
+ */
+export declare function getDecodedAccounts<T>(transport: HttpTransport, pubkeys: Pubkey[], decoder: (data: Uint8Array) => T, opts?: {
+    commitment?: Commitment;
+} & CallOptions): Promise<(DecodedAccountResult<T> | null)[]>;
+export {};
+//# sourceMappingURL=helpers.d.ts.map

package/dist/cjs/accounts/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/accounts/helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAQ,MAAM,eAAe,CAAC;AAU9D,uEAAuE;AACvE,UAAU,cAAc;IACtB,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC;IAChC,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAID;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC;IACrC,4BAA4B;IAC5B,OAAO,EAAE,CAAC,CAAC;IACX,iEAAiE;IACjE,GAAG,EAAE,cAAc,CAAC;IACpB,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;CACd;AAID;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,GAAG,OAAO,GAAG,UAAU,CAoBnF;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EACvC,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,CAAC,EAChC,IAAI,GAAE;IAAE,UAAU,CAAC,EAAE,UAAU,CAAA;CAAE,GAAG,WAAgB,GACnD,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAqBzC;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,CAAC,CAAC,EACxC,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,CAAC,EAChC,IAAI,GAAE;IAAE,UAAU,CAAC,EAAE,UAAU,CAAA;CAAE,GAAG,WAAgB,GACnD,OAAO,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,CAoB7C"}

package/dist/cjs/accounts/helpers.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * Generic decoded account fetcher utilities.
+ *
+ * Provides a reusable pattern for fetching raw account data via RPC
+ * and decoding it with a typed decoder function.
+ *
+ * @module accounts/helpers
+ * @since 1.1.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64ToBytes = base64ToBytes;
+exports.getDecodedAccount = getDecodedAccount;
+exports.getDecodedAccounts = getDecodedAccounts;
+// ── Base64 decoding ────────────────────────────────────────────
+/**
+ * Base64-decode a Solana RPC account data field.
+ *
+ * The RPC returns account data as `[base64String, "base64"]` when
+ * `encoding: "base64"` is used.
+ *
+ * @param data - The raw data field from getAccountInfo.
+ * @returns Decoded Uint8Array.
+ * @since 1.1.0
+ */
+function base64ToBytes(data) {
+    let b64;
+    if (Array.isArray(data) && typeof data[0] === 'string') {
+        b64 = data[0];
+    }
+    else if (typeof data === 'string') {
+        b64 = data;
+    }
+    else {
+        throw new Error('Unexpected account data format: expected [base64, "base64"] or string');
+    }
+    // Node.js Buffer path (fast)
+    if (typeof Buffer !== 'undefined') {
+        return new Uint8Array(Buffer.from(b64, 'base64'));
+    }
+    // Browser / edge path
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+        bytes[i] = binary.charCodeAt(i);
+    return bytes;
+}
+// ── Core fetcher ───────────────────────────────────────────────
+/**
+ * Fetch a raw account and decode its data using the provided decoder.
+ *
+ * This is the core building block for all typed account fetchers.
+ * It handles the RPC call, base64 decoding, and applies the decoder.
+ *
+ * @typeParam T - The decoded account type.
+ * @param transport - HTTP transport for RPC calls.
+ * @param pubkey - Account public key to fetch.
+ * @param decoder - Function that decodes raw bytes into type T.
+ * @param opts - RPC options (commitment, call overrides).
+ * @returns Decoded result, or `null` if the account doesn't exist.
+ *
+ * @example
+ * ```ts
+ * import { getDecodedAccount } from '@oobe-protocol-labs/synapse-client-sdk/accounts';
+ * import { decodeTokenAccount } from '@oobe-protocol-labs/synapse-client-sdk/decoders';
+ *
+ * const result = await getDecodedAccount(transport, pubkey, decodeTokenAccount);
+ * if (result) console.log(`Amount: ${result.decoded.amount}`);
+ * ```
+ *
+ * @since 1.1.0
+ */
+async function getDecodedAccount(transport, pubkey, decoder, opts = {}) {
+    const { commitment, ...callOpts } = opts;
+    const cfg = { encoding: 'base64' };
+    if (commitment)
+        cfg.commitment = commitment;
+    const result = await transport.request('getAccountInfo', [pubkey, cfg], callOpts);
+    if (!result.value)
+        return null;
+    const bytes = base64ToBytes(result.value.data);
+    const decoded = decoder(bytes);
+    return {
+        decoded,
+        raw: result.value,
+        slot: result.context.slot,
+    };
+}
+/**
+ * Fetch multiple accounts and decode them in batch (single RPC call).
+ *
+ * @typeParam T - The decoded account type.
+ * @param transport - HTTP transport for RPC calls.
+ * @param pubkeys - Account public keys to fetch.
+ * @param decoder - Function that decodes raw bytes into type T.
+ * @param opts - RPC options.
+ * @returns Array of decoded results (null entries for non-existent accounts).
+ * @since 1.1.0
+ */
+async function getDecodedAccounts(transport, pubkeys, decoder, opts = {}) {
+    const { commitment, ...callOpts } = opts;
+    const cfg = { encoding: 'base64' };
+    if (commitment)
+        cfg.commitment = commitment;
+    const result = await transport.request('getMultipleAccounts', [pubkeys, cfg], callOpts);
+    return result.value.map((acct) => {
+        if (!acct)
+            return null;
+        const bytes = base64ToBytes(acct.data);
+        return {
+            decoded: decoder(bytes),
+            raw: acct,
+            slot: result.context.slot,
+        };
+    });
+}
+//# sourceMappingURL=helpers.js.map

package/dist/cjs/accounts/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../src/accounts/helpers.ts"],"names":[],"mappings":"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"}

package/dist/cjs/accounts/index.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Typed account fetchers with built-in decoding.
+ *
+ * Provides high-level methods that fetch raw account data via RPC
+ * and return fully decoded, typed objects. This is the "batteries-included"
+ * layer that eliminates manual base64 decoding and byte layout parsing.
+ *
+ * @module accounts
+ * @since 1.1.0
+ *
+ * @example
+ * ```ts
+ * const client = new SynapseClient({ endpoint: '...' });
+ *
+ * // One call, fully decoded:
+ * const mint = await client.accounts.fetchMint(mintPubkey);
+ * console.log(`Supply: ${mint.decoded.supply}, Decimals: ${mint.decoded.decimals}`);
+ *
+ * const acct = await client.accounts.fetchTokenAccount(tokenPubkey);
+ * console.log(`Balance: ${acct.decoded.amount}`);
+ * ```
+ */
+import type { HttpTransport, CallOptions } from '../core/transport';
+import type { Pubkey, Commitment } from '../core/types';
+export { fetchTokenAccount, fetchMint, fetchTokenAccountsByOwner } from './token';
+export { fetchStakeAccount } from './stake';
+export { fetchNonceAccount } from './nonce';
+export { fetchLookupTable } from './lookup';
+export { getDecodedAccount, getDecodedAccounts, base64ToBytes } from './helpers';
+export type { DecodedAccountResult } from './helpers';
+export type { FetchedTokenAccount, FetchedMint } from './token';
+/** Options for account fetch methods. @since 1.1.0 */
+export type AccountFetchOpts = {
+    commitment?: Commitment;
+} & CallOptions;
+/**
+ * High-level accounts client with decoded fetch methods.
+ *
+ * Exposed as `client.accounts` on {@link SynapseClient}. Each method
+ * fetches raw data, base64-decodes it, and runs the appropriate native
+ * decoder — returning a fully typed object.
+ *
+ * @since 1.1.0
+ */
+export declare class AccountsClient {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    /**
+     * Fetch and decode a single SPL Token account.
+     * Auto-detects Token vs Token-2022 and includes extensions.
+     * @since 1.1.0
+     */
+    fetchTokenAccount(pubkey: Pubkey, opts?: AccountFetchOpts): Promise<import("./token").FetchedTokenAccount | null>;
+    /**
+     * Fetch and decode a token mint.
+     * Auto-detects Token vs Token-2022 and includes extensions.
+     * @since 1.1.0
+     */
+    fetchMint(pubkey: Pubkey, opts?: AccountFetchOpts): Promise<import("./token").FetchedMint | null>;
+    /**
+     * Fetch all token accounts owned by a wallet, optionally filtered by mint.
+     * @since 1.1.0
+     */
+    fetchTokenAccountsByOwner(owner: Pubkey, mint?: Pubkey, opts?: AccountFetchOpts & {
+        programId?: Pubkey;
+    }): Promise<import("./token").FetchedTokenAccount[]>;
+    /**
+     * Fetch and decode a stake account.
+     * @since 1.1.0
+     */
+    fetchStakeAccount(pubkey: Pubkey, opts?: AccountFetchOpts): Promise<import("./helpers").DecodedAccountResult<import("..").DecodedStakeAccount> | null>;
+    /**
+     * Fetch and decode a durable nonce account.
+     * @since 1.1.0
+     */
+    fetchNonceAccount(pubkey: Pubkey, opts?: AccountFetchOpts): Promise<import("./helpers").DecodedAccountResult<import("..").DecodedNonceAccount> | null>;
+    /**
+     * Fetch and decode an Address Lookup Table.
+     * @since 1.1.0
+     */
+    fetchLookupTable(pubkey: Pubkey, opts?: AccountFetchOpts): Promise<import("./helpers").DecodedAccountResult<import("..").DecodedLookupTable> | null>;
+    /**
+     * Fetch any account and decode it with a custom decoder function.
+     *
+     * @typeParam T - The decoded type.
+     * @param pubkey - Account public key.
+     * @param decoder - Custom decoder function `(data: Uint8Array) => T`.
+     * @param opts - RPC options.
+     * @returns Decoded result or null.
+     * @since 1.1.0
+     */
+    fetchDecoded<T>(pubkey: Pubkey, decoder: (data: Uint8Array) => T, opts?: AccountFetchOpts): Promise<import("./helpers").DecodedAccountResult<T> | null>;
+    /**
+     * Fetch multiple accounts and decode them with a custom decoder (single RPC call).
+     *
+     * @typeParam T - The decoded type.
+     * @param pubkeys - Account public keys.
+     * @param decoder - Custom decoder function.
+     * @param opts - RPC options.
+     * @returns Array of decoded results (null for non-existent).
+     * @since 1.1.0
+     */
+    fetchDecodedBatch<T>(pubkeys: Pubkey[], decoder: (data: Uint8Array) => T, opts?: AccountFetchOpts): Promise<(import("./helpers").DecodedAccountResult<T> | null)[]>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/accounts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/accounts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAQxD,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AACjF,YAAY,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AACtD,YAAY,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEhE,sDAAsD;AACtD,MAAM,MAAM,gBAAgB,GAAG;IAAE,UAAU,CAAC,EAAE,UAAU,CAAA;CAAE,GAAG,WAAW,CAAC;AAEzE;;;;;;;;GAQG;AACH,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,aAAa;IAIrD;;;;OAIG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB;IAIzD;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB;IAIjD;;;OAGG;IACH,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;IAMxG;;;OAGG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB;IAMzD;;;OAGG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB;IAMzD;;;OAGG;IACH,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB;IAMxD;;;;;;;;;OASG;IACH,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,CAAC,EAAE,IAAI,CAAC,EAAE,gBAAgB;IAIzF;;;;;;;;;OASG;IACH,iBAAiB,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,CAAC,EAAE,IAAI,CAAC,EAAE,gBAAgB;CAGlG"}

package/dist/cjs/accounts/index.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * Typed account fetchers with built-in decoding.
+ *
+ * Provides high-level methods that fetch raw account data via RPC
+ * and return fully decoded, typed objects. This is the "batteries-included"
+ * layer that eliminates manual base64 decoding and byte layout parsing.
+ *
+ * @module accounts
+ * @since 1.1.0
+ *
+ * @example
+ * ```ts
+ * const client = new SynapseClient({ endpoint: '...' });
+ *
+ * // One call, fully decoded:
+ * const mint = await client.accounts.fetchMint(mintPubkey);
+ * console.log(`Supply: ${mint.decoded.supply}, Decimals: ${mint.decoded.decimals}`);
+ *
+ * const acct = await client.accounts.fetchTokenAccount(tokenPubkey);
+ * console.log(`Balance: ${acct.decoded.amount}`);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountsClient = exports.base64ToBytes = exports.getDecodedAccounts = exports.getDecodedAccount = exports.fetchLookupTable = exports.fetchNonceAccount = exports.fetchStakeAccount = exports.fetchTokenAccountsByOwner = exports.fetchMint = exports.fetchTokenAccount = void 0;
+const token_1 = require("./token");
+const stake_1 = require("./stake");
+const nonce_1 = require("./nonce");
+const lookup_1 = require("./lookup");
+const helpers_1 = require("./helpers");
+// ── Re-export individual fetchers for tree-shaking ─────────────
+var token_2 = require("./token");
+Object.defineProperty(exports, "fetchTokenAccount", { enumerable: true, get: function () { return token_2.fetchTokenAccount; } });
+Object.defineProperty(exports, "fetchMint", { enumerable: true, get: function () { return token_2.fetchMint; } });
+Object.defineProperty(exports, "fetchTokenAccountsByOwner", { enumerable: true, get: function () { return token_2.fetchTokenAccountsByOwner; } });
+var stake_2 = require("./stake");
+Object.defineProperty(exports, "fetchStakeAccount", { enumerable: true, get: function () { return stake_2.fetchStakeAccount; } });
+var nonce_2 = require("./nonce");
+Object.defineProperty(exports, "fetchNonceAccount", { enumerable: true, get: function () { return nonce_2.fetchNonceAccount; } });
+var lookup_2 = require("./lookup");
+Object.defineProperty(exports, "fetchLookupTable", { enumerable: true, get: function () { return lookup_2.fetchLookupTable; } });
+var helpers_2 = require("./helpers");
+Object.defineProperty(exports, "getDecodedAccount", { enumerable: true, get: function () { return helpers_2.getDecodedAccount; } });
+Object.defineProperty(exports, "getDecodedAccounts", { enumerable: true, get: function () { return helpers_2.getDecodedAccounts; } });
+Object.defineProperty(exports, "base64ToBytes", { enumerable: true, get: function () { return helpers_2.base64ToBytes; } });
+/**
+ * High-level accounts client with decoded fetch methods.
+ *
+ * Exposed as `client.accounts` on {@link SynapseClient}. Each method
+ * fetches raw data, base64-decodes it, and runs the appropriate native
+ * decoder — returning a fully typed object.
+ *
+ * @since 1.1.0
+ */
+class AccountsClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    // ── Token ────────────────────────────────────────────────────
+    /**
+     * Fetch and decode a single SPL Token account.
+     * Auto-detects Token vs Token-2022 and includes extensions.
+     * @since 1.1.0
+     */
+    fetchTokenAccount(pubkey, opts) {
+        return (0, token_1.fetchTokenAccount)(this.transport, pubkey, opts);
+    }
+    /**
+     * Fetch and decode a token mint.
+     * Auto-detects Token vs Token-2022 and includes extensions.
+     * @since 1.1.0
+     */
+    fetchMint(pubkey, opts) {
+        return (0, token_1.fetchMint)(this.transport, pubkey, opts);
+    }
+    /**
+     * Fetch all token accounts owned by a wallet, optionally filtered by mint.
+     * @since 1.1.0
+     */
+    fetchTokenAccountsByOwner(owner, mint, opts) {
+        return (0, token_1.fetchTokenAccountsByOwner)(this.transport, owner, mint, opts);
+    }
+    // ── Stake ────────────────────────────────────────────────────
+    /**
+     * Fetch and decode a stake account.
+     * @since 1.1.0
+     */
+    fetchStakeAccount(pubkey, opts) {
+        return (0, stake_1.fetchStakeAccount)(this.transport, pubkey, opts);
+    }
+    // ── Nonce ────────────────────────────────────────────────────
+    /**
+     * Fetch and decode a durable nonce account.
+     * @since 1.1.0
+     */
+    fetchNonceAccount(pubkey, opts) {
+        return (0, nonce_1.fetchNonceAccount)(this.transport, pubkey, opts);
+    }
+    // ── Lookup Table ─────────────────────────────────────────────
+    /**
+     * Fetch and decode an Address Lookup Table.
+     * @since 1.1.0
+     */
+    fetchLookupTable(pubkey, opts) {
+        return (0, lookup_1.fetchLookupTable)(this.transport, pubkey, opts);
+    }
+    // ── Generic ──────────────────────────────────────────────────
+    /**
+     * Fetch any account and decode it with a custom decoder function.
+     *
+     * @typeParam T - The decoded type.
+     * @param pubkey - Account public key.
+     * @param decoder - Custom decoder function `(data: Uint8Array) => T`.
+     * @param opts - RPC options.
+     * @returns Decoded result or null.
+     * @since 1.1.0
+     */
+    fetchDecoded(pubkey, decoder, opts) {
+        return (0, helpers_1.getDecodedAccount)(this.transport, pubkey, decoder, opts);
+    }
+    /**
+     * Fetch multiple accounts and decode them with a custom decoder (single RPC call).
+     *
+     * @typeParam T - The decoded type.
+     * @param pubkeys - Account public keys.
+     * @param decoder - Custom decoder function.
+     * @param opts - RPC options.
+     * @returns Array of decoded results (null for non-existent).
+     * @since 1.1.0
+     */
+    fetchDecodedBatch(pubkeys, decoder, opts) {
+        return (0, helpers_1.getDecodedAccounts)(this.transport, pubkeys, decoder, opts);
+    }
+}
+exports.AccountsClient = AccountsClient;
+//# sourceMappingURL=index.js.map

package/dist/cjs/accounts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/accounts/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;;;AAIH,mCAAkF;AAClF,mCAA4C;AAC5C,mCAA4C;AAC5C,qCAA4C;AAC5C,uCAAkE;AAElE,kEAAkE;AAClE,iCAAkF;AAAzE,0GAAA,iBAAiB,OAAA;AAAE,kGAAA,SAAS,OAAA;AAAE,kHAAA,yBAAyB,OAAA;AAChE,iCAA4C;AAAnC,0GAAA,iBAAiB,OAAA;AAC1B,iCAA4C;AAAnC,0GAAA,iBAAiB,OAAA;AAC1B,mCAA4C;AAAnC,0GAAA,gBAAgB,OAAA;AACzB,qCAAiF;AAAxE,4GAAA,iBAAiB,OAAA;AAAE,6GAAA,kBAAkB,OAAA;AAAE,wGAAA,aAAa,OAAA;AAO7D;;;;;;;;GAQG;AACH,MAAa,cAAc;IACI;IAA7B,YAA6B,SAAwB;QAAxB,cAAS,GAAT,SAAS,CAAe;IAAG,CAAC;IAEzD,gEAAgE;IAEhE;;;;OAIG;IACH,iBAAiB,CAAC,MAAc,EAAE,IAAuB;QACvD,OAAO,IAAA,yBAAiB,EAAC,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IACzD,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,MAAc,EAAE,IAAuB;QAC/C,OAAO,IAAA,iBAAS,EAAC,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IACjD,CAAC;IAED;;;OAGG;IACH,yBAAyB,CAAC,KAAa,EAAE,IAAa,EAAE,IAAgD;QACtG,OAAO,IAAA,iCAAyB,EAAC,IAAI,CAAC,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IACtE,CAAC;IAED,gEAAgE;IAEhE;;;OAGG;IACH,iBAAiB,CAAC,MAAc,EAAE,IAAuB;QACvD,OAAO,IAAA,yBAAiB,EAAC,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IACzD,CAAC;IAED,gEAAgE;IAEhE;;;OAGG;IACH,iBAAiB,CAAC,MAAc,EAAE,IAAuB;QACvD,OAAO,IAAA,yBAAiB,EAAC,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IACzD,CAAC;IAED,gEAAgE;IAEhE;;;OAGG;IACH,gBAAgB,CAAC,MAAc,EAAE,IAAuB;QACtD,OAAO,IAAA,yBAAgB,EAAC,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IACxD,CAAC;IAED,gEAAgE;IAEhE;;;;;;;;;OASG;IACH,YAAY,CAAI,MAAc,EAAE,OAAgC,EAAE,IAAuB;QACvF,OAAO,IAAA,2BAAiB,EAAC,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;;;;OASG;IACH,iBAAiB,CAAI,OAAiB,EAAE,OAAgC,EAAE,IAAuB;QAC/F,OAAO,IAAA,4BAAkB,EAAC,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;IACpE,CAAC;CACF;AA1FD,wCA0FC"}

package/dist/cjs/accounts/lookup.d.ts

@@ -0,0 +1,30 @@
+/**
+ * High-level Address Lookup Table fetcher.
+ *
+ * @module accounts/lookup
+ * @since 1.1.0
+ */
+import type { HttpTransport, CallOptions } from '../core/transport';
+import type { Pubkey, Commitment } from '../core/types';
+import type { DecodedLookupTable } from '../decoders/lookup-table';
+import type { DecodedAccountResult } from './helpers';
+/**
+ * Fetch and decode an Address Lookup Table account.
+ *
+ * @param transport - HTTP transport.
+ * @param pubkey - Lookup table account public key.
+ * @param opts - RPC options.
+ * @returns Decoded lookup table, or `null` if not found.
+ *
+ * @example
+ * ```ts
+ * const lut = await fetchLookupTable(transport, lutPubkey);
+ * if (lut) console.log(`Contains ${lut.decoded.addresses.length} addresses`);
+ * ```
+ *
+ * @since 1.1.0
+ */
+export declare function fetchLookupTable(transport: HttpTransport, pubkey: Pubkey, opts?: {
+    commitment?: Commitment;
+} & CallOptions): Promise<DecodedAccountResult<DecodedLookupTable> | null>;
+//# sourceMappingURL=lookup.d.ts.map

package/dist/cjs/accounts/lookup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lookup.d.ts","sourceRoot":"","sources":["../../../src/accounts/lookup.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAExD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAEtD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,MAAM,EACd,IAAI,GAAE;IAAE,UAAU,CAAC,EAAE,UAAU,CAAA;CAAE,GAAG,WAAgB,GACnD,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC,CAE1D"}

package/dist/cjs/accounts/lookup.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * High-level Address Lookup Table fetcher.
+ *
+ * @module accounts/lookup
+ * @since 1.1.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchLookupTable = fetchLookupTable;
+const lookup_table_1 = require("../decoders/lookup-table");
+const helpers_1 = require("./helpers");
+/**
+ * Fetch and decode an Address Lookup Table account.
+ *
+ * @param transport - HTTP transport.
+ * @param pubkey - Lookup table account public key.
+ * @param opts - RPC options.
+ * @returns Decoded lookup table, or `null` if not found.
+ *
+ * @example
+ * ```ts
+ * const lut = await fetchLookupTable(transport, lutPubkey);
+ * if (lut) console.log(`Contains ${lut.decoded.addresses.length} addresses`);
+ * ```
+ *
+ * @since 1.1.0
+ */
+async function fetchLookupTable(transport, pubkey, opts = {}) {
+    return (0, helpers_1.getDecodedAccount)(transport, pubkey, lookup_table_1.decodeLookupTable, opts);
+}
+//# sourceMappingURL=lookup.js.map

package/dist/cjs/accounts/lookup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lookup.js","sourceRoot":"","sources":["../../../src/accounts/lookup.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AAyBH,4CAMC;AA3BD,2DAA6D;AAE7D,uCAA8C;AAG9C;;;;;;;;;;;;;;;GAeG;AACI,KAAK,UAAU,gBAAgB,CACpC,SAAwB,EACxB,MAAc,EACd,OAAkD,EAAE;IAEpD,OAAO,IAAA,2BAAiB,EAAC,SAAS,EAAE,MAAM,EAAE,gCAAiB,EAAE,IAAI,CAAC,CAAC;AACvE,CAAC"}

package/dist/cjs/accounts/nonce.d.ts

@@ -0,0 +1,30 @@
+/**
+ * High-level typed nonce account fetcher.
+ *
+ * @module accounts/nonce
+ * @since 1.1.0
+ */
+import type { HttpTransport, CallOptions } from '../core/transport';
+import type { Pubkey, Commitment } from '../core/types';
+import type { DecodedNonceAccount } from '../decoders/nonce';
+import type { DecodedAccountResult } from './helpers';
+/**
+ * Fetch and decode a Solana nonce account.
+ *
+ * @param transport - HTTP transport.
+ * @param pubkey - Nonce account public key.
+ * @param opts - RPC options.
+ * @returns Decoded nonce account, or `null` if not found.
+ *
+ * @example
+ * ```ts
+ * const nonce = await fetchNonceAccount(transport, noncePubkey);
+ * if (nonce) console.log(`Blockhash: ${nonce.decoded.blockhash}`);
+ * ```
+ *
+ * @since 1.1.0
+ */
+export declare function fetchNonceAccount(transport: HttpTransport, pubkey: Pubkey, opts?: {
+    commitment?: Commitment;
+} & CallOptions): Promise<DecodedAccountResult<DecodedNonceAccount> | null>;
+//# sourceMappingURL=nonce.d.ts.map

package/dist/cjs/accounts/nonce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nonce.d.ts","sourceRoot":"","sources":["../../../src/accounts/nonce.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAExD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAEtD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,MAAM,EACd,IAAI,GAAE;IAAE,UAAU,CAAC,EAAE,UAAU,CAAA;CAAE,GAAG,WAAgB,GACnD,OAAO,CAAC,oBAAoB,CAAC,mBAAmB,CAAC,GAAG,IAAI,CAAC,CAE3D"}