@drift-labs/sdk 2.140.0-beta.0 → 2.140.0-beta.2

package/VERSION

@@ -1 +1 @@
-2.140.0-beta.0
+2.140.0-beta.2

package/lib/browser/addresses/pda.d.ts

@@ -33,3 +33,5 @@ export declare function getTokenProgramForSpotMarket(spotMarketAccount: SpotMark
 export declare function getHighLeverageModeConfigPublicKey(programId: PublicKey): PublicKey;
 export declare function getProtectedMakerModeConfigPublicKey(programId: PublicKey): PublicKey;
 export declare function getIfRebalanceConfigPublicKey(programId: PublicKey, inMarketIndex: number, outMarketIndex: number): PublicKey;
+export declare function getRevenueShareAccountPublicKey(programId: PublicKey, authority: PublicKey): PublicKey;
+export declare function getRevenueShareEscrowAccountPublicKey(programId: PublicKey, authority: PublicKey): PublicKey;

package/lib/browser/addresses/pda.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIfRebalanceConfigPublicKey = exports.getProtectedMakerModeConfigPublicKey = exports.getHighLeverageModeConfigPublicKey = exports.getTokenProgramForSpotMarket = exports.getPythLazerOraclePublicKey = exports.getPythPullOraclePublicKey = exports.getPrelaunchOraclePublicKey = exports.getProtocolIfSharesTransferConfigPublicKey = exports.getReferrerNamePublicKeySync = exports.getOpenbookV2FulfillmentConfigPublicKey = exports.getPhoenixFulfillmentConfigPublicKey = exports.getSerumFulfillmentConfigPublicKey = exports.getSerumSignerPublicKey = exports.getSerumOpenOrdersPublicKey = exports.getDriftSignerPublicKey = exports.getInsuranceFundStakeAccountPublicKey = exports.getInsuranceFundVaultPublicKey = exports.getSpotMarketVaultPublicKey = exports.getSpotMarketPublicKeySync = exports.getSpotMarketPublicKey = exports.getPerpMarketPublicKeySync = exports.getPerpMarketPublicKey = exports.getSignedMsgWsDelegatesAccountPublicKey = exports.getSignedMsgUserAccountPublicKey = exports.getFuelOverflowAccountPublicKey = exports.getUserStatsAccountPublicKey = exports.getUserAccountPublicKeySync = exports.getUserAccountPublicKey = exports.getUserAccountPublicKeyAndNonce = exports.getDriftStateAccountPublicKey = exports.getDriftStateAccountPublicKeyAndNonce = void 0;
+exports.getRevenueShareEscrowAccountPublicKey = exports.getRevenueShareAccountPublicKey = exports.getIfRebalanceConfigPublicKey = exports.getProtectedMakerModeConfigPublicKey = exports.getHighLeverageModeConfigPublicKey = exports.getTokenProgramForSpotMarket = exports.getPythLazerOraclePublicKey = exports.getPythPullOraclePublicKey = exports.getPrelaunchOraclePublicKey = exports.getProtocolIfSharesTransferConfigPublicKey = exports.getReferrerNamePublicKeySync = exports.getOpenbookV2FulfillmentConfigPublicKey = exports.getPhoenixFulfillmentConfigPublicKey = exports.getSerumFulfillmentConfigPublicKey = exports.getSerumSignerPublicKey = exports.getSerumOpenOrdersPublicKey = exports.getDriftSignerPublicKey = exports.getInsuranceFundStakeAccountPublicKey = exports.getInsuranceFundVaultPublicKey = exports.getSpotMarketVaultPublicKey = exports.getSpotMarketPublicKeySync = exports.getSpotMarketPublicKey = exports.getPerpMarketPublicKeySync = exports.getPerpMarketPublicKey = exports.getSignedMsgWsDelegatesAccountPublicKey = exports.getSignedMsgUserAccountPublicKey = exports.getFuelOverflowAccountPublicKey = exports.getUserStatsAccountPublicKey = exports.getUserAccountPublicKeySync = exports.getUserAccountPublicKey = exports.getUserAccountPublicKeyAndNonce = exports.getDriftStateAccountPublicKey = exports.getDriftStateAccountPublicKeyAndNonce = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const anchor = __importStar(require("@coral-xyz/anchor"));
 const anchor_1 = require("@coral-xyz/anchor");
@@ -232,3 +232,17 @@ function getIfRebalanceConfigPublicKey(programId, inMarketIndex, outMarketIndex)
     ], programId)[0];
 }
 exports.getIfRebalanceConfigPublicKey = getIfRebalanceConfigPublicKey;
+function getRevenueShareAccountPublicKey(programId, authority) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('REV_SHARE')),
+        authority.toBuffer(),
+    ], programId)[0];
+}
+exports.getRevenueShareAccountPublicKey = getRevenueShareAccountPublicKey;
+function getRevenueShareEscrowAccountPublicKey(programId, authority) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('REV_ESCROW')),
+        authority.toBuffer(),
+    ], programId)[0];
+}
+exports.getRevenueShareEscrowAccountPublicKey = getRevenueShareEscrowAccountPublicKey;

package/lib/browser/adminClient.d.ts

@@ -242,4 +242,8 @@ export declare class AdminClient extends DriftClient {
     getUpdateDelegateUserGovTokenInsuranceStakeIx(authority: PublicKey, delegate: PublicKey): Promise<TransactionInstruction>;
     depositIntoInsuranceFundStake(marketIndex: number, amount: BN, userStatsPublicKey: PublicKey, insuranceFundStakePublicKey: PublicKey, userTokenAccountPublicKey: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
     getDepositIntoInsuranceFundStakeIx(marketIndex: number, amount: BN, userStatsPublicKey: PublicKey, insuranceFundStakePublicKey: PublicKey, userTokenAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
+    updateFeatureBitFlagsBuilderCodes(enable: boolean): Promise<TransactionSignature>;
+    getUpdateFeatureBitFlagsBuilderCodesIx(enable: boolean): Promise<TransactionInstruction>;
+    updateFeatureBitFlagsBuilderReferral(enable: boolean): Promise<TransactionSignature>;
+    getUpdateFeatureBitFlagsBuilderReferralIx(enable: boolean): Promise<TransactionInstruction>;
 }

package/lib/browser/adminClient.js

@@ -2216,5 +2216,37 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
+    async updateFeatureBitFlagsBuilderCodes(enable) {
+        const updateFeatureBitFlagsBuilderCodesIx = await this.getUpdateFeatureBitFlagsBuilderCodesIx(enable);
+        const tx = await this.buildTransaction(updateFeatureBitFlagsBuilderCodesIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateFeatureBitFlagsBuilderCodesIx(enable) {
+        return this.program.instruction.updateFeatureBitFlagsBuilderCodes(enable, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().admin,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateFeatureBitFlagsBuilderReferral(enable) {
+        const updateFeatureBitFlagsBuilderReferralIx = await this.getUpdateFeatureBitFlagsBuilderReferralIx(enable);
+        const tx = await this.buildTransaction(updateFeatureBitFlagsBuilderReferralIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateFeatureBitFlagsBuilderReferralIx(enable) {
+        return this.program.instruction.updateFeatureBitFlagsBuilderReferral(enable, {
+            accounts: {
+                admin: this.useHotWalletAdmin
+                    ? this.wallet.publicKey
+                    : this.getStateAccount().admin,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
 }
 exports.AdminClient = AdminClient;

package/lib/browser/constants/perpMarkets.js

@@ -1228,6 +1228,18 @@ exports.MainnetPerpMarkets = [
         pythFeedId: '0xa903b5a82cb572397e3d47595d2889cf80513f5b4cf7a36b513ae10cc8b1e338',
         pythLazerId: 2310,
     },
+    {
+        fullName: 'PLASMA',
+        category: ['DEX'],
+        symbol: 'XPL-PERP',
+        baseAssetSymbol: 'XPL',
+        marketIndex: 77,
+        oracle: new web3_js_1.PublicKey('6kgE1KJcxTux4tkPLE8LL8GRyW2cAsvyZsDFWqCrhHVe'),
+        launchTs: 1758898862000,
+        oracleSource: types_1.OracleSource.PYTH_LAZER,
+        pythFeedId: '0x9873512f5cb33c77ad7a5af098d74812c62111166be395fd0941c8cedb9b00d4',
+        pythLazerId: 2312,
+    },
 ];
 exports.PerpMarkets = {
     devnet: exports.DevnetPerpMarkets,

package/lib/browser/driftClient.d.ts

@@ -25,6 +25,7 @@ import { WormholeCoreBridgeSolana } from '@pythnetwork/pyth-solana-receiver/lib/
 import { PythSolanaReceiver } from '@pythnetwork/pyth-solana-receiver/lib/idl/pyth_solana_receiver';
 import { Slothash } from './slot/SlothashSubscriber';
 import { SignedMsgOrderParams } from './types';
+import { RevenueShareEscrowMap } from './userMap/revenueShareEscrowMap';
 type RemainingAccountParams = {
     userAccounts: UserAccount[];
     writablePerpMarketIndexes?: number[];
@@ -171,6 +172,16 @@ export declare class DriftClient {
     getResizeSignedMsgUserOrdersInstruction(authority: PublicKey, numOrders: number, userSubaccountId?: number): Promise<TransactionInstruction>;
     initializeSignedMsgWsDelegatesAccount(authority: PublicKey, delegates?: PublicKey[], txParams?: TxParams): Promise<TransactionSignature>;
     getInitializeSignedMsgWsDelegatesAccountIx(authority: PublicKey, delegates?: PublicKey[]): Promise<TransactionInstruction>;
+    initializeRevenueShare(authority: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
+    getInitializeRevenueShareIx(authority: PublicKey): Promise<TransactionInstruction>;
+    initializeRevenueShareEscrow(authority: PublicKey, numOrders: number, txParams?: TxParams): Promise<TransactionSignature>;
+    getInitializeRevenueShareEscrowIx(authority: PublicKey, numOrders: number): Promise<TransactionInstruction>;
+    migrateReferrer(authority: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
+    getMigrateReferrerIx(authority: PublicKey): Promise<TransactionInstruction>;
+    resizeRevenueShareEscrowOrders(authority: PublicKey, numOrders: number, txParams?: TxParams): Promise<TransactionSignature>;
+    getResizeRevenueShareEscrowOrdersIx(authority: PublicKey, numOrders: number): Promise<TransactionInstruction>;
+    changeApprovedBuilder(builder: PublicKey, maxFeeTenthBps: number, add: boolean, txParams?: TxParams): Promise<TransactionSignature>;
+    getChangeApprovedBuilderIx(builder: PublicKey, maxFeeTenthBps: number, add: boolean): Promise<TransactionInstruction>;
     addSignedMsgWsDelegate(authority: PublicKey, delegate: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
     getAddSignedMsgWsDelegateIx(authority: PublicKey, delegate: PublicKey): Promise<TransactionInstruction>;
     removeSignedMsgWsDelegate(authority: PublicKey, delegate: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
@@ -292,6 +303,7 @@ export declare class DriftClient {
     getRemainingAccounts(params: RemainingAccountParams): AccountMeta[];
     addPerpMarketToRemainingAccountMaps(marketIndex: number, writable: boolean, oracleAccountMap: Map<string, AccountMeta>, spotMarketAccountMap: Map<number, AccountMeta>, perpMarketAccountMap: Map<number, AccountMeta>): void;
     addSpotMarketToRemainingAccountMaps(marketIndex: number, writable: boolean, oracleAccountMap: Map<string, AccountMeta>, spotMarketAccountMap: Map<number, AccountMeta>): void;
+    addBuilderToRemainingAccounts(builders: PublicKey[], remainingAccounts: AccountMeta[]): void;
     getRemainingAccountMapsForUsers(userAccounts: UserAccount[]): {
         oracleAccountMap: Map<string, AccountMeta>;
         spotMarketAccountMap: Map<number, AccountMeta>;
@@ -471,8 +483,8 @@ export declare class DriftClient {
         placeOrdersTx: anchor.web3.Transaction | anchor.web3.VersionedTransaction;
     }>;
     getPlaceOrdersIx(params: OptionalOrderParams[], subAccountId?: number): Promise<TransactionInstruction>;
-    fillPerpOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams, fillerSubAccountId?: number, fillerAuthority?: PublicKey): Promise<TransactionSignature>;
-    getFillPerpOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, fillerSubAccountId?: number, isSignedMsg?: boolean, fillerAuthority?: PublicKey): Promise<TransactionInstruction>;
+    fillPerpOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams, fillerSubAccountId?: number, fillerAuthority?: PublicKey, hasBuilderFee?: boolean): Promise<TransactionSignature>;
+    getFillPerpOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, fillerSubAccountId?: number, isSignedMsg?: boolean, fillerAuthority?: PublicKey, hasBuilderFee?: boolean): Promise<TransactionInstruction>;
     getRevertFillIx(fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
     placeSpotOrder(orderParams: OptionalOrderParams, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     preparePlaceSpotOrderTx(orderParams: OptionalOrderParams, txParams?: TxParams, subAccountId?: number): Promise<{
@@ -788,13 +800,13 @@ export declare class DriftClient {
         settleeUserAccountPublicKey: PublicKey;
         settleeUserAccount: UserAccount;
     }[], marketIndexes: number[]): Promise<Array<TransactionInstruction>>;
-    settlePNL(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number, txParams?: TxParams, optionalIxs?: TransactionInstruction[]): Promise<TransactionSignature>;
-    settlePNLIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
-    settleMultiplePNLs(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndexes: number[], mode: SettlePnlMode, txParams?: TxParams): Promise<TransactionSignature>;
-    settleMultiplePNLsMultipleTxs(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndexes: number[], mode: SettlePnlMode, txParams?: TxParams, optionalIxs?: TransactionInstruction[]): Promise<TransactionSignature[]>;
+    settlePNL(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number, txParams?: TxParams, optionalIxs?: TransactionInstruction[], escrowMap?: RevenueShareEscrowMap): Promise<TransactionSignature>;
+    settlePNLIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number, revenueShareEscrowMap?: RevenueShareEscrowMap): Promise<TransactionInstruction>;
+    settleMultiplePNLs(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndexes: number[], mode: SettlePnlMode, revenueShareEscrowMap?: RevenueShareEscrowMap, txParams?: TxParams): Promise<TransactionSignature>;
+    settleMultiplePNLsMultipleTxs(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndexes: number[], mode: SettlePnlMode, txParams?: TxParams, optionalIxs?: TransactionInstruction[], revenueShareEscrowMap?: RevenueShareEscrowMap): Promise<TransactionSignature[]>;
     settleMultiplePNLsIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndexes: number[], mode: SettlePnlMode, overrides?: {
         authority?: PublicKey;
-    }): Promise<TransactionInstruction>;
+    }, revenueShareEscrowMap?: RevenueShareEscrowMap): Promise<TransactionInstruction>;
     getSetUserStatusToBeingLiquidatedIx(userAccountPublicKey: PublicKey, userAccount: UserAccount): Promise<TransactionInstruction>;
     setUserStatusToBeingLiquidated(userAccountPublicKey: PublicKey, userAccount: UserAccount): Promise<TransactionSignature>;
     liquidatePerp(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, maxBaseAssetAmount: BN, limitPrice?: BN, txParams?: TxParams, liquidatorSubAccountId?: number): Promise<TransactionSignature>;

package/lib/browser/driftClient.js

@@ -72,6 +72,8 @@ const oracleId_1 = require("./oracles/oracleId");
 const sha256_1 = require("@noble/hashes/sha256");
 const utils_3 = require("./oracles/utils");
 const webSocketDriftClientAccountSubscriber_1 = require("./accounts/webSocketDriftClientAccountSubscriber");
+const orders_1 = require("./math/orders");
+const builder_1 = require("./math/builder");
 /**
  * # DriftClient
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -692,6 +694,97 @@ class DriftClient {
         });
         return ix;
     }
+    async initializeRevenueShare(authority, txParams) {
+        const ix = await this.getInitializeRevenueShareIx(authority);
+        const tx = await this.buildTransaction([ix], txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getInitializeRevenueShareIx(authority) {
+        const revenueShare = (0, pda_1.getRevenueShareAccountPublicKey)(this.program.programId, authority);
+        return this.program.instruction.initializeRevenueShare({
+            accounts: {
+                revenueShare,
+                authority,
+                payer: this.wallet.publicKey,
+                rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+            },
+        });
+    }
+    async initializeRevenueShareEscrow(authority, numOrders, txParams) {
+        const ix = await this.getInitializeRevenueShareEscrowIx(authority, numOrders);
+        const tx = await this.buildTransaction([ix], txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getInitializeRevenueShareEscrowIx(authority, numOrders) {
+        const escrow = (0, pda_1.getRevenueShareEscrowAccountPublicKey)(this.program.programId, authority);
+        return this.program.instruction.initializeRevenueShareEscrow(numOrders, {
+            accounts: {
+                escrow,
+                authority,
+                payer: this.wallet.publicKey,
+                userStats: (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, authority),
+                state: await this.getStatePublicKey(),
+                rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+            },
+        });
+    }
+    async migrateReferrer(authority, txParams) {
+        const ix = await this.getMigrateReferrerIx(authority);
+        const tx = await this.buildTransaction([ix], txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getMigrateReferrerIx(authority) {
+        const escrow = (0, pda_1.getRevenueShareEscrowAccountPublicKey)(this.program.programId, authority);
+        return this.program.instruction.migrateReferrer({
+            accounts: {
+                escrow,
+                authority,
+                userStats: (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, authority),
+                state: await this.getStatePublicKey(),
+                payer: this.wallet.publicKey,
+            },
+        });
+    }
+    async resizeRevenueShareEscrowOrders(authority, numOrders, txParams) {
+        const ix = await this.getResizeRevenueShareEscrowOrdersIx(authority, numOrders);
+        const tx = await this.buildTransaction([ix], txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getResizeRevenueShareEscrowOrdersIx(authority, numOrders) {
+        const escrow = (0, pda_1.getRevenueShareEscrowAccountPublicKey)(this.program.programId, authority);
+        return this.program.instruction.resizeRevenueShareEscrowOrders(numOrders, {
+            accounts: {
+                escrow,
+                authority,
+                payer: this.wallet.publicKey,
+                systemProgram: anchor.web3.SystemProgram.programId,
+            },
+        });
+    }
+    async changeApprovedBuilder(builder, maxFeeTenthBps, add, txParams) {
+        const ix = await this.getChangeApprovedBuilderIx(builder, maxFeeTenthBps, add);
+        const tx = await this.buildTransaction([ix], txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getChangeApprovedBuilderIx(builder, maxFeeTenthBps, add) {
+        const authority = this.wallet.publicKey;
+        const escrow = (0, pda_1.getRevenueShareEscrowAccountPublicKey)(this.program.programId, authority);
+        return this.program.instruction.changeApprovedBuilder(builder, maxFeeTenthBps, add, {
+            accounts: {
+                escrow,
+                authority,
+                payer: this.wallet.publicKey,
+                systemProgram: anchor.web3.SystemProgram.programId,
+            },
+        });
+    }
     async addSignedMsgWsDelegate(authority, delegate, txParams) {
         const ix = await this.getAddSignedMsgWsDelegateIx(authority, delegate);
         const tx = await this.buildTransaction([ix], txParams);
@@ -1096,6 +1189,16 @@ class DriftClient {
             userAccounts: [userAccount],
             writableSpotMarketIndexes,
         });
+        for (const order of userAccount.orders) {
+            if ((0, orders_1.hasBuilder)(order)) {
+                remainingAccounts.push({
+                    pubkey: (0, pda_1.getRevenueShareEscrowAccountPublicKey)(this.program.programId, userAccount.authority),
+                    isWritable: true,
+                    isSigner: false,
+                });
+                break;
+            }
+        }
         const tokenPrograms = new Set();
         for (const spotPosition of userAccount.spotPositions) {
             if ((0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
@@ -1399,6 +1502,24 @@ class DriftClient {
             });
         }
     }
+    addBuilderToRemainingAccounts(builders, remainingAccounts) {
+        for (const builder of builders) {
+            // Add User account for the builder
+            const builderUserAccount = (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, builder, 0 // subAccountId 0 for builder user account
+            );
+            remainingAccounts.push({
+                pubkey: builderUserAccount,
+                isSigner: false,
+                isWritable: true,
+            });
+            const builderAccount = (0, pda_1.getRevenueShareAccountPublicKey)(this.program.programId, builder);
+            remainingAccounts.push({
+                pubkey: builderAccount,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
+    }
     getRemainingAccountMapsForUsers(userAccounts) {
         const oracleAccountMap = new Map();
         const spotMarketAccountMap = new Map();
@@ -2446,11 +2567,11 @@ class DriftClient {
             remainingAccounts,
         });
     }
-    async fillPerpOrder(userAccountPublicKey, user, order, makerInfo, referrerInfo, txParams, fillerSubAccountId, fillerAuthority) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getFillPerpOrderIx(userAccountPublicKey, user, order, makerInfo, referrerInfo, fillerSubAccountId, undefined, fillerAuthority), txParams), [], this.opts);
+    async fillPerpOrder(userAccountPublicKey, user, order, makerInfo, referrerInfo, txParams, fillerSubAccountId, fillerAuthority, hasBuilderFee) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getFillPerpOrderIx(userAccountPublicKey, user, order, makerInfo, referrerInfo, fillerSubAccountId, undefined, fillerAuthority, hasBuilderFee), txParams), [], this.opts);
         return txSig;
     }
-    async getFillPerpOrderIx(userAccountPublicKey, userAccount, order, makerInfo, referrerInfo, fillerSubAccountId, isSignedMsg, fillerAuthority) {
+    async getFillPerpOrderIx(userAccountPublicKey, userAccount, order, makerInfo, referrerInfo, fillerSubAccountId, isSignedMsg, fillerAuthority, hasBuilderFee) {
         const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         let filler;
         if (fillerAuthority) {
@@ -2510,6 +2631,31 @@ class DriftClient {
                 });
             }
         }
+        let withBuilder = false;
+        if (hasBuilderFee) {
+            withBuilder = true;
+        }
+        else {
+            // figure out if we need builder account or not
+            if (order && !isSignedMsg) {
+                const userOrder = userAccount.orders.find((o) => o.orderId === order.orderId);
+                if (userOrder) {
+                    withBuilder = (0, orders_1.hasBuilder)(userOrder);
+                }
+            }
+            else if (isSignedMsg) {
+                // Order hasn't been placed yet, we cant tell if it has a builder or not.
+                // Include it optimistically
+                withBuilder = true;
+            }
+        }
+        if (withBuilder) {
+            remainingAccounts.push({
+                pubkey: (0, pda_1.getRevenueShareEscrowAccountPublicKey)(this.program.programId, userAccount.authority),
+                isWritable: true,
+                isSigner: false,
+            });
+        }
         const orderId = isSignedMsg ? null : order.orderId;
         return await this.program.instruction.fillPerpOrder(orderId, null, {
             accounts: {
@@ -3428,7 +3574,19 @@ class DriftClient {
                 isSigner: false,
             });
         }
+        remainingAccounts.push({
+            pubkey: (0, pda_1.getRevenueShareEscrowAccountPublicKey)(this.program.programId, takerInfo.takerUserAccount.authority),
+            isWritable: true,
+            isSigner: false,
+        });
         const takerOrderId = takerInfo.order.orderId;
+        if ((0, orders_1.hasBuilder)(takerInfo.order)) {
+            remainingAccounts.push({
+                pubkey: (0, pda_1.getRevenueShareEscrowAccountPublicKey)(this.program.programId, takerInfo.takerUserAccount.authority),
+                isWritable: true,
+                isSigner: false,
+            });
+        }
         return await this.program.instruction.placeAndMakePerpOrder(orderParams, takerOrderId, {
             accounts: {
                 state: await this.getStatePublicKey(),
@@ -3479,11 +3637,21 @@ class DriftClient {
             ? 'global' + ':' + 'SignedMsgOrderParamsDelegateMessage'
             : 'global' + ':' + 'SignedMsgOrderParamsMessage';
         const prefix = Buffer.from((0, sha256_1.sha256)(anchorIxName).slice(0, 8));
+        // Backwards-compat: normalize optional builder fields to null for encoding
+        const withBuilderDefaults = {
+            ...orderParamsMessage,
+            builderIdx: orderParamsMessage.builderIdx !== undefined
+                ? orderParamsMessage.builderIdx
+                : null,
+            builderFeeTenthBps: orderParamsMessage.builderFeeTenthBps !== undefined
+                ? orderParamsMessage.builderFeeTenthBps
+                : null,
+        };
         const buf = Buffer.concat([
             prefix,
             delegateSigner
-                ? this.program.coder.types.encode('SignedMsgOrderParamsDelegateMessage', orderParamsMessage)
-                : this.program.coder.types.encode('SignedMsgOrderParamsMessage', orderParamsMessage),
+                ? this.program.coder.types.encode('SignedMsgOrderParamsDelegateMessage', withBuilderDefaults)
+                : this.program.coder.types.encode('SignedMsgOrderParamsMessage', withBuilderDefaults),
         ]);
         return buf;
     }
@@ -3518,18 +3686,21 @@ class DriftClient {
         });
         const isDelegateSigner = takerInfo.signingAuthority.equals(takerInfo.takerUserAccount.delegate);
         const borshBuf = Buffer.from(signedSignedMsgOrderParams.orderParams.toString(), 'hex');
-        try {
-            const { signedMsgOrderParams } = this.decodeSignedMsgOrderParamsMessage(borshBuf, isDelegateSigner);
-            if ((0, orderParams_1.isUpdateHighLeverageMode)(signedMsgOrderParams.bitFlags)) {
-                remainingAccounts.push({
-                    pubkey: (0, pda_1.getHighLeverageModeConfigPublicKey)(this.program.programId),
-                    isWritable: true,
-                    isSigner: false,
-                });
-            }
+        const signedMessage = this.decodeSignedMsgOrderParamsMessage(borshBuf, isDelegateSigner);
+        if ((0, orderParams_1.isUpdateHighLeverageMode)(signedMessage.signedMsgOrderParams.bitFlags)) {
+            remainingAccounts.push({
+                pubkey: (0, pda_1.getHighLeverageModeConfigPublicKey)(this.program.programId),
+                isWritable: true,
+                isSigner: false,
+            });
         }
-        catch (err) {
-            console.error('invalid signed order encoding');
+        if (signedMessage.builderFeeTenthBps !== null &&
+            signedMessage.builderIdx !== null) {
+            remainingAccounts.push({
+                pubkey: (0, pda_1.getRevenueShareEscrowAccountPublicKey)(this.program.programId, takerInfo.takerUserAccount.authority),
+                isWritable: true,
+                isSigner: false,
+            });
         }
         const messageLengthBuffer = Buffer.alloc(2);
         messageLengthBuffer.writeUInt16LE(signedSignedMsgOrderParams.orderParams.length);
@@ -3584,6 +3755,17 @@ class DriftClient {
                 isSigner: false,
             });
         }
+        const isDelegateSigner = takerInfo.signingAuthority.equals(takerInfo.takerUserAccount.delegate);
+        const borshBuf = Buffer.from(signedSignedMsgOrderParams.orderParams.toString(), 'hex');
+        const signedMessage = this.decodeSignedMsgOrderParamsMessage(borshBuf, isDelegateSigner);
+        if (signedMessage.builderFeeTenthBps !== null &&
+            signedMessage.builderIdx !== null) {
+            remainingAccounts.push({
+                pubkey: (0, pda_1.getRevenueShareEscrowAccountPublicKey)(this.program.programId, takerInfo.takerUserAccount.authority),
+                isWritable: true,
+                isSigner: false,
+            });
+        }
         const placeAndMakeIx = await this.program.instruction.placeAndMakeSignedMsgPerpOrder(orderParams, signedMsgOrderUuid, {
             accounts: {
                 state: await this.getStatePublicKey(),
@@ -3914,17 +4096,76 @@ class DriftClient {
         }
         return ixs;
     }
-    async settlePNL(settleeUserAccountPublicKey, settleeUserAccount, marketIndex, txParams, optionalIxs) {
+    async settlePNL(settleeUserAccountPublicKey, settleeUserAccount, marketIndex, txParams, optionalIxs, escrowMap) {
         const lookupTableAccounts = await this.fetchAllLookupTableAccounts();
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex), txParams, undefined, lookupTableAccounts, undefined, undefined, optionalIxs), [], this.opts);
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex, escrowMap), txParams, undefined, lookupTableAccounts, undefined, undefined, optionalIxs), [], this.opts);
         return txSig;
     }
-    async settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
+    async settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex, revenueShareEscrowMap) {
         const remainingAccounts = this.getRemainingAccounts({
             userAccounts: [settleeUserAccount],
             writablePerpMarketIndexes: [marketIndex],
             writableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
         });
+        if (revenueShareEscrowMap) {
+            const escrow = revenueShareEscrowMap.get(settleeUserAccount.authority.toBase58());
+            if (escrow) {
+                const escrowPk = (0, pda_1.getRevenueShareEscrowAccountPublicKey)(this.program.programId, settleeUserAccount.authority);
+                const builders = new Map();
+                for (const order of escrow.orders) {
+                    const eligibleBuilder = (0, builder_1.isBuilderOrderCompleted)(order) &&
+                        !(0, builder_1.isBuilderOrderReferral)(order) &&
+                        order.feesAccrued.gt(numericConstants_1.ZERO) &&
+                        order.marketIndex === marketIndex;
+                    if (eligibleBuilder && !builders.has(order.builderIdx)) {
+                        builders.set(order.builderIdx, escrow.approvedBuilders[order.builderIdx].authority);
+                    }
+                }
+                if (builders.size > 0) {
+                    if (!remainingAccounts.find((a) => a.pubkey.equals(escrowPk))) {
+                        remainingAccounts.push({
+                            pubkey: escrowPk,
+                            isSigner: false,
+                            isWritable: true,
+                        });
+                    }
+                    this.addBuilderToRemainingAccounts(Array.from(builders.values()), remainingAccounts);
+                }
+                // Include escrow and referrer accounts if referral rewards exist for this market
+                const hasReferralForMarket = escrow.orders.some((o) => (0, builder_1.isBuilderOrderReferral)(o) &&
+                    o.feesAccrued.gt(numericConstants_1.ZERO) &&
+                    o.marketIndex === marketIndex);
+                if (hasReferralForMarket) {
+                    if (!remainingAccounts.find((a) => a.pubkey.equals(escrowPk))) {
+                        remainingAccounts.push({
+                            pubkey: escrowPk,
+                            isSigner: false,
+                            isWritable: true,
+                        });
+                    }
+                    if (!escrow.referrer.equals(web3_js_1.PublicKey.default)) {
+                        this.addBuilderToRemainingAccounts([escrow.referrer], remainingAccounts);
+                    }
+                }
+            }
+            else {
+                // Stale-cache fallback: if the user has any builder orders, include escrow PDA. This allows
+                // the program to lazily clean up any completed builder orders.
+                for (const order of settleeUserAccount.orders) {
+                    if ((0, orders_1.hasBuilder)(order)) {
+                        const escrowPk = (0, pda_1.getRevenueShareEscrowAccountPublicKey)(this.program.programId, settleeUserAccount.authority);
+                        if (!remainingAccounts.find((a) => a.pubkey.equals(escrowPk))) {
+                            remainingAccounts.push({
+                                pubkey: escrowPk,
+                                isSigner: false,
+                                isWritable: true,
+                            });
+                        }
+                        break;
+                    }
+                }
+            }
+        }
         return await this.program.instruction.settlePnl(marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
@@ -3935,11 +4176,11 @@ class DriftClient {
             remainingAccounts: remainingAccounts,
         });
     }
-    async settleMultiplePNLs(settleeUserAccountPublicKey, settleeUserAccount, marketIndexes, mode, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.settleMultiplePNLsIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndexes, mode), txParams), [], this.opts);
+    async settleMultiplePNLs(settleeUserAccountPublicKey, settleeUserAccount, marketIndexes, mode, revenueShareEscrowMap, txParams) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.settleMultiplePNLsIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndexes, mode, undefined, revenueShareEscrowMap), txParams), [], this.opts);
         return txSig;
     }
-    async settleMultiplePNLsMultipleTxs(settleeUserAccountPublicKey, settleeUserAccount, marketIndexes, mode, txParams, optionalIxs) {
+    async settleMultiplePNLsMultipleTxs(settleeUserAccountPublicKey, settleeUserAccount, marketIndexes, mode, txParams, optionalIxs, revenueShareEscrowMap) {
         // need multiple TXs because settling more than 4 markets won't fit in a single TX
         const txsToSign = [];
         const marketIndexesInFourGroups = [];
@@ -3947,7 +4188,7 @@ class DriftClient {
             marketIndexesInFourGroups.push(marketIndexes.slice(i, i + 4));
         }
         for (const marketIndexes of marketIndexesInFourGroups) {
-            const ix = await this.settleMultiplePNLsIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndexes, mode);
+            const ix = await this.settleMultiplePNLsIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndexes, mode, undefined, revenueShareEscrowMap);
             const computeUnits = Math.min(300000 * marketIndexes.length, 1400000);
             const tx = await this.buildTransaction(ix, {
                 ...txParams,
@@ -3970,13 +4211,75 @@ class DriftClient {
         }
         return txSigs;
     }
-    async settleMultiplePNLsIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndexes, mode, overrides) {
+    async settleMultiplePNLsIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndexes, mode, overrides, revenueShareEscrowMap) {
         var _a;
         const remainingAccounts = this.getRemainingAccounts({
             userAccounts: [settleeUserAccount],
             writablePerpMarketIndexes: marketIndexes,
             writableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
         });
+        if (revenueShareEscrowMap) {
+            const escrow = revenueShareEscrowMap.get(settleeUserAccount.authority.toBase58());
+            const builders = new Map();
+            if (escrow) {
+                for (const order of escrow.orders) {
+                    const eligibleBuilder = (0, builder_1.isBuilderOrderCompleted)(order) &&
+                        !(0, builder_1.isBuilderOrderReferral)(order) &&
+                        order.feesAccrued.gt(numericConstants_1.ZERO) &&
+                        marketIndexes.includes(order.marketIndex);
+                    if (eligibleBuilder && !builders.has(order.builderIdx)) {
+                        builders.set(order.builderIdx, escrow.approvedBuilders[order.builderIdx].authority);
+                    }
+                }
+                if (builders.size > 0) {
+                    const escrowPk = (0, pda_1.getRevenueShareEscrowAccountPublicKey)(this.program.programId, settleeUserAccount.authority);
+                    if (!remainingAccounts.find((a) => a.pubkey.equals(escrowPk))) {
+                        remainingAccounts.push({
+                            pubkey: escrowPk,
+                            isSigner: false,
+                            isWritable: true,
+                        });
+                    }
+                    this.addBuilderToRemainingAccounts(Array.from(builders.values()), remainingAccounts);
+                }
+                // Include escrow and referrer accounts when there are referral rewards
+                // for any of the markets we are settling, so on-chain sweep can find them.
+                const hasReferralForRequestedMarkets = escrow.orders.some((o) => (0, builder_1.isBuilderOrderReferral)(o) &&
+                    o.feesAccrued.gt(numericConstants_1.ZERO) &&
+                    marketIndexes.includes(o.marketIndex));
+                if (hasReferralForRequestedMarkets) {
+                    const escrowPk = (0, pda_1.getRevenueShareEscrowAccountPublicKey)(this.program.programId, settleeUserAccount.authority);
+                    if (!remainingAccounts.find((a) => a.pubkey.equals(escrowPk))) {
+                        remainingAccounts.push({
+                            pubkey: escrowPk,
+                            isSigner: false,
+                            isWritable: true,
+                        });
+                    }
+                    // Add referrer's User and RevenueShare accounts
+                    if (!escrow.referrer.equals(web3_js_1.PublicKey.default)) {
+                        this.addBuilderToRemainingAccounts([escrow.referrer], remainingAccounts);
+                    }
+                }
+            }
+            else {
+                // Stale-cache fallback: if the user has any builder orders, include escrow PDA. This allows
+                // the program to lazily clean up any completed builder orders.
+                for (const order of settleeUserAccount.orders) {
+                    if ((0, orders_1.hasBuilder)(order)) {
+                        const escrowPk = (0, pda_1.getRevenueShareEscrowAccountPublicKey)(this.program.programId, settleeUserAccount.authority);
+                        if (!remainingAccounts.find((a) => a.pubkey.equals(escrowPk))) {
+                            remainingAccounts.push({
+                                pubkey: escrowPk,
+                                isSigner: false,
+                                isWritable: true,
+                            });
+                        }
+                        break;
+                    }
+                }
+            }
+        }
         return await this.program.instruction.settleMultiplePnls(marketIndexes, mode, {
             accounts: {
                 state: await this.getStatePublicKey(),