|
1 | 1 | use std::ops::{Add, BitAnd, BitOrAssign, BitXor, Div, Mul, MulAssign};
|
2 | 2 |
|
3 |
| -use crate::{error::UniswapV3MathError, U256_1}; |
4 |
| -// use alloy_primitives::utils::ParseUnits::U256; |
| 3 | +use alloy::primitives::U256; |
5 | 4 |
|
6 |
| -use alloy::primitives::{Uint, U256}; |
7 |
| - |
8 |
| -pub const ONE: Uint<256, 4> = Uint::<256, 4>::from_limbs([1, 0, 0, 0]); |
9 |
| -pub const TWO: Uint<256, 4> = Uint::<256, 4>::from_limbs([2, 0, 0, 0]); |
10 |
| -pub const THREE: Uint<256, 4> = Uint::<256, 4>::from_limbs([3, 0, 0, 0]); |
| 5 | +use crate::{error::UniswapV3MathError, U256_1, U256_2, U256_3}; |
11 | 6 |
|
12 | 7 | // returns (uint256 result)
|
13 | 8 | pub fn mul_div(a: U256, b: U256, mut denominator: U256) -> Result<U256, UniswapV3MathError> {
|
@@ -81,24 +76,24 @@ pub fn mul_div(a: U256, b: U256, mut denominator: U256) -> Result<U256, UniswapV
|
81 | 76 | // Now that denominator is an odd number, it has an inverse
|
82 | 77 | // modulo 2**256 such that denominator * inv = 1 mod 2**256.
|
83 | 78 | // Compute the inverse by starting with a seed that is correct
|
84 |
| - // correct for four bits. That is, denominator * inv = 1 mod 2**4 |
| 79 | + // for four bits. That is, denominator * inv = 1 mod 2**4 |
85 | 80 |
|
86 |
| - let mut inv = THREE.mul(denominator).bitxor(TWO); |
| 81 | + let mut inv = U256_3.mul(denominator).bitxor(U256_2); |
87 | 82 |
|
88 | 83 | // Now use Newton-Raphson iteration to improve the precision.
|
89 | 84 | // Thanks to Hensel's lifting lemma, this also works in modular
|
90 | 85 | // arithmetic, doubling the correct bits in each step.
|
91 | 86 |
|
92 |
| - inv.mul_assign(TWO - denominator * inv); // inverse mod 2**8 |
93 |
| - inv.mul_assign(TWO - denominator * inv); // inverse mod 2**16 |
94 |
| - inv.mul_assign(TWO - denominator * inv); // inverse mod 2**32 |
95 |
| - inv.mul_assign(TWO - denominator * inv); // inverse mod 2**64 |
96 |
| - inv.mul_assign(TWO - denominator * inv); // inverse mod 2**128 |
97 |
| - inv.mul_assign(TWO - denominator * inv); // inverse mod 2**256 |
| 87 | + inv.mul_assign(U256_2 - denominator * inv); // inverse mod 2**8 |
| 88 | + inv.mul_assign(U256_2 - denominator * inv); // inverse mod 2**16 |
| 89 | + inv.mul_assign(U256_2 - denominator * inv); // inverse mod 2**32 |
| 90 | + inv.mul_assign(U256_2 - denominator * inv); // inverse mod 2**64 |
| 91 | + inv.mul_assign(U256_2 - denominator * inv); // inverse mod 2**128 |
| 92 | + inv.mul_assign(U256_2 - denominator * inv); // inverse mod 2**256 |
98 | 93 |
|
99 | 94 | // Because the division is now exact we can divide by multiplying
|
100 | 95 | // with the modular inverse of denominator. This will give us the
|
101 |
| - // correct result modulo 2**256. Since the precoditions guarantee |
| 96 | + // correct result modulo 2**256. Since the preconditions guarantee |
102 | 97 | // that the outcome is less than 2**256, this is the final result.
|
103 | 98 | // We don't need to compute the high bits of the result and prod1
|
104 | 99 | // is no longer required.
|
@@ -154,7 +149,6 @@ mod tests {
|
154 | 149 |
|
155 | 150 | #[cfg(test)]
|
156 | 151 | mod test {
|
157 |
| - |
158 | 152 | use std::ops::{Div, Mul, Sub};
|
159 | 153 |
|
160 | 154 | use alloy::primitives::U256;
|
|
0 commit comments