@atomicfinance/bitcoin-wallet-provider 4.2.8 → 4.3.0

package/.yalc/@node-dlc/core/lib/dlc/finance/CoveredCall.ts

@@ -0,0 +1,110 @@
+import { PayoutFunction } from '@node-dlc/messaging';
+import BN from 'bignumber.js';
+
+import { toBigInt } from '../../utils/BigIntUtils';
+import { HyperbolaPayoutCurve } from '../HyperbolaPayoutCurve';
+
+const buildCurve = (
+  strikePrice: bigint,
+  contractSize: bigint,
+  oracleBase: number,
+  oracleDigits: number,
+): {
+  maxOutcome: bigint;
+  totalCollateral: bigint;
+  payoutCurve: HyperbolaPayoutCurve;
+} => {
+  const a = new BN(1);
+  const b = new BN(0);
+  const c = new BN(0);
+  const d = new BN((strikePrice * contractSize).toString());
+
+  const f_1 = new BN(0);
+  const _f_2 = new BN(0);
+
+  const _tempHyperbolaPayoutCurve = new HyperbolaPayoutCurve(
+    a,
+    b,
+    c,
+    d,
+    f_1,
+    _f_2,
+  );
+
+  const maxOutcome = BigInt(
+    new BN(oracleBase).pow(oracleDigits).minus(1).toString(10),
+  );
+  const maxOutcomePayout = _tempHyperbolaPayoutCurve
+    .getPayout(maxOutcome)
+    .integerValue();
+
+  return {
+    maxOutcome,
+    totalCollateral: contractSize - toBigInt(maxOutcomePayout),
+    payoutCurve: new HyperbolaPayoutCurve(
+      a,
+      b,
+      c,
+      d,
+      f_1,
+      maxOutcomePayout.negated(),
+    ),
+  };
+};
+
+const buildPayoutFunction = (
+  strikePrice: bigint,
+  contractSize: bigint,
+  oracleBase: number,
+  oracleDigits: number,
+): { payoutFunction: PayoutFunction; totalCollateral: bigint } => {
+  const { maxOutcome, totalCollateral, payoutCurve } = buildCurve(
+    strikePrice,
+    contractSize,
+    oracleBase,
+    oracleDigits,
+  );
+
+  const payoutFunction = new PayoutFunction();
+
+  // Defensive fix: ensure payoutFunctionPieces is initialized as an array
+  if (!payoutFunction.payoutFunctionPieces) {
+    payoutFunction.payoutFunctionPieces = [];
+  }
+
+  const curvePiece = payoutCurve.toPayoutCurvePiece();
+
+  // Set the left and right endpoints for the hyperbola piece (matching rust-dlc structure)
+  curvePiece.leftEndPoint = {
+    eventOutcome: BigInt(0),
+    outcomePayout: totalCollateral,
+    extraPrecision: 0,
+  };
+  curvePiece.rightEndPoint = {
+    eventOutcome: maxOutcome,
+    outcomePayout: BigInt(0),
+    extraPrecision: 0,
+  };
+
+  payoutFunction.payoutFunctionPieces.push({
+    endPoint: {
+      eventOutcome: maxOutcome,
+      outcomePayout: BigInt(0),
+      extraPrecision: 0,
+    },
+    payoutCurvePiece: curvePiece,
+  });
+
+  payoutFunction.lastEndpoint = {
+    eventOutcome: maxOutcome,
+    outcomePayout: BigInt(0),
+    extraPrecision: 0,
+  };
+
+  return {
+    payoutFunction,
+    totalCollateral,
+  };
+};
+
+export const CoveredCall = { buildCurve, buildPayoutFunction };

package/.yalc/@node-dlc/core/lib/dlc/finance/CsoInfo.ts

@@ -0,0 +1,498 @@
+import { Value } from '@node-dlc/bitcoin';
+import {
+  ContractDescriptorType,
+  ContractInfo,
+  ContractInfoType,
+  DigitDecompositionEventDescriptor,
+  MessageType,
+  MultiOracleInfo,
+  NumericalDescriptor,
+  OrderPositionInfo,
+  PayoutCurvePieceType,
+  PayoutFunction,
+  PolynomialPayoutCurvePiece,
+  SingleContractInfo,
+  SingleOracleInfo,
+} from '@node-dlc/messaging';
+import assert from 'assert';
+import Decimal from 'decimal.js';
+
+import {
+  DlcParty,
+  roundToNearestMultiplier,
+  roundUpToNearestMultiplier,
+  UNIT_MULTIPLIER,
+} from './Builder';
+import { HasContractInfo, HasOfferCollateral, HasType } from './OptionInfo';
+
+export interface CsoInfo {
+  normalizedMaxGain: Value; // Max Gain Relative to 1 BTC Contract
+  normalizedMaxLoss: Value; // Max Loss Relative to 1 BTC Contract
+  maxGainForContractSize: Value; // Max Gain Relative to Contract Size
+  maxLossForContractSize: Value; // Max Loss Relative to Contract Size
+  minPayout: bigint;
+  maxPayout: bigint;
+  contractSize: Value;
+  offerCollateral: Value;
+  totalCollateral: Value;
+  expiry: Date;
+}
+
+export interface CsoInfoParams {
+  normalizedMaxGain: Value; // Max Gain Relative to 1 BTC Contract
+  normalizedMaxLoss: Value; // Max Loss Relative to 1 BTC Contract
+  maxGainForContractSize: Value; // Max Gain Relative to Contract Size
+  maxLossForContractSize: Value; // Max Loss Relative to Contract Size
+  offerCollateral: Value; // Offer Collateral
+}
+
+const ONE_BTC_CONTRACT = Value.fromBitcoin(1);
+
+export type MaybeHasPositionInfo = {
+  positionInfo?: OrderPositionInfo;
+};
+
+/**
+ * getCsoInfoParamsFromContractInfo V0
+ *
+ * Old getCsoInfoParamsFromContractInfo implementation
+ *
+ * @param {Value} contractSize - The size of the contract in terms of value.
+ * @param {Value} collateral - The collateral value put up for the contract.
+ * @param {DlcParty} shiftForFees - Specifies which party ('offeror' or 'acceptor') will bear the fees, affecting the outcome values.
+ * @param {Value} fees - The fees associated with the contract.
+ * @param {string} unit - The unit of measurement for the contract outcomes (e.g., 'BTC').
+ * @param {Value} startOutcomeValue - The starting outcome value for the contract.
+ * @param {Value} endOutcomeValue - The ending outcome value for the contract.
+ * @returns {CsoInfoParams} An object containing the calculated CSO parameters:
+ *                          - normalizedMaxGain: Maximum gain relative to a 1 BTC contract.
+ *                          - normalizedMaxLoss: Maximum loss relative to a 1 BTC contract.
+ *                          - maxGainForContractSize: Maximum gain for the actual contract size.
+ *                          - maxLossForContractSize: Maximum loss for the actual contract size.
+ *                          - offerCollateral: The offer collateral value after adjustments.
+ *
+ * Note: This function calculates the adjusted fees incorrectly, using collateral instead of contract size. Use v1 where possible.
+ */
+export const getCsoInfoParamsFromContractInfoV0 = (
+  contractSize: Value,
+  collateral: Value,
+  shiftForFees: DlcParty,
+  fees: Value,
+  unit: string,
+  startOutcomeValue: Value,
+  endOutcomeValue: Value,
+): CsoInfoParams => {
+  const leverageMultiplier = parseFloat(
+    new Decimal(contractSize.bitcoin).dividedBy(collateral.bitcoin).toFixed(1),
+  );
+
+  const defaultContractSize = Value.fromBitcoin(1);
+
+  const shiftValue =
+    collateral.sats > 0
+      ? Value.fromSats(
+          roundToNearestMultiplier(
+            (fees.sats * defaultContractSize.sats) / collateral.sats, // WARNING: this should be contract size not collateral
+            UNIT_MULTIPLIER[unit.toLowerCase()], // (use v1 if possible)
+          ),
+        )
+      : Value.zero();
+
+  if (shiftForFees === 'offeror') {
+    startOutcomeValue.sub(shiftValue);
+    endOutcomeValue.sub(shiftValue);
+  } else if (shiftForFees === 'acceptor') {
+    startOutcomeValue.add(shiftValue);
+    endOutcomeValue.add(shiftValue);
+  }
+
+  const normalizedMaxGain = endOutcomeValue.clone();
+  normalizedMaxGain.sub(ONE_BTC_CONTRACT);
+
+  const normalizedMaxLoss = ONE_BTC_CONTRACT.clone();
+  normalizedMaxLoss.sub(startOutcomeValue);
+
+  const maxGainForContractSize = Value.fromBitcoin(
+    new Decimal(normalizedMaxGain.bitcoin)
+      .times(leverageMultiplier)
+      .toDecimalPlaces(5)
+      .toNumber(),
+  );
+
+  const maxLossForContractSize = Value.fromBitcoin(
+    new Decimal(normalizedMaxLoss.bitcoin)
+      .times(contractSize.bitcoin)
+      .toDecimalPlaces(
+        8 - Math.log10(Number(UNIT_MULTIPLIER[unit.toLowerCase()])),
+      )
+      .toNumber(),
+  );
+
+  const offerCollateral = collateral.clone();
+  offerCollateral.sub(
+    Value.fromSats(
+      (maxGainForContractSize.sats * collateral.sats) / BigInt(1e8),
+    ),
+  );
+
+  return {
+    normalizedMaxGain,
+    normalizedMaxLoss,
+    maxGainForContractSize,
+    maxLossForContractSize,
+    offerCollateral,
+  };
+};
+
+/**
+ * getCsoInfoParamsFromContractInfo V1
+ *
+ * Fixed getCsoInfoParamsFromContractInfo implementation
+ *
+ * @param {Value} contractSize - The size of the contract in terms of value.
+ * @param {Value} collateral - The collateral value put up for the contract.
+ * @param {DlcParty} shiftForFees - Specifies which party ('offeror' or 'acceptor') will bear the fees, affecting the outcome values.
+ * @param {Value} fees - The fees associated with the contract.
+ * @param {string} unit - The unit of measurement for the contract outcomes (e.g., 'BTC').
+ * @param {Value} startOutcomeValue - The starting outcome value for the contract.
+ * @param {Value} endOutcomeValue - The ending outcome value for the contract.
+ * @returns {CsoInfoParams} An object containing the calculated CSO parameters:
+ *                          - normalizedMaxGain: Maximum gain relative to a 1 BTC contract.
+ *                          - normalizedMaxLoss: Maximum loss relative to a 1 BTC contract.
+ *                          - maxGainForContractSize: Maximum gain for the actual contract size.
+ *                          - maxLossForContractSize: Maximum loss for the actual contract size.
+ *                          - offerCollateral: The offer collateral value after adjustments.
+ *
+ * This version improves upon the previous by correctly adjusting fees based on the contract size, leading to more accurate
+ * calculations of CSO parameters.
+ */
+export const getCsoInfoParamsFromContractInfoV1 = (
+  contractSize: Value,
+  collateral: Value,
+  shiftForFees: DlcParty,
+  fees: Value,
+  unit: string,
+  startOutcomeValue: Value,
+  endOutcomeValue: Value,
+): CsoInfoParams => {
+  const feesAdjusted = Value.fromSats(
+    roundToNearestMultiplier(
+      (fees.sats * BigInt(1e8)) / contractSize.sats, // NOTE: this is done correctly using contractSize
+      BigInt(UNIT_MULTIPLIER[unit.toLowerCase()]),
+    ),
+  );
+
+  if (shiftForFees === 'offeror') {
+    startOutcomeValue.sub(feesAdjusted);
+    endOutcomeValue.sub(feesAdjusted);
+  } else if (shiftForFees === 'acceptor') {
+    startOutcomeValue.add(feesAdjusted);
+    endOutcomeValue.add(feesAdjusted);
+  }
+
+  const normalizedMaxGain = endOutcomeValue.clone();
+  normalizedMaxGain.sub(ONE_BTC_CONTRACT);
+
+  const normalizedMaxLoss = ONE_BTC_CONTRACT.clone();
+  normalizedMaxLoss.sub(startOutcomeValue);
+
+  const maxGainForContractSize = Value.fromSats(
+    roundUpToNearestMultiplier(
+      (normalizedMaxGain.sats * contractSize.sats) / BigInt(1e8),
+      BigInt(UNIT_MULTIPLIER[unit.toLowerCase()]),
+    ),
+  );
+
+  const maxLossForContractSize = Value.fromSats(
+    roundUpToNearestMultiplier(
+      (normalizedMaxLoss.sats * contractSize.sats) / BigInt(1e8),
+      BigInt(UNIT_MULTIPLIER[unit.toLowerCase()]),
+    ),
+  );
+
+  const offerCollateral = collateral.clone();
+  offerCollateral.sub(maxGainForContractSize);
+
+  return {
+    normalizedMaxGain,
+    normalizedMaxLoss,
+    maxGainForContractSize,
+    maxLossForContractSize,
+    offerCollateral,
+  };
+};
+
+/**
+ * Decode CsoInfo from a ContractInfo object. Essentially the opposite of buildCustomStrategyOrderOffer
+ *
+ * @param {_contractInfo} ContractInfo - Contract Info object, containing oracle and descriptor info
+ * @param {DlcParty} shiftForFees - Specifies which party ('offeror', 'acceptor', or 'neither') will pay for network fees
+ * @param {Value} fees - Network fees associated with the contract. Defaults to 0 sats.
+ * @param {_contractSize} Value - Optional.  If not provided, it defaults to the total collateral.
+ * @param {csoVersion} 'v0' | 'v1' - Specifies the version of the CSO parameter calculation to use. Defaults to 'v1'.
+ * @returns {CsoInfo} An object containing the calculated CSO information:
+ *                    - normalizedMaxGain: Maximum gain relative to a 1 BTC contract.
+ *                    - normalizedMaxLoss: Maximum loss relative to a 1 BTC contract.
+ *                    - maxGainForContractSize: Maximum gain for the actual contract size.
+ *                    - maxLossForContractSize: Maximum loss for the actual contract size.
+ *                    - minPayout: Minimum payout as determined by the contract's payout function.
+ *                    - maxPayout: Maximum payout as determined by the contract's payout function.
+ *                    - contractSize: The size of the contract in terms of value.
+ *                    - offerCollateral: The offer collateral value after adjustments.
+ *                    - totalCollateral: The total collateral put up for the contract.
+ *                    - expiry: The expiry date of the contract based on the oracle's event maturity epoch.
+ *
+ * Note: This function performs several validations to ensure that the contract information and its components are of the
+ * expected types and formats.
+ *       It throws errors if unsupported types or formats are encountered.
+ */
+export const getCsoInfoFromContractInfo = (
+  _contractInfo: ContractInfo,
+  shiftForFees: DlcParty = 'neither',
+  fees: Value = Value.fromSats(0),
+  _contractSize?: Value,
+  csoVersion: 'v0' | 'v1' = 'v1',
+): CsoInfo => {
+  if (_contractInfo.contractInfoType !== ContractInfoType.Single)
+    throw Error('Only ContractInfoV0 currently supported');
+
+  const contractInfo = _contractInfo as SingleContractInfo;
+  if (
+    contractInfo.contractDescriptor.contractDescriptorType !==
+    ContractDescriptorType.NumericOutcome
+  )
+    throw Error('Only Numeric Descriptor currently supported');
+
+  const oracleInfo = contractInfo.oracleInfo;
+
+  // Handle both SingleOracleInfo and MultiOracleInfo
+  let eventMaturityEpoch: number;
+  let eventDescriptor: DigitDecompositionEventDescriptor;
+
+  switch (oracleInfo.type) {
+    case MessageType.SingleOracleInfo: {
+      const singleOracleInfo = oracleInfo as SingleOracleInfo;
+      eventMaturityEpoch =
+        singleOracleInfo.announcement.oracleEvent.eventMaturityEpoch;
+      eventDescriptor = singleOracleInfo.announcement.oracleEvent
+        .eventDescriptor as DigitDecompositionEventDescriptor;
+
+      if (
+        singleOracleInfo.announcement.oracleEvent.eventDescriptor.type !==
+        MessageType.DigitDecompositionEventDescriptor
+      )
+        throw Error(
+          'Only DigitDecompositionEventDescriptor currently supported',
+        );
+      break;
+    }
+    case MessageType.MultiOracleInfo: {
+      const multiOracleInfo = oracleInfo as MultiOracleInfo;
+      eventMaturityEpoch =
+        multiOracleInfo.announcements[0].oracleEvent.eventMaturityEpoch;
+      eventDescriptor = multiOracleInfo.announcements[0].oracleEvent
+        .eventDescriptor as DigitDecompositionEventDescriptor;
+
+      if (
+        multiOracleInfo.announcements[0].oracleEvent.eventDescriptor.type !==
+        MessageType.DigitDecompositionEventDescriptor
+      )
+        throw Error(
+          'Only DigitDecompositionEventDescriptor currently supported',
+        );
+      break;
+    }
+    default:
+      throw Error('Unknown oracle info type');
+  }
+
+  const contractDescriptor = contractInfo.contractDescriptor as NumericalDescriptor;
+  if (contractDescriptor.payoutFunction.type !== MessageType.PayoutFunction)
+    throw Error('Only PayoutFunction currently supported');
+
+  const payoutFunction = contractDescriptor.payoutFunction as PayoutFunction;
+
+  validateCsoPayoutFunction(payoutFunction);
+
+  const initialPiece = payoutFunction.payoutFunctionPieces[0];
+  const midPiece = payoutFunction.payoutFunctionPieces[1];
+
+  const minPayout = initialPiece.endPoint.outcomePayout;
+  const maxPayout = midPiece.endPoint.outcomePayout;
+
+  const startOutcome = initialPiece.endPoint.eventOutcome;
+  const endOutcome = midPiece.endPoint.eventOutcome;
+
+  const unit = eventDescriptor.unit;
+
+  const collateral = Value.fromSats(contractInfo.totalCollateral);
+  const contractSize =
+    _contractSize && _contractSize.sats > 0 ? _contractSize : collateral;
+
+  const startOutcomeValue = Value.fromSats(
+    startOutcome * UNIT_MULTIPLIER[unit.toLowerCase()],
+  );
+  const endOutcomeValue = Value.fromSats(
+    endOutcome * UNIT_MULTIPLIER[unit.toLowerCase()],
+  );
+
+  const getCsoInfoParamsFromContractInfo =
+    csoVersion === 'v0'
+      ? getCsoInfoParamsFromContractInfoV0
+      : getCsoInfoParamsFromContractInfoV1;
+
+  const {
+    normalizedMaxGain,
+    normalizedMaxLoss,
+    maxGainForContractSize,
+    maxLossForContractSize,
+    offerCollateral,
+  } = getCsoInfoParamsFromContractInfo(
+    contractSize,
+    collateral,
+    shiftForFees,
+    fees,
+    unit,
+    startOutcomeValue,
+    endOutcomeValue,
+  );
+
+  const expiry = new Date(eventMaturityEpoch * 1000);
+
+  return {
+    normalizedMaxGain,
+    normalizedMaxLoss,
+    maxGainForContractSize,
+    maxLossForContractSize,
+    minPayout,
+    maxPayout,
+    contractSize,
+    offerCollateral,
+    totalCollateral: collateral,
+    expiry,
+  };
+};
+
+/**
+ * Get CsoInfo from OrderOffer or DlcOffer and validate
+ *
+ * @param {HasContractInfo & HasType} offer
+ * @returns {CsoInfo}
+ */
+export const getCsoInfoFromOffer = (
+  offer: HasContractInfo & HasType & HasOfferCollateral & MaybeHasPositionInfo,
+  csoVersion: 'v0' | 'v1' = 'v1',
+): CsoInfo => {
+  if (
+    offer.type !== MessageType.DlcOffer &&
+    offer.type !== MessageType.OrderOffer
+  )
+    throw Error('Only DlcOffer and OrderOffer currently supported');
+
+  let shiftForFees: DlcParty = 'neither';
+  const fees = Value.zero();
+  const contractSize = Value.zero();
+
+  if (offer.positionInfo) {
+    shiftForFees = (offer.positionInfo as OrderPositionInfo).shiftForFees;
+    fees.add(Value.fromSats((offer.positionInfo as OrderPositionInfo).fees));
+    contractSize.add(
+      Value.fromSats((offer.positionInfo as OrderPositionInfo).contractSize),
+    );
+  }
+
+  const positionInfo = getCsoInfoFromContractInfo(
+    offer.contractInfo,
+    shiftForFees,
+    fees,
+    contractSize,
+    csoVersion,
+  );
+
+  if (positionInfo.offerCollateral.sats !== offer.offerCollateral)
+    throw Error('Offer was not generated with CSO ContractInfo');
+
+  return positionInfo;
+};
+
+/**
+ * Validate Payout Function for proper CSO format
+ *
+ * It should have 3 PayoutCurvePieces which consist of a flat line (maxLoss),
+ * ascending line (maxLoss to maxGain) and finally another flat line (maxGain)
+ *
+ * All PayoutCurvePieces should be type PolynomialPayoutCurvePieces
+ *
+ * @param {PayoutFunction} payoutFunction
+ */
+export const validateCsoPayoutFunction = (
+  payoutFunction: PayoutFunction,
+): void => {
+  assert(
+    payoutFunction.payoutFunctionPieces.length === 3,
+    'CSO Payout Function must have 3 PayoutFunctionPieces',
+  );
+  for (const [i, piece] of payoutFunction.payoutFunctionPieces.entries()) {
+    assert(
+      piece.payoutCurvePiece.payoutCurvePieceType ===
+        PayoutCurvePieceType.Polynomial ||
+        piece.payoutCurvePiece.type === MessageType.PolynomialPayoutCurvePiece,
+      'CSO Payout Function PayoutCurvePieces must be PolynomialCurvePieces',
+    );
+
+    const payoutCurvePiece = piece.payoutCurvePiece as PolynomialPayoutCurvePiece;
+    const points = payoutCurvePiece.points;
+
+    // eventOutcome should always be ascending
+    assert(
+      points[0].eventOutcome < points[1].eventOutcome,
+      'CSO Payout Function PayoutCurvePiece point payout should be an ascending line',
+    );
+
+    // endpoints should always be ascending
+    let previousPiece, previousPoints;
+    if (i > 0) {
+      previousPiece = payoutFunction.payoutFunctionPieces[i - 1];
+      previousPoints = previousPiece.payoutCurvePiece.points;
+      assert(
+        previousPiece.endPoint.eventOutcome < piece.endPoint.eventOutcome,
+        'CSO Payout Function point endpoints should be an ascending line',
+      );
+      assert(
+        previousPoints[1].outcomePayout === points[0].outcomePayout,
+        'CSO Payout Function point outcome payout should be continuous without gaps',
+      );
+    }
+
+    switch (i) {
+      case 0:
+        // First piece - should start from initial endpoint
+        // maxLoss should be a flat line
+        assert(
+          points[0].outcomePayout === points[1].outcomePayout,
+          'CSO Payout Function maxLoss PayoutCurvePiece point should be a flat line',
+        );
+        break;
+      case 1:
+        // maxLoss to maxGain should be an ascending line
+        assert(
+          previousPiece.endPoint.outcomePayout < piece.endPoint.outcomePayout,
+        );
+        assert(
+          points[0].outcomePayout < points[1].outcomePayout,
+          'CSO Payout Function maxLoss to maxGain PayoutCurvePiece point should be an ascending line',
+        );
+        break;
+      case 2:
+        // maxGain should be a flat line
+        assert(
+          previousPiece.endPoint.outcomePayout === piece.endPoint.outcomePayout,
+        );
+        assert(
+          points[0].outcomePayout === points[1].outcomePayout,
+          'CSO Payout Function maxGain PayoutCurvePiece point should be a flat line',
+        );
+        break;
+    }
+  }
+};

package/.yalc/@node-dlc/core/lib/dlc/finance/LinearPayout.ts

@@ -0,0 +1,94 @@
+import { PayoutFunction } from '@node-dlc/messaging';
+import BN from 'bignumber.js';
+
+import { PolynomialPayoutCurve } from '../PolynomialPayoutCurve';
+
+const buildPayoutFunction = (
+  minPayout: bigint,
+  maxPayout: bigint,
+  startOutcome: bigint,
+  endOutcome: bigint,
+  oracleBase: number,
+  oracleDigits: number,
+): { payoutFunction: PayoutFunction } => {
+  // Max outcome limited by the oracle
+  const maxOutcome = BigInt(
+    new BN(oracleBase).pow(oracleDigits).minus(1).toString(10),
+  );
+
+  // max loss line
+  const payoutCurveMaxLoss = new PolynomialPayoutCurve([
+    { outcome: new BN(0), payout: new BN(Number(minPayout)) },
+    {
+      outcome: new BN(Number(startOutcome)),
+      payout: new BN(Number(minPayout)),
+    },
+  ]);
+
+  // payout line
+  const payoutCurve = new PolynomialPayoutCurve([
+    {
+      outcome: new BN(Number(startOutcome)),
+      payout: new BN(Number(minPayout)),
+    },
+    {
+      outcome: new BN(Number(endOutcome)),
+      payout: new BN(Number(maxPayout)),
+    },
+  ]);
+
+  // max gain line
+  const payoutCurveMaxGain = new PolynomialPayoutCurve([
+    { outcome: new BN(Number(endOutcome)), payout: new BN(Number(maxPayout)) },
+    {
+      outcome: new BN(Number(maxOutcome)),
+      payout: new BN(Number(maxPayout)),
+    },
+  ]);
+
+  const payoutFunction = new PayoutFunction();
+
+  // Defensive fix: ensure payoutFunctionPieces is initialized as an array
+  if (!payoutFunction.payoutFunctionPieces) {
+    payoutFunction.payoutFunctionPieces = [];
+  }
+
+  payoutFunction.payoutFunctionPieces.push({
+    endPoint: {
+      eventOutcome: startOutcome,
+      outcomePayout: minPayout,
+      extraPrecision: 0,
+    },
+    payoutCurvePiece: payoutCurveMaxLoss.toPayoutCurvePiece(),
+  });
+
+  payoutFunction.payoutFunctionPieces.push({
+    endPoint: {
+      eventOutcome: endOutcome,
+      outcomePayout: maxPayout,
+      extraPrecision: 0,
+    },
+    payoutCurvePiece: payoutCurve.toPayoutCurvePiece(),
+  });
+
+  payoutFunction.payoutFunctionPieces.push({
+    endPoint: {
+      eventOutcome: maxOutcome,
+      outcomePayout: maxPayout,
+      extraPrecision: 0,
+    },
+    payoutCurvePiece: payoutCurveMaxGain.toPayoutCurvePiece(),
+  });
+
+  payoutFunction.lastEndpoint = {
+    eventOutcome: maxOutcome,
+    outcomePayout: maxPayout,
+    extraPrecision: 0,
+  };
+
+  return {
+    payoutFunction,
+  };
+};
+
+export const LinearPayout = { buildPayoutFunction };