@kamino-finance/kliquidity-sdk 6.2.1 → 6.3.0

package/src/rebalance_methods/expanderRebalance.ts

@@ -0,0 +1,371 @@
+import Decimal from 'decimal.js';
+import { PositionRange, RebalanceFieldInfo, RebalanceFieldsDict } from '../utils/types';
+import { DefaultLowerPercentageBPSDecimal, DefaultUpperPercentageBPSDecimal } from '../utils/CreationParameters';
+import { RebalanceRaw } from '../kamino-client/types';
+import { RebalanceTypeLabelName } from './consts';
+import { Dex, readBigUint128LE } from '../utils';
+import { sqrtPriceX64ToPrice } from '@orca-so/whirlpool-sdk';
+import BN from 'bn.js';
+import { upsertManyRebalanceFieldInfos } from './utils';
+import { getPriceRangeFromPriceAndDiffBPS, getResetRangeFromPriceAndDiffBPS } from './math_utils';
+import { getPriceFromQ64Price } from '../utils/meteora';
+
+export const DefaultMaxNumberOfExpansions = new Decimal(10);
+export const DefaultExpansionSizeBPS = new Decimal(100);
+export const DefaultSwapUnevenAllowed = new Decimal(1);
+export const ExpanderRebalanceTypeName = 'expander';
+
+export function getExpanderRebalanceFieldInfos(
+  price: Decimal,
+  lowerPercentageBPS: Decimal,
+  upperPercentageBPS: Decimal,
+  resetLowerPercentageBPS: Decimal,
+  resetUpperPercentageBPS: Decimal,
+  expansionBPS: Decimal,
+  maxNumberOfExpansions: Decimal,
+  swapUnevenAllowed: Decimal,
+  enabled: boolean = true
+): RebalanceFieldInfo[] {
+  const rebalanceType: RebalanceFieldInfo = {
+    label: RebalanceTypeLabelName,
+    type: 'string',
+    value: ExpanderRebalanceTypeName,
+    enabled,
+  };
+  const lowerBpsRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'lowerRangeBps',
+    type: 'number',
+    value: lowerPercentageBPS,
+    enabled,
+  };
+  const upperBpsRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'upperRangeBps',
+    type: 'number',
+    value: upperPercentageBPS,
+    enabled,
+  };
+  const resetLowerBpsRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'resetLowerRangeBps',
+    type: 'number',
+    value: resetLowerPercentageBPS,
+    enabled,
+  };
+  const resetUpperBpsRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'resetUpperRangeBps',
+    type: 'number',
+    value: resetUpperPercentageBPS,
+    enabled,
+  };
+  const expansionBpsRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'expansionBps',
+    type: 'number',
+    value: expansionBPS,
+    enabled,
+  };
+  const maxNumberOfExpansionsRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'maxNumberOfExpansions',
+    type: 'number',
+    value: maxNumberOfExpansions,
+    enabled,
+  };
+  const swapUnevenAllowedFieldInfo: RebalanceFieldInfo = {
+    label: 'swapUnevenAllowed',
+    type: 'number',
+    value: swapUnevenAllowed,
+    enabled,
+  };
+
+  const { lowerPrice, upperPrice } = getPositionRangeFromExpanderParams(price, lowerPercentageBPS, upperPercentageBPS);
+  const lowerRangeRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'rangePriceLower',
+    type: 'number',
+    value: lowerPrice,
+    enabled: false,
+  };
+  const upperRangeRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'rangePriceUpper',
+    type: 'number',
+    value: upperPrice,
+    enabled: false,
+  };
+
+  const { lowerPrice: resetLowerPrice, upperPrice: resetUpperPrice } = getPositionResetRangeFromExpanderParams(
+    price,
+    lowerPercentageBPS,
+    upperPercentageBPS,
+    resetLowerPercentageBPS,
+    resetUpperPercentageBPS
+  );
+  const resetLowerRangeRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'resetPriceLower',
+    type: 'number',
+    value: resetLowerPrice,
+    enabled: false,
+  };
+  const resetUpperRangeRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'resetPriceUpper',
+    type: 'number',
+    value: resetUpperPrice,
+    enabled: false,
+  };
+
+  return [
+    rebalanceType,
+    lowerBpsRebalanceFieldInfo,
+    upperBpsRebalanceFieldInfo,
+    resetLowerBpsRebalanceFieldInfo,
+    resetUpperBpsRebalanceFieldInfo,
+    expansionBpsRebalanceFieldInfo,
+    maxNumberOfExpansionsRebalanceFieldInfo,
+    swapUnevenAllowedFieldInfo,
+    lowerRangeRebalanceFieldInfo,
+    upperRangeRebalanceFieldInfo,
+    resetLowerRangeRebalanceFieldInfo,
+    resetUpperRangeRebalanceFieldInfo,
+  ];
+}
+
+export function getPositionRangeFromExpanderParams(
+  price: Decimal,
+  lowerPriceDifferenceBPS: Decimal,
+  upperPriceDifferenceBPS: Decimal
+): PositionRange {
+  return getPriceRangeFromPriceAndDiffBPS(price, lowerPriceDifferenceBPS, upperPriceDifferenceBPS);
+}
+
+export function getPositionResetRangeFromExpanderParams(
+  price: Decimal,
+  lowerPriceDifferenceBPS: Decimal,
+  upperPriceDifferenceBPS: Decimal,
+  resetLowerPriceDifferenceBPS: Decimal,
+  resetUpperPriceDifferenceBPS: Decimal
+): PositionRange {
+  return getResetRangeFromPriceAndDiffBPS(
+    price,
+    lowerPriceDifferenceBPS,
+    upperPriceDifferenceBPS,
+    resetLowerPriceDifferenceBPS,
+    resetUpperPriceDifferenceBPS
+  );
+}
+
+export function getDefaultExpanderRebalanceFieldInfos(price: Decimal): RebalanceFieldInfo[] {
+  return getExpanderRebalanceFieldInfos(
+    price,
+    DefaultLowerPercentageBPSDecimal,
+    DefaultUpperPercentageBPSDecimal,
+    DefaultLowerPercentageBPSDecimal,
+    DefaultUpperPercentageBPSDecimal,
+    DefaultLowerPercentageBPSDecimal,
+    DefaultMaxNumberOfExpansions,
+    DefaultSwapUnevenAllowed
+  );
+}
+
+export function readRawExpanderRebalanceParamsFromStrategy(rebalanceRaw: RebalanceRaw) {
+  const paramsBuffer = Buffer.from(rebalanceRaw.params);
+  const params: RebalanceFieldsDict = {};
+
+  params['lowerRangeBps'] = new Decimal(paramsBuffer.readUInt16LE(0));
+  params['upperRangeBps'] = new Decimal(paramsBuffer.readUInt16LE(2));
+  params['lowerResetRatioBps'] = new Decimal(paramsBuffer.readUInt16LE(4));
+  params['upperResetRatioBps'] = new Decimal(paramsBuffer.readUInt16LE(6));
+  params['expansionBps'] = new Decimal(paramsBuffer.readUInt16LE(8));
+  params['maxNumberOfExpansions'] = new Decimal(paramsBuffer.readUInt16LE(10));
+  params['swapUnevenAllowed'] = new Decimal(paramsBuffer.readUInt8(12));
+
+  return params;
+}
+
+export function readExpanderRebalanceParamsFromStrategy(rebalanceRaw: RebalanceRaw): RebalanceFieldInfo[] {
+  const paramsBuffer = Buffer.from(rebalanceRaw.params);
+
+  const lowerRangeBps = new Decimal(paramsBuffer.readUInt16LE(0));
+  const upperRangeBps = new Decimal(paramsBuffer.readUInt16LE(2));
+  const lowerResetRatioBps = new Decimal(paramsBuffer.readUInt16LE(4));
+  const upperResetRatioBps = new Decimal(paramsBuffer.readUInt16LE(6));
+  const expansionBps = new Decimal(paramsBuffer.readUInt16LE(8));
+  const maxNumberOfExpansions = new Decimal(paramsBuffer.readUInt16LE(10));
+  const swapUnevenAllowed = new Decimal(paramsBuffer.readUInt8(12));
+
+  const lowerBpsRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'lowerRangeBps',
+    type: 'number',
+    value: lowerRangeBps,
+    enabled: true,
+  };
+  const upperBpsRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'upperRangeBps',
+    type: 'number',
+    value: upperRangeBps,
+    enabled: true,
+  };
+  const resetLowerBpsRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'resetLowerRangeBps',
+    type: 'number',
+    value: lowerResetRatioBps,
+    enabled: true,
+  };
+  const resetUpperBpsRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'resetUpperRangeBps',
+    type: 'number',
+    value: upperResetRatioBps,
+    enabled: true,
+  };
+  const expansionBpsRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'expansionBps',
+    type: 'number',
+    value: expansionBps,
+    enabled: true,
+  };
+  const maxNumberOfExpansionsRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'maxNumberOfExpansions',
+    type: 'number',
+    value: maxNumberOfExpansions,
+    enabled: true,
+  };
+  const swapUnevenAllowedFieldInfo: RebalanceFieldInfo = {
+    label: 'swapUnevenAllowed',
+    type: 'number',
+    value: swapUnevenAllowed,
+    enabled: true,
+  };
+
+  return [
+    lowerBpsRebalanceFieldInfo,
+    upperBpsRebalanceFieldInfo,
+    resetLowerBpsRebalanceFieldInfo,
+    resetUpperBpsRebalanceFieldInfo,
+    expansionBpsRebalanceFieldInfo,
+    maxNumberOfExpansionsRebalanceFieldInfo,
+    swapUnevenAllowedFieldInfo,
+  ];
+}
+
+export function readRawExpanderRebalanceStateFromStrategy(rebalanceRaw: RebalanceRaw) {
+  const stateBuffer = Buffer.from(rebalanceRaw.state);
+  const state: RebalanceFieldsDict = {};
+
+  state['initialPoolPrice'] = new Decimal(readBigUint128LE(stateBuffer, 0).toString());
+  state['expansionCount'] = new Decimal(stateBuffer.readUInt16LE(16));
+
+  return state;
+}
+
+export function readExpanderRebalanceStateFromStrategy(
+  dex: Dex,
+  tokenADecimals: number,
+  tokenBDecimals: number,
+  rebalanceRaw: RebalanceRaw
+): RebalanceFieldInfo[] {
+  const params = readRawExpanderRebalanceParamsFromStrategy(rebalanceRaw);
+
+  const lowerRangeBps = params['lowerRangeBps'];
+  const upperRangeBps = params['upperRangeBps'];
+  const lowerResetRatioBps = params['lowerResetRatioBps'];
+  const upperResetRatioBps = params['upperResetRatioBps'];
+  const expansionBps = params['expansionBps'];
+
+  const state = readRawExpanderRebalanceStateFromStrategy(rebalanceRaw);
+
+  const initialPriceX64 = state['initialPoolPrice'];
+  const expansionCount = state['expansionCount'];
+
+  let initialPrice: Decimal;
+  if (dex == 'ORCA') {
+    initialPrice = sqrtPriceX64ToPrice(new BN(initialPriceX64.toString()), tokenADecimals, tokenBDecimals);
+  } else if (dex == 'RAYDIUM') {
+    initialPrice = sqrtPriceX64ToPrice(new BN(initialPriceX64.toString()), tokenADecimals, tokenBDecimals);
+  } else if (dex == 'METEORA') {
+    initialPrice = getPriceFromQ64Price(new Decimal(initialPriceX64.toString()), tokenADecimals, tokenBDecimals);
+  } else {
+    throw new Error(`Unknown DEX ${dex}`);
+  }
+
+  const lowerRangeFactorBPS = lowerRangeBps.add(expansionBps.mul(expansionCount));
+  const upperRangeFactorBPS = upperRangeBps.add(expansionBps.mul(expansionCount));
+
+  const { lowerPrice, upperPrice } = getPriceRangeFromPriceAndDiffBPS(
+    initialPrice,
+    lowerRangeFactorBPS,
+    upperRangeFactorBPS
+  );
+
+  const { lowerPrice: lowerResetPrice, upperPrice: upperResetPrice } = getResetRangeFromPriceAndDiffBPS(
+    initialPrice,
+    lowerRangeFactorBPS,
+    upperRangeFactorBPS,
+    lowerResetRatioBps,
+    upperResetRatioBps
+  );
+
+  const lowerRangeRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'rangePriceLower',
+    type: 'number',
+    value: lowerPrice,
+    enabled: false,
+  };
+  const upperRangeRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'rangePriceUpper',
+    type: 'number',
+    value: upperPrice,
+    enabled: false,
+  };
+
+  const resetLowerRangeRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'resetPriceLower',
+    type: 'number',
+    value: lowerResetPrice,
+    enabled: false,
+  };
+  const resetUpperRangeRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'resetPriceUpper',
+    type: 'number',
+    value: upperResetPrice,
+    enabled: false,
+  };
+
+  return [
+    lowerRangeRebalanceFieldInfo,
+    upperRangeRebalanceFieldInfo,
+    resetLowerRangeRebalanceFieldInfo,
+    resetUpperRangeRebalanceFieldInfo,
+  ];
+}
+
+export function readExpanderRebalanceFieldInfosFromStrategy(price: Decimal, rebalanceRaw: RebalanceRaw) {
+  const paramsBuffer = Buffer.from(rebalanceRaw.params);
+
+  const lowerRangeBps = new Decimal(paramsBuffer.readUInt16LE(0));
+  const upperRangeBps = new Decimal(paramsBuffer.readUInt16LE(2));
+  const lowerResetRatioBps = new Decimal(paramsBuffer.readUInt16LE(4));
+  const upperResetRatioBps = new Decimal(paramsBuffer.readUInt16LE(6));
+  const expansionBps = new Decimal(paramsBuffer.readUInt16LE(8));
+  const maxNumberOfExpansions = new Decimal(paramsBuffer.readUInt16LE(10));
+  const swapUnevenAllowed = new Decimal(paramsBuffer.readUInt8(12));
+
+  return getExpanderRebalanceFieldInfos(
+    price,
+    lowerRangeBps,
+    upperRangeBps,
+    lowerResetRatioBps,
+    upperResetRatioBps,
+    expansionBps,
+    maxNumberOfExpansions,
+    swapUnevenAllowed
+  );
+}
+
+export function deserializeExpanderRebalanceWithStateOverride(
+  dex: Dex,
+  tokenADecimals: number,
+  tokenBDecimals: number,
+  price: Decimal,
+  rebalanceRaw: RebalanceRaw
+): RebalanceFieldInfo[] {
+  const stateFields = readExpanderRebalanceStateFromStrategy(dex, tokenADecimals, tokenBDecimals, rebalanceRaw);
+
+  const fields = readExpanderRebalanceFieldInfosFromStrategy(price, rebalanceRaw);
+
+  return upsertManyRebalanceFieldInfos(fields, stateFields);
+}

package/src/rebalance_methods/index.ts

@@ -0,0 +1,7 @@
+export * from './manualRebalance';
+export * from './pricePercentageRebalance';
+export * from './pricePercentageWithResetRebalance';
+export * from './takeProfitRebalance';
+export * from './driftRebalance';
+export * from './expanderRebalance';
+export * from './periodicRebalance';

package/src/rebalance_methods/manualRebalance.ts

@@ -0,0 +1,43 @@
+import Decimal from 'decimal.js';
+import { RebalanceFieldInfo } from '../utils/types';
+import {
+  DefaultLowerPercentageBPSDecimal,
+  DefaultUpperPercentageBPSDecimal,
+  FullBPSDecimal,
+} from '../utils/CreationParameters';
+import { RebalanceTypeLabelName } from './consts';
+
+export const ManualRebalanceTypeName = 'manual';
+
+export function getManualRebalanceFieldInfos(
+  lowerPrice: Decimal,
+  upperPrice: Decimal,
+  enabled: boolean = true
+): RebalanceFieldInfo[] {
+  const rebalanceType: RebalanceFieldInfo = {
+    label: RebalanceTypeLabelName,
+    type: 'string',
+    value: ManualRebalanceTypeName,
+    enabled,
+  };
+  const lowerRangeRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'rangePriceLower',
+    type: 'number',
+    value: lowerPrice,
+    enabled,
+  };
+  const upperRangeRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'rangePriceUpper',
+    type: 'number',
+    value: upperPrice,
+    enabled,
+  };
+  return [rebalanceType, lowerRangeRebalanceFieldInfo, upperRangeRebalanceFieldInfo];
+}
+
+export function getDefaultManualRebalanceFieldInfos(price: Decimal): RebalanceFieldInfo[] {
+  const lowerPrice = price.mul(FullBPSDecimal.sub(DefaultLowerPercentageBPSDecimal)).div(FullBPSDecimal);
+  const upperPrice = price.mul(FullBPSDecimal.add(DefaultUpperPercentageBPSDecimal)).div(FullBPSDecimal);
+
+  return getManualRebalanceFieldInfos(lowerPrice, upperPrice);
+}

package/src/rebalance_methods/math_utils.ts

@@ -0,0 +1,28 @@
+import Decimal from 'decimal.js';
+import { FullBPSDecimal } from '../utils/CreationParameters';
+import { PositionRange } from '../utils';
+
+export function getPriceRangeFromPriceAndDiffBPS(
+  price: Decimal,
+  lowerDiffBPS: Decimal,
+  upperDiffBPS: Decimal
+): PositionRange {
+  const lowerPrice = price.mul(FullBPSDecimal.sub(lowerDiffBPS)).div(FullBPSDecimal);
+  const upperPrice = price.mul(FullBPSDecimal.add(upperDiffBPS)).div(FullBPSDecimal);
+
+  return { lowerPrice, upperPrice };
+}
+
+export function getResetRangeFromPriceAndDiffBPS(
+  price: Decimal,
+  lowerDiffBPS: Decimal,
+  upperDiffBPS: Decimal,
+  resetLowerDiffBPS: Decimal,
+  resetUpperDiffBPS: Decimal
+): PositionRange {
+  const resetLowerFactor = resetLowerDiffBPS.mul(lowerDiffBPS).div(FullBPSDecimal);
+  const resetUpperFactor = resetUpperDiffBPS.mul(upperDiffBPS).div(FullBPSDecimal);
+  const resetLowerPrice = price.mul(FullBPSDecimal.sub(resetLowerFactor)).div(FullBPSDecimal);
+  const resetUpperPrice = price.mul(FullBPSDecimal.add(resetUpperFactor)).div(FullBPSDecimal);
+  return { lowerPrice: resetLowerPrice, upperPrice: resetUpperPrice };
+}

package/src/rebalance_methods/periodicRebalance.ts

@@ -0,0 +1,115 @@
+import Decimal from 'decimal.js';
+import { PositionRange, RebalanceFieldInfo, RebalanceFieldsDict } from '../utils/types';
+import { RebalanceRaw } from '../kamino-client/types';
+import { RebalanceTypeLabelName } from './consts';
+import { getPriceRangeFromPriceAndDiffBPS } from './math_utils';
+
+export const DEFAULT_LOWER_RANGE_PRICE_DIFF_BPS_PERIODIC_REBALANCE = new Decimal(500);
+export const DEFAULT_UPPER_RANGE_PRICE_DIFF_BPS_PERIODIC_REBALANCE = new Decimal(500);
+export const DEFAULT_REBALANCE_PERIOD = new Decimal(3600 * 24 * 3); // 3 days
+export const PeriodicRebalanceTypeName = 'periodicRebalance';
+
+export function getPeriodicRebalanceRebalanceFieldInfos(
+  price: Decimal,
+  period: Decimal, // seconds
+  lowerRangeBps: Decimal,
+  upperRangeBps: Decimal,
+  enabled: boolean = true
+): RebalanceFieldInfo[] {
+  const rebalanceType: RebalanceFieldInfo = {
+    label: RebalanceTypeLabelName,
+    type: 'string',
+    value: PeriodicRebalanceTypeName,
+    enabled,
+  };
+  const periodRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'period',
+    type: 'number',
+    value: period,
+    enabled,
+  };
+  const lowerRangeBpsRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'lowerRangeBps',
+    type: 'number',
+    value: lowerRangeBps,
+    enabled,
+  };
+  const upperRangeBpsRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'upperRangeBps',
+    type: 'number',
+    value: upperRangeBps,
+    enabled,
+  };
+
+  const { lowerPrice, upperPrice } = getPositionRangeFromPeriodicRebalanceParams(price, lowerRangeBps, upperRangeBps);
+
+  const lowerRangeRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'rangePriceLower',
+    type: 'number',
+    value: lowerPrice,
+    enabled: false,
+  };
+  const upperRangeRebalanceFieldInfo: RebalanceFieldInfo = {
+    label: 'rangePriceUpper',
+    type: 'number',
+    value: upperPrice,
+    enabled: false,
+  };
+
+  return [
+    rebalanceType,
+    periodRebalanceFieldInfo,
+    lowerRangeBpsRebalanceFieldInfo,
+    upperRangeBpsRebalanceFieldInfo,
+    lowerRangeRebalanceFieldInfo,
+    upperRangeRebalanceFieldInfo,
+  ];
+}
+
+export function getPositionRangeFromPeriodicRebalanceParams(
+  price: Decimal,
+  lowerPercentageBPS: Decimal,
+  upperPercentageBPS: Decimal
+): PositionRange {
+  return getPriceRangeFromPriceAndDiffBPS(price, lowerPercentageBPS, upperPercentageBPS);
+}
+
+export function getDefaultPeriodicRebalanceFieldInfos(price: Decimal): RebalanceFieldInfo[] {
+  return getPeriodicRebalanceRebalanceFieldInfos(
+    price,
+    DEFAULT_REBALANCE_PERIOD,
+    DEFAULT_LOWER_RANGE_PRICE_DIFF_BPS_PERIODIC_REBALANCE,
+    DEFAULT_UPPER_RANGE_PRICE_DIFF_BPS_PERIODIC_REBALANCE
+  );
+}
+
+export function readPeriodicRebalanceRebalanceParamsFromStrategy(rebalanceRaw: RebalanceRaw) {
+  const paramsBuffer = Buffer.from(rebalanceRaw.params);
+  const params: RebalanceFieldsDict = {};
+
+  params['period'] = new Decimal(paramsBuffer.readBigUInt64LE(0).toString());
+  params['lowerRangeBps'] = new Decimal(paramsBuffer.readUInt16LE(8));
+  params['upperRangeBps'] = new Decimal(paramsBuffer.readUInt16LE(10));
+
+  return params;
+}
+
+export function readPeriodicRebalanceRebalanceStateFromStrategy(rebalanceRaw: RebalanceRaw) {
+  const stateBuffer = Buffer.from(rebalanceRaw.state);
+  const state: RebalanceFieldsDict = {};
+
+  state['lastRebalanceTimestamp'] = new Decimal(stateBuffer.readBigUInt64LE(0).toString());
+
+  return state;
+}
+
+export function deserializePeriodicRebalanceFromOnchainParams(price: Decimal, rebalanceRaw: RebalanceRaw) {
+  const params = readPeriodicRebalanceRebalanceParamsFromStrategy(rebalanceRaw);
+
+  return getPeriodicRebalanceRebalanceFieldInfos(
+    price,
+    params['period'],
+    params['lowerRangeBps'],
+    params['upperRangeBps']
+  );
+}