@drift-labs/sdk 2.49.0-beta.16 → 2.49.0-beta.18

package/VERSION

@@ -1 +1 @@
-2.49.0-beta.16
+2.49.0-beta.18

package/lib/adminClient.d.ts

@@ -37,6 +37,7 @@ export declare class AdminClient extends DriftClient {
     updateOracleGuardRails(oracleGuardRails: OracleGuardRails): Promise<TransactionSignature>;
     updateStateSettlementDuration(settlementDuration: number): Promise<TransactionSignature>;
     updateStateMaxNumberOfSubAccounts(maxNumberOfSubAccounts: number): Promise<TransactionSignature>;
+    updateStateMaxInitializeUserFee(maxInitializeUserFee: number): Promise<TransactionSignature>;
     updateWithdrawGuardThreshold(spotMarketIndex: number, withdrawGuardThreshold: BN): Promise<TransactionSignature>;
     updateSpotMarketIfFactor(spotMarketIndex: number, userIfFactor: BN, totalIfFactor: BN): Promise<TransactionSignature>;
     updateSpotMarketRevenueSettlePeriod(spotMarketIndex: number, revenueSettlePeriod: BN): Promise<TransactionSignature>;

package/lib/adminClient.js

@@ -455,6 +455,14 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
+    async updateStateMaxInitializeUserFee(maxInitializeUserFee) {
+        return await this.program.rpc.updateStateMaxInitializeUserFee(maxInitializeUserFee, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
     async updateWithdrawGuardThreshold(spotMarketIndex, withdrawGuardThreshold) {
         const tx = await this.program.transaction.updateWithdrawGuardThreshold(withdrawGuardThreshold, {
             accounts: {

package/lib/decode/user.d.ts

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

package/lib/decode/user.js

@@ -0,0 +1,328 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeUser = void 0;
+const types_1 = require("../types");
+const web3_js_1 = require("@solana/web3.js");
+const __1 = require("../");
+const __2 = require("../");
+function readUnsignedBigInt64LE(buffer, offset) {
+    return new __1.BN(buffer.subarray(offset, offset + 8), 10, 'le');
+}
+function readSignedBigInt64LE(buffer, offset) {
+    const unsignedValue = new __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(__2.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 lpShares = readUnsignedBigInt64LE(buffer, offset + 64);
+        const openOrders = buffer.readUInt8(offset + 94);
+        if (baseAssetAmount.eq(__2.ZERO) &&
+            openOrders === 0 &&
+            quoteAssetAmount.eq(__2.ZERO) &&
+            lpShares.eq(__2.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.readUint32LE(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) === 0) {
+            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;
+        offset += 3; // padding
+        orders.push({
+            slot,
+            price,
+            baseAssetAmount,
+            baseAssetAmountFilled,
+            quoteAssetAmountFilled,
+            triggerPrice,
+            auctionStartPrice,
+            auctionEndPrice,
+            maxTs,
+            oraclePriceOffset,
+            orderId,
+            marketIndex,
+            status,
+            orderType,
+            marketType,
+            userOrderId,
+            existingPositionDirection,
+            direction,
+            reduceOnly,
+            postOnly,
+            immediateOrCancel,
+            triggerCondition,
+            auctionDuration,
+        });
+    }
+    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;
+    // @ts-ignore
+    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,
+    };
+}
+exports.decodeUser = decodeUser;

package/lib/idl/drift.json

@@ -4184,6 +4184,27 @@
                 }
             ]
         },
+        {
+            "name": "updateStateMaxInitializeUserFee",
+            "accounts": [
+                {
+                    "name": "admin",
+                    "isMut": false,
+                    "isSigner": true
+                },
+                {
+                    "name": "state",
+                    "isMut": true,
+                    "isSigner": false
+                }
+            ],
+            "args": [
+                {
+                    "name": "maxInitializeUserFee",
+                    "type": "u16"
+                }
+            ]
+        },
         {
             "name": "updatePerpMarketOracle",
             "accounts": [
@@ -5747,12 +5768,16 @@
                         "name": "maxNumberOfSubAccounts",
                         "type": "u16"
                     },
+                    {
+                        "name": "maxInitializeUserFee",
+                        "type": "u16"
+                    },
                     {
                         "name": "padding",
                         "type": {
                             "array": [
                                 "u8",
-                                12
+                                10
                             ]
                         }
                     }
@@ -11094,6 +11119,11 @@
             "code": 6255,
             "name": "InvalidMarginCalculation",
             "msg": "InvalidMarginCalculation"
+        },
+        {
+            "code": 6256,
+            "name": "CantPayUserInitFee",
+            "msg": "CantPayUserInitFee"
         }
     ]
 }

package/lib/index.d.ts

@@ -55,6 +55,7 @@ export * from './math/margin';
 export * from './math/insurance';
 export * from './math/superStake';
 export * from './math/spotPosition';
+export * from './math/state';
 export * from './marinade';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';

package/lib/index.js

@@ -78,6 +78,7 @@ __exportStar(require("./math/margin"), exports);
 __exportStar(require("./math/insurance"), exports);
 __exportStar(require("./math/superStake"), exports);
 __exportStar(require("./math/spotPosition"), exports);
+__exportStar(require("./math/state"), exports);
 __exportStar(require("./marinade"), exports);
 __exportStar(require("./orderParams"), exports);
 __exportStar(require("./slot/SlotSubscriber"), exports);

package/lib/math/state.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="bn.js" />
+import { StateAccount } from '../types';
+import { BN } from '../';
+export declare function calculateInitUserFee(stateAccount: StateAccount): BN;
+export declare function getMaxNumberOfSubAccounts(stateAccount: StateAccount): BN;

package/lib/math/state.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaxNumberOfSubAccounts = exports.calculateInitUserFee = void 0;
+const __1 = require("../");
+function calculateInitUserFee(stateAccount) {
+    const maxInitFee = new __1.BN(stateAccount.maxInitializeUserFee)
+        .mul(__1.LAMPORTS_PRECISION)
+        .divn(100);
+    const targetUtilization = __1.PERCENTAGE_PRECISION.muln(8).divn(10);
+    const accountSpaceUtilization = stateAccount.numberOfSubAccounts
+        .addn(1)
+        .mul(__1.PERCENTAGE_PRECISION)
+        .div(getMaxNumberOfSubAccounts(stateAccount));
+    if (accountSpaceUtilization.gt(targetUtilization)) {
+        return maxInitFee
+            .mul(accountSpaceUtilization.sub(targetUtilization))
+            .div(__1.PERCENTAGE_PRECISION.sub(targetUtilization));
+    }
+    else {
+        return __1.ZERO;
+    }
+}
+exports.calculateInitUserFee = calculateInitUserFee;
+function getMaxNumberOfSubAccounts(stateAccount) {
+    return new __1.BN(stateAccount.maxNumberOfSubAccounts).muln(100);
+}
+exports.getMaxNumberOfSubAccounts = getMaxNumberOfSubAccounts;

package/lib/orderSubscriber/OrderSubscriber.d.ts

@@ -1,7 +1,9 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { DriftClient } from '../driftClient';
 import { UserAccount } from '../types';
 import { Commitment } from '@solana/web3.js';
+import { Buffer } from 'buffer';
 import { DLOB } from '../dlob/DLOB';
 import { OrderSubscriberConfig, OrderSubscriberEvents } from './types';
 import { PollingSubscription } from './PollingSubscription';
@@ -20,6 +22,7 @@ export declare class OrderSubscriber {
     fetchPromise?: Promise<void>;
     fetchPromiseResolver: () => void;
     mostRecentSlot: number;
+    decodeFn: (name: string, data: Buffer) => UserAccount;
     constructor(config: OrderSubscriberConfig);
     subscribe(): Promise<void>;
     fetch(): Promise<void>;

package/lib/orderSubscriber/OrderSubscriber.js

@@ -9,8 +9,10 @@ const PollingSubscription_1 = require("./PollingSubscription");
 const WebsocketSubscription_1 = require("./WebsocketSubscription");
 const events_1 = require("events");
 const index_1 = require("../index");
+const user_1 = require("../decode/user");
 class OrderSubscriber {
     constructor(config) {
+        var _a;
         this.usersAccounts = new Map();
         this.driftClient = config.driftClient;
         this.commitment = config.subscriptionConfig.commitment || 'processed';
@@ -28,6 +30,13 @@ class OrderSubscriber {
                 resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
             });
         }
+        if ((_a = config.fastDecode) !== null && _a !== void 0 ? _a : true) {
+            this.decodeFn = (name, data) => (0, user_1.decodeUser)(data);
+        }
+        else {
+            this.decodeFn =
+                this.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(this.driftClient.program.account.user.coder.accounts);
+        }
         this.eventEmitter = new events_1.EventEmitter();
     }
     async subscribe() {
@@ -96,8 +105,7 @@ class OrderSubscriber {
                     slotAndUserAccount.userAccount.lastActiveSlot.gt(newLastActiveSlot)) {
                     return;
                 }
-                userAccount =
-                    this.driftClient.program.account.user.coder.accounts.decodeUnchecked('User', buffer);
+                userAccount = this.decodeFn('User', buffer);
             }
             else {
                 userAccount = data;

package/lib/orderSubscriber/WebsocketSubscription.js

@@ -14,7 +14,7 @@ class WebsocketSubscription {
         if (this.subscriber) {
             return;
         }
-        this.subscriber = new webSocketProgramAccountSubscriber_1.WebSocketProgramAccountSubscriber('OrderSubscriber', 'User', this.orderSubscriber.driftClient.program, this.orderSubscriber.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(this.orderSubscriber.driftClient.program.account.user.coder.accounts), {
+        this.subscriber = new webSocketProgramAccountSubscriber_1.WebSocketProgramAccountSubscriber('OrderSubscriber', 'User', this.orderSubscriber.driftClient.program, this.orderSubscriber.decodeFn, {
             filters: [(0, memcmp_1.getUserFilter)(), (0, memcmp_1.getNonIdleUserFilter)()],
             commitment: this.commitment,
         }, this.resubTimeoutMs);

package/lib/orderSubscriber/types.d.ts

@@ -13,6 +13,7 @@ export type OrderSubscriberConfig = {
         resubTimeoutMs?: number;
         commitment?: Commitment;
     };
+    fastDecode?: boolean;
 };
 export interface OrderSubscriberEvents {
     orderCreated: (account: UserAccount, updatedOrders: Order[], pubkey: PublicKey, slot: number, dataType: 'raw' | 'decoded') => void;

package/lib/types.d.ts

@@ -629,6 +629,7 @@ export type StateAccount = {
     lpCooldownTime: BN;
     initialPctToLiquidate: number;
     liquidationDuration: number;
+    maxInitializeUserFee: number;
 };
 export type PerpMarketAccount = {
     status: MarketStatus;
@@ -914,7 +915,6 @@ export type Order = {
     price: BN;
     baseAssetAmount: BN;
     baseAssetAmountFilled: BN;
-    quoteAssetAmount: BN;
     quoteAssetAmountFilled: BN;
     direction: PositionDirection;
     reduceOnly: boolean;

package/lib/user.d.ts

@@ -95,7 +95,7 @@ export declare class User {
      * @returns : the dust base asset amount (ie, < stepsize)
      * @returns : pnl from settle
      */
-    getPerpPositionWithLPSettle(marketIndex: number, originalPosition?: PerpPosition, burnLpShares?: boolean): [PerpPosition, BN, BN];
+    getPerpPositionWithLPSettle(marketIndex: number, originalPosition?: PerpPosition, burnLpShares?: boolean, includeRemainderInBaseAmount?: boolean): [PerpPosition, BN, BN];
     /**
      * calculates Buying Power = free collateral / initial margin ratio
      * @returns : Precision QUOTE_PRECISION

package/lib/user.js

@@ -251,7 +251,7 @@ class User {
      * @returns : the dust base asset amount (ie, < stepsize)
      * @returns : pnl from settle
      */
-    getPerpPositionWithLPSettle(marketIndex, originalPosition, burnLpShares = false) {
+    getPerpPositionWithLPSettle(marketIndex, originalPosition, burnLpShares = false, includeRemainderInBaseAmount = false) {
         var _a;
         originalPosition =
             (_a = originalPosition !== null && originalPosition !== void 0 ? originalPosition : this.getPerpPosition(marketIndex)) !== null && _a !== void 0 ? _a : this.getEmptyPosition(marketIndex);
@@ -396,7 +396,12 @@ class User {
         else {
             position.lastCumulativeFundingRate = numericConstants_1.ZERO;
         }
-        return [position, remainderBaa, pnl];
+        const remainderBeforeRemoval = new _1.BN(position.remainderBaseAssetAmount);
+        if (includeRemainderInBaseAmount) {
+            position.baseAssetAmount = position.baseAssetAmount.add(remainderBeforeRemoval);
+            position.remainderBaseAssetAmount = 0;
+        }
+        return [position, remainderBeforeRemoval, pnl];
     }
     /**
      * calculates Buying Power = free collateral / initial margin ratio

package/lib/userMap/PollingSubscription.js

@@ -11,7 +11,9 @@ class PollingSubscription {
         if (this.intervalId) {
             return;
         }
-        this.intervalId = setInterval(this.userMap.sync.bind(this.userMap), this.frequency);
+        if (this.frequency > 0) {
+            this.intervalId = setInterval(this.userMap.sync.bind(this.userMap), this.frequency);
+        }
         if (!this.skipInitialLoad) {
             await this.userMap.sync();
         }

package/lib/userMap/WebsocketSubscription.d.ts

@@ -1,4 +1,6 @@
+/// <reference types="node" />
 import { UserMap } from './userMap';
+import { UserAccount } from '../types';
 import { Commitment } from '@solana/web3.js';
 export declare class WebsocketSubscription {
     private userMap;
@@ -6,13 +8,15 @@ export declare class WebsocketSubscription {
     private skipInitialLoad;
     private resubTimeoutMs?;
     private includeIdle?;
+    private decodeFn;
     private subscriber;
-    constructor({ userMap, commitment, skipInitialLoad, resubTimeoutMs, includeIdle, }: {
+    constructor({ userMap, commitment, skipInitialLoad, resubTimeoutMs, includeIdle, decodeFn, }: {
         userMap: UserMap;
         commitment: Commitment;
         skipInitialLoad?: boolean;
         resubTimeoutMs?: number;
         includeIdle?: boolean;
+        decodeFn: (name: string, data: Buffer) => UserAccount;
     });
     subscribe(): Promise<void>;
     unsubscribe(): Promise<void>;

package/lib/userMap/WebsocketSubscription.js

@@ -4,12 +4,13 @@ exports.WebsocketSubscription = void 0;
 const memcmp_1 = require("../memcmp");
 const webSocketProgramAccountSubscriber_1 = require("../accounts/webSocketProgramAccountSubscriber");
 class WebsocketSubscription {
-    constructor({ userMap, commitment, skipInitialLoad = false, resubTimeoutMs, includeIdle = false, }) {
+    constructor({ userMap, commitment, skipInitialLoad = false, resubTimeoutMs, includeIdle = false, decodeFn, }) {
         this.userMap = userMap;
         this.commitment = commitment;
         this.skipInitialLoad = skipInitialLoad;
         this.resubTimeoutMs = resubTimeoutMs;
         this.includeIdle = includeIdle || false;
+        this.decodeFn = decodeFn;
     }
     async subscribe() {
         if (!this.subscriber) {
@@ -17,7 +18,7 @@ class WebsocketSubscription {
             if (!this.includeIdle) {
                 filters.push((0, memcmp_1.getNonIdleUserFilter)());
             }
-            this.subscriber = new webSocketProgramAccountSubscriber_1.WebSocketProgramAccountSubscriber('UserMap', 'User', this.userMap.driftClient.program, this.userMap.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(this.userMap.driftClient.program.account.user.coder.accounts), {
+            this.subscriber = new webSocketProgramAccountSubscriber_1.WebSocketProgramAccountSubscriber('UserMap', 'User', this.userMap.driftClient.program, this.decodeFn, {
                 filters,
                 commitment: this.commitment,
             }, this.resubTimeoutMs);

package/lib/userMap/userMap.d.ts

@@ -21,6 +21,7 @@ export declare class UserMap implements UserMapInterface {
     private lastNumberOfSubAccounts;
     private subscription;
     private stateAccountUpdateCallback;
+    private decode;
     private syncPromise?;
     private syncPromiseResolver;
     /**