spl-math: Add separate package to test instruction usage (#1205)

* Refactor to use spl-math

* Run cargo fmt

* Fixup fuzz

* Add spl math program

* Add u64-based approximation

* Cleanup

* Downgrade solana sdk for CI

* Move U256 impl to stable curve

* Remove generic newtonian, use traits

* Cargo fmt

* Move math/program -> libraries/math

* Revert Cargo.lock changes

* Add u128 instruction count tests

* cargo fmt

Author: joncinque

Cargo.lock

@@ -8,6 +8,7 @@ members = [
   "examples/rust/transfer-lamports",
   "feature-proposal/program",
   "feature-proposal/cli",
+  "libraries/math",
   "memo/program",
   "shared-memory/program",
   "stake-pool/cli",

Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "spl-math"
+version = "0.1.0"
+description = "Solana Program Library Math"
+authors = ["Solana Maintainers <[email protected]>"]
+repository = "https://github.com/solana-labs/solana-program-library"
+license = "Apache-2.0"
+edition = "2018"
+
+[features]
+no-entrypoint = []
+test-bpf = []
+
+[dependencies]
+borsh = "0.7.1"
+borsh-derive = "0.7.1"
+num-derive = "0.3"
+num-traits = "0.2"
+solana-program = "1.5.4"
+thiserror = "1.0"
+uint = "0.8"
+
+[dev-dependencies]
+proptest = "0.10"
+solana-program-test = "1.5.4"
+solana-sdk = "1.5.4"
+tokio = { version = "0.3", features = ["macros"]}
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

libraries/math/Cargo.toml

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []

libraries/math/Xargo.toml

@@ -0,0 +1,61 @@
+//! Approximation calculations
+
+use {
+    num_traits::{CheckedAdd, CheckedDiv, One, Zero},
+    std::cmp::Eq,
+};
+
+const SQRT_ITERATIONS: u8 = 50;
+
+/// Perform square root
+pub fn sqrt<T: CheckedAdd + CheckedDiv + One + Zero + Eq + Copy>(radicand: T) -> Option<T> {
+    if radicand == T::zero() {
+        return Some(T::zero());
+    }
+    // A good initial guess is the average of the interval that contains the
+    // input number.  For all numbers, that will be between 1 and the given number.
+    let one = T::one();
+    let two = one.checked_add(&one)?;
+    let mut guess = radicand.checked_div(&two)?.checked_add(&one)?;
+    let mut last_guess = guess;
+    for _ in 0..SQRT_ITERATIONS {
+        // x_k+1 = (x_k + radicand / x_k) / 2
+        guess = last_guess
+            .checked_add(&radicand.checked_div(&last_guess)?)?
+            .checked_div(&two)?;
+        if last_guess == guess {
+            break;
+        } else {
+            last_guess = guess;
+        }
+    }
+    Some(guess)
+}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, proptest::prelude::*};
+
+    fn check_square_root(radicand: u128) {
+        let root = sqrt(radicand).unwrap();
+        let lower_bound = root.saturating_sub(1).checked_pow(2).unwrap();
+        let upper_bound = root.checked_add(1).unwrap().checked_pow(2).unwrap();
+        assert!(radicand as u128 <= upper_bound);
+        assert!(radicand as u128 >= lower_bound);
+    }
+
+    #[test]
+    fn test_square_root_min_max() {
+        let test_roots = [0, u64::MAX];
+        for i in test_roots.iter() {
+            check_square_root(*i as u128);
+        }
+    }
+
+    proptest! {
+        #[test]
+        fn test_square_root(a in 0..u64::MAX) {
+            check_square_root(a as u128);
+        }
+    }
+}

libraries/math/src/approximations.rs

@@ -0,0 +1,16 @@
+//! Program entrypoint
+
+#![cfg(not(feature = "no-entrypoint"))]
+
+use solana_program::{
+    account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, pubkey::Pubkey,
+};
+
+entrypoint!(process_instruction);
+fn process_instruction(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    crate::processor::process_instruction(program_id, accounts, instruction_data)
+}

libraries/math/src/entrypoint.rs

@@ -0,0 +1,28 @@
+//! Error types
+
+use {
+    num_derive::FromPrimitive,
+    solana_program::{decode_error::DecodeError, program_error::ProgramError},
+    thiserror::Error,
+};
+
+/// Errors that may be returned by the Math program.
+#[derive(Clone, Debug, Eq, Error, FromPrimitive, PartialEq)]
+pub enum MathError {
+    /// Calculation overflowed the destination number
+    #[error("Calculation overflowed the destination number")]
+    Overflow,
+    /// Calculation underflowed the destination number
+    #[error("Calculation underflowed the destination number")]
+    Underflow,
+}
+impl From<MathError> for ProgramError {
+    fn from(e: MathError) -> Self {
+        ProgramError::Custom(e as u32)
+    }
+}
+impl<T> DecodeError<T> for MathError {
+    fn type_of() -> &'static str {
+        "Math Error"
+    }
+}

libraries/math/src/error.rs

@@ -0,0 +1,70 @@
+//! Program instructions, used for end-to-end testing and instruction counts
+
+use {
+    crate::id,
+    borsh::{BorshDeserialize, BorshSerialize},
+    solana_program::instruction::Instruction,
+};
+
+/// Instructions supported by the math program, used for testing instruction
+/// counts
+#[derive(Clone, Debug, BorshSerialize, BorshDeserialize, PartialEq)]
+pub enum MathInstruction {
+    /// Calculate the square root of the given u64 with decimals
+    ///
+    /// No accounts required for this instruction
+    PreciseSquareRoot {
+        /// Number underneath the square root sign, whose square root will be
+        /// calculated
+        radicand: u64,
+    },
+    /// Calculate the integer square root of the given u64
+    ///
+    /// No accounts required for this instruction
+    SquareRootU64 {
+        /// Number underneath the square root sign, whose square root will be
+        /// calculated
+        radicand: u64,
+    },
+    /// Calculate the integer square root of the given u128
+    ///
+    /// No accounts required for this instruction
+    SquareRootU128 {
+        /// Number underneath the square root sign, whose square root will be
+        /// calculated
+        radicand: u128,
+    },
+}
+
+/// Create PreciseSquareRoot instruction
+pub fn precise_sqrt(radicand: u64) -> Instruction {
+    Instruction {
+        program_id: id(),
+        accounts: vec![],
+        data: MathInstruction::PreciseSquareRoot { radicand }
+            .try_to_vec()
+            .unwrap(),
+    }
+}
+
+/// Create SquareRoot instruction
+pub fn sqrt_u64(radicand: u64) -> Instruction {
+    Instruction {
+        program_id: id(),
+        accounts: vec![],
+        data: MathInstruction::SquareRootU64 { radicand }
+            .try_to_vec()
+            .unwrap(),
+    }
+}
+
+/// Create SquareRoot instruction
+pub fn sqrt_u128(radicand: u128) -> Instruction {
+    Instruction {
+        program_id: id(),
+        accounts: vec![],
+        data: MathInstruction::SquareRootU128 { radicand }
+            .try_to_vec()
+            .unwrap(),
+    }
+}

libraries/math/src/instruction.rs

@@ -0,0 +1,14 @@
+//! Math operations using unsigned integers
+
+#![deny(missing_docs)]
+#![forbid(unsafe_code)]
+
+pub mod approximations;
+mod entrypoint;
+pub mod error;
+pub mod instruction;
+pub mod precise_number;
+pub mod processor;
+pub mod uint;
+
+solana_program::declare_id!("Math111111111111111111111111111111111111111");