# How to calculate price using getAmountsIn?

I have a function inside an arbitrage bot that is supposed to use `getAmountsIn` to determine the profitability of the trade. However, due to the current implementation, every single trade results in a high predicted loss. Below, you'll find the relevant code, a printout displaying the heavy loss prediction, and my own math that seems to contradict the finding of `getAmountsIn`

Where is this implementation going wrong?

The code:

``````        const determineProfitability = async (_routerPath, _token0Contract, _token0, _token1, uPairValue, sPairValue) => {

let reserves, exchangeToBuy, exchangeToSell, reserve0, reserve1

reserves = await getReserves(sPairValue)
otherReserves = await getReserves(uPairValue)
exchangeToSell = 'Sushiswap'

} else {
reserves = await getReserves(uPairValue)
otherReserves  = await getReserves(sPairValue)
exchangeToSell = 'Uniswap'
}

try {

// v-- This is where the calculation seems to go wrong --v

let result = await _routerPath[0].methods.getAmountsIn(reserves[0], [_token1.address, _token0.address]).call()

const token0In = result[0]
const token1In = result[1]

const { amountIn, amountOut } = await getEstimatedReturn(token0In, _routerPath, _token0, _token1)

const gasPrice = await web3.eth.getGasPrice();
const gasCalc = (gasPrice * 21000).toString();
const estimatedGasCost = web3.utils.fromWei(gasCalc, 'ether')

let ethBalanceBefore = await web3.eth.getBalance(account)
ethBalanceBefore = web3.utils.fromWei(ethBalanceBefore, 'ether')
const ethBalanceAfter = ethBalanceBefore - estimatedGasCost

const amountDifference = amountOut - amountIn
let wethBalanceBefore = await _token0Contract.methods.balanceOf(account).call()
wethBalanceBefore = web3.utils.fromWei(wethBalanceBefore, 'ether')

const wethBalanceAfter = amountDifference + Number(wethBalanceBefore)
const wethBalanceDifference = wethBalanceAfter - Number(wethBalanceBefore)

const totalGained = wethBalanceDifference - Number(estimatedGasCost)

if (totalGained < 0 || amountOut < amountIn) {
return false
}

amount = token0In
return true

} catch (error) {
console.log(error)
return false
}

}
``````

Here's the printout:

``````Swap Initiated on Sushiswap, Checking Price...

Current Block: 16587119
-----------------------------------------
UNISWAP   | WETH/FXS     | 142
SUSHISWAP | WETH/FXS     | 143

Percentage Difference: -0.70%

Determining Direction...

Potential Arbitrage Direction:

Sell     -->     Uniswap

Determining Profitability...

Reserves on Uniswap (0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)
WETH: 94.71862096607386039
FXS: 13480.822150599881758659

Reserves on Sushiswap (0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F)
OtherWETH: 1263.203664453649794659
OtherFXS: 180432.001225073992589556

token0In: 102.30694284028118994
token1In: 13480.822150599881758659
result[0]: 13480.822150599881758659
result[1]: 47.288164798785998402

Estimated amount of WETH needed to buy enough FXS on Sushiswap      | 102.30694284028118994
Estimated amount of WETH returned after swapping FXS on Uniswap | 47.288164798785998402

┌─────────────────────┬────────────────────────┐
│       (index)       │         Values         │
├─────────────────────┼────────────────────────┤
│ ETH Balance Before  │ '0.011059137636702474' │
│  ETH Balance After  │  0.010474034995509474  │
│   ETH Spent (gas)   │  '0.000585102641193'   │
│          -          │                        │
│ WETH Balance BEFORE │      '0.00003675'      │
│ WETH Balance AFTER  │  -55.018741291495196   │
│  WETH Gained/Lost   │  -55.018778041495196   │
│  Total Gained/Lost  │   -55.01936314413639   │
└─────────────────────┴────────────────────────┘
No Arbitrage Currently Available
``````

Here's my math on this:

``````WETH reserves on UniSwap were 94.7186209660738
At a price of 1 WETH / 143 FXS on Sushiswap, the output from using all that WETH would be 13544.7627981486000 FXS
Selling that amount of FXS of Uniswap at a price of 1 WETH / 142 FXS would provide a return in WETH of 95.38565351
Gas was 0.0005851026412 ETH for this transaction
There are also .3% transaction fees to account for on Uniswap and Sushiswap

So here's the calculation:
95.38565351 - (95.38565351 * .003) - 0.0005851026412 - 94.7186209660738 - (94.7186209660738 *.003) = 0.0981357135770 ETH

Now, just for fun, what if we change the transaction fee to 30% for each?

Then the total becomes -56.1647251402709 ETH ... very close to the -55.01936314413639 ETH final calculation spurred on by getAmountsIn.
``````

I don't know if that last bit is a false equivalency or not, but I've seen it when doing the math on 10-20 or more swaps like this. In any case, there should have been a gain of nearly .1 ETH on this transaction. So why is `getAmountsIn` giving me such a drastically different number?

I ended up just not using `getAmountsIn` or `getAmountsOut` at all and opting for a simple math equation. Seems like one of those situations where the library just made life harder.