@acta-markets/ts-sdk 0.0.1-beta

package/dist/chain/fetch.d.ts

@@ -0,0 +1,204 @@
+import type { Address } from "@solana/addresses";
+import { createSolanaRpc } from "@solana/rpc";
+import type { Base58EncodedBytes, Commitment } from "@solana/rpc-types";
+import { type Config } from "../generated/accounts/config";
+import { type Market } from "../generated/accounts/market";
+import { type Oracle } from "../generated/accounts/oracle";
+import { type Position } from "../generated/accounts/position";
+import { type Maker } from "../generated/accounts/maker";
+import { Buffer } from "buffer";
+export declare const POSITION_OFFSET_STATUS = 4;
+export declare const POSITION_OFFSET_TAKER_OWNER = 8;
+export declare const POSITION_OFFSET_MAKER_OWNER = 40;
+export declare const POSITION_OFFSET_MARKET = 72;
+export declare const MARKET_OFFSET_UNDERLYING_DECIMALS = 3;
+export declare const MARKET_OFFSET_QUOTE_DECIMALS = 4;
+export declare const MARKET_OFFSET_FLAGS = 5;
+export declare const MARKET_OFFSET_EXPIRY_TS = 8;
+export declare const MARKET_OFFSET_SETTLEMENT_PRICE = 16;
+export declare const MARKET_OFFSET_UNDERLYING_MINT = 32;
+export declare const MARKET_OFFSET_QUOTE_MINT = 64;
+export declare const MARKET_OFFSET_UNDERLYING_ORACLE_ADDRESS = 160;
+export declare const MARKET_OFFSET_QUOTE_ORACLE_ADDRESS = 192;
+export declare const ORACLE_OFFSET_ORACLE_TYPE = 3;
+export declare const ORACLE_OFFSET_FLAGS = 4;
+export declare const ORACLE_OFFSET_DECIMALS = 5;
+export declare const ORACLE_OFFSET_ACTIVE_MARKETS_COUNT = 6;
+export declare const ORACLE_OFFSET_PRICE = 8;
+export declare const ORACLE_OFFSET_UPDATED_AT = 16;
+export declare const ORACLE_OFFSET_EXPIRY_TS = 24;
+export declare const ORACLE_OFFSET_MINT = 32;
+export declare const ORACLE_OFFSET_AUTHORITY = 64;
+export declare const ORACLE_OFFSET_FEED_ID = 96;
+export declare const MAKER_OFFSET_MAKER_OWNER = 4;
+export declare const MAKER_OFFSET_QUOTE_SIGNING = 36;
+export declare const POSITION_ACCOUNT_DISCRIMINATOR = 1;
+export declare const MAKER_ACCOUNT_DISCRIMINATOR = 2;
+export declare const CONFIG_ACCOUNT_DISCRIMINATOR = 3;
+export declare const MARKET_ACCOUNT_DISCRIMINATOR = 4;
+export declare const ORACLE_ACCOUNT_DISCRIMINATOR = 5;
+export declare const POSITION_ACCOUNT_SIZE_BYTES = 416;
+export declare const MAKER_ACCOUNT_SIZE_BYTES = 328;
+export declare const CONFIG_ACCOUNT_SIZE_BYTES = 392;
+export declare const MARKET_ACCOUNT_SIZE_BYTES = 416;
+export declare const ORACLE_ACCOUNT_SIZE_BYTES = 384;
+type FetchOptions = {
+    commitment?: Commitment;
+    dataSlice?: {
+        offset: number;
+        length: number;
+    };
+};
+type Rpc = ReturnType<typeof createSolanaRpc>;
+export type DecodedPositionAccount = ReturnType<typeof decodePositionAccount>;
+export type DecodedMarketAccount = ReturnType<typeof decodeMarketAccount>;
+export type DecodedConfigAccount = ReturnType<typeof decodeConfigAccount>;
+export type DecodedOracleAccount = ReturnType<typeof decodeOracleAccount>;
+type DecodedAccount<T> = {
+    pubkey: Address<string>;
+    account: T;
+};
+export declare function fetchPositionsByMaker(rpc: Rpc, makerOwner: Address<string>, options?: FetchOptions): Promise<Readonly<{
+    account: Readonly<{
+        executable: boolean;
+        lamports: import("@solana/rpc-types").Lamports;
+        owner: Address;
+        space: bigint;
+    }> & Readonly<{
+        data: Base58EncodedBytes;
+    }>;
+    pubkey: Address;
+}>[]>;
+export declare function fetchPositionsByMakerDecoded(rpc: Rpc, makerOwner: Address<string>, options?: FetchOptions): Promise<DecodedAccount<DecodedPositionAccount>[]>;
+export declare function fetchPositionsByTaker(rpc: Rpc, takerOwner: Address<string>, options?: FetchOptions): Promise<Readonly<{
+    account: Readonly<{
+        executable: boolean;
+        lamports: import("@solana/rpc-types").Lamports;
+        owner: Address;
+        space: bigint;
+    }> & Readonly<{
+        data: Base58EncodedBytes;
+    }>;
+    pubkey: Address;
+}>[]>;
+export declare function fetchPositionsByTakerDecoded(rpc: Rpc, takerOwner: Address<string>, options?: FetchOptions): Promise<DecodedAccount<DecodedPositionAccount>[]>;
+export declare function fetchPositionsByMarket(rpc: Rpc, market: Address<string>, options?: FetchOptions): Promise<Readonly<{
+    account: Readonly<{
+        executable: boolean;
+        lamports: import("@solana/rpc-types").Lamports;
+        owner: Address;
+        space: bigint;
+    }> & Readonly<{
+        data: Base58EncodedBytes;
+    }>;
+    pubkey: Address;
+}>[]>;
+export declare function fetchPositionsByMarketDecoded(rpc: Rpc, market: Address<string>, options?: FetchOptions): Promise<DecodedAccount<DecodedPositionAccount>[]>;
+export declare function fetchPositionsByStatus(rpc: Rpc, status: number, options?: FetchOptions): Promise<Readonly<{
+    account: Readonly<{
+        executable: boolean;
+        lamports: import("@solana/rpc-types").Lamports;
+        owner: Address;
+        space: bigint;
+    }> & Readonly<{
+        data: Base58EncodedBytes;
+    }>;
+    pubkey: Address;
+}>[]>;
+export declare function fetchPositionsByMakerAndStatus(rpc: Rpc, makerOwner: Address<string>, status: number, options?: FetchOptions): Promise<Readonly<{
+    account: Readonly<{
+        executable: boolean;
+        lamports: import("@solana/rpc-types").Lamports;
+        owner: Address;
+        space: bigint;
+    }> & Readonly<{
+        data: Base58EncodedBytes;
+    }>;
+    pubkey: Address;
+}>[]>;
+export declare function fetchPositionsByMarketAndStatus(rpc: Rpc, market: Address<string>, status: number, options?: FetchOptions): Promise<Readonly<{
+    account: Readonly<{
+        executable: boolean;
+        lamports: import("@solana/rpc-types").Lamports;
+        owner: Address;
+        space: bigint;
+    }> & Readonly<{
+        data: Base58EncodedBytes;
+    }>;
+    pubkey: Address;
+}>[]>;
+export declare function fetchPositionsByStatusDecoded(rpc: Rpc, status: number, options?: FetchOptions): Promise<DecodedAccount<DecodedPositionAccount>[]>;
+export declare function fetchAllConfigsDecoded(rpc: Rpc, options?: FetchOptions): Promise<DecodedAccount<DecodedConfigAccount>[]>;
+export declare function fetchAllMakersDecoded(rpc: Rpc, options?: FetchOptions): Promise<DecodedAccount<ReturnType<typeof decodeMakerAccount>>[]>;
+export declare function fetchAllMarketsDecoded(rpc: Rpc, options?: FetchOptions): Promise<DecodedAccount<DecodedMarketAccount>[]>;
+export declare function fetchAllOraclesDecoded(rpc: Rpc, options?: FetchOptions): Promise<DecodedAccount<DecodedOracleAccount>[]>;
+export declare function fetchAllPositionsDecoded(rpc: Rpc, options?: FetchOptions): Promise<DecodedAccount<DecodedPositionAccount>[]>;
+export declare function fetchMarketsByUnderlying(rpc: Rpc, underlying: Address<string>, options?: FetchOptions): Promise<Readonly<{
+    account: Readonly<{
+        executable: boolean;
+        lamports: import("@solana/rpc-types").Lamports;
+        owner: Address;
+        space: bigint;
+    }> & Readonly<{
+        data: Base58EncodedBytes;
+    }>;
+    pubkey: Address;
+}>[]>;
+export declare function fetchMarketsByUnderlyingDecoded(rpc: Rpc, underlying: Address<string>, options?: FetchOptions): Promise<DecodedAccount<DecodedMarketAccount>[]>;
+export declare function fetchMarketsByQuote(rpc: Rpc, quote: Address<string>, options?: FetchOptions): Promise<Readonly<{
+    account: Readonly<{
+        executable: boolean;
+        lamports: import("@solana/rpc-types").Lamports;
+        owner: Address;
+        space: bigint;
+    }> & Readonly<{
+        data: Base58EncodedBytes;
+    }>;
+    pubkey: Address;
+}>[]>;
+export declare function fetchMarketsByQuoteDecoded(rpc: Rpc, quote: Address<string>, options?: FetchOptions): Promise<DecodedAccount<DecodedMarketAccount>[]>;
+export declare function fetchMarketsByExpiry(rpc: Rpc, expiryTs: bigint | number, options?: FetchOptions): Promise<Readonly<{
+    account: Readonly<{
+        executable: boolean;
+        lamports: import("@solana/rpc-types").Lamports;
+        owner: Address;
+        space: bigint;
+    }> & Readonly<{
+        data: Base58EncodedBytes;
+    }>;
+    pubkey: Address;
+}>[]>;
+export declare function fetchMarketsByExpiryDecoded(rpc: Rpc, expiryTs: bigint | number, options?: FetchOptions): Promise<DecodedAccount<DecodedMarketAccount>[]>;
+export declare function fetchMarketsByQuoteAndExpiry(rpc: Rpc, quote: Address<string>, expiryTs: bigint | number, options?: FetchOptions): Promise<Readonly<{
+    account: Readonly<{
+        executable: boolean;
+        lamports: import("@solana/rpc-types").Lamports;
+        owner: Address;
+        space: bigint;
+    }> & Readonly<{
+        data: Base58EncodedBytes;
+    }>;
+    pubkey: Address;
+}>[]>;
+export declare function fetchMarketsByQuoteAndExpiryDecoded(rpc: Rpc, quote: Address<string>, expiryTs: bigint | number, options?: FetchOptions): Promise<DecodedAccount<DecodedMarketAccount>[]>;
+export declare function fetchMarketsByUnderlyingAndExpiry(rpc: Rpc, underlying: Address<string>, expiryTs: bigint | number, options?: FetchOptions): Promise<Readonly<{
+    account: Readonly<{
+        executable: boolean;
+        lamports: import("@solana/rpc-types").Lamports;
+        owner: Address;
+        space: bigint;
+    }> & Readonly<{
+        data: Base58EncodedBytes;
+    }>;
+    pubkey: Address;
+}>[]>;
+export declare function fetchConfigAccountByAddress(rpc: Rpc, address: Address<string>, commitment?: Commitment): Promise<DecodedAccount<DecodedConfigAccount>>;
+export declare function fetchMarketAccountByAddress(rpc: Rpc, address: Address<string>, commitment?: Commitment): Promise<DecodedAccount<DecodedMarketAccount>>;
+export declare function fetchOracleAccountByAddress(rpc: Rpc, address: Address<string>, commitment?: Commitment): Promise<DecodedAccount<DecodedOracleAccount>>;
+export declare function fetchMarketsByUnderlyingAndExpiryDecoded(rpc: Rpc, underlying: Address<string>, expiryTs: bigint | number, options?: FetchOptions): Promise<DecodedAccount<DecodedMarketAccount>[]>;
+export declare function decodePositionAccount(data: Buffer): Position;
+export declare function decodeMarketAccount(data: Buffer): Market;
+export declare function decodeConfigAccount(data: Buffer): Config;
+export declare function decodeMakerAccount(data: Buffer): Maker;
+export declare function decodeOracleAccount(data: Buffer): Oracle;
+export {};

