Added stable curve invariant to the token swap smart contract (#838)

* Added stable curve invariant to the token swap smart contract

* Fixed formatting

* Added missing stable curve constraints

* Symbol renames to make math clearer

* Small refactoring according to PR comments, fixes for JS tests

Author: ysavchenko

token-swap/js/client/token-swap.js

@@ -76,6 +76,7 @@ export const TokenSwapLayout: typeof BufferLayout.Structure = BufferLayout.struc
     Layout.uint64('ownerWithdrawFeeDenominator'),
     Layout.uint64('hostFeeNumerator'),
     Layout.uint64('hostFeeDenominator'),
+    Layout.uint64('amp'),
   ],
 );
 
@@ -310,6 +311,7 @@ export class TokenSwap {
       BufferLayout.nu64('ownerWithdrawFeeDenominator'),
       BufferLayout.nu64('hostFeeNumerator'),
       BufferLayout.nu64('hostFeeDenominator'),
+      BufferLayout.nu64('amp'),
     ]);
     let data = Buffer.alloc(1024);
     {

token-swap/program/src/constraints.rs

@@ -2,7 +2,7 @@
 
 use crate::{
     curve::base::{CurveType, SwapCurve},
-    curve::{constant_product::ConstantProductCurve, flat::FlatCurve},
+    curve::{constant_product::ConstantProductCurve, flat::FlatCurve, stable::StableCurve},
     error::SwapError,
 };
 
@@ -24,6 +24,8 @@ pub struct FeeConstraints<'a> {
     pub valid_flat_curves: &'a [FlatCurve],
     /// Valid constant product curves for the program
     pub valid_constant_product_curves: &'a [ConstantProductCurve],
+    /// Valid stable curves for the program
+    pub valid_stable_curves: &'a [StableCurve],
 }
 
 impl<'a> FeeConstraints<'a> {
@@ -46,6 +48,14 @@ impl<'a> FeeConstraints<'a> {
                     calculator: Box::new(x.clone()),
                 })
                 .collect(),
+            CurveType::Stable => self
+                .valid_stable_curves
+                .iter()
+                .map(|x| SwapCurve {
+                    curve_type: swap_curve.curve_type,
+                    calculator: Box::new(x.clone()),
+                })
+                .collect(),
         };
         if valid_swap_curves.iter().any(|x| *x == *swap_curve) {
             Ok(())
@@ -79,6 +89,8 @@ const VALID_FLAT_CURVES: &[FlatCurve] = &[FlatCurve {
     host_fee_numerator: 20,
     host_fee_denominator: 100,
 }];
+#[cfg(feature = "production")]
+const VALID_STABLE_CURVES: &[StableCurve] = &[];
 
 /// Fee structure defined by program creator in order to enforce certain
 /// fees when others use the program.  Adds checks on pool creation and
@@ -90,6 +102,7 @@ pub const FEE_CONSTRAINTS: Option<FeeConstraints> = {
             owner_key: OWNER_KEY,
             valid_constant_product_curves: VALID_CONSTANT_PRODUCT_CURVES,
             valid_flat_curves: VALID_FLAT_CURVES,
+            valid_stable_curves: VALID_STABLE_CURVES,
         })
     }
     #[cfg(not(feature = "production"))]
@@ -134,6 +147,7 @@ mod tests {
             owner_key,
             valid_constant_product_curves: &[calculator.clone()],
             valid_flat_curves: &[],
+            valid_stable_curves: &[],
         };
 
         fee_constraints.validate_curve(&swap_curve).unwrap();

token-swap/program/src/curve/base.rs

@@ -7,6 +7,7 @@ use solana_program::{
 
 use crate::curve::{
     calculator::CurveCalculator, constant_product::ConstantProductCurve, flat::FlatCurve,
+    stable::StableCurve,
 };
 use arrayref::{array_mut_ref, array_ref, array_refs, mut_array_refs};
 use std::convert::{TryFrom, TryInto};
@@ -20,6 +21,8 @@ pub enum CurveType {
     ConstantProduct,
     /// Flat line, always providing 1:1 from one token to another
     Flat,
+    /// Stable, Like uniswap, but with wide zone of 1:1 instead of one point
+    Stable,
 }
 
 /// Concrete struct to wrap around the trait object which performs calculation.
@@ -75,15 +78,15 @@ impl Sealed for SwapCurve {}
 impl Pack for SwapCurve {
     /// Size of encoding of all curve parameters, which include fees and any other
     /// constants used to calculate swaps, deposits, and withdrawals.
-    /// This includes 1 byte for the type, and 64 for the calculator to use as
-    /// it needs.  Some calculators may be smaller than 64 bytes.
-    const LEN: usize = 65;
+    /// This includes 1 byte for the type, and 72 for the calculator to use as
+    /// it needs.  Some calculators may be smaller than 72 bytes.
+    const LEN: usize = 73;
 
     /// Unpacks a byte buffer into a SwapCurve
     fn unpack_from_slice(input: &[u8]) -> Result<Self, ProgramError> {
-        let input = array_ref![input, 0, 65];
+        let input = array_ref![input, 0, 73];
         #[allow(clippy::ptr_offset_with_cast)]
-        let (curve_type, calculator) = array_refs![input, 1, 64];
+        let (curve_type, calculator) = array_refs![input, 1, 72];
         let curve_type = curve_type[0].try_into()?;
         Ok(Self {
             curve_type,
@@ -92,14 +95,15 @@ impl Pack for SwapCurve {
                     Box::new(ConstantProductCurve::unpack_from_slice(calculator)?)
                 }
                 CurveType::Flat => Box::new(FlatCurve::unpack_from_slice(calculator)?),
+                CurveType::Stable => Box::new(StableCurve::unpack_from_slice(calculator)?),
             },
         })
     }
 
     /// Pack SwapCurve into a byte buffer
     fn pack_into_slice(&self, output: &mut [u8]) {
-        let output = array_mut_ref![output, 0, 65];
-        let (curve_type, calculator) = mut_array_refs![output, 1, 64];
+        let output = array_mut_ref![output, 0, 73];
+        let (curve_type, calculator) = mut_array_refs![output, 1, 72];
         curve_type[0] = self.curve_type as u8;
         self.calculator.pack_into_slice(&mut calculator[..]);
     }
@@ -120,6 +124,7 @@ impl TryFrom<u8> for CurveType {
         match curve_type {
             0 => Ok(CurveType::ConstantProduct),
             1 => Ok(CurveType::Flat),
+            2 => Ok(CurveType::Stable),
             _ => Err(ProgramError::InvalidAccountData),
         }
     }
@@ -170,6 +175,7 @@ mod tests {
         packed.extend_from_slice(&owner_withdraw_fee_denominator.to_le_bytes());
         packed.extend_from_slice(&host_fee_numerator.to_le_bytes());
         packed.extend_from_slice(&host_fee_denominator.to_le_bytes());
+        packed.extend_from_slice(&0u64.to_le_bytes()); // 8 bytes reserved for larget calcs
         let unpacked = SwapCurve::unpack_from_slice(&packed).unwrap();
         assert_eq!(swap_curve, unpacked);
     }

token-swap/program/src/curve/calculator.rs

@@ -81,6 +81,12 @@ pub trait CurveCalculator: Debug + DynPack {
         Some(0)
     }
 
+    /// Calculate the trading fee in trading tokens
+    /// Default implementation assumes no fee
+    fn owner_trading_fee(&self, _trading_tokens: u128) -> Option<u128> {
+        Some(0)
+    }
+
     /// Calculate the pool token equivalent of the owner fee on trade
     /// See the math at: https://balancer.finance/whitepaper/#single-asset-deposit
     /// For the moment, we do an approximation for the square root.  For numbers

token-swap/program/src/curve/constant_product.rs

@@ -42,11 +42,7 @@ impl CurveCalculator for ConstantProductCurve {
     ) -> Option<SwapResult> {
         // debit the fee to calculate the amount swapped
         let trade_fee = self.trading_fee(source_amount)?;
-        let owner_fee = calculate_fee(
-            source_amount,
-            u128::try_from(self.owner_trade_fee_numerator).ok()?,
-            u128::try_from(self.owner_trade_fee_denominator).ok()?,
-        )?;
+        let owner_fee = self.owner_trading_fee(source_amount)?;
 
         let invariant = swap_source_amount.checked_mul(swap_destination_amount)?;
         let new_source_amount_less_fee = swap_source_amount
@@ -86,6 +82,15 @@ impl CurveCalculator for ConstantProductCurve {
         )
     }
 
+    /// Calculate the owner trading fee in trading tokens
+    fn owner_trading_fee(&self, trading_tokens: u128) -> Option<u128> {
+        calculate_fee(
+            trading_tokens,
+            u128::try_from(self.owner_trade_fee_numerator).ok()?,
+            u128::try_from(self.owner_trade_fee_denominator).ok()?,
+        )
+    }
+
     /// Calculate the host fee based on the owner fee, only used in production
     /// situations where a program is hosted by multiple frontends
     fn host_fee(&self, owner_fee: u128) -> Option<u128> {
@@ -106,6 +111,10 @@ impl IsInitialized for ConstantProductCurve {
 impl Sealed for ConstantProductCurve {}
 impl Pack for ConstantProductCurve {
     const LEN: usize = 64;
+    fn pack_into_slice(&self, output: &mut [u8]) {
+        (self as &dyn DynPack).pack_into_slice(output);
+    }
+
     fn unpack_from_slice(input: &[u8]) -> Result<ConstantProductCurve, ProgramError> {
         let input = array_ref![input, 0, 64];
         #[allow(clippy::ptr_offset_with_cast)]
@@ -130,10 +139,6 @@ impl Pack for ConstantProductCurve {
             host_fee_denominator: u64::from_le_bytes(*host_fee_denominator),
         })
     }
-
-    fn pack_into_slice(&self, output: &mut [u8]) {
-        (self as &dyn DynPack).pack_into_slice(output);
-    }
 }
 
 impl DynPack for ConstantProductCurve {

token-swap/program/src/curve/flat.rs

@@ -39,16 +39,8 @@ impl CurveCalculator for FlatCurve {
         swap_destination_amount: u128,
     ) -> Option<SwapResult> {
         // debit the fee to calculate the amount swapped
-        let trade_fee = calculate_fee(
-            source_amount,
-            u128::try_from(self.trade_fee_numerator).ok()?,
-            u128::try_from(self.trade_fee_denominator).ok()?,
-        )?;
-        let owner_fee = calculate_fee(
-            source_amount,
-            u128::try_from(self.owner_trade_fee_numerator).ok()?,
-            u128::try_from(self.owner_trade_fee_denominator).ok()?,
-        )?;
+        let trade_fee = self.trading_fee(source_amount)?;
+        let owner_fee = self.owner_trading_fee(source_amount)?;
 
         let amount_swapped = source_amount
             .checked_sub(trade_fee)?
@@ -75,6 +67,24 @@ impl CurveCalculator for FlatCurve {
         )
     }
 
+    /// Calculate the trading fee in trading tokens
+    fn trading_fee(&self, trading_tokens: u128) -> Option<u128> {
+        calculate_fee(
+            trading_tokens,
+            u128::try_from(self.trade_fee_numerator).ok()?,
+            u128::try_from(self.trade_fee_denominator).ok()?,
+        )
+    }
+
+    /// Calculate the owner trading fee in trading tokens
+    fn owner_trading_fee(&self, trading_tokens: u128) -> Option<u128> {
+        calculate_fee(
+            trading_tokens,
+            u128::try_from(self.owner_trade_fee_numerator).ok()?,
+            u128::try_from(self.owner_trade_fee_denominator).ok()?,
+        )
+    }
+
     /// Calculate the host fee based on the owner fee, only used in production
     /// situations where a program is hosted by multiple frontends
     fn host_fee(&self, owner_fee: u128) -> Option<u128> {
@@ -95,6 +105,10 @@ impl IsInitialized for FlatCurve {
 impl Sealed for FlatCurve {}
 impl Pack for FlatCurve {
     const LEN: usize = 64;
+    fn pack_into_slice(&self, output: &mut [u8]) {
+        (self as &dyn DynPack).pack_into_slice(output);
+    }
+
     fn unpack_from_slice(input: &[u8]) -> Result<FlatCurve, ProgramError> {
         let input = array_ref![input, 0, 64];
         #[allow(clippy::ptr_offset_with_cast)]
@@ -119,10 +133,6 @@ impl Pack for FlatCurve {
             host_fee_denominator: u64::from_le_bytes(*host_fee_denominator),
         })
     }
-
-    fn pack_into_slice(&self, output: &mut [u8]) {
-        (self as &dyn DynPack).pack_into_slice(output);
-    }
 }
 
 impl DynPack for FlatCurve {

token-swap/program/src/curve/mod.rs

@@ -4,3 +4,4 @@ pub mod base;
 pub mod calculator;
 pub mod constant_product;
 pub mod flat;
+pub mod stable;