@acta-markets/ts-sdk 0.0.1-beta

package/dist/cjs/chain/fetch.js

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

package/dist/cjs/chain/fetch.test.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fetch_1 = require("./fetch");
+const addresses_1 = require("@solana/addresses");
+const orders_1 = require("./orders");
+const maker_1 = require("../generated/accounts/maker");
+const market_1 = require("../generated/accounts/market");
+const position_1 = require("../generated/accounts/position");
+const buffer_1 = require("buffer");
+describe("fetch offsets and order encode", () => {
+    it("position offsets match", () => {
+        expect(fetch_1.POSITION_OFFSET_STATUS).toBe(4);
+        expect(fetch_1.POSITION_OFFSET_TAKER_OWNER).toBe(8);
+        expect(fetch_1.POSITION_OFFSET_MAKER_OWNER).toBe(40);
+        expect(fetch_1.POSITION_OFFSET_MARKET).toBe(72);
+    });
+    it("market offsets match", () => {
+        expect(fetch_1.MARKET_OFFSET_UNDERLYING_MINT).toBe(32);
+        expect(fetch_1.MARKET_OFFSET_QUOTE_MINT).toBe(64);
+        expect(fetch_1.MARKET_OFFSET_UNDERLYING_DECIMALS).toBe(3);
+        expect(fetch_1.MARKET_OFFSET_QUOTE_DECIMALS).toBe(4);
+        expect(fetch_1.MARKET_OFFSET_FLAGS).toBe(5);
+        expect(fetch_1.MARKET_OFFSET_EXPIRY_TS).toBe(8);
+        expect(fetch_1.MARKET_OFFSET_SETTLEMENT_PRICE).toBe(16);
+    });
+    it("maker offsets match", () => {
+        expect(fetch_1.MAKER_OFFSET_MAKER_OWNER).toBe(4);
+        expect(fetch_1.MAKER_OFFSET_QUOTE_SIGNING).toBe(36);
+    });
+    it("offsets are consistent with generated account encoders (IDL-backed)", () => {
+        const decoder = (0, addresses_1.getAddressDecoder)();
+        const underlyingBytes = Uint8Array.from({ length: 32 }, (_, i) => i + 1);
+        const quoteBytes = Uint8Array.from({ length: 32 }, (_, i) => 101 + i);
+        const underlyingTokenProgramBytes = Uint8Array.from({ length: 32 }, (_, i) => 31 + i);
+        const quoteTokenProgramBytes = Uint8Array.from({ length: 32 }, (_, i) => 61 + i);
+        const makerOwnerBytes = Uint8Array.from({ length: 32 }, (_, i) => 51 + i);
+        const makerSigningBytes = Uint8Array.from({ length: 32 }, (_, i) => 151 + i);
+        const underlyingOracleBytes = Uint8Array.from({ length: 32 }, (_, i) => 181 + i);
+        const quoteOracleBytes = Uint8Array.from({ length: 32 }, (_, i) => 211 + i);
+        const takerBytes = Uint8Array.from({ length: 32 }, (_, i) => 9 + i);
+        const marketBytes = Uint8Array.from({ length: 32 }, (_, i) => 77 + i);
+        const underlyingMint = decoder.decode(underlyingBytes);
+        const quoteMint = decoder.decode(quoteBytes);
+        const makerOwner = decoder.decode(makerOwnerBytes);
+        const quoteSigning = decoder.decode(makerSigningBytes);
+        const takerOwner = decoder.decode(takerBytes);
+        const market = decoder.decode(marketBytes);
+        const underlyingTokenProgramId = decoder.decode(underlyingTokenProgramBytes);
+        const quoteTokenProgramId = decoder.decode(quoteTokenProgramBytes);
+        const underlyingOracleAddress = decoder.decode(underlyingOracleBytes);
+        const quoteOracleAddress = decoder.decode(quoteOracleBytes);
+        // --- Market layout ---
+        const expiryTs = 0x0102030405060708n;
+        const settlementPrice = 0x1122334455667788n;
+        const marketData = (0, market_1.getMarketEncoder)().encode({
+            discriminator: 4,
+            version: 1,
+            bump: 9,
+            underlyingDecimals: 7,
+            quoteDecimals: 8,
+            flags: 0b0000_0010,
+            reservedByte1: 0,
+            reservedByte2: 0,
+            expiryTs,
+            settlementPrice,
+            openPositionsCount: 0x9999888877776666n,
+            underlyingTokenProgramId,
+            quoteTokenProgramId,
+            underlyingOracleAddress,
+            quoteOracleAddress,
+            reserved: Array(24).fill(0n),
+            underlyingMint,
+            quoteMint,
+        });
+        expect(marketData.length).toBe((0, market_1.getMarketSize)());
+        expect(buffer_1.Buffer.from(marketData.slice(fetch_1.MARKET_OFFSET_UNDERLYING_MINT, fetch_1.MARKET_OFFSET_UNDERLYING_MINT + 32))).toEqual(buffer_1.Buffer.from(underlyingBytes));
+        expect(buffer_1.Buffer.from(marketData.slice(fetch_1.MARKET_OFFSET_QUOTE_MINT, fetch_1.MARKET_OFFSET_QUOTE_MINT + 32))).toEqual(buffer_1.Buffer.from(quoteBytes));
+        expect(marketData[fetch_1.MARKET_OFFSET_UNDERLYING_DECIMALS]).toBe(7);
+        expect(marketData[fetch_1.MARKET_OFFSET_QUOTE_DECIMALS]).toBe(8);
+        const expiryBuf = buffer_1.Buffer.alloc(8);
+        expiryBuf.writeBigUInt64LE(expiryTs);
+        expect(buffer_1.Buffer.from(marketData.slice(fetch_1.MARKET_OFFSET_EXPIRY_TS, fetch_1.MARKET_OFFSET_EXPIRY_TS + 8))).toEqual(expiryBuf);
+        expect(marketData[fetch_1.MARKET_OFFSET_FLAGS]).toBe(0b0000_0010);
+        const settleBuf = buffer_1.Buffer.alloc(8);
+        settleBuf.writeBigUInt64LE(settlementPrice);
+        expect(buffer_1.Buffer.from(marketData.slice(fetch_1.MARKET_OFFSET_SETTLEMENT_PRICE, fetch_1.MARKET_OFFSET_SETTLEMENT_PRICE + 8))).toEqual(settleBuf);
+        expect(buffer_1.Buffer.from(marketData.slice(fetch_1.MARKET_OFFSET_UNDERLYING_ORACLE_ADDRESS, fetch_1.MARKET_OFFSET_UNDERLYING_ORACLE_ADDRESS + 32))).toEqual(buffer_1.Buffer.from(underlyingOracleBytes));
+        expect(buffer_1.Buffer.from(marketData.slice(fetch_1.MARKET_OFFSET_QUOTE_ORACLE_ADDRESS, fetch_1.MARKET_OFFSET_QUOTE_ORACLE_ADDRESS + 32))).toEqual(buffer_1.Buffer.from(quoteOracleBytes));
+        // --- Position layout ---
+        const positionData = (0, position_1.getPositionEncoder)().encode({
+            discriminator: 1,
+            version: 1,
+            bump: 7,
+            positionType: 9,
+            status: 3,
+            flags: 0,
+            flags2: 0,
+            flags3: 0,
+            takerOwner,
+            makerOwner,
+            market,
+            strike: 0x0102030405060708n,
+            quantity: 0x1111222233334444n,
+            totalPremium: 0x9999888877776666n,
+            orderId: new Uint8Array(32).fill(0x88),
+            reserved: Array(32).fill(0n),
+        });
+        expect(positionData.length).toBe((0, position_1.getPositionSize)());
+        expect(positionData[fetch_1.POSITION_OFFSET_STATUS]).toBe(3);
+        expect(buffer_1.Buffer.from(positionData.slice(fetch_1.POSITION_OFFSET_TAKER_OWNER, fetch_1.POSITION_OFFSET_TAKER_OWNER + 32))).toEqual(buffer_1.Buffer.from(takerBytes));
+        expect(buffer_1.Buffer.from(positionData.slice(fetch_1.POSITION_OFFSET_MAKER_OWNER, fetch_1.POSITION_OFFSET_MAKER_OWNER + 32))).toEqual(buffer_1.Buffer.from(makerOwnerBytes));
+        expect(buffer_1.Buffer.from(positionData.slice(fetch_1.POSITION_OFFSET_MARKET, fetch_1.POSITION_OFFSET_MARKET + 32))).toEqual(buffer_1.Buffer.from(marketBytes));
+        // --- Maker layout ---
+        const makerData = (0, maker_1.getMakerEncoder)().encode({
+            discriminator: 2,
+            version: 1,
+            bump: 5,
+            flags: 0,
+            makerOwner,
+            quoteSigning,
+            reserved: Array(32).fill(0n),
+        });
+        expect(makerData.length).toBe((0, maker_1.getMakerSize)());
+        expect(buffer_1.Buffer.from(makerData.slice(fetch_1.MAKER_OFFSET_MAKER_OWNER, fetch_1.MAKER_OFFSET_MAKER_OWNER + 32))).toEqual(buffer_1.Buffer.from(makerOwnerBytes));
+        expect(buffer_1.Buffer.from(makerData.slice(fetch_1.MAKER_OFFSET_QUOTE_SIGNING, fetch_1.MAKER_OFFSET_QUOTE_SIGNING + 32))).toEqual(buffer_1.Buffer.from(makerSigningBytes));
+    });
+    it("order preimage encodes to 182 bytes", () => {
+        const decoder = (0, addresses_1.getAddressDecoder)();
+        const marketBytes = new Uint8Array(Array(32).fill(1));
+        const makerBytes = new Uint8Array(Array(32).fill(7));
+        const takerBytes = new Uint8Array(Array(32).fill(8));
+        const programBytes = new Uint8Array(Array(32).fill(9));
+        const market = decoder.decode(marketBytes);
+        const maker = decoder.decode(makerBytes);
+        const taker = decoder.decode(takerBytes);
+        const programId = decoder.decode(programBytes);
+        const preimage = (0, orders_1.encodeOrderPreimage)({
+            chainId: 0n,
+            programId,
+            isTakerBuy: false,
+            positionType: 0,
+            market,
+            strike: 2n,
+            quantity: 3n,
+            price: 4n,
+            validUntil: 5n,
+            maker,
+            taker,
+            nonce: 6n,
+        });
+        expect(preimage.length).toBe(4 + 8 + 32 + 138);
+        expect(preimage.slice(0, 4)).toEqual(new Uint8Array([0x41, 0x43, 0x54, 0x41])); // "ACTA"
+        expect(preimage.slice(12, 44)).toEqual(programBytes);
+        const base = 44;
+        expect(preimage[base]).toBe(0);
+        expect(preimage.slice(base + 2, base + 34)).toEqual(marketBytes);
+        expect(preimage.slice(base + 66, base + 98)).toEqual(makerBytes);
+        expect(preimage.slice(base + 98, base + 130)).toEqual(takerBytes);
+    });
+});

