@glamsystems/glam-sdk 0.1.19 → 0.1.21

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@glamsystems/glam-sdk",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "TypeScript SDK for the GLAM Protocol",
   "main": "./index.cjs.js",
   "module": "./index.esm.js",
   "homepage": "https://www.glam.systems",
   "repository": {
     "type": "git",
-    "url": "git@github.com:glamsystems/glam.git"
+    "url": "git@github.com:glamsystems/glam-sdk.git"
   },
   "keywords": [
     "glam",
@@ -20,9 +20,7 @@
   "dependencies": {
     "@coral-xyz/anchor": "^0.31.0",
     "@coral-xyz/borsh": "^0.31.0",
-    "@drift-labs/sdk": "2.114.0-beta.3",
     "@marinade.finance/marinade-ts-sdk": "^5.0.15",
-    "@pythnetwork/client": "^2.21.1",
     "@meteora-ag/dlmm": "^1.4.11",
     "@solana/spl-stake-pool": "^1.1.5",
     "@solana/spl-token": "^0.4.9",

package/src/client/drift.d.ts

@@ -1,61 +1,61 @@
 import * as anchor from "@coral-xyz/anchor";
 import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
-import { MarketType, OrderParams, PositionDirection, SpotPosition, PerpPosition, ModifyOrderParams } from "@drift-labs/sdk";
+import { MarketType, OrderParams, PositionDirection, SpotPosition, PerpPosition, ModifyOrderParams, OracleSource, SpotBalanceType, MarginMode, Order } from "../utils/driftTypes";
 import { BaseClient, TxOptions } from "./base";
 import { AccountMeta } from "@solana/web3.js";
 import { PriceDenom, StateModel } from "../models";
+import { BN } from "@coral-xyz/anchor";
 interface OrderConstants {
     perpBaseScale: number;
     quoteScale: number;
 }
-export interface PerpMarketConfig {
-    fullName: string;
-    categories: string[];
-    symbol: string;
-    baseAsset: string;
+export interface SpotMarket {
+    name: string;
     marketIndex: number;
-    launchTs: string;
-    oracle: string;
-    oracleSource: string;
-    pythPullOraclePDA: string;
-    pythFeedId: string;
-    marketPDA: string;
-}
-export interface SpotMarketConfig {
-    symbol: string;
+    marketPda: PublicKey;
+    vault: PublicKey;
+    oracle: PublicKey;
+    oracleSource: OracleSource;
+    mint: PublicKey;
     decimals: number;
+    tokenProgram: PublicKey;
+    cumulativeDepositInterest: BN;
+    cumulativeBorrowInterest: BN;
+}
+export interface PerpMarket {
+    name: string;
     marketIndex: number;
-    launchTs?: string;
-    oracle: string;
-    oracleSource: string;
-    pythPullOraclePDA: string;
-    pythFeedId: string;
-    marketPDA: string;
-    mint: string;
-    serumMarket?: string;
-    phoenixMarket?: string;
-    openBookMarket?: string;
-    vaultPDA: string;
+    marketPda: PublicKey;
+    oracle: PublicKey;
+    oracleSource: OracleSource;
 }
 export interface DriftMarketConfigs {
     orderConstants: OrderConstants;
-    perp: PerpMarketConfig[];
-    spot: SpotMarketConfig[];
+    perpMarkets: PerpMarket[];
+    spotMarkets: SpotMarket[];
 }
-export interface GlamDriftUser {
-    delegate: string;
+export interface DriftUser {
+    delegate: PublicKey;
     name: string;
     spotPositions: (SpotPosition & {
-        balance: string;
+        amount: number;
+        uiAmount: number;
+        mint: PublicKey;
+        decimals: number;
+        marketName: string;
     })[];
     perpPositions: PerpPosition[];
-    marginMode: string;
+    marginMode: MarginMode;
     subAccountId: number;
     isMarginTradingEnabled: boolean;
     maxMarginRatio: number;
+    orders: Order[];
 }
 export declare class DriftClient {
     readonly base: BaseClient;
+    private spotMarkets;
+    private perpMarkets;
+    private marketConfigs;
     constructor(base: BaseClient);
     initialize(statePda: PublicKey | string, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
     updateUserCustomMarginRatio(statePda: PublicKey, maxLeverage: number, // 1=1x, 2=2x ... 50=50x leverage
@@ -63,34 +63,50 @@ export declare class DriftClient {
     updateUserMarginTradingEnabled(statePda: PublicKey, marginTradingEnabled: boolean, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
     updateUserDelegate(statePda: PublicKey | string, delegate: PublicKey | string, subAccountId?: number): Promise<TransactionSignature>;
     deleteUser(statePda: PublicKey | string, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    deposit(statePda: PublicKey | string, amount: anchor.BN, marketIndex: number, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
-    withdraw(statePda: PublicKey | string, amount: anchor.BN, marketIndex: number, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
-    placeOrder(statePda: PublicKey | string, orderParams: OrderParams, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
-    modifyOrder(statePda: PublicKey | string, modifyOrderParams: ModifyOrderParams, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
-    cancelOrders(statePda: PublicKey | string, marketType: MarketType, marketIndex: number, direction: PositionDirection, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
-    cancelOrdersByIds(statePda: PublicKey | string, orderIds: number[], subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
-    settlePnl(statePda: PublicKey | string, marketIndex: number, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
-    priceDrift(statePda: PublicKey | string, marketConfigs: DriftMarketConfigs, priceDenom: PriceDenom, txOptions?: TxOptions): Promise<TransactionSignature>;
-    getUser(statePda: PublicKey | string, subAccountId?: number): PublicKey[];
-    fetchMarketConfigs(): Promise<DriftMarketConfigs>;
-    fetchGlamDriftUser(glamState: PublicKey | string, subAccountId?: number): Promise<GlamDriftUser>;
-    getPositions(statePda: PublicKey | string, subAccountId?: number): Promise<{
-        spotPositions: (SpotPosition & {
-            balance: string;
-        })[];
-        perpPositions: PerpPosition[];
+    deposit(statePda: PublicKey | string, amount: anchor.BN, marketIndex?: number, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    withdraw(statePda: PublicKey | string, amount: anchor.BN, marketIndex?: number, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    placeOrder(statePda: PublicKey | string, orderParams: OrderParams, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    modifyOrder(statePda: PublicKey | string, modifyOrderParams: ModifyOrderParams, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    cancelOrders(statePda: PublicKey | string, marketType: MarketType, marketIndex: number, direction: PositionDirection, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    cancelOrdersByIds(statePda: PublicKey | string, orderIds: number[], subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    settlePnl(statePda: PublicKey | string, marketIndex: number, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    priceDrift(statePda: PublicKey | string, priceDenom: PriceDenom, txOptions?: TxOptions): Promise<TransactionSignature>;
+    getMarketPda: (marketType: MarketType, marketIndex: number) => anchor.web3.PublicKey;
+    getUserPda: (authority: PublicKey, subAccountId?: number) => anchor.web3.PublicKey;
+    getUserStatsPda: (authority: PublicKey) => PublicKey;
+    getGlamReferrerPdas(): {
+        user: PublicKey;
+        userStats: PublicKey;
+    };
+    parsePerpMarket(data: Buffer): PerpMarket;
+    parseSpotMarket(data: Buffer): SpotMarket;
+    calcSpotBalance(marketIndex: number, scaledBalance: BN, scaledBalanceType: SpotBalanceType): Promise<{
+        amount: number;
+        uiAmount: number;
     }>;
+    getDriftUserPdas(statePda: PublicKey | string, subAccountId?: number): {
+        user: PublicKey;
+        userStats: PublicKey;
+    };
+    get driftStatePda(): PublicKey;
+    fetchAndParseSpotMarket(marketIndex: number): Promise<SpotMarket>;
+    fetchAndParseSpotMarkets(marketIndexes: number[]): Promise<SpotMarket[]>;
+    fetchAndParsePerpMarket(marketIndex: number): Promise<PerpMarket>;
+    fetchAndParsePerpMarkets(marketIndexes: number[]): Promise<PerpMarket[]>;
+    fetchMarketConfigs(): Promise<DriftMarketConfigs>;
+    charsToName(chars: number[] | Buffer): string;
+    fetchDriftUser(statePda: PublicKey | string, subAccountId?: number): Promise<DriftUser | null>;
     fetchPolicyConfig(glamState: StateModel): Promise<{
         driftAccessControl: number;
-        driftDelegatedAccount: any;
+        driftDelegatedAccount: anchor.web3.PublicKey;
         driftMarketIndexesPerp: number[];
         driftOrderTypes: number[];
         driftMaxLeverage: number;
-        driftEnableSpot: any;
+        driftEnableSpot: boolean;
         driftMarketIndexesSpot: number[];
     }>;
     marketTypeEquals: (a: MarketType | undefined, b: MarketType) => boolean;
-    composeRemainingAccounts(glamState: PublicKey, subAccountId: number, marketConfigs: DriftMarketConfigs, marketType?: MarketType, marketIndex?: number): Promise<AccountMeta[]>;
+    composeRemainingAccounts(glamState: PublicKey, subAccountId: number, marketType?: MarketType, marketIndex?: number): Promise<AccountMeta[]>;
     initializeUserStatsIx(glamState: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction>;
     initializeUserIx(glamState: PublicKey, glamSigner: PublicKey, subAccountId: number): Promise<TransactionInstruction>;
     initializeTx(glamState: PublicKey, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
@@ -103,13 +119,13 @@ export declare class DriftClient {
     updateUserDelegateIx(glamState: PublicKey, delegate: PublicKey | string, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionInstruction>;
     updateUserDelegateTx(glamState: PublicKey, delegate: PublicKey, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
     deleteUserTx(glamState: PublicKey, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    depositTx(glamState: PublicKey, amount: anchor.BN, marketIndex: number, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    withdrawTx(statePda: PublicKey, amount: anchor.BN, marketIndex: number, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    placeOrderTx(glamState: PublicKey, orderParams: OrderParams, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    modifyOrderTx(statePda: PublicKey, modifyOrderParams: ModifyOrderParams, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    cancelOrdersTx(glamState: PublicKey, marketType: MarketType, marketIndex: number, direction: PositionDirection, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    cancelOrdersByIdsTx(glamState: PublicKey, orderIds: number[], subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    settlePnlTx(glamState: PublicKey, marketIndex: number, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    priceDriftTx(glamState: PublicKey, marketConfigs: DriftMarketConfigs, priceDenom: PriceDenom, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    depositTx(glamState: PublicKey, amount: anchor.BN, marketIndex?: number, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    withdrawTx(statePda: PublicKey, amount: anchor.BN, marketIndex?: number, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    placeOrderTx(glamState: PublicKey, orderParams: OrderParams, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    modifyOrderTx(statePda: PublicKey, modifyOrderParams: ModifyOrderParams, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    cancelOrdersTx(glamState: PublicKey, marketType: MarketType, marketIndex: number, direction: PositionDirection, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    cancelOrdersByIdsTx(glamState: PublicKey, orderIds: number[], subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    settlePnlTx(glamState: PublicKey, marketIndex: number, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    priceDriftTx(glamState: PublicKey, priceDenom: PriceDenom, txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
 export {};

package/src/client/kamino.d.ts

@@ -12,6 +12,8 @@ interface ParsedReserve {
     feeVault: PublicKey;
 }
 interface ParsedObligation {
+    address: PublicKey;
+    lendingMarket: PublicKey | null;
     deposits: {
         reserve: PublicKey;
     }[];
@@ -84,13 +86,10 @@ export declare class KaminoLendingClient {
         id: number;
     }): PublicKey;
     getObligationFarmState(obligation: PublicKey, farm: PublicKey): PublicKey;
-    initUserMetadataTx(glamState: PublicKey, referrer: PublicKey, txOptions: TxOptions): Promise<VersionedTransaction>;
+    initUserMetadataTx(glamState: PublicKey, referrer: PublicKey | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
     refreshReserveIxs(lendingMarket: PublicKey, reserves: PublicKey[]): TransactionInstruction[];
     refreshObligationFarmsForReserveIxs(obligation: PublicKey, lendingMarket: PublicKey, parsedReserves: ParsedReserve[]): TransactionInstruction[];
-    /**
-     * Returns an array of instructions for refreshing an existing obligation and reserves it depends on.
-     */
-    getRefreshIxs(obligation: PublicKey, lendingMarket: PublicKey): Promise<TransactionInstruction[]>;
+    getRefreshIxs(obligation: PublicKey, refreshFarms?: boolean): Promise<TransactionInstruction[]>;
     getMarketAuthority(market: PublicKey): PublicKey;
     reservePdas(market: PublicKey, mint: PublicKey): {
         liquiditySupplyVault: PublicKey;
@@ -106,13 +105,15 @@ export declare class KaminoLendingClient {
      */
     fetchAndParseObligation(obligation: PublicKey): Promise<ParsedObligation>;
     pubkeyArraysEqual: (a: PublicKey[], b: PublicKey[]) => boolean;
-    /**
-     * We only need pubkeys that don't change over time. No need to fetch them every time.
-     *
-     * @param market
-     * @param asset
-     * @returns
-     */
+    _parseReserveAccount(data: Buffer): {
+        liquiditySupplyVault: PublicKey;
+        collateralMint: PublicKey;
+        collateralSupplyVault: PublicKey;
+        feeVault: PublicKey;
+        farmCollateral: PublicKey;
+        farmDebt: PublicKey;
+        liquidityMint: PublicKey;
+    };
     fetchAndParseReserves(reserves: PublicKey[]): Promise<ParsedReserve[]>;
     findAndParseReserve(market: PublicKey, asset: PublicKey): Promise<ParsedReserve>;
     depositTx(glamState: PublicKey, market: PublicKey, asset: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
@@ -120,4 +121,27 @@ export declare class KaminoLendingClient {
     borrowTx(glamState: PublicKey, market: PublicKey, asset: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
     repayTx(glamState: PublicKey, market: PublicKey, asset: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
+export declare class KaminoFarmClient {
+    readonly base: BaseClient;
+    constructor(base: BaseClient);
+    findAndParseFarmStates(owner: PublicKey): Promise<{
+        userFarmState: PublicKey;
+        farmState: PublicKey;
+    }[]>;
+    parseFarm(data: Buffer): Promise<{
+        globalConfig: PublicKey;
+        rewards: {
+            index: number;
+            mint: PublicKey;
+            minClaimDurationSeconds: any;
+            tokenProgram: PublicKey;
+            rewardsVault: PublicKey;
+        }[];
+    }>;
+    fetchAndParseFarms(farms: PublicKey[]): Promise<Map<any, any>>;
+    farmVaultsAuthority: (farm: PublicKey) => PublicKey;
+    rewardsTreasuryVault: (globalConfig: PublicKey, mint: PublicKey) => PublicKey;
+    harvest(statePda: PublicKey | string, txOptions?: TxOptions): Promise<TransactionSignature>;
+    harvestTx(glamState: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
 export {};

package/src/client/meteora.d.ts

@@ -17,7 +17,7 @@ export declare class MeteoraDlmmClient {
     width: number): PublicKey;
     autoFillY(dlmmPool: DLMM, amountX: BN): Promise<{
         amountX: BN;
-        amountY: BN;
+        amountY: any;
         activeBinId: number;
     }>;
 }

package/src/client/price.d.ts

@@ -1,22 +1,19 @@
 import { PublicKey, TransactionInstruction } from "@solana/web3.js";
-import { BN } from "@coral-xyz/anchor";
+import { KaminoLendingClient } from "./kamino";
 import { BaseClient } from "./base";
 import { PriceDenom } from "../models";
 export declare class PriceClient {
     readonly base: BaseClient;
-    constructor(base: BaseClient);
+    readonly klend: KaminoLendingClient;
+    constructor(base: BaseClient, klend: KaminoLendingClient);
     /**
      * !! This is a convenience method that calculates the AUM of the vault based on priced assets.
      * !! It doesn't reflect the actual AUM of the vault.
      * !! If the vault has not been priced or pricing data is outdated, the number is NOT meaningful.
      */
     getAum(glamState: PublicKey): Promise<BN>;
+    priceKaminoIxs(glamState: PublicKey, priceDenom: PriceDenom): Promise<any[]>;
     priceVaultIxs(glamState: PublicKey, priceDenom: PriceDenom): Promise<TransactionInstruction[]>;
-    remainingAccountsForPricingKamino: (glamState: PublicKey) => Promise<{
-        pubkey: PublicKey;
-        isSigner: boolean;
-        isWritable: boolean;
-    }[]>;
     remainingAccountsForPricingMeteora: (glamState: PublicKey) => Promise<{
         pubkey: PublicKey;
         isSigner: boolean;

package/src/client.d.ts

@@ -8,7 +8,7 @@ import { WSolClient } from "./client/wsol";
 import { StakingClient } from "./client/staking";
 import { StateClient } from "./client/state";
 import { MintClient } from "./client/mint";
-import { KaminoLendingClient } from "./client/kamino";
+import { KaminoFarmClient, KaminoLendingClient } from "./client/kamino";
 import { MeteoraDlmmClient } from "./client/meteora";
 import { InvestorClient } from "./client/investor";
 import { PriceClient } from "./client/price";
@@ -30,6 +30,7 @@ export declare class GlamClient extends BaseClient {
     private _state?;
     private _mint?;
     private _kaminoLending?;
+    private _kaminoFarm?;
     private _meteoraDlmm?;
     constructor(config?: GlamClientConfig);
     get drift(): DriftClient;
@@ -43,5 +44,6 @@ export declare class GlamClient extends BaseClient {
     get state(): StateClient;
     get mint(): MintClient;
     get kaminoLending(): KaminoLendingClient;
+    get kaminoFarm(): KaminoFarmClient;
     get meteoraDlmm(): MeteoraDlmmClient;
 }

package/src/constants.d.ts

@@ -41,3 +41,7 @@ export declare const MEMO_PROGRAM: PublicKey;
  */
 export declare const JITO_STAKE_POOL: PublicKey;
 export declare const JUPSOL_STAKE_POOL: PublicKey;
+/**
+ * Referrers
+ */
+export declare const GLAM_REFERRER: PublicKey;

package/src/index.d.ts

@@ -7,6 +7,9 @@ export * from "./client/drift";
 export * from "./client/base";
 export * from "./utils/helpers";
 export * from "./utils/priorityfee";
+export * from "./utils/driftOrderParams";
+export * from "./utils/driftTypes";
+export * from "./utils/driftUser";
 export * from "./constants";
 export * from "./error";
 export * from "./client/assets";

package/src/react/glam.d.ts

@@ -1,7 +1,7 @@
 import type { DelegateAcl, StateModel } from "../models";
 import { GlamClient } from "../client";
 import { PublicKey } from "@solana/web3.js";
-import { DriftMarketConfigs, GlamDriftUser } from "../client/drift";
+import { DriftMarketConfigs, DriftUser } from "../client/drift";
 import { TokenAccount } from "../client/base";
 declare global {
     interface Window {
@@ -33,7 +33,7 @@ interface GlamProviderContext {
     prices: TokenPrice[];
     jupTokenList?: JupTokenListItem[];
     driftMarketConfigs: DriftMarketConfigs;
-    driftUser: GlamDriftUser;
+    driftUser: DriftUser;
     setActiveGlamState: (f: GlamStateCache) => void;
     refresh: () => Promise<void>;
 }

package/src/utils/driftOrderParams.d.ts

@@ -0,0 +1,28 @@
+import { OptionalOrderParams, OrderParams, OrderTriggerCondition } from "./driftTypes";
+import { BN } from "@coral-xyz/anchor";
+export declare function getLimitOrderParams(params: Omit<OptionalOrderParams, "orderType"> & {
+    price: BN;
+}): OptionalOrderParams;
+export declare function getTriggerMarketOrderParams(params: Omit<OptionalOrderParams, "orderType"> & {
+    triggerCondition: OrderTriggerCondition;
+    triggerPrice: BN;
+}): OptionalOrderParams;
+export declare function getTriggerLimitOrderParams(params: Omit<OptionalOrderParams, "orderType"> & {
+    triggerCondition: OrderTriggerCondition;
+    triggerPrice: BN;
+    price: BN;
+}): OptionalOrderParams;
+export declare function getMarketOrderParams(params: Omit<OptionalOrderParams, "orderType">): OptionalOrderParams;
+/**
+ * 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
+ */
+export declare function getOrderParams(optionalOrderParams: OptionalOrderParams, overridingParams?: Record<string, any>): OrderParams;