package/dist/chain/fetch.js

@@ -0,0 +1,392 @@
+import { getAddressEncoder } from "@solana/addresses";
+import { fetchConfig as fetchGeneratedConfig, getConfigDecoder, } from "../generated/accounts/config";
+import { fetchMarket as fetchGeneratedMarket, getMarketDecoder, } from "../generated/accounts/market";
+import { fetchOracle as fetchGeneratedOracle, getOracleDecoder, } from "../generated/accounts/oracle";
+import { getPositionDecoder, } from "../generated/accounts/position";
+import { getMakerDecoder } from "../generated/accounts/maker";
+import { getActaProgramId } from "../index";
+import { Buffer } from "buffer";
+import bs58 from "bs58";
+// Offsets match Rust account layouts (discriminator is the first field).
+export const POSITION_OFFSET_STATUS = 4;
+export const POSITION_OFFSET_TAKER_OWNER = 8;
+export const POSITION_OFFSET_MAKER_OWNER = 40;
+export const POSITION_OFFSET_MARKET = 72;
+export const MARKET_OFFSET_UNDERLYING_DECIMALS = 3;
+export const MARKET_OFFSET_QUOTE_DECIMALS = 4;
+export const MARKET_OFFSET_FLAGS = 5;
+export const MARKET_OFFSET_EXPIRY_TS = 8;
+export const MARKET_OFFSET_SETTLEMENT_PRICE = 16;
+export const MARKET_OFFSET_UNDERLYING_MINT = 32;
+export const MARKET_OFFSET_QUOTE_MINT = 64;
+export const MARKET_OFFSET_UNDERLYING_ORACLE_ADDRESS = 160;
+export const MARKET_OFFSET_QUOTE_ORACLE_ADDRESS = 192;
+export const ORACLE_OFFSET_ORACLE_TYPE = 3;
+export const ORACLE_OFFSET_FLAGS = 4;
+export const ORACLE_OFFSET_DECIMALS = 5;
+export const ORACLE_OFFSET_ACTIVE_MARKETS_COUNT = 6;
+export const ORACLE_OFFSET_PRICE = 8;
+export const ORACLE_OFFSET_UPDATED_AT = 16;
+export const ORACLE_OFFSET_EXPIRY_TS = 24;
+export const ORACLE_OFFSET_MINT = 32;
+export const ORACLE_OFFSET_AUTHORITY = 64;
+export const ORACLE_OFFSET_FEED_ID = 96;
+// Maker (account) offsets
+export const MAKER_OFFSET_MAKER_OWNER = 4;
+export const MAKER_OFFSET_QUOTE_SIGNING = 36;
+// Account discriminators (first byte of account data).
+export const POSITION_ACCOUNT_DISCRIMINATOR = 1;
+export const MAKER_ACCOUNT_DISCRIMINATOR = 2;
+export const CONFIG_ACCOUNT_DISCRIMINATOR = 3;
+export const MARKET_ACCOUNT_DISCRIMINATOR = 4;
+export const ORACLE_ACCOUNT_DISCRIMINATOR = 5;
+// Account sizes (bytes). Note: Maker includes 4 bytes of padding on-chain.
+export const POSITION_ACCOUNT_SIZE_BYTES = 416;
+export const MAKER_ACCOUNT_SIZE_BYTES = 328;
+export const CONFIG_ACCOUNT_SIZE_BYTES = 392;
+export const MARKET_ACCOUNT_SIZE_BYTES = 416;
+export const ORACLE_ACCOUNT_SIZE_BYTES = 384;
+const addressEncoder = getAddressEncoder();
+function memcmp(offset, addressOrBytes) {
+    const bytes = addressOrBytes instanceof Uint8Array
+        ? bs58.encode(addressOrBytes)
+        : addressOrBytes;
+    return {
+        memcmp: {
+            offset: BigInt(offset),
+            bytes,
+            encoding: "base58",
+        },
+    };
+}
+function u64Le(value) {
+    const buf = Buffer.alloc(8);
+    buf.writeBigUInt64LE(BigInt(value));
+    return buf;
+}
+function addrBytes(address) {
+    return Buffer.from(addressEncoder.encode(address));
+}
+async function fetchAndDecode(rpc, config, decode) {
+    // IMPORTANT: Solana JSON-RPC rejects base58 encoding for account data > 128 bytes.
+    // Always request base64 here, because we decode bytes locally.
+    const configWithEncoding = {
+        ...config,
+        encoding: "base64",
+    };
+    const accounts = (await rpc
+        .getProgramAccounts(getActaProgramId(), configWithEncoding)
+        .send());
+    return accounts.map((acc) => {
+        const [b64] = acc.account.data;
+        const buf = Buffer.from(b64, "base64");
+        return { pubkey: acc.pubkey, account: decode(buf) };
+    });
+}
+function dataSize(bytes) {
+    return { dataSize: BigInt(bytes) };
+}
+// --- Positions ---
+export async function fetchPositionsByMaker(rpc, makerOwner, options) {
+    return rpc
+        .getProgramAccounts(getActaProgramId(), {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            dataSize(POSITION_ACCOUNT_SIZE_BYTES),
+            memcmp(0, new Uint8Array([POSITION_ACCOUNT_DISCRIMINATOR])),
+            memcmp(POSITION_OFFSET_MAKER_OWNER, addrBytes(makerOwner)),
+        ],
+    })
+        .send();
+}
+export async function fetchPositionsByMakerDecoded(rpc, makerOwner, options) {
+    return fetchAndDecode(rpc, {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            dataSize(POSITION_ACCOUNT_SIZE_BYTES),
+            memcmp(0, new Uint8Array([POSITION_ACCOUNT_DISCRIMINATOR])),
+            memcmp(POSITION_OFFSET_MAKER_OWNER, addrBytes(makerOwner)),
+        ],
+    }, decodePositionAccount);
+}
+export async function fetchPositionsByTaker(rpc, takerOwner, options) {
+    return rpc
+        .getProgramAccounts(getActaProgramId(), {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            dataSize(POSITION_ACCOUNT_SIZE_BYTES),
+            memcmp(0, new Uint8Array([POSITION_ACCOUNT_DISCRIMINATOR])),
+            memcmp(POSITION_OFFSET_TAKER_OWNER, addrBytes(takerOwner)),
+        ],
+    })
+        .send();
+}
+export async function fetchPositionsByTakerDecoded(rpc, takerOwner, options) {
+    return fetchAndDecode(rpc, {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            dataSize(POSITION_ACCOUNT_SIZE_BYTES),
+            memcmp(0, new Uint8Array([POSITION_ACCOUNT_DISCRIMINATOR])),
+            memcmp(POSITION_OFFSET_TAKER_OWNER, addrBytes(takerOwner)),
+        ],
+    }, decodePositionAccount);
+}
+export async function fetchPositionsByMarket(rpc, market, options) {
+    return rpc
+        .getProgramAccounts(getActaProgramId(), {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            dataSize(POSITION_ACCOUNT_SIZE_BYTES),
+            memcmp(0, new Uint8Array([POSITION_ACCOUNT_DISCRIMINATOR])),
+            memcmp(POSITION_OFFSET_MARKET, addrBytes(market)),
+        ],
+    })
+        .send();
+}
+export async function fetchPositionsByMarketDecoded(rpc, market, options) {
+    return fetchAndDecode(rpc, {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            dataSize(POSITION_ACCOUNT_SIZE_BYTES),
+            memcmp(0, new Uint8Array([POSITION_ACCOUNT_DISCRIMINATOR])),
+            memcmp(POSITION_OFFSET_MARKET, addrBytes(market)),
+        ],
+    }, decodePositionAccount);
+}
+export async function fetchPositionsByStatus(rpc, status, options) {
+    return rpc
+        .getProgramAccounts(getActaProgramId(), {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            dataSize(POSITION_ACCOUNT_SIZE_BYTES),
+            memcmp(0, new Uint8Array([POSITION_ACCOUNT_DISCRIMINATOR])),
+            memcmp(POSITION_OFFSET_STATUS, new Uint8Array([status])),
+        ],
+    })
+        .send();
+}
+export async function fetchPositionsByMakerAndStatus(rpc, makerOwner, status, options) {
+    return rpc
+        .getProgramAccounts(getActaProgramId(), {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            dataSize(POSITION_ACCOUNT_SIZE_BYTES),
+            memcmp(0, new Uint8Array([POSITION_ACCOUNT_DISCRIMINATOR])),
+            memcmp(POSITION_OFFSET_MAKER_OWNER, addrBytes(makerOwner)),
+            memcmp(POSITION_OFFSET_STATUS, new Uint8Array([status])),
+        ],
+    })
+        .send();
+}
+export async function fetchPositionsByMarketAndStatus(rpc, market, status, options) {
+    return rpc
+        .getProgramAccounts(getActaProgramId(), {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            dataSize(POSITION_ACCOUNT_SIZE_BYTES),
+            memcmp(0, new Uint8Array([POSITION_ACCOUNT_DISCRIMINATOR])),
+            memcmp(POSITION_OFFSET_MARKET, addrBytes(market)),
+            memcmp(POSITION_OFFSET_STATUS, new Uint8Array([status])),
+        ],
+    })
+        .send();
+}
+export async function fetchPositionsByStatusDecoded(rpc, status, options) {
+    return fetchAndDecode(rpc, {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            dataSize(POSITION_ACCOUNT_SIZE_BYTES),
+            memcmp(0, new Uint8Array([POSITION_ACCOUNT_DISCRIMINATOR])),
+            memcmp(POSITION_OFFSET_STATUS, new Uint8Array([status])),
+        ],
+    }, decodePositionAccount);
+}
+// --- Fetch-all (GPA) helpers ---
+export async function fetchAllConfigsDecoded(rpc, options) {
+    return fetchAndDecode(rpc, {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            dataSize(CONFIG_ACCOUNT_SIZE_BYTES),
+            memcmp(0, new Uint8Array([CONFIG_ACCOUNT_DISCRIMINATOR])),
+        ],
+    }, decodeConfigAccount);
+}
+export async function fetchAllMakersDecoded(rpc, options) {
+    return fetchAndDecode(rpc, {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            dataSize(MAKER_ACCOUNT_SIZE_BYTES),
+            memcmp(0, new Uint8Array([MAKER_ACCOUNT_DISCRIMINATOR])),
+        ],
+    }, decodeMakerAccount);
+}
+export async function fetchAllMarketsDecoded(rpc, options) {
+    return fetchAndDecode(rpc, {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            dataSize(MARKET_ACCOUNT_SIZE_BYTES),
+            memcmp(0, new Uint8Array([MARKET_ACCOUNT_DISCRIMINATOR])),
+        ],
+    }, decodeMarketAccount);
+}
+export async function fetchAllOraclesDecoded(rpc, options) {
+    return fetchAndDecode(rpc, {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            dataSize(ORACLE_ACCOUNT_SIZE_BYTES),
+            memcmp(0, new Uint8Array([ORACLE_ACCOUNT_DISCRIMINATOR])),
+        ],
+    }, decodeOracleAccount);
+}
+export async function fetchAllPositionsDecoded(rpc, options) {
+    return fetchAndDecode(rpc, {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            dataSize(POSITION_ACCOUNT_SIZE_BYTES),
+            memcmp(0, new Uint8Array([POSITION_ACCOUNT_DISCRIMINATOR])),
+        ],
+    }, decodePositionAccount);
+}
+// --- Markets ---
+export async function fetchMarketsByUnderlying(rpc, underlying, options) {
+    return rpc
+        .getProgramAccounts(getActaProgramId(), {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [memcmp(MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying))],
+    })
+        .send();
+}
+export async function fetchMarketsByUnderlyingDecoded(rpc, underlying, options) {
+    return fetchAndDecode(rpc, {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [memcmp(MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying))],
+    }, decodeMarketAccount);
+}
+export async function fetchMarketsByQuote(rpc, quote, options) {
+    return rpc
+        .getProgramAccounts(getActaProgramId(), {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [memcmp(MARKET_OFFSET_QUOTE_MINT, addrBytes(quote))],
+    })
+        .send();
+}
+export async function fetchMarketsByQuoteDecoded(rpc, quote, options) {
+    return fetchAndDecode(rpc, {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [memcmp(MARKET_OFFSET_QUOTE_MINT, addrBytes(quote))],
+    }, decodeMarketAccount);
+}
+export async function fetchMarketsByExpiry(rpc, expiryTs, options) {
+    return rpc
+        .getProgramAccounts(getActaProgramId(), {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))],
+    })
+        .send();
+}
+export async function fetchMarketsByExpiryDecoded(rpc, expiryTs, options) {
+    return fetchAndDecode(rpc, {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs))],
+    }, decodeMarketAccount);
+}
+export async function fetchMarketsByQuoteAndExpiry(rpc, quote, expiryTs, options) {
+    return rpc
+        .getProgramAccounts(getActaProgramId(), {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            memcmp(MARKET_OFFSET_QUOTE_MINT, addrBytes(quote)),
+            memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs)),
+        ],
+    })
+        .send();
+}
+export async function fetchMarketsByQuoteAndExpiryDecoded(rpc, quote, expiryTs, options) {
+    return fetchAndDecode(rpc, {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            memcmp(MARKET_OFFSET_QUOTE_MINT, addrBytes(quote)),
+            memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs)),
+        ],
+    }, decodeMarketAccount);
+}
+export async function fetchMarketsByUnderlyingAndExpiry(rpc, underlying, expiryTs, options) {
+    return rpc
+        .getProgramAccounts(getActaProgramId(), {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            memcmp(MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying)),
+            memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs)),
+        ],
+    })
+        .send();
+}
+// --- Single account fetch helpers ---
+export async function fetchConfigAccountByAddress(rpc, address, commitment) {
+    const resp = await fetchGeneratedConfig(rpc, address, {
+        commitment,
+    });
+    return { pubkey: resp.address, account: resp.data };
+}
+export async function fetchMarketAccountByAddress(rpc, address, commitment) {
+    const resp = await fetchGeneratedMarket(rpc, address, {
+        commitment,
+    });
+    return { pubkey: resp.address, account: resp.data };
+}
+export async function fetchOracleAccountByAddress(rpc, address, commitment) {
+    const resp = await fetchGeneratedOracle(rpc, address, {
+        commitment,
+    });
+    return { pubkey: resp.address, account: resp.data };
+}
+export async function fetchMarketsByUnderlyingAndExpiryDecoded(rpc, underlying, expiryTs, options) {
+    return fetchAndDecode(rpc, {
+        commitment: options?.commitment,
+        dataSlice: options?.dataSlice,
+        filters: [
+            memcmp(MARKET_OFFSET_UNDERLYING_MINT, addrBytes(underlying)),
+            memcmp(MARKET_OFFSET_EXPIRY_TS, u64Le(expiryTs)),
+        ],
+    }, decodeMarketAccount);
+}
+// --- Decode helpers ---
+export function decodePositionAccount(data) {
+    return getPositionDecoder().decode(data);
+}
+export function decodeMarketAccount(data) {
+    return getMarketDecoder().decode(data);
+}
+export function decodeConfigAccount(data) {
+    return getConfigDecoder().decode(data);
+}
+export function decodeMakerAccount(data) {
+    return getMakerDecoder().decode(data);
+}
+export function decodeOracleAccount(data) {
+    return getOracleDecoder().decode(data);
+}

package/dist/chain/fetch.test.d.ts

@@ -0,0 +1 @@
+export {};