@velocity-exchange/sdk 0.0.1

package/lib/browser/core/remainingAccounts.d.ts

@@ -0,0 +1,27 @@
+import { PublicKey, type AccountMeta } from '@solana/web3.js';
+import type { UserAccount, SpotMarketAccount, PerpMarketAccount } from '../types';
+export type RemainingAccountParams = {
+    userAccounts: UserAccount[];
+    writablePerpMarketIndexes?: number[];
+    writableSpotMarketIndexes?: number[];
+    readablePerpMarketIndex?: number | number[];
+    readableSpotMarketIndexes?: number[];
+    useMarketLastSlotCache?: boolean;
+};
+export type RemainingAccountsContext = {
+    /** Used to resolve market accounts. */
+    getPerpMarketAccount: (marketIndex: number) => PerpMarketAccount;
+    getSpotMarketAccount: (marketIndex: number) => SpotMarketAccount;
+    /** Used to resolve user's last slot for cache invalidation. */
+    getUserAccountAndSlot: (subAccountId: number, authority: PublicKey) => {
+        slot: number;
+    } | undefined;
+    activeSubAccountId: number;
+    authority: PublicKey;
+    /** Mutable caches + forced-market sets (owned by caller). */
+    perpMarketLastSlotCache: Map<number, number>;
+    spotMarketLastSlotCache: Map<number, number>;
+    mustIncludePerpMarketIndexes: Set<number>;
+    mustIncludeSpotMarketIndexes: Set<number>;
+};
+export declare function getRemainingAccounts(ctx: RemainingAccountsContext, params: RemainingAccountParams): AccountMeta[];

package/lib/browser/core/remainingAccounts.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRemainingAccounts = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const types_1 = require("../types");
+const numericConstants_1 = require("../constants/numericConstants");
+const spotPosition_1 = require("../math/spotPosition");
+const position_1 = require("../math/position");
+function getRemainingAccounts(ctx, params) {
+    var _a;
+    const { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap } = getRemainingAccountMapsForUsers(ctx, params.userAccounts);
+    if (params.useMarketLastSlotCache) {
+        const lastUserSlot = (_a = ctx.getUserAccountAndSlot(params.userAccounts.length > 0
+            ? params.userAccounts[0].subAccountId
+            : ctx.activeSubAccountId, params.userAccounts.length > 0
+            ? params.userAccounts[0].authority
+            : ctx.authority)) === null || _a === void 0 ? void 0 : _a.slot;
+        for (const [marketIndex, slot] of ctx.perpMarketLastSlotCache.entries()) {
+            if (slot > lastUserSlot) {
+                addPerpMarketToRemainingAccountMaps(ctx, marketIndex, false, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
+            }
+            else {
+                ctx.perpMarketLastSlotCache.delete(marketIndex);
+            }
+        }
+        for (const [marketIndex, slot] of ctx.spotMarketLastSlotCache.entries()) {
+            if (slot > lastUserSlot) {
+                addSpotMarketToRemainingAccountMaps(ctx, marketIndex, false, oracleAccountMap, spotMarketAccountMap);
+            }
+            else {
+                ctx.spotMarketLastSlotCache.delete(marketIndex);
+            }
+        }
+    }
+    if (params.readablePerpMarketIndex !== undefined) {
+        const readablePerpMarketIndexes = Array.isArray(params.readablePerpMarketIndex)
+            ? params.readablePerpMarketIndex
+            : [params.readablePerpMarketIndex];
+        for (const marketIndex of readablePerpMarketIndexes) {
+            addPerpMarketToRemainingAccountMaps(ctx, marketIndex, false, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
+        }
+    }
+    for (const perpMarketIndex of ctx.mustIncludePerpMarketIndexes.values()) {
+        addPerpMarketToRemainingAccountMaps(ctx, perpMarketIndex, false, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
+    }
+    if (params.readableSpotMarketIndexes !== undefined) {
+        for (const readableSpotMarketIndex of params.readableSpotMarketIndexes) {
+            addSpotMarketToRemainingAccountMaps(ctx, readableSpotMarketIndex, false, oracleAccountMap, spotMarketAccountMap);
+        }
+    }
+    for (const spotMarketIndex of ctx.mustIncludeSpotMarketIndexes.values()) {
+        addSpotMarketToRemainingAccountMaps(ctx, spotMarketIndex, false, oracleAccountMap, spotMarketAccountMap);
+    }
+    if (params.writablePerpMarketIndexes !== undefined) {
+        for (const writablePerpMarketIndex of params.writablePerpMarketIndexes) {
+            addPerpMarketToRemainingAccountMaps(ctx, writablePerpMarketIndex, true, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
+        }
+    }
+    if (params.writableSpotMarketIndexes !== undefined) {
+        for (const writableSpotMarketIndex of params.writableSpotMarketIndexes) {
+            addSpotMarketToRemainingAccountMaps(ctx, writableSpotMarketIndex, true, oracleAccountMap, spotMarketAccountMap);
+        }
+    }
+    return [
+        ...oracleAccountMap.values(),
+        ...spotMarketAccountMap.values(),
+        ...perpMarketAccountMap.values(),
+    ];
+}
+exports.getRemainingAccounts = getRemainingAccounts;
+function addPerpMarketToRemainingAccountMaps(ctx, marketIndex, writable, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap) {
+    const perpMarketAccount = ctx.getPerpMarketAccount(marketIndex);
+    perpMarketAccountMap.set(marketIndex, {
+        pubkey: perpMarketAccount.pubkey,
+        isSigner: false,
+        isWritable: writable,
+    });
+    const oracleWritable = writable && (0, types_1.isVariant)(perpMarketAccount.amm.oracleSource, 'prelaunch');
+    oracleAccountMap.set(perpMarketAccount.amm.oracle.toString(), {
+        pubkey: perpMarketAccount.amm.oracle,
+        isSigner: false,
+        isWritable: oracleWritable,
+    });
+    addSpotMarketToRemainingAccountMaps(ctx, perpMarketAccount.quoteSpotMarketIndex, false, oracleAccountMap, spotMarketAccountMap);
+}
+function addSpotMarketToRemainingAccountMaps(ctx, marketIndex, writable, oracleAccountMap, spotMarketAccountMap) {
+    const spotMarketAccount = ctx.getSpotMarketAccount(marketIndex);
+    spotMarketAccountMap.set(spotMarketAccount.marketIndex, {
+        pubkey: spotMarketAccount.pubkey,
+        isSigner: false,
+        isWritable: writable,
+    });
+    if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+        oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+            pubkey: spotMarketAccount.oracle,
+            isSigner: false,
+            isWritable: false,
+        });
+    }
+}
+function getRemainingAccountMapsForUsers(ctx, userAccounts) {
+    const oracleAccountMap = new Map();
+    const spotMarketAccountMap = new Map();
+    const perpMarketAccountMap = new Map();
+    for (const userAccount of userAccounts) {
+        for (const spotPosition of userAccount.spotPositions) {
+            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                addSpotMarketToRemainingAccountMaps(ctx, spotPosition.marketIndex, false, oracleAccountMap, spotMarketAccountMap);
+                if (!spotPosition.openAsks.eq(numericConstants_1.ZERO) ||
+                    !spotPosition.openBids.eq(numericConstants_1.ZERO)) {
+                    addSpotMarketToRemainingAccountMaps(ctx, numericConstants_1.QUOTE_SPOT_MARKET_INDEX, false, oracleAccountMap, spotMarketAccountMap);
+                }
+            }
+        }
+        for (const position of userAccount.perpPositions) {
+            if (!(0, position_1.positionIsAvailable)(position)) {
+                addPerpMarketToRemainingAccountMaps(ctx, position.marketIndex, false, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
+            }
+        }
+    }
+    return { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap };
+}

package/lib/browser/core/signedMsg.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { SignedMsgOrderParamsDelegateMessage, SignedMsgOrderParamsMessage } from '../types';
+export type AnchorTypesCoder = {
+    encode: (typeName: string, value: any) => Buffer;
+    decode: (typeName: string, buffer: Buffer) => any;
+};
+export declare function encodeSignedMsgOrderParamsMessage(args: {
+    coderTypes: AnchorTypesCoder;
+    orderParamsMessage: SignedMsgOrderParamsMessage | SignedMsgOrderParamsDelegateMessage;
+    delegateSigner?: boolean;
+}): Buffer;
+export declare function decodeSignedMsgOrderParamsMessage(args: {
+    coderTypes: AnchorTypesCoder;
+    encodedMessage: Buffer;
+    delegateSigner?: boolean;
+}): SignedMsgOrderParamsMessage | SignedMsgOrderParamsDelegateMessage;

package/lib/browser/core/signedMsg.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeSignedMsgOrderParamsMessage = exports.encodeSignedMsgOrderParamsMessage = void 0;
+const sha256_1 = require("@noble/hashes/sha256");
+function encodeSignedMsgOrderParamsMessage(args) {
+    const { coderTypes, delegateSigner } = args;
+    const orderParamsMessage = { ...args.orderParamsMessage };
+    if (orderParamsMessage.maxMarginRatio === undefined) {
+        orderParamsMessage.maxMarginRatio = null;
+    }
+    if (orderParamsMessage.isolatedPositionDeposit === undefined) {
+        orderParamsMessage.isolatedPositionDeposit = null;
+    }
+    const anchorIxName = delegateSigner
+        ? 'global' + ':' + 'SignedMsgOrderParamsDelegateMessage'
+        : 'global' + ':' + 'SignedMsgOrderParamsMessage';
+    const prefix = Buffer.from((0, sha256_1.sha256)(anchorIxName).slice(0, 8));
+    const withBuilderDefaults = {
+        ...orderParamsMessage,
+        builderIdx: orderParamsMessage.builderIdx !== undefined
+            ? orderParamsMessage.builderIdx
+            : null,
+        builderFeeTenthBps: orderParamsMessage.builderFeeTenthBps !== undefined
+            ? orderParamsMessage.builderFeeTenthBps
+            : null,
+    };
+    const body = delegateSigner
+        ? coderTypes.encode('signedMsgOrderParamsDelegateMessage', withBuilderDefaults)
+        : coderTypes.encode('signedMsgOrderParamsMessage', withBuilderDefaults);
+    return Buffer.concat([prefix, body]);
+}
+exports.encodeSignedMsgOrderParamsMessage = encodeSignedMsgOrderParamsMessage;
+function decodeSignedMsgOrderParamsMessage(args) {
+    const decodeStr = args.delegateSigner
+        ? 'signedMsgOrderParamsDelegateMessage'
+        : 'signedMsgOrderParamsMessage';
+    return args.coderTypes.decode(decodeStr, Buffer.concat([args.encodedMessage.slice(8), Buffer.alloc(128)]));
+}
+exports.decodeSignedMsgOrderParamsMessage = decodeSignedMsgOrderParamsMessage;

package/lib/browser/decode/customCoder.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Buffer } from 'buffer';
+import { Idl, BorshEventCoder, BorshInstructionCoder } from '../isomorphic/anchor';
+export declare class CustomBorshCoder<A extends string = string, _T extends string = string> {
+    readonly idl: Idl;
+    /**
+     * Instruction coder.
+     */
+    readonly instruction: BorshInstructionCoder;
+    /**
+     * Account coder.
+     */
+    readonly accounts: CustomBorshAccountsCoder<A>;
+    /**
+     * Coder for events.
+     */
+    readonly events: BorshEventCoder;
+    /**
+     * Coder for user-defined types.
+     */
+    readonly types: any;
+    constructor(idl: Idl);
+}
+/**
+ * Custom accounts coder that wraps BorshAccountsCoder to fix encode buffer sizing.
+ */
+export declare class CustomBorshAccountsCoder<A extends string = string> {
+    private baseCoder;
+    private idl;
+    constructor(idl: Idl);
+    encode<T = any>(accountName: A, account: T): Promise<Buffer>;
+    decode<T = any>(accountName: A, data: Buffer): T;
+    decodeAny<T = any>(data: Buffer): T;
+    decodeUnchecked<T = any>(accountName: A, ix: Buffer): T;
+    memcmp(accountName: A, appendData?: Buffer): any;
+    size(accountName: A | string): number;
+    /**
+     * Calculates and returns a unique 8 byte discriminator prepended to all anchor accounts.
+     *
+     * @param name The name of the account to get the discriminator of.
+     */
+    static accountDiscriminator(_name: string): Buffer;
+}

package/lib/browser/decode/customCoder.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomBorshAccountsCoder = exports.CustomBorshCoder = void 0;
+const buffer_1 = require("buffer");
+const anchor_1 = require("../isomorphic/anchor");
+class CustomBorshCoder {
+    constructor(idl) {
+        const baseCoder = new anchor_1.BorshCoder(idl);
+        this.instruction = baseCoder.instruction;
+        this.accounts = new CustomBorshAccountsCoder(idl);
+        this.events = baseCoder.events;
+        this.types = baseCoder.types;
+        this.idl = idl;
+    }
+}
+exports.CustomBorshCoder = CustomBorshCoder;
+/**
+ * Custom accounts coder that wraps BorshAccountsCoder to fix encode buffer sizing.
+ */
+class CustomBorshAccountsCoder {
+    constructor(idl) {
+        this.baseCoder = new anchor_1.BorshAccountsCoder(idl);
+        this.idl = idl;
+    }
+    async encode(accountName, account) {
+        const layout = this.baseCoder['accountLayouts'].get(accountName);
+        if (!layout) {
+            throw new Error(`Unknown account: ${accountName}`);
+        }
+        // Fix: compute proper buffer size instead of the hardcoded 1000 bytes
+        const size = this.baseCoder.size(accountName);
+        const buffer = buffer_1.Buffer.alloc(Math.max(size, 1000));
+        const len = layout.layout.encode(account, buffer);
+        const accountData = buffer.slice(0, len);
+        const discriminator = buffer_1.Buffer.from(layout.discriminator);
+        return buffer_1.Buffer.concat([discriminator, accountData]);
+    }
+    // Delegate all other methods to the base coder
+    decode(accountName, data) {
+        return this.baseCoder.decode(accountName, data);
+    }
+    decodeAny(data) {
+        return this.baseCoder.decodeAny(data);
+    }
+    decodeUnchecked(accountName, ix) {
+        return this.baseCoder.decodeUnchecked(accountName, ix);
+    }
+    memcmp(accountName, appendData) {
+        return this.baseCoder.memcmp(accountName, appendData);
+    }
+    size(accountName) {
+        return this.baseCoder.size(accountName);
+    }
+    /**
+     * Calculates and returns a unique 8 byte discriminator prepended to all anchor accounts.
+     *
+     * @param name The name of the account to get the discriminator of.
+     */
+    static accountDiscriminator(_name) {
+        // Delegate to an instance method since anchor 0.32 uses IDL discriminators
+        throw new Error('accountDiscriminator requires an instance; use coder.accountDiscriminator(name)');
+    }
+}
+exports.CustomBorshAccountsCoder = CustomBorshAccountsCoder;

package/lib/browser/decode/user.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { UserAccount } from '../types';
+export declare function decodeUser(buffer: Buffer): UserAccount;

package/lib/browser/decode/user.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeUser = void 0;
+const anchor_1 = require("../isomorphic/anchor");
+const types_1 = require("../types");
+const web3_js_1 = require("@solana/web3.js");
+const numericConstants_1 = require("../constants/numericConstants");
+function readUnsignedBigInt64LE(buffer, offset) {
+    return new anchor_1.BN(buffer.subarray(offset, offset + 8), 10, 'le');
+}
+function readSignedBigInt64LE(buffer, offset) {
+    const unsignedValue = new anchor_1.BN(buffer.subarray(offset, offset + 8), 10, 'le');
+    if (unsignedValue.testn(63)) {
+        const inverted = unsignedValue.notn(64).addn(1);
+        return inverted.neg();
+    }
+    else {
+        return unsignedValue;
+    }
+}
+function decodeUser(buffer) {
+    let offset = 8;
+    const authority = new web3_js_1.PublicKey(buffer.slice(offset, offset + 32));
+    offset += 32;
+    const delegate = new web3_js_1.PublicKey(buffer.slice(offset, offset + 32));
+    offset += 32;
+    const name = [];
+    for (let i = 0; i < 32; i++) {
+        name.push(buffer.readUint8(offset + i));
+    }
+    offset += 32;
+    const spotPositions = [];
+    for (let i = 0; i < 8; i++) {
+        const scaledBalance = readUnsignedBigInt64LE(buffer, offset);
+        const openOrders = buffer.readUInt8(offset + 35);
+        if (scaledBalance.eq(numericConstants_1.ZERO) && openOrders === 0) {
+            offset += 40;
+            continue;
+        }
+        offset += 8;
+        const openBids = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const openAsks = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const cumulativeDeposits = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const marketIndex = buffer.readUInt16LE(offset);
+        offset += 2;
+        const balanceTypeNum = buffer.readUInt8(offset);
+        let balanceType;
+        if (balanceTypeNum === 0) {
+            balanceType = types_1.SpotBalanceType.DEPOSIT;
+        }
+        else {
+            balanceType = types_1.SpotBalanceType.BORROW;
+        }
+        offset += 6;
+        spotPositions.push({
+            scaledBalance,
+            openBids,
+            openAsks,
+            cumulativeDeposits,
+            marketIndex,
+            balanceType,
+            openOrders,
+        });
+    }
+    const perpPositions = [];
+    for (let i = 0; i < 8; i++) {
+        const baseAssetAmount = readSignedBigInt64LE(buffer, offset + 8);
+        const quoteAssetAmount = readSignedBigInt64LE(buffer, offset + 16);
+        const isolatedPositionScaledBalance = readUnsignedBigInt64LE(buffer, offset + 64);
+        const openOrders = buffer.readUInt8(offset + 78);
+        const positionFlag = buffer.readUInt8(offset + 79);
+        if (baseAssetAmount.eq(numericConstants_1.ZERO) &&
+            openOrders === 0 &&
+            quoteAssetAmount.eq(numericConstants_1.ZERO) &&
+            isolatedPositionScaledBalance.eq(numericConstants_1.ZERO) &&
+            !((positionFlag &
+                (types_1.PositionFlag.BeingLiquidated | types_1.PositionFlag.Bankruptcy)) >
+                0)) {
+            offset += 80;
+            continue;
+        }
+        const lastCumulativeFundingRate = readSignedBigInt64LE(buffer, offset);
+        offset += 24;
+        const quoteBreakEvenAmount = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const quoteEntryAmount = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const openBids = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const openAsks = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const settledPnl = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        offset += 8; // isolated_position_scaled_balance (already pre-read above)
+        offset += 2; // skip padding[u8; 2]
+        const maxMarginRatio = buffer.readUInt16LE(offset); // offset+74
+        offset += 2;
+        const marketIndex = buffer.readUInt16LE(offset); // offset+76
+        offset += 4; // advance past marketIndex(2) + openOrders(1) + positionFlag(1)
+        perpPositions.push({
+            lastCumulativeFundingRate,
+            baseAssetAmount,
+            quoteAssetAmount,
+            quoteBreakEvenAmount,
+            quoteEntryAmount,
+            openBids,
+            openAsks,
+            settledPnl,
+            remainderBaseAssetAmount: 0,
+            marketIndex,
+            openOrders,
+            maxMarginRatio,
+            positionFlag,
+            isolatedPositionScaledBalance,
+        });
+    }
+    const orders = [];
+    for (let i = 0; i < 32; i++) {
+        // skip order if it's not open
+        if (buffer.readUint8(offset + 82) !== 1) {
+            offset += 96;
+            continue;
+        }
+        const slot = readUnsignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const price = readUnsignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const baseAssetAmount = readUnsignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const baseAssetAmountFilled = readUnsignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const quoteAssetAmountFilled = readUnsignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const triggerPrice = readUnsignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const auctionStartPrice = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const auctionEndPrice = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const maxTs = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const oraclePriceOffset = buffer.readInt32LE(offset);
+        offset += 4;
+        const orderId = buffer.readUInt32LE(offset);
+        offset += 4;
+        const marketIndex = buffer.readUInt16LE(offset);
+        offset += 2;
+        const orderStatusNum = buffer.readUInt8(offset);
+        let status;
+        if (orderStatusNum === 0) {
+            status = types_1.OrderStatus.INIT;
+        }
+        else if (orderStatusNum === 1) {
+            status = types_1.OrderStatus.OPEN;
+        }
+        offset += 1;
+        const orderTypeNum = buffer.readUInt8(offset);
+        let orderType;
+        if (orderTypeNum === 0) {
+            orderType = types_1.OrderType.MARKET;
+        }
+        else if (orderTypeNum === 1) {
+            orderType = types_1.OrderType.LIMIT;
+        }
+        else if (orderTypeNum === 2) {
+            orderType = types_1.OrderType.TRIGGER_MARKET;
+        }
+        else if (orderTypeNum === 3) {
+            orderType = types_1.OrderType.TRIGGER_LIMIT;
+        }
+        else if (orderTypeNum === 4) {
+            orderType = types_1.OrderType.ORACLE;
+        }
+        offset += 1;
+        const marketTypeNum = buffer.readUInt8(offset);
+        let marketType;
+        if (marketTypeNum === 0) {
+            marketType = types_1.MarketType.SPOT;
+        }
+        else {
+            marketType = types_1.MarketType.PERP;
+        }
+        offset += 1;
+        const userOrderId = buffer.readUint8(offset);
+        offset += 1;
+        const existingPositionDirectionNum = buffer.readUInt8(offset);
+        let existingPositionDirection;
+        if (existingPositionDirectionNum === 0) {
+            existingPositionDirection = types_1.PositionDirection.LONG;
+        }
+        else {
+            existingPositionDirection = types_1.PositionDirection.SHORT;
+        }
+        offset += 1;
+        const positionDirectionNum = buffer.readUInt8(offset);
+        let direction;
+        if (positionDirectionNum === 0) {
+            direction = types_1.PositionDirection.LONG;
+        }
+        else {
+            direction = types_1.PositionDirection.SHORT;
+        }
+        offset += 1;
+        const reduceOnly = buffer.readUInt8(offset) === 1;
+        offset += 1;
+        const postOnly = buffer.readUInt8(offset) === 1;
+        offset += 1;
+        const immediateOrCancel = buffer.readUInt8(offset) === 1;
+        offset += 1;
+        const triggerConditionNum = buffer.readUInt8(offset);
+        let triggerCondition;
+        if (triggerConditionNum === 0) {
+            triggerCondition = types_1.OrderTriggerCondition.ABOVE;
+        }
+        else if (triggerConditionNum === 1) {
+            triggerCondition = types_1.OrderTriggerCondition.BELOW;
+        }
+        else if (triggerConditionNum === 2) {
+            triggerCondition = types_1.OrderTriggerCondition.TRIGGERED_ABOVE;
+        }
+        else if (triggerConditionNum === 3) {
+            triggerCondition = types_1.OrderTriggerCondition.TRIGGERED_BELOW;
+        }
+        offset += 1;
+        const auctionDuration = buffer.readUInt8(offset);
+        offset += 1;
+        const postedSlotTail = buffer.readUint8(offset);
+        offset += 1;
+        const bitFlags = buffer.readUint8(offset);
+        offset += 1;
+        offset += 1; // padding
+        orders.push({
+            slot,
+            price,
+            baseAssetAmount,
+            quoteAssetAmount: undefined,
+            baseAssetAmountFilled,
+            quoteAssetAmountFilled,
+            triggerPrice,
+            auctionStartPrice,
+            auctionEndPrice,
+            maxTs,
+            oraclePriceOffset,
+            orderId,
+            marketIndex,
+            status,
+            orderType,
+            marketType,
+            userOrderId,
+            existingPositionDirection,
+            direction,
+            reduceOnly,
+            postOnly,
+            immediateOrCancel,
+            triggerCondition,
+            auctionDuration,
+            bitFlags,
+            postedSlotTail,
+        });
+    }
+    const totalDeposits = readUnsignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const totalWithdraws = readUnsignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const totalSocialLoss = readUnsignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const settledPerpPnl = readSignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const cumulativeSpotFees = readSignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const cumulativePerpFunding = readSignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const liquidationMarginFreed = readUnsignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const lastActiveSlot = readUnsignedBigInt64LE(buffer, offset);
+    offset += 8;
+    const nextOrderId = buffer.readUInt32LE(offset);
+    offset += 4;
+    const maxMarginRatio = buffer.readUInt32LE(offset);
+    offset += 4;
+    const nextLiquidationId = buffer.readUInt16LE(offset);
+    offset += 2;
+    const subAccountId = buffer.readUInt16LE(offset);
+    offset += 2;
+    const status = buffer.readUInt8(offset);
+    offset += 1;
+    const isMarginTradingEnabled = buffer.readUInt8(offset) === 1;
+    offset += 1;
+    const idle = buffer.readUInt8(offset) === 1;
+    offset += 1;
+    const openOrders = buffer.readUInt8(offset);
+    offset += 1;
+    const hasOpenOrder = buffer.readUInt8(offset) === 1;
+    offset += 1;
+    const openAuctions = buffer.readUInt8(offset);
+    offset += 1;
+    const hasOpenAuction = buffer.readUInt8(offset) === 1;
+    offset += 1;
+    const poolId = buffer.readUint8(offset);
+    offset += 1;
+    const specialUserStatus = buffer.readUInt8(offset);
+    offset += 1;
+    offset += 14; // padding
+    return {
+        authority,
+        delegate,
+        name,
+        spotPositions,
+        perpPositions,
+        orders,
+        totalDeposits,
+        totalWithdraws,
+        totalSocialLoss,
+        settledPerpPnl,
+        cumulativeSpotFees,
+        cumulativePerpFunding,
+        liquidationMarginFreed,
+        lastActiveSlot,
+        nextOrderId,
+        maxMarginRatio,
+        nextLiquidationId,
+        subAccountId,
+        status,
+        isMarginTradingEnabled,
+        idle,
+        openOrders,
+        hasOpenOrder,
+        openAuctions,
+        hasOpenAuction,
+        poolId,
+        specialUserStatus,
+    };
+}
+exports.decodeUser = decodeUser;