package/dist/cjs/chain/flows/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./openPosition"), exports);

package/dist/cjs/chain/flows/openPosition.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOpenPositionFlowIxs = buildOpenPositionFlowIxs;
+const orders_1 = require("../orders");
+const helpers_1 = require("../helpers");
+const instructions_1 = require("../instructions");
+const orderId_1 = require("../../types/orderId");
+const index_1 = require("../../index");
+const toAddress = (value) => typeof value === "string" ? value : value.address;
+function assertSignerPubkeyMatches(label, signer, expected) {
+    if (signer.publicKey !== expected) {
+        throw new Error(`${label}.publicKey must match ${expected}`);
+    }
+}
+/**
+ * Build the minimal instruction set required for `open_position`:
+ * - Ed25519 verify (maker quote signing key) over 32-byte orderId
+ * - OpenPosition instruction
+ */
+async function buildOpenPositionFlowIxs(args) {
+    assertSignerPubkeyMatches("makerSigner", args.makerSigner, args.makerQuoteSigning);
+    const marketPda = await (0, helpers_1.findMarketPda)({
+        underlyingMint: args.underlyingMint,
+        quoteMint: args.quoteMint,
+        expiryTs: args.expiryTs,
+        isPut: args.isPut,
+    });
+    const orderId = (0, orders_1.computeOrderId)({
+        chainId: 0,
+        programId: args.programId ?? (0, index_1.getActaProgramId)(),
+        isTakerBuy: false,
+        positionType: args.positionType,
+        market: marketPda,
+        strike: args.strike,
+        quantity: args.quantity,
+        price: args.price,
+        validUntil: args.validUntil,
+        maker: args.makerOwner,
+        taker: toAddress(args.user),
+        nonce: args.nonce,
+    });
+    (0, orderId_1.assertOrderId32)(orderId);
+    const positionPda = await (0, helpers_1.findPositionPda)({ orderId });
+    const makerSig = await args.makerSigner.signMessage(orderId);
+    const makerSigIx = (0, orders_1.orderSignatureInstruction)({
+        publicKey: args.makerQuoteSigning,
+        signature: makerSig,
+        message: orderId,
+    });
+    const openPositionIx = await (0, instructions_1.buildOpenPositionIx)({
+        keeper: args.keeper,
+        user: args.user,
+        makerOwner: args.makerOwner,
+        underlyingMint: args.underlyingMint,
+        quoteMint: args.quoteMint,
+        premiumMint: args.premiumMint,
+        positionType: args.positionType,
+        strike: args.strike,
+        quantity: args.quantity,
+        price: args.price,
+        validUntil: args.validUntil,
+        nonce: args.nonce,
+        orderId,
+        isPut: args.isPut,
+        expiryTs: args.expiryTs,
+        configPda: args.configPda,
+        tokenProgram: args.tokenProgram,
+        underlyingTokenProgram: args.underlyingTokenProgram,
+        quoteTokenProgram: args.quoteTokenProgram,
+        rpc: args.rpc,
+    });
+    return {
+        orderId,
+        orderIdHex: (0, orderId_1.orderIdToHex)(orderId),
+        marketPda,
+        positionPda,
+        makerSigIx,
+        openPositionIx,
+        ixs: [makerSigIx, openPositionIx],
+    };
+}