@glamsystems/glam-sdk 0.1.20 → 0.1.21

package/index.cjs.js

@@ -6,7 +6,6 @@ var splToken = require('@solana/spl-token');
 var splTokenMetadata = require('@solana/spl-token-metadata');
 var DLMM = require('@meteora-ag/dlmm');
 var bytes = require('@coral-xyz/anchor/dist/cjs/utils/bytes');
-var sdk = require('@drift-labs/sdk');
 var marinadeTsSdk = require('@marinade.finance/marinade-ts-sdk');
 var splStakePool = require('@solana/spl-stake-pool');
 var borsh = require('@coral-xyz/borsh');
@@ -9216,16 +9215,21 @@ var errors = [
     },
     {
         code: 50004,
+        name: "InvalidPlatformFeeForSwap",
+        msg: "Invalid platform fee"
+    },
+    {
+        code: 50005,
         name: "InvalidTokenAccount",
         msg: "Invalid token account"
     },
     {
-        code: 50005,
+        code: 50006,
         name: "InvalidVoteSide",
         msg: "Invalid vote side"
     },
     {
-        code: 50006,
+        code: 50007,
         name: "MultipleStakeAccountsDisallowed",
         msg: "Multiple stake accounts disallowed"
     },
@@ -12929,6 +12933,13 @@ const getErrorFromRPCResponse = (rpcResponse)=>{
         throw Error(error.toString());
     }
 };
+const setsAreEqual = (a, b)=>{
+    if (a.size !== b.size) return false;
+    for (let item of a){
+        if (!b.has(item)) return false;
+    }
+    return true;
+};
 
 const ASSETS_MAINNET = new Map([
     [
@@ -13598,7 +13609,901 @@ class BaseClient {
     }
 }
 
-const DRIFT_VAULT = new web3_js.PublicKey("JCNCMFXo5M5qwUPg2Utu1u6YWp3MbygxqBsBeXXJfrw");
+const ZERO = new anchor.BN(0);
+// # Utility Types / Enums / Constants
+var ExchangeStatus = /*#__PURE__*/ function(ExchangeStatus) {
+    ExchangeStatus[ExchangeStatus["ACTIVE"] = 0] = "ACTIVE";
+    ExchangeStatus[ExchangeStatus["DEPOSIT_PAUSED"] = 1] = "DEPOSIT_PAUSED";
+    ExchangeStatus[ExchangeStatus["WITHDRAW_PAUSED"] = 2] = "WITHDRAW_PAUSED";
+    ExchangeStatus[ExchangeStatus["AMM_PAUSED"] = 4] = "AMM_PAUSED";
+    ExchangeStatus[ExchangeStatus["FILL_PAUSED"] = 8] = "FILL_PAUSED";
+    ExchangeStatus[ExchangeStatus["LIQ_PAUSED"] = 16] = "LIQ_PAUSED";
+    ExchangeStatus[ExchangeStatus["FUNDING_PAUSED"] = 32] = "FUNDING_PAUSED";
+    ExchangeStatus[ExchangeStatus["SETTLE_PNL_PAUSED"] = 64] = "SETTLE_PNL_PAUSED";
+    ExchangeStatus[ExchangeStatus["AMM_IMMEDIATE_FILL_PAUSED"] = 128] = "AMM_IMMEDIATE_FILL_PAUSED";
+    ExchangeStatus[ExchangeStatus["PAUSED"] = 255] = "PAUSED";
+    return ExchangeStatus;
+}({});
+class MarketStatus {
+}
+MarketStatus.INITIALIZED = {
+    initialized: {}
+};
+MarketStatus.ACTIVE = {
+    active: {}
+};
+MarketStatus.FUNDING_PAUSED = {
+    fundingPaused: {}
+};
+MarketStatus.AMM_PAUSED = {
+    ammPaused: {}
+};
+MarketStatus.FILL_PAUSED = {
+    fillPaused: {}
+};
+MarketStatus.WITHDRAW_PAUSED = {
+    withdrawPaused: {}
+};
+MarketStatus.REDUCE_ONLY = {
+    reduceOnly: {}
+};
+MarketStatus.SETTLEMENT = {
+    settlement: {}
+};
+MarketStatus.DELISTED = {
+    delisted: {}
+};
+var PerpOperation = /*#__PURE__*/ function(PerpOperation) {
+    PerpOperation[PerpOperation["UPDATE_FUNDING"] = 1] = "UPDATE_FUNDING";
+    PerpOperation[PerpOperation["AMM_FILL"] = 2] = "AMM_FILL";
+    PerpOperation[PerpOperation["FILL"] = 4] = "FILL";
+    PerpOperation[PerpOperation["SETTLE_PNL"] = 8] = "SETTLE_PNL";
+    PerpOperation[PerpOperation["SETTLE_PNL_WITH_POSITION"] = 16] = "SETTLE_PNL_WITH_POSITION";
+    PerpOperation[PerpOperation["LIQUIDATION"] = 32] = "LIQUIDATION";
+    return PerpOperation;
+}({});
+var SpotOperation = /*#__PURE__*/ function(SpotOperation) {
+    SpotOperation[SpotOperation["UPDATE_CUMULATIVE_INTEREST"] = 1] = "UPDATE_CUMULATIVE_INTEREST";
+    SpotOperation[SpotOperation["FILL"] = 2] = "FILL";
+    SpotOperation[SpotOperation["DEPOSIT"] = 4] = "DEPOSIT";
+    SpotOperation[SpotOperation["WITHDRAW"] = 8] = "WITHDRAW";
+    SpotOperation[SpotOperation["LIQUIDATION"] = 16] = "LIQUIDATION";
+    return SpotOperation;
+}({});
+var InsuranceFundOperation = /*#__PURE__*/ function(InsuranceFundOperation) {
+    InsuranceFundOperation[InsuranceFundOperation["INIT"] = 1] = "INIT";
+    InsuranceFundOperation[InsuranceFundOperation["ADD"] = 2] = "ADD";
+    InsuranceFundOperation[InsuranceFundOperation["REQUEST_REMOVE"] = 4] = "REQUEST_REMOVE";
+    InsuranceFundOperation[InsuranceFundOperation["REMOVE"] = 8] = "REMOVE";
+    return InsuranceFundOperation;
+}({});
+var UserStatus = /*#__PURE__*/ function(UserStatus) {
+    UserStatus[UserStatus["BEING_LIQUIDATED"] = 1] = "BEING_LIQUIDATED";
+    UserStatus[UserStatus["BANKRUPT"] = 2] = "BANKRUPT";
+    UserStatus[UserStatus["REDUCE_ONLY"] = 4] = "REDUCE_ONLY";
+    UserStatus[UserStatus["ADVANCED_LP"] = 8] = "ADVANCED_LP";
+    UserStatus[UserStatus["PROTECTED_MAKER"] = 16] = "PROTECTED_MAKER";
+    return UserStatus;
+}({});
+class MarginMode {
+}
+MarginMode.DEFAULT = {
+    default: {}
+};
+MarginMode.HIGH_LEVERAGE = {
+    highLeverage: {}
+};
+class ContractType {
+}
+ContractType.PERPETUAL = {
+    perpetual: {}
+};
+ContractType.FUTURE = {
+    future: {}
+};
+ContractType.PREDICTION = {
+    prediction: {}
+};
+class ContractTier {
+}
+ContractTier.A = {
+    a: {}
+};
+ContractTier.B = {
+    b: {}
+};
+ContractTier.C = {
+    c: {}
+};
+ContractTier.SPECULATIVE = {
+    speculative: {}
+};
+ContractTier.HIGHLY_SPECULATIVE = {
+    highlySpeculative: {}
+};
+ContractTier.ISOLATED = {
+    isolated: {}
+};
+class AssetTier {
+}
+AssetTier.COLLATERAL = {
+    collateral: {}
+};
+AssetTier.PROTECTED = {
+    protected: {}
+};
+AssetTier.CROSS = {
+    cross: {}
+};
+AssetTier.ISOLATED = {
+    isolated: {}
+};
+AssetTier.UNLISTED = {
+    unlisted: {}
+};
+class SwapDirection {
+}
+SwapDirection.ADD = {
+    add: {}
+};
+SwapDirection.REMOVE = {
+    remove: {}
+};
+class SpotBalanceType {
+}
+SpotBalanceType.DEPOSIT = {
+    deposit: {}
+};
+SpotBalanceType.BORROW = {
+    borrow: {}
+};
+class PositionDirection {
+}
+PositionDirection.LONG = {
+    long: {}
+};
+PositionDirection.SHORT = {
+    short: {}
+};
+class DepositDirection {
+}
+DepositDirection.DEPOSIT = {
+    deposit: {}
+};
+DepositDirection.WITHDRAW = {
+    withdraw: {}
+};
+class OracleSource {
+    static get(n) {
+        const name = Object.entries(OracleSourceNum).find(([, v])=>v === n)?.[0];
+        const source = Object.entries(OracleSource).find(([key, _])=>key.toLocaleLowerCase() === name?.toLocaleLowerCase())?.[1];
+        if (!source) {
+            throw new Error(`Invalid oracle source enum value: ${n}`);
+        }
+        return source;
+    }
+}
+OracleSource.PYTH = {
+    pyth: {}
+};
+OracleSource.PYTH_1K = {
+    pyth1K: {}
+};
+OracleSource.PYTH_1M = {
+    pyth1M: {}
+};
+OracleSource.PYTH_PULL = {
+    pythPull: {}
+};
+OracleSource.PYTH_1K_PULL = {
+    pyth1KPull: {}
+};
+OracleSource.PYTH_1M_PULL = {
+    pyth1MPull: {}
+};
+OracleSource.SWITCHBOARD = {
+    switchboard: {}
+};
+OracleSource.QUOTE_ASSET = {
+    quoteAsset: {}
+};
+OracleSource.PYTH_STABLE_COIN = {
+    pythStableCoin: {}
+};
+OracleSource.PYTH_STABLE_COIN_PULL = {
+    pythStableCoinPull: {}
+};
+OracleSource.Prelaunch = {
+    prelaunch: {}
+};
+OracleSource.SWITCHBOARD_ON_DEMAND = {
+    switchboardOnDemand: {}
+};
+OracleSource.PYTH_LAZER = {
+    pythLazer: {}
+};
+OracleSource.PYTH_LAZER_1K = {
+    pythLazer1K: {}
+};
+OracleSource.PYTH_LAZER_1M = {
+    pythLazer1M: {}
+};
+OracleSource.PYTH_LAZER_STABLE_COIN = {
+    pythLazerStableCoin: {}
+};
+class OracleSourceNum {
+}
+OracleSourceNum.PYTH = 0;
+OracleSourceNum.PYTH_1K = 1;
+OracleSourceNum.PYTH_1M = 2;
+OracleSourceNum.PYTH_PULL = 3;
+OracleSourceNum.PYTH_1K_PULL = 4;
+OracleSourceNum.PYTH_1M_PULL = 5;
+OracleSourceNum.SWITCHBOARD = 6;
+OracleSourceNum.QUOTE_ASSET = 7;
+OracleSourceNum.PYTH_STABLE_COIN = 8;
+OracleSourceNum.PYTH_STABLE_COIN_PULL = 9;
+OracleSourceNum.PRELAUNCH = 10;
+OracleSourceNum.SWITCHBOARD_ON_DEMAND = 11;
+OracleSourceNum.PYTH_LAZER = 12;
+OracleSourceNum.PYTH_LAZER_1K = 13;
+OracleSourceNum.PYTH_LAZER_1M = 14;
+OracleSourceNum.PYTH_LAZER_STABLE_COIN = 15;
+class OrderType {
+}
+OrderType.LIMIT = {
+    limit: {}
+};
+OrderType.TRIGGER_MARKET = {
+    triggerMarket: {}
+};
+OrderType.TRIGGER_LIMIT = {
+    triggerLimit: {}
+};
+OrderType.MARKET = {
+    market: {}
+};
+OrderType.ORACLE = {
+    oracle: {}
+};
+class MarketType {
+}
+MarketType.SPOT = {
+    spot: {}
+};
+MarketType.PERP = {
+    perp: {}
+};
+class OrderStatus {
+}
+OrderStatus.INIT = {
+    init: {}
+};
+OrderStatus.OPEN = {
+    open: {}
+};
+OrderStatus.FILLED = {
+    filled: {}
+};
+OrderStatus.CANCELED = {
+    canceled: {}
+};
+class OrderAction {
+}
+OrderAction.PLACE = {
+    place: {}
+};
+OrderAction.CANCEL = {
+    cancel: {}
+};
+OrderAction.EXPIRE = {
+    expire: {}
+};
+OrderAction.FILL = {
+    fill: {}
+};
+OrderAction.TRIGGER = {
+    trigger: {}
+};
+class OrderActionExplanation {
+}
+OrderActionExplanation.NONE = {
+    none: {}
+};
+OrderActionExplanation.INSUFFICIENT_FREE_COLLATERAL = {
+    insufficientFreeCollateral: {}
+};
+OrderActionExplanation.ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
+    oraclePriceBreachedLimitPrice: {}
+};
+OrderActionExplanation.MARKET_ORDER_FILLED_TO_LIMIT_PRICE = {
+    marketOrderFilledToLimitPrice: {}
+};
+OrderActionExplanation.ORDER_EXPIRED = {
+    orderExpired: {}
+};
+OrderActionExplanation.LIQUIDATION = {
+    liquidation: {}
+};
+OrderActionExplanation.ORDER_FILLED_WITH_AMM = {
+    orderFilledWithAmm: {}
+};
+OrderActionExplanation.ORDER_FILLED_WITH_AMM_JIT = {
+    orderFilledWithAmmJit: {}
+};
+OrderActionExplanation.ORDER_FILLED_WITH_AMM_JIT_LP_SPLIT = {
+    orderFilledWithAmmJitLpSplit: {}
+};
+OrderActionExplanation.ORDER_FILLED_WITH_LP_JIT = {
+    orderFilledWithLpJit: {}
+};
+OrderActionExplanation.ORDER_FILLED_WITH_MATCH = {
+    orderFilledWithMatch: {}
+};
+OrderActionExplanation.ORDER_FILLED_WITH_MATCH_JIT = {
+    orderFilledWithMatchJit: {}
+};
+OrderActionExplanation.MARKET_EXPIRED = {
+    marketExpired: {}
+};
+OrderActionExplanation.RISK_INCREASING_ORDER = {
+    riskingIncreasingOrder: {}
+};
+OrderActionExplanation.ORDER_FILLED_WITH_SERUM = {
+    orderFillWithSerum: {}
+};
+OrderActionExplanation.ORDER_FILLED_WITH_OPENBOOK_V2 = {
+    orderFilledWithOpenbookV2: {}
+};
+OrderActionExplanation.ORDER_FILLED_WITH_PHOENIX = {
+    orderFillWithPhoenix: {}
+};
+OrderActionExplanation.REDUCE_ONLY_ORDER_INCREASED_POSITION = {
+    reduceOnlyOrderIncreasedPosition: {}
+};
+OrderActionExplanation.DERISK_LP = {
+    deriskLp: {}
+};
+OrderActionExplanation.TRANSFER_PERP_POSITION = {
+    transferPerpPosition: {}
+};
+class OrderTriggerCondition {
+}
+OrderTriggerCondition.ABOVE = {
+    above: {}
+};
+OrderTriggerCondition.BELOW = {
+    below: {}
+};
+OrderTriggerCondition.TRIGGERED_ABOVE = {
+    triggeredAbove: {}
+} // above condition has been triggered
+;
+OrderTriggerCondition.TRIGGERED_BELOW = {
+    triggeredBelow: {}
+} // below condition has been triggered
+;
+class SpotFulfillmentType {
+}
+SpotFulfillmentType.EXTERNAL = {
+    external: {}
+};
+SpotFulfillmentType.MATCH = {
+    match: {}
+};
+class SpotFulfillmentStatus {
+}
+SpotFulfillmentStatus.ENABLED = {
+    enabled: {}
+};
+SpotFulfillmentStatus.DISABLED = {
+    disabled: {}
+};
+class DepositExplanation {
+}
+DepositExplanation.NONE = {
+    none: {}
+};
+DepositExplanation.TRANSFER = {
+    transfer: {}
+};
+DepositExplanation.BORROW = {
+    borrow: {}
+};
+DepositExplanation.REPAY_BORROW = {
+    repayBorrow: {}
+};
+class SettlePnlExplanation {
+}
+SettlePnlExplanation.NONE = {
+    none: {}
+};
+SettlePnlExplanation.EXPIRED_POSITION = {
+    expiredPosition: {}
+};
+class SpotFulfillmentConfigStatus {
+}
+SpotFulfillmentConfigStatus.ENABLED = {
+    enabled: {}
+};
+SpotFulfillmentConfigStatus.DISABLED = {
+    disabled: {}
+};
+class StakeAction {
+}
+StakeAction.STAKE = {
+    stake: {}
+};
+StakeAction.UNSTAKE_REQUEST = {
+    unstakeRequest: {}
+};
+StakeAction.UNSTAKE_CANCEL_REQUEST = {
+    unstakeCancelRequest: {}
+};
+StakeAction.UNSTAKE = {
+    unstake: {}
+};
+StakeAction.UNSTAKE_TRANSFER = {
+    unstakeTransfer: {}
+};
+StakeAction.STAKE_TRANSFER = {
+    stakeTransfer: {}
+};
+class SettlePnlMode {
+}
+SettlePnlMode.TRY_SETTLE = {
+    trySettle: {}
+};
+SettlePnlMode.MUST_SETTLE = {
+    mustSettle: {}
+};
+function isVariant(object, type) {
+    return object.hasOwnProperty(type);
+}
+function isOneOfVariant(object, types) {
+    return types.reduce((result, type)=>{
+        return result || object.hasOwnProperty(type);
+    }, false);
+}
+function getVariant(object) {
+    return Object.keys(object)[0];
+}
+var TradeSide = /*#__PURE__*/ function(TradeSide) {
+    TradeSide[TradeSide["None"] = 0] = "None";
+    TradeSide[TradeSide["Buy"] = 1] = "Buy";
+    TradeSide[TradeSide["Sell"] = 2] = "Sell";
+    return TradeSide;
+}({});
+class LPAction {
+}
+LPAction.ADD_LIQUIDITY = {
+    addLiquidity: {}
+};
+LPAction.REMOVE_LIQUIDITY = {
+    removeLiquidity: {}
+};
+LPAction.SETTLE_LIQUIDITY = {
+    settleLiquidity: {}
+};
+LPAction.REMOVE_LIQUIDITY_DERISK = {
+    removeLiquidityDerisk: {}
+};
+class LiquidationType {
+}
+LiquidationType.LIQUIDATE_PERP = {
+    liquidatePerp: {}
+};
+LiquidationType.LIQUIDATE_BORROW_FOR_PERP_PNL = {
+    liquidateBorrowForPerpPnl: {}
+};
+LiquidationType.LIQUIDATE_PERP_PNL_FOR_DEPOSIT = {
+    liquidatePerpPnlForDeposit: {}
+};
+LiquidationType.PERP_BANKRUPTCY = {
+    perpBankruptcy: {}
+};
+LiquidationType.SPOT_BANKRUPTCY = {
+    spotBankruptcy: {}
+};
+LiquidationType.LIQUIDATE_SPOT = {
+    liquidateSpot: {}
+};
+class PostOnlyParams {
+}
+PostOnlyParams.NONE = {
+    none: {}
+};
+PostOnlyParams.MUST_POST_ONLY = {
+    mustPostOnly: {}
+} // Tx fails if order can't be post only
+;
+PostOnlyParams.TRY_POST_ONLY = {
+    tryPostOnly: {}
+} // Tx succeeds and order not placed if can't be post only
+;
+PostOnlyParams.SLIDE = {
+    slide: {}
+} // Modify price to be post only if can't be post only
+;
+var ModifyOrderPolicy = /*#__PURE__*/ function(ModifyOrderPolicy) {
+    ModifyOrderPolicy[ModifyOrderPolicy["MustModify"] = 1] = "MustModify";
+    ModifyOrderPolicy[ModifyOrderPolicy["ExcludePreviousFill"] = 2] = "ExcludePreviousFill";
+    return ModifyOrderPolicy;
+}({});
+const DefaultOrderParams = {
+    orderType: OrderType.MARKET,
+    marketType: MarketType.PERP,
+    userOrderId: 0,
+    direction: PositionDirection.LONG,
+    baseAssetAmount: ZERO,
+    price: ZERO,
+    marketIndex: 0,
+    reduceOnly: false,
+    postOnly: PostOnlyParams.NONE,
+    immediateOrCancel: false,
+    triggerPrice: null,
+    triggerCondition: OrderTriggerCondition.ABOVE,
+    oraclePriceOffset: null,
+    auctionDuration: null,
+    maxTs: null,
+    auctionStartPrice: null,
+    auctionEndPrice: null
+};
+var ReferrerStatus = /*#__PURE__*/ function(ReferrerStatus) {
+    ReferrerStatus[ReferrerStatus["IsReferrer"] = 1] = "IsReferrer";
+    ReferrerStatus[ReferrerStatus["IsReferred"] = 2] = "IsReferred";
+    return ReferrerStatus;
+}({});
+var FuelOverflowStatus = /*#__PURE__*/ function(FuelOverflowStatus) {
+    FuelOverflowStatus[FuelOverflowStatus["Exists"] = 1] = "Exists";
+    return FuelOverflowStatus;
+}({});
+var PlaceAndTakeOrderSuccessCondition = /*#__PURE__*/ function(PlaceAndTakeOrderSuccessCondition) {
+    PlaceAndTakeOrderSuccessCondition[PlaceAndTakeOrderSuccessCondition["PartialFill"] = 1] = "PartialFill";
+    PlaceAndTakeOrderSuccessCondition[PlaceAndTakeOrderSuccessCondition["FullFill"] = 2] = "FullFill";
+    return PlaceAndTakeOrderSuccessCondition;
+}({});
+class SwapReduceOnly {
+}
+SwapReduceOnly.In = {
+    in: {}
+};
+SwapReduceOnly.Out = {
+    out: {}
+};
+
+function readUnsignedBigInt64LE(buffer, offset) {
+    return new anchor.BN(buffer.subarray(offset, offset + 8), 10, "le");
+}
+function readSignedBigInt64LE(buffer, offset) {
+    const unsignedValue = new anchor.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.PublicKey(buffer.slice(offset, offset + 32));
+    offset += 32;
+    const delegate = new web3_js.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(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 = SpotBalanceType.DEPOSIT;
+        } else {
+            balanceType = 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 lpShares = readUnsignedBigInt64LE(buffer, offset + 64);
+        const openOrders = buffer.readUInt8(offset + 94);
+        if (baseAssetAmount.eq(ZERO) && openOrders === 0 && quoteAssetAmount.eq(ZERO) && lpShares.eq(ZERO)) {
+            offset += 96;
+            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 += 16;
+        const lastBaseAssetAmountPerLp = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const lastQuoteAssetAmountPerLp = readSignedBigInt64LE(buffer, offset);
+        offset += 8;
+        const remainderBaseAssetAmount = buffer.readInt32LE(offset);
+        offset += 4;
+        const marketIndex = buffer.readUInt16LE(offset);
+        offset += 3;
+        const perLpBase = buffer.readUInt8(offset);
+        offset += 1;
+        perpPositions.push({
+            lastCumulativeFundingRate,
+            baseAssetAmount,
+            quoteAssetAmount,
+            quoteBreakEvenAmount,
+            quoteEntryAmount,
+            openBids,
+            openAsks,
+            settledPnl,
+            lpShares,
+            lastBaseAssetAmountPerLp,
+            lastQuoteAssetAmountPerLp,
+            remainderBaseAssetAmount,
+            marketIndex,
+            openOrders,
+            perLpBase
+        });
+    }
+    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 = OrderStatus.INIT;
+        if (orderStatusNum === 0) {
+            status = OrderStatus.INIT;
+        } else if (orderStatusNum === 1) {
+            status = OrderStatus.OPEN;
+        } else if (orderStatusNum === 2) {
+            status = OrderStatus.FILLED;
+        } else if (orderStatusNum === 3) {
+            status = OrderStatus.CANCELED;
+        }
+        offset += 1;
+        const orderTypeNum = buffer.readUInt8(offset);
+        let orderType = OrderType.MARKET;
+        if (orderTypeNum === 0) {
+            orderType = OrderType.MARKET;
+        } else if (orderTypeNum === 1) {
+            orderType = OrderType.LIMIT;
+        } else if (orderTypeNum === 2) {
+            orderType = OrderType.TRIGGER_MARKET;
+        } else if (orderTypeNum === 3) {
+            orderType = OrderType.TRIGGER_LIMIT;
+        } else if (orderTypeNum === 4) {
+            orderType = OrderType.ORACLE;
+        }
+        offset += 1;
+        const marketTypeNum = buffer.readUInt8(offset);
+        let marketType;
+        if (marketTypeNum === 0) {
+            marketType = MarketType.SPOT;
+        } else {
+            marketType = MarketType.PERP;
+        }
+        offset += 1;
+        const userOrderId = buffer.readUint8(offset);
+        offset += 1;
+        const existingPositionDirectionNum = buffer.readUInt8(offset);
+        let existingPositionDirection;
+        if (existingPositionDirectionNum === 0) {
+            existingPositionDirection = PositionDirection.LONG;
+        } else {
+            existingPositionDirection = PositionDirection.SHORT;
+        }
+        offset += 1;
+        const positionDirectionNum = buffer.readUInt8(offset);
+        let direction;
+        if (positionDirectionNum === 0) {
+            direction = PositionDirection.LONG;
+        } else {
+            direction = 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 = OrderTriggerCondition.ABOVE;
+        if (triggerConditionNum === 0) {
+            triggerCondition = OrderTriggerCondition.ABOVE;
+        } else if (triggerConditionNum === 1) {
+            triggerCondition = OrderTriggerCondition.BELOW;
+        } else if (triggerConditionNum === 2) {
+            triggerCondition = OrderTriggerCondition.TRIGGERED_ABOVE;
+        } else if (triggerConditionNum === 3) {
+            triggerCondition = 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 lastAddPerpLpSharesTs = readSignedBigInt64LE(buffer, offset);
+    offset += 8;
+    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;
+    let marginMode;
+    const marginModeNum = buffer.readUInt8(offset);
+    if (marginModeNum === 0) {
+        marginMode = MarginMode.DEFAULT;
+    } else {
+        marginMode = MarginMode.HIGH_LEVERAGE;
+    }
+    offset += 1;
+    const poolId = buffer.readUint8(offset);
+    offset += 1;
+    offset += 3; // padding
+    const lastFuelBonusUpdateTs = buffer.readUint32LE(offset);
+    offset += 4;
+    return {
+        authority,
+        delegate,
+        name,
+        spotPositions,
+        perpPositions,
+        orders,
+        lastAddPerpLpSharesTs,
+        totalDeposits,
+        totalWithdraws,
+        totalSocialLoss,
+        settledPerpPnl,
+        cumulativeSpotFees,
+        cumulativePerpFunding,
+        liquidationMarginFreed,
+        lastActiveSlot,
+        nextOrderId,
+        maxMarginRatio,
+        nextLiquidationId,
+        subAccountId,
+        status,
+        isMarginTradingEnabled,
+        idle,
+        openOrders,
+        hasOpenOrder,
+        openAuctions,
+        hasOpenAuction,
+        marginMode,
+        poolId,
+        lastFuelBonusUpdateTs
+    };
+}
+
+const DRIFT_SIGNER = new web3_js.PublicKey("JCNCMFXo5M5qwUPg2Utu1u6YWp3MbygxqBsBeXXJfrw");
 const DRIFT_MARGIN_PRECISION = 10000;
 class DriftClient {
     /*
@@ -13623,89 +14528,268 @@ class DriftClient {
         const tx = await this.deleteUserTx(new web3_js.PublicKey(statePda), subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async deposit(statePda, amount, marketIndex = 1, subAccountId = 0, marketConfigs, txOptions = {}) {
-        const tx = await this.depositTx(new web3_js.PublicKey(statePda), amount, marketIndex, subAccountId, marketConfigs, txOptions);
+    async deposit(statePda, amount, marketIndex = 1, subAccountId = 0, txOptions = {}) {
+        const tx = await this.depositTx(new web3_js.PublicKey(statePda), amount, marketIndex, subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async withdraw(statePda, amount, marketIndex = 1, subAccountId = 0, marketConfigs, txOptions = {}) {
-        const tx = await this.withdrawTx(new web3_js.PublicKey(statePda), amount, marketIndex, subAccountId, marketConfigs, txOptions);
+    async withdraw(statePda, amount, marketIndex = 1, subAccountId = 0, txOptions = {}) {
+        const tx = await this.withdrawTx(new web3_js.PublicKey(statePda), amount, marketIndex, subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async placeOrder(statePda, orderParams, subAccountId = 0, marketConfigs, txOptions = {}) {
-        const tx = await this.placeOrderTx(new web3_js.PublicKey(statePda), orderParams, subAccountId, marketConfigs, txOptions);
+    async placeOrder(statePda, orderParams, subAccountId = 0, txOptions = {}) {
+        const tx = await this.placeOrderTx(new web3_js.PublicKey(statePda), orderParams, subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async modifyOrder(statePda, modifyOrderParams, subAccountId = 0, marketConfigs, txOptions = {}) {
-        const tx = await this.modifyOrderTx(new web3_js.PublicKey(statePda), modifyOrderParams, subAccountId, marketConfigs, txOptions);
+    async modifyOrder(statePda, modifyOrderParams, subAccountId = 0, txOptions = {}) {
+        const tx = await this.modifyOrderTx(new web3_js.PublicKey(statePda), modifyOrderParams, subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async cancelOrders(statePda, marketType, marketIndex, direction, subAccountId = 0, marketConfigs, txOptions = {}) {
-        const tx = await this.cancelOrdersTx(new web3_js.PublicKey(statePda), marketType, marketIndex, direction, subAccountId, marketConfigs, txOptions);
+    async cancelOrders(statePda, marketType, marketIndex, direction, subAccountId = 0, txOptions = {}) {
+        const tx = await this.cancelOrdersTx(new web3_js.PublicKey(statePda), marketType, marketIndex, direction, subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async cancelOrdersByIds(statePda, orderIds, subAccountId = 0, marketConfigs, txOptions = {}) {
-        const tx = await this.cancelOrdersByIdsTx(new web3_js.PublicKey(statePda), orderIds, subAccountId, marketConfigs, txOptions);
+    async cancelOrdersByIds(statePda, orderIds, subAccountId = 0, txOptions = {}) {
+        const tx = await this.cancelOrdersByIdsTx(new web3_js.PublicKey(statePda), orderIds, subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async settlePnl(statePda, marketIndex, subAccountId = 0, marketConfigs, txOptions = {}) {
-        const tx = await this.settlePnlTx(new web3_js.PublicKey(statePda), marketIndex, subAccountId, marketConfigs, txOptions);
+    async settlePnl(statePda, marketIndex, subAccountId = 0, txOptions = {}) {
+        const tx = await this.settlePnlTx(new web3_js.PublicKey(statePda), marketIndex, subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async priceDrift(statePda, marketConfigs, priceDenom, txOptions = {}) {
-        const tx = await this.priceDriftTx(new web3_js.PublicKey(statePda), marketConfigs, priceDenom, txOptions);
+    async priceDrift(statePda, priceDenom, txOptions = {}) {
+        const tx = await this.priceDriftTx(new web3_js.PublicKey(statePda), priceDenom, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    /*
-   * Utils
-   */ getUser(statePda, subAccountId = 0) {
+    getGlamReferrerPdas() {
+        return {
+            user: this.getUserPda(GLAM_REFERRER, 0),
+            userStats: this.getUserStatsPda(GLAM_REFERRER)
+        };
+    }
+    parsePerpMarket(data) {
+        const marketPda = new web3_js.PublicKey(data.subarray(8, 40));
+        const oracle = new web3_js.PublicKey(data.subarray(40, 72));
+        const name = this.charsToName(data.subarray(1000, 1032));
+        const oralceEnum = data.subarray(926, 927).readUint8();
+        const oracleSource = OracleSource.get(oralceEnum);
+        const marketIndex = data.subarray(1160, 1162).readUint16LE();
+        return {
+            name,
+            marketPda,
+            marketIndex,
+            oracle,
+            oracleSource
+        };
+    }
+    parseSpotMarket(data) {
+        const marketPda = new web3_js.PublicKey(data.subarray(8, 40));
+        const oracle = new web3_js.PublicKey(data.subarray(40, 72));
+        const mint = new web3_js.PublicKey(data.subarray(72, 104));
+        const vault = new web3_js.PublicKey(data.subarray(104, 136));
+        const name = this.charsToName(data.subarray(136, 168));
+        const cumulativeDepositInterest = new anchor.BN(data.subarray(464, 480), "le");
+        const cumulativeBorrowInterest = new anchor.BN(data.subarray(480, 496), "le");
+        const decimals = data.subarray(680, 684).readUint32LE();
+        const marketIndex = data.subarray(684, 686).readUint16LE();
+        const oralceEnum = data.subarray(687, 688).readUint8();
+        const oracleSource = OracleSource.get(oralceEnum);
+        const tokenProgram = data.subarray(734, 735).readUint8() == 0 ? splToken.TOKEN_PROGRAM_ID : splToken.TOKEN_2022_PROGRAM_ID;
+        return {
+            name,
+            marketIndex,
+            marketPda,
+            oracle,
+            oracleSource,
+            vault,
+            mint,
+            decimals,
+            tokenProgram,
+            cumulativeDepositInterest,
+            cumulativeBorrowInterest
+        };
+    }
+    async calcSpotBalance(marketIndex, scaledBalance, scaledBalanceType) {
+        const { decimals, cumulativeDepositInterest, cumulativeBorrowInterest } = await this.fetchAndParseSpotMarket(marketIndex);
+        const precisionAdjustment = new anchor.BN(10 ** (19 - decimals));
+        let interest = cumulativeDepositInterest;
+        if (scaledBalanceType === SpotBalanceType.BORROW) {
+            interest = cumulativeBorrowInterest;
+        }
+        const balance = scaledBalance.mul(interest).div(precisionAdjustment);
+        const amount = scaledBalanceType === SpotBalanceType.BORROW ? balance.neg().toNumber() : balance.toNumber();
+        const uiAmount = amount / 10 ** decimals;
+        return {
+            amount,
+            uiAmount
+        };
+    }
+    getDriftUserPdas(statePda, subAccountId = 0) {
         const vault = this.base.getVaultPda(new web3_js.PublicKey(statePda));
-        return [
-            sdk.getUserAccountPublicKeySync(DRIFT_PROGRAM_ID, vault, subAccountId),
-            sdk.getUserStatsAccountPublicKey(DRIFT_PROGRAM_ID, vault)
-        ];
+        return {
+            user: this.getUserPda(vault, subAccountId),
+            userStats: this.getUserStatsPda(vault)
+        };
     }
-    getGlamReferrer() {
-        return [
-            sdk.getUserAccountPublicKeySync(DRIFT_PROGRAM_ID, GLAM_REFERRER, 0),
-            sdk.getUserStatsAccountPublicKey(DRIFT_PROGRAM_ID, GLAM_REFERRER)
-        ];
+    get driftStatePda() {
+        return web3_js.PublicKey.findProgramAddressSync([
+            Buffer.from("drift_state")
+        ], DRIFT_PROGRAM_ID)[0];
     }
-    async fetchMarketConfigs() {
-        const response = await fetch("https://api.glam.systems/v0/drift/market_configs/");
-        if (!response.ok) {
-            throw new Error(`Failed to fetch market configs: ${response.status}`);
+    async fetchAndParseSpotMarket(marketIndex) {
+        const markets = await this.fetchAndParseSpotMarkets([
+            marketIndex
+        ]);
+        if (!markets || markets.length === 0) {
+            throw new Error(`Spot market not found at index ${marketIndex}`);
         }
-        const data = await response.json();
-        return data;
+        return markets[0];
+    }
+    async fetchAndParseSpotMarkets(marketIndexes) {
+        const indexesToFetch = marketIndexes.filter((marketIndex)=>!this.spotMarkets.has(marketIndex));
+        if (indexesToFetch.length > 0) {
+            console.log("Fetching spot markets:", indexesToFetch);
+            const marketPdas = indexesToFetch.map((marketIndex)=>this.getMarketPda(MarketType.SPOT, marketIndex));
+            const accounts = await this.base.provider.connection.getMultipleAccountsInfo(marketPdas);
+            accounts.forEach((account)=>{
+                if (account) {
+                    const spotMarket = this.parseSpotMarket(account.data);
+                    this.spotMarkets.set(spotMarket.marketIndex, spotMarket);
+                }
+            });
+        }
+        // At this point this.spotMarkets has all the requested markets
+        return marketIndexes.map((marketIndex)=>this.spotMarkets.get(marketIndex)).filter((m)=>m);
     }
-    async fetchGlamDriftUser(glamState, subAccountId = 0) {
-        const vault = this.base.getVaultPda(new web3_js.PublicKey(glamState));
-        const response = await fetch(`https://api.glam.systems/v0/drift/user?authority=${vault.toBase58()}&accountId=${subAccountId}`);
-        const data = await response.json();
-        if (!data) {
-            throw new Error("Failed to fetch drift user.");
+    async fetchAndParsePerpMarket(marketIndex) {
+        const markets = await this.fetchAndParsePerpMarkets([
+            marketIndex
+        ]);
+        if (!markets || markets.length === 0) {
+            throw new Error(`Perp market not found at index ${marketIndex}`);
         }
-        return data;
+        return markets[0];
+    }
+    async fetchAndParsePerpMarkets(marketIndexes) {
+        const indexesToFetch = marketIndexes.filter((marketIndex)=>!this.perpMarkets.has(marketIndex));
+        if (indexesToFetch.length > 0) {
+            console.log("Fetching perp markets:", indexesToFetch);
+            const marketPdas = marketIndexes.map((marketIndex)=>this.getMarketPda(MarketType.PERP, marketIndex));
+            const accounts = await this.base.provider.connection.getMultipleAccountsInfo(marketPdas);
+            accounts.forEach((account)=>{
+                if (account) {
+                    const perpMarket = this.parsePerpMarket(account.data);
+                    this.perpMarkets.set(perpMarket.marketIndex, perpMarket);
+                }
+            });
+        } else {
+            console.log("Requested perp markets already cached:", marketIndexes);
+        }
+        return marketIndexes.map((marketIndex)=>this.perpMarkets.get(marketIndex)).filter((m)=>m);
     }
-    async getPositions(statePda, subAccountId = 0) {
-        const { spotPositions, perpPositions } = await this.fetchGlamDriftUser(new web3_js.PublicKey(statePda), subAccountId);
+    async fetchMarketConfigs() {
+        // const response = await fetch(
+        //   "https://api.glam.systems/v0/drift/market_configs/",
+        // );
+        // if (!response.ok) {
+        //   throw new Error(`Failed to fetch market configs: ${response.status}`);
+        // }
+        // const data = await response.json();
+        // const { orderConstants, perp, spot } = data;
+        // // Transform perp market from API to `PerpMarket` type
+        // const perpMarkets = perp.map((m: any) => ({
+        //   marketIndex: m.marketIndex,
+        //   marketPda: m.marketPDA,
+        //   oracle: new PublicKey(m.oracle),
+        // }));
+        // // Transform spot market from API to `SpotMarket` type
+        // const spotMarkets = spot.map((m: any) => ({
+        //   marketIndex: m.marketIndex,
+        //   marketPda: m.marketPDA,
+        //   oracle: new PublicKey(m.oracle),
+        //   mint: new PublicKey(m.mint),
+        //   vault: new PublicKey(m.vaultPDA),
+        //   decimals: m.decimals,
+        // }));
+        if (!this.marketConfigs) {
+            const perpMarkets = await this.fetchAndParsePerpMarkets(Array.from(Array(100).keys()));
+            const spotMarkets = await this.fetchAndParseSpotMarkets(Array.from(Array(100).keys()));
+            this.marketConfigs = {
+                orderConstants: {
+                    perpBaseScale: 9,
+                    quoteScale: 6
+                },
+                perpMarkets,
+                spotMarkets
+            };
+        }
+        return this.marketConfigs;
+    }
+    // public async fetchGlamDriftUser(
+    //   glamState: PublicKey | string,
+    //   subAccountId: number = 0,
+    // ): Promise<GlamDriftUser> {
+    //   const vault = this.base.getVaultPda(new PublicKey(glamState));
+    //   const response = await fetch(
+    //     `https://api.glam.systems/v0/drift/user?authority=${vault.toBase58()}&accountId=${subAccountId}`,
+    //   );
+    //   const data = await response.json();
+    //   if (!data) {
+    //     throw new Error("Failed to fetch drift user.");
+    //   }
+    //   return data as GlamDriftUser;
+    // }
+    charsToName(chars) {
+        return String.fromCharCode(...chars).replace(/\0/g, "").trim();
+    }
+    async fetchDriftUser(statePda, subAccountId = 0) {
+        const { user } = this.getDriftUserPdas(new web3_js.PublicKey(statePda), subAccountId);
+        const accountInfo = await this.base.provider.connection.getAccountInfo(user);
+        if (!accountInfo) {
+            return null;
+        }
+        const { delegate, name, spotPositions, marginMode, perpPositions, isMarginTradingEnabled, maxMarginRatio, orders } = decodeUser(accountInfo.data);
+        // Prefetch market configs
+        const marketConfigs = await this.fetchMarketConfigs();
+        const spotPositionsExt = await Promise.all(spotPositions.map(async (p)=>{
+            const { amount, uiAmount } = await this.calcSpotBalance(p.marketIndex, p.scaledBalance, p.balanceType);
+            const spotMarket = marketConfigs.spotMarkets.find((m)=>m.marketIndex === p.marketIndex);
+            return {
+                ...p,
+                amount,
+                uiAmount,
+                mint: spotMarket.mint,
+                decimals: spotMarket.decimals,
+                marketName: spotMarket.name
+            };
+        }));
         return {
-            spotPositions,
-            perpPositions
+            delegate,
+            name: this.charsToName(name),
+            spotPositions: spotPositionsExt,
+            perpPositions,
+            orders,
+            marginMode,
+            subAccountId,
+            isMarginTradingEnabled,
+            maxMarginRatio
         };
     }
+    // async getPositions(statePda: PublicKey | string, subAccountId: number = 0) {
+    //   const driftUser = await this.fetchDriftUser(
+    //     new PublicKey(statePda),
+    //     subAccountId,
+    //   );
+    //   if (!driftUser) {
+    //     return { spotPositions: [], perpPositions: [] };
+    //   }
+    //   const marketConfigs = await this.fetchMarketConfigs();
+    //   const { spotPositions, perpPositions } = driftUser;
+    //   return { spotPositions, perpPositions };
+    // }
     async fetchPolicyConfig(glamState) {
-        let driftUserAccount;
-        if (glamState && glamState.id) {
-            const [driftUserAddress] = this.getUser(glamState.id);
-            const connection = this.base.provider.connection;
-            const info = await connection.getAccountInfo(driftUserAddress, connection.commitment);
-            if (info) {
-                driftUserAccount = sdk.decodeUser(info.data);
-            }
-        }
+        const driftUserAccount = glamState && glamState.id && await this.fetchDriftUser(glamState.id);
         let delegate = driftUserAccount?.delegate;
-        if (delegate && delegate.equals(new web3_js.PublicKey(0))) {
+        if (delegate && delegate.equals(web3_js.PublicKey.default)) {
             delegate = undefined;
         }
         return {
@@ -13718,26 +14802,33 @@ class DriftClient {
             driftMarketIndexesSpot: glamState?.driftMarketIndexesSpot || []
         };
     }
-    async composeRemainingAccounts(glamState, subAccountId, marketConfigs, marketType, marketIndex) {
-        const { spotPositions, perpPositions } = await this.getPositions(glamState, subAccountId);
+    async composeRemainingAccounts(glamState, subAccountId, marketType, marketIndex) {
+        const driftUser = await this.fetchDriftUser(glamState, subAccountId);
+        if (!driftUser) {
+            throw new Error("Drift user not found");
+        }
+        const { spotPositions, perpPositions } = driftUser;
         const spotMarketIndexes = spotPositions.map((p)=>p.marketIndex);
         const perpMarketIndexes = perpPositions.map((p)=>p.marketIndex);
         // Note that marketIndex is could be 0, need to explicitly check undefined
-        if (this.marketTypeEquals(marketType, sdk.MarketType.SPOT) && marketIndex !== undefined && !spotMarketIndexes.includes(marketIndex)) {
+        if (this.marketTypeEquals(marketType, MarketType.SPOT) && marketIndex !== undefined && !spotMarketIndexes.includes(marketIndex)) {
             spotMarketIndexes.push(marketIndex);
-        } else if (this.marketTypeEquals(marketType, sdk.MarketType.PERP) && marketIndex !== undefined && !perpMarketIndexes.includes(marketIndex)) {
+        } else if (this.marketTypeEquals(marketType, MarketType.PERP) && marketIndex !== undefined && !perpMarketIndexes.includes(marketIndex)) {
             perpMarketIndexes.push(marketIndex);
         }
         // Also include USDC spot market if we're composing remaining accounts for spot or perp orders
-        if (this.marketTypeEquals(marketType, sdk.MarketType.PERP) || this.marketTypeEquals(marketType, sdk.MarketType.SPOT)) {
+        if (this.marketTypeEquals(marketType, MarketType.PERP) || this.marketTypeEquals(marketType, MarketType.SPOT)) {
             if (!spotMarketIndexes.includes(0)) {
                 spotMarketIndexes.push(0);
             }
         }
-        const oracles = spotMarketIndexes.map((i)=>marketConfigs.spot[i].oracle).concat(perpMarketIndexes.map((i)=>marketConfigs.perp[i].oracle));
-        const markets = spotMarketIndexes.map((i)=>marketConfigs.spot[i].marketPDA).concat(perpMarketIndexes.map((i)=>marketConfigs.perp[i].marketPDA));
-        console.log("[composeRemainingAccounts] markets:", markets);
-        console.log("[composeRemainingAccounts] oracles:", oracles);
+        const spotMarkets = await this.fetchAndParseSpotMarkets(spotMarketIndexes);
+        const perpMarkets = await this.fetchAndParsePerpMarkets(perpMarketIndexes);
+        console.log("[composeRemainingAccounts] perpMarkets:", perpMarkets);
+        const oracles = spotMarkets.map((m)=>m.oracle).concat(perpMarkets.map((m)=>m.oracle));
+        const markets = spotMarkets.map((m)=>m.marketPda).concat(perpMarkets.map((m)=>m.marketPda));
+        console.log("[composeRemainingAccounts] markets:", markets.map((m)=>m.toBase58()));
+        console.log("[composeRemainingAccounts] oracles:", oracles.map((o)=>o.toBase58()));
         return oracles.map((o)=>({
                 pubkey: new web3_js.PublicKey(o),
                 isWritable: false,
@@ -13749,30 +14840,36 @@ class DriftClient {
             })));
     }
     async initializeUserStatsIx(glamState, glamSigner) {
-        const [_, userStats] = this.getUser(glamState);
-        const state = await sdk.getDriftStateAccountPublicKey(DRIFT_PROGRAM_ID);
+        const { userStats } = this.getDriftUserPdas(glamState);
         // @ts-ignore
         return await this.base.program.methods.driftInitializeUserStats().accounts({
             glamState,
             glamSigner,
-            state,
+            state: this.driftStatePda,
             userStats
         }).instruction();
     }
     async initializeUserIx(glamState, glamSigner, subAccountId) {
         const name = `GLAM *.+ ${subAccountId}`.split("").map((char)=>char.charCodeAt(0)).concat(Array(24).fill(0));
-        const [user, userStats] = this.getUser(glamState, subAccountId);
-        const state = await sdk.getDriftStateAccountPublicKey(DRIFT_PROGRAM_ID);
-        const remainingAccounts = this.getGlamReferrer().map((p)=>({
-                pubkey: p,
+        const { user, userStats } = this.getDriftUserPdas(glamState, subAccountId);
+        const { user: referrer, userStats: referrerStats } = this.getGlamReferrerPdas();
+        const remainingAccounts = [
+            {
+                pubkey: referrer,
                 isWritable: true,
                 isSigner: false
-            }));
+            },
+            {
+                pubkey: referrerStats,
+                isWritable: true,
+                isSigner: false
+            }
+        ];
         return await this.base.program.methods.driftInitializeUser(subAccountId, name).accounts({
             glamState,
             user,
             userStats,
-            state,
+            state: this.driftStatePda,
             glamSigner
         }).remainingAccounts(remainingAccounts).instruction();
     }
@@ -13780,7 +14877,7 @@ class DriftClient {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const tx = new web3_js.Transaction();
         // Create userStats account if it doesn't exist
-        const [_, userStats] = this.getUser(glamState);
+        const { userStats } = this.getDriftUserPdas(glamState);
         const userStatsInfo = await this.base.provider.connection.getAccountInfo(userStats);
         if (!userStatsInfo) {
             tx.add(await this.initializeUserStatsIx(glamState, glamSigner));
@@ -13791,7 +14888,7 @@ class DriftClient {
     }
     async updateUserCustomMarginRatioIx(glamState, maxLeverage, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const [user] = this.getUser(glamState, subAccountId);
+        const { user } = this.getDriftUserPdas(glamState, subAccountId);
         // https://github.com/drift-labs/protocol-v2/blob/babed162b08b1fe34e49a81c5aa3e4ec0a88ecdf/programs/drift/src/math/constants.rs#L183-L184
         const marginRatio = DRIFT_MARGIN_PRECISION / maxLeverage;
         return await this.base.program.methods.driftUpdateUserCustomMarginRatio(subAccountId, marginRatio).accounts({
@@ -13806,7 +14903,7 @@ class DriftClient {
     }
     async updateUserMarginTradingEnabledIx(glamState, marginTradingEnabled, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const [user] = this.getUser(glamState, subAccountId);
+        const { user } = this.getDriftUserPdas(glamState, subAccountId);
         return await this.base.program.methods.driftUpdateUserMarginTradingEnabled(subAccountId, marginTradingEnabled).accounts({
             glamState,
             glamSigner,
@@ -13819,7 +14916,7 @@ class DriftClient {
     }
     async updateUserDelegateIx(glamState, delegate, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const [user] = this.getUser(glamState, subAccountId);
+        const { user } = this.getDriftUserPdas(glamState, subAccountId);
         return await this.base.program.methods.driftUpdateUserDelegate(subAccountId, new web3_js.PublicKey(delegate)).accounts({
             glamState,
             glamSigner,
@@ -13832,32 +14929,28 @@ class DriftClient {
     }
     async deleteUserTx(glamState, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const [user, userStats] = this.getUser(glamState, subAccountId);
-        const state = await sdk.getDriftStateAccountPublicKey(DRIFT_PROGRAM_ID);
+        const { user, userStats } = this.getDriftUserPdas(glamState, subAccountId);
         const tx = await this.base.program.methods.driftDeleteUser().accounts({
             glamState,
-            state,
+            state: this.driftStatePda,
             user,
             userStats,
             glamSigner
         }).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async depositTx(glamState, amount, marketIndex = 1, subAccountId = 0, marketConfigs, txOptions = {}) {
+    async depositTx(glamState, amount, marketIndex = 1, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const [user, userStats] = this.getUser(glamState, subAccountId);
-        const state = await sdk.getDriftStateAccountPublicKey(DRIFT_PROGRAM_ID);
-        const { mint, oracle, marketPDA, vaultPDA } = marketConfigs.spot[marketIndex];
-        console.log("mint, oracle, marketPDA, vaultPDA", mint, oracle, marketPDA, vaultPDA);
+        const { user, userStats } = this.getDriftUserPdas(glamState, subAccountId);
+        const { mint, oracle, tokenProgram, marketPda, vault: driftVault } = await this.fetchAndParseSpotMarket(marketIndex);
+        console.log(`Spot market ${marketIndex} mint ${mint}, oracle: ${oracle}, marketPda: ${marketPda}, vault: ${driftVault}`);
         const preInstructions = [];
         const postInstructions = [];
         // If drift user doesn't exist, prepend initializeUserStats and initializeUser instructions
-        try {
-            await this.fetchGlamDriftUser(glamState, subAccountId);
-        } catch (_) {
+        if (!await this.fetchDriftUser(glamState, subAccountId)) {
             preInstructions.push(await this.initializeUserStatsIx(glamState, glamSigner), await this.initializeUserIx(glamState, glamSigner, subAccountId));
         }
-        if (mint === WSOL.toBase58()) {
+        if (mint.equals(WSOL)) {
             const wrapSolIxs = await this.base.maybeWrapSol(glamState, amount, glamSigner);
             preInstructions.push(...wrapSolIxs);
             // If we need to wrap SOL, it means the wSOL balance will be drained,
@@ -13871,79 +14964,97 @@ class DriftClient {
             }).instruction();
             postInstructions.push(closeTokenAccountIx);
         }
-        const tx = await this.base.program.methods.driftDeposit(marketIndex, amount, false).accounts({
-            glamState,
-            state,
-            user,
-            userStats,
-            spotMarketVault: new web3_js.PublicKey(vaultPDA),
-            userTokenAccount: this.base.getVaultAta(glamState, new web3_js.PublicKey(mint)),
-            glamSigner,
-            tokenProgram: splToken.TOKEN_PROGRAM_ID
-        }).remainingAccounts([
+        const remainingAccounts = [
             {
                 pubkey: new web3_js.PublicKey(oracle),
                 isSigner: false,
                 isWritable: false
             },
             {
-                pubkey: new web3_js.PublicKey(marketPDA),
+                pubkey: new web3_js.PublicKey(marketPda),
                 isSigner: false,
                 isWritable: true
             }
-        ]).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+        ];
+        if (tokenProgram.equals(splToken.TOKEN_2022_PROGRAM_ID)) {
+            remainingAccounts.push({
+                pubkey: mint,
+                isSigner: false,
+                isWritable: false
+            });
+        }
+        const tx = await this.base.program.methods.driftDeposit(marketIndex, amount, false).accounts({
+            glamState,
+            state: this.driftStatePda,
+            user,
+            userStats,
+            spotMarketVault: driftVault,
+            userTokenAccount: this.base.getVaultAta(glamState, mint, tokenProgram),
+            glamSigner,
+            tokenProgram
+        }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async withdrawTx(statePda, amount, marketIndex = 1, subAccountId = 0, marketConfigs, txOptions = {}) {
+    async withdrawTx(statePda, amount, marketIndex = 1, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const [user, userStats] = this.getUser(statePda, subAccountId);
-        const state = await sdk.getDriftStateAccountPublicKey(DRIFT_PROGRAM_ID);
-        const { mint: m, vaultPDA: d } = marketConfigs.spot[marketIndex];
-        const mint = new web3_js.PublicKey(m);
-        const driftAta = new web3_js.PublicKey(d); // drift vault ata
-        const vault = this.base.getVaultPda(statePda);
-        const vaultAta = this.base.getVaultAta(statePda, mint); // glam vault ata
-        const remainingAccounts = await this.composeRemainingAccounts(statePda, subAccountId, marketConfigs, sdk.MarketType.SPOT, marketIndex);
-        const { tokenProgram } = await this.base.fetchMintWithOwner(mint);
+        const { user, userStats } = this.getDriftUserPdas(statePda, subAccountId);
+        const { mint, tokenProgram, vault: driftVault } = await this.fetchAndParseSpotMarket(marketIndex);
+        const glamVault = this.base.getVaultPda(statePda);
+        const glamVaultAta = this.base.getVaultAta(statePda, mint, tokenProgram);
+        const remainingAccounts = await this.composeRemainingAccounts(statePda, subAccountId, MarketType.SPOT, marketIndex);
+        if (tokenProgram.equals(splToken.TOKEN_2022_PROGRAM_ID)) {
+            remainingAccounts.push({
+                pubkey: mint,
+                isSigner: false,
+                isWritable: false
+            });
+        }
         // Create vault ata in case it doesn't exist
         const preInstructions = [
-            splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, vaultAta, vault, mint, tokenProgram)
+            splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, glamVaultAta, glamVault, mint, tokenProgram)
         ];
         const tx = await this.base.program.methods.driftWithdraw(marketIndex, amount, false).accounts({
             glamState: statePda,
-            state,
+            state: this.driftStatePda,
             user,
             userStats,
             glamSigner,
-            spotMarketVault: driftAta,
-            userTokenAccount: vaultAta,
-            driftSigner: DRIFT_VAULT,
-            tokenProgram: splToken.TOKEN_PROGRAM_ID
+            spotMarketVault: driftVault,
+            userTokenAccount: glamVaultAta,
+            driftSigner: DRIFT_SIGNER,
+            tokenProgram
         }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async placeOrderTx(glamState, orderParams, subAccountId = 0, marketConfigs, txOptions = {}) {
+    async placeOrderTx(glamState, orderParams, subAccountId = 0, txOptions = {}) {
         const { marketIndex, marketType } = orderParams;
-        const remainingAccounts = (await this.composeRemainingAccounts(glamState, subAccountId, marketConfigs, marketType, marketIndex)).concat(this.getGlamReferrer().map((p)=>({
-                pubkey: p,
+        const { user: referrer, userStats: referrerStats } = this.getGlamReferrerPdas();
+        const remainingAccounts = (await this.composeRemainingAccounts(glamState, subAccountId, marketType, marketIndex)).concat([
+            {
+                pubkey: referrer,
                 isWritable: true,
                 isSigner: false
-            })));
+            },
+            {
+                pubkey: referrerStats,
+                isWritable: true,
+                isSigner: false
+            }
+        ]);
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const [user] = this.getUser(glamState, subAccountId);
-        const state = await sdk.getDriftStateAccountPublicKey(DRIFT_PROGRAM_ID);
-        const tx = await this.base.program.methods// @ts-ignore
-        .driftPlaceOrders([
+        const { user } = this.getDriftUserPdas(glamState, subAccountId);
+        // @ts-ignore
+        const tx = await this.base.program.methods.driftPlaceOrders([
             orderParams
         ]).accounts({
             glamState,
             user,
-            state,
+            state: this.driftStatePda,
             glamSigner
         }).remainingAccounts(remainingAccounts).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async modifyOrderTx(statePda, modifyOrderParams, subAccountId = 0, marketConfigs, txOptions = {}) {
+    async modifyOrderTx(statePda, modifyOrderParams, subAccountId = 0, txOptions = {}) {
         // const { marketIndex, marketType } = orderParams;
         // const remainingAccounts = await this.composeRemainingAccounts(
         //   statePda,
@@ -13953,65 +15064,62 @@ class DriftClient {
         //   marketIndex,
         // );
         const signer = txOptions.signer || this.base.getSigner();
-        const [user] = this.getUser(statePda, subAccountId);
-        const driftState = await sdk.getDriftStateAccountPublicKey(DRIFT_PROGRAM_ID);
+        const { user } = this.getDriftUserPdas(statePda, subAccountId);
         const tx = await this.base.program.methods// @ts-ignore
         .driftModifyOrder(1, modifyOrderParams).accounts({
             glamState: statePda,
             glamSigner: signer,
             user,
-            state: driftState
+            state: this.driftStatePda
         })// .remainingAccounts(remainingAccounts)
         .transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async cancelOrdersTx(glamState, marketType, marketIndex, direction, subAccountId = 0, marketConfigs, txOptions = {}) {
+    async cancelOrdersTx(glamState, marketType, marketIndex, direction, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const [user] = this.getUser(glamState, subAccountId);
-        const driftState = await sdk.getDriftStateAccountPublicKey(DRIFT_PROGRAM_ID);
-        const remainingAccounts = await this.composeRemainingAccounts(glamState, subAccountId, marketConfigs, marketType, marketIndex);
+        const { user } = this.getDriftUserPdas(glamState, subAccountId);
+        const remainingAccounts = await this.composeRemainingAccounts(glamState, subAccountId, marketType, marketIndex);
         // @ts-ignore
         const tx = await this.base.program.methods.driftCancelOrders(marketType, marketIndex, direction).accounts({
             glamState,
             glamSigner,
             user,
-            state: driftState
+            state: this.driftStatePda
         }).remainingAccounts(remainingAccounts).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async cancelOrdersByIdsTx(glamState, orderIds, subAccountId = 0, marketConfigs, txOptions = {}) {
+    async cancelOrdersByIdsTx(glamState, orderIds, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const [user] = this.getUser(glamState, subAccountId);
-        const driftState = await sdk.getDriftStateAccountPublicKey(DRIFT_PROGRAM_ID);
-        const remainingAccounts = await this.composeRemainingAccounts(glamState, subAccountId, marketConfigs);
+        const { user } = this.getDriftUserPdas(glamState, subAccountId);
+        const remainingAccounts = await this.composeRemainingAccounts(glamState, subAccountId);
+        // @ts-ignore
         const tx = await this.base.program.methods.driftCancelOrdersByIds(orderIds).accounts({
             glamState,
             glamSigner,
             user,
-            state: driftState
+            state: this.driftStatePda
         }).remainingAccounts(remainingAccounts).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async settlePnlTx(glamState, marketIndex, subAccountId = 0, marketConfigs, txOptions = {}) {
+    async settlePnlTx(glamState, marketIndex, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const [user] = this.getUser(glamState, subAccountId);
-        const driftState = await sdk.getDriftStateAccountPublicKey(DRIFT_PROGRAM_ID);
-        const { vaultPDA } = marketConfigs.spot[marketIndex];
+        const { user } = this.getDriftUserPdas(glamState, subAccountId);
+        const { vault: driftVault } = await this.fetchAndParseSpotMarket(marketIndex);
+        // @ts-ignore
         const tx = await this.base.program.methods.driftSettlePnl(marketIndex).accounts({
             glamState,
             glamSigner,
             user,
-            state: driftState,
-            spotMarketVault: new web3_js.PublicKey(vaultPDA)
+            state: this.driftStatePda,
+            spotMarketVault: driftVault
         }).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async priceDriftTx(glamState, marketConfigs, priceDenom, txOptions = {}) {
+    async priceDriftTx(glamState, priceDenom, txOptions = {}) {
         const signer = txOptions.signer || this.base.getSigner();
         const glamVault = this.base.getVaultPda(glamState);
-        const [user, userStats] = this.getUser(glamState);
-        const driftState = await sdk.getDriftStateAccountPublicKey(DRIFT_PROGRAM_ID);
-        const remainingAccounts = await this.composeRemainingAccounts(glamState, 0, marketConfigs);
+        const { user, userStats } = this.getDriftUserPdas(glamState);
+        const remainingAccounts = await this.composeRemainingAccounts(glamState, 0);
         const tx = await this.base.program.methods.priceDrift(priceDenom).accounts({
             glamState,
             signer,
@@ -14019,12 +15127,30 @@ class DriftClient {
             user,
             userStats,
             solOracle: SOL_ORACLE,
-            state: driftState
+            state: this.driftStatePda
         }).remainingAccounts(remainingAccounts).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
     constructor(base){
         this.base = base;
+        this.spotMarkets = new Map();
+        this.perpMarkets = new Map();
+        this.marketConfigs = null;
+        this./*
+   * Utils
+   */ getMarketPda = (marketType, marketIndex)=>web3_js.PublicKey.findProgramAddressSync([
+                Buffer.from(`${marketType === MarketType.PERP ? "perp" : "spot"}_market`),
+                new anchor__namespace.BN(marketIndex).toArrayLike(Buffer, "le", 2)
+            ], DRIFT_PROGRAM_ID)[0];
+        this.getUserPda = (authority, subAccountId = 0)=>web3_js.PublicKey.findProgramAddressSync([
+                Buffer.from("user"),
+                authority.toBuffer(),
+                new anchor__namespace.BN(subAccountId).toArrayLike(Buffer, "le", 2)
+            ], DRIFT_PROGRAM_ID)[0];
+        this.getUserStatsPda = (authority)=>web3_js.PublicKey.findProgramAddressSync([
+                Buffer.from("user_stats"),
+                authority.toBuffer()
+            ], DRIFT_PROGRAM_ID)[0];
         this.marketTypeEquals = (a, b)=>a && Object.keys(a)[0] === Object.keys(b)[0];
     }
 }
@@ -17387,15 +18513,58 @@ const getPriorityFeeEstimate = async (heliusApiKey, tx, accountKeys, priorityLev
     return data.result.priorityFeeEstimate;
 };
 
+function getLimitOrderParams(params) {
+    return getOrderParams(Object.assign({}, params, {
+        orderType: OrderType.LIMIT
+    }));
+}
+function getTriggerMarketOrderParams(params) {
+    return getOrderParams(Object.assign({}, params, {
+        orderType: OrderType.TRIGGER_MARKET
+    }));
+}
+function getTriggerLimitOrderParams(params) {
+    return getOrderParams(Object.assign({}, params, {
+        orderType: OrderType.TRIGGER_LIMIT
+    }));
+}
+function getMarketOrderParams(params) {
+    return getOrderParams(Object.assign({}, params, {
+        orderType: OrderType.MARKET
+    }));
+}
+/**
+ * Creates an OrderParams object with the given OptionalOrderParams and any params to override.
+ *
+ * example:
+ * ```
+ * const orderParams = getOrderParams(optionalOrderParams, { marketType: MarketType.PERP });
+ * ```
+ *
+ * @param optionalOrderParams
+ * @param overridingParams
+ * @returns
+ */ function getOrderParams(optionalOrderParams, overridingParams = {}) {
+    return Object.assign({}, DefaultOrderParams, optionalOrderParams, overridingParams);
+}
+
 exports.ASSETS_MAINNET = ASSETS_MAINNET;
 exports.ASSETS_TESTS = ASSETS_TESTS;
+exports.AssetTier = AssetTier;
 exports.BaseClient = BaseClient;
 exports.ClusterNetwork = ClusterNetwork;
 exports.CompanyModel = CompanyModel;
+exports.ContractTier = ContractTier;
+exports.ContractType = ContractType;
 exports.CreatedModel = CreatedModel;
 exports.DRIFT_PROGRAM_ID = DRIFT_PROGRAM_ID;
+exports.DefaultOrderParams = DefaultOrderParams;
 exports.DelegateAcl = DelegateAcl;
+exports.DepositDirection = DepositDirection;
+exports.DepositExplanation = DepositExplanation;
 exports.DriftClient = DriftClient;
+exports.ExchangeStatus = ExchangeStatus;
+exports.FuelOverflowStatus = FuelOverflowStatus;
 exports.FundOpenfundsModel = FundOpenfundsModel;
 exports.GLAM_REFERRER = GLAM_REFERRER;
 exports.GOVERNANCE_PROGRAM_ID = GOVERNANCE_PROGRAM_ID;
@@ -17405,6 +18574,7 @@ exports.GlamIdl = GlamIdl;
 exports.GlamIntegrations = GlamIntegrations;
 exports.GlamPermissions = GlamPermissions;
 exports.GlamProtocolIdlJson = GlamProtocolIdlJson;
+exports.InsuranceFundOperation = InsuranceFundOperation;
 exports.JITOSOL = JITOSOL;
 exports.JITO_STAKE_POOL = JITO_STAKE_POOL;
 exports.JITO_TIP_DEFAULT = JITO_TIP_DEFAULT;
@@ -17418,6 +18588,8 @@ exports.JupiterVoteClient = JupiterVoteClient;
 exports.KAMINO_FARM_PROGRAM = KAMINO_FARM_PROGRAM;
 exports.KAMINO_LENDING_PROGRAM = KAMINO_LENDING_PROGRAM;
 exports.KAMINO_OBTRIGATION_SIZE = KAMINO_OBTRIGATION_SIZE;
+exports.LPAction = LPAction;
+exports.LiquidationType = LiquidationType;
 exports.MARINADE_PROGRAM_ID = MARINADE_PROGRAM_ID;
 exports.MARINADE_TICKET_SIZE = MARINADE_TICKET_SIZE;
 exports.MEMO_PROGRAM = MEMO_PROGRAM;
@@ -17426,11 +18598,27 @@ exports.METEORA_DLMM_PROGRAM = METEORA_DLMM_PROGRAM;
 exports.METEORA_POSITION_SIZE = METEORA_POSITION_SIZE;
 exports.MSOL = MSOL;
 exports.ManagerModel = ManagerModel;
+exports.MarginMode = MarginMode;
+exports.MarketStatus = MarketStatus;
+exports.MarketType = MarketType;
 exports.Metadata = Metadata;
 exports.MintIdlModel = MintIdlModel;
 exports.MintModel = MintModel;
 exports.MintOpenfundsModel = MintOpenfundsModel;
+exports.ModifyOrderPolicy = ModifyOrderPolicy;
+exports.OracleSource = OracleSource;
+exports.OracleSourceNum = OracleSourceNum;
+exports.OrderAction = OrderAction;
+exports.OrderActionExplanation = OrderActionExplanation;
+exports.OrderStatus = OrderStatus;
+exports.OrderTriggerCondition = OrderTriggerCondition;
+exports.OrderType = OrderType;
+exports.PerpOperation = PerpOperation;
+exports.PlaceAndTakeOrderSuccessCondition = PlaceAndTakeOrderSuccessCondition;
+exports.PositionDirection = PositionDirection;
+exports.PostOnlyParams = PostOnlyParams;
 exports.PriceDenom = PriceDenom;
+exports.ReferrerStatus = ReferrerStatus;
 exports.SANCTUM_STAKE_POOL_PROGRAM_ID = SANCTUM_STAKE_POOL_PROGRAM_ID;
 exports.SEED_ESCROW = SEED_ESCROW;
 exports.SEED_METADATA = SEED_METADATA;
@@ -17439,20 +18627,43 @@ exports.SEED_STATE = SEED_STATE;
 exports.SEED_VAULT = SEED_VAULT;
 exports.SOL_ORACLE = SOL_ORACLE;
 exports.STAKE_ACCOUNT_SIZE = STAKE_ACCOUNT_SIZE;
+exports.SettlePnlExplanation = SettlePnlExplanation;
+exports.SettlePnlMode = SettlePnlMode;
+exports.SpotBalanceType = SpotBalanceType;
+exports.SpotFulfillmentConfigStatus = SpotFulfillmentConfigStatus;
+exports.SpotFulfillmentStatus = SpotFulfillmentStatus;
+exports.SpotFulfillmentType = SpotFulfillmentType;
+exports.SpotOperation = SpotOperation;
+exports.StakeAction = StakeAction;
 exports.StateIdlModel = StateIdlModel;
 exports.StateModel = StateModel;
+exports.SwapDirection = SwapDirection;
+exports.SwapReduceOnly = SwapReduceOnly;
 exports.TRANSFER_HOOK_PROGRAM = TRANSFER_HOOK_PROGRAM;
+exports.TradeSide = TradeSide;
 exports.USDC = USDC;
+exports.UserStatus = UserStatus;
 exports.WBTC = WBTC;
 exports.WETH = WETH;
 exports.WSOL = WSOL;
+exports.ZERO = ZERO;
+exports.decodeUser = decodeUser;
 exports.fetchKaminoObligations = fetchKaminoObligations;
 exports.fetchMarinadeTicketAccounts = fetchMarinadeTicketAccounts;
 exports.fetchMeteoraPositions = fetchMeteoraPositions;
 exports.fetchStakeAccounts = fetchStakeAccounts;
 exports.getGlamProgram = getGlamProgram;
 exports.getGlamProgramId = getGlamProgramId;
+exports.getLimitOrderParams = getLimitOrderParams;
+exports.getMarketOrderParams = getMarketOrderParams;
+exports.getOrderParams = getOrderParams;
 exports.getPriorityFeeEstimate = getPriorityFeeEstimate;
 exports.getSimulationComputeUnits = getSimulationComputeUnits;
+exports.getTriggerLimitOrderParams = getTriggerLimitOrderParams;
+exports.getTriggerMarketOrderParams = getTriggerMarketOrderParams;
+exports.getVariant = getVariant;
 exports.isBrowser = isBrowser;
+exports.isOneOfVariant = isOneOfVariant;
+exports.isVariant = isVariant;
 exports.parseMeteoraPosition = parseMeteoraPosition;
+exports.setsAreEqual = setsAreEqual;