Unlike Uniswap v2, the factory contract has no allPairs method, so we cannot call allPairs to iterate all pools.

In the uniswap v3 contract, only position can be traversed, so we can start with the position contract NonfungiblePositionManager.

We need to use three methods of the NonfungiblePositionManager contract:

interface INonfungiblePositionManager {
    function positions(
        uint256 tokenId
    )
        external
        view
        returns (
            uint96 nonce,
            address operator,
            address token0,
            address token1,
            uint24 fee,
            int24 tickLower,
            int24 tickUpper,
            uint128 liquidity,
            uint256 feeGrowthInside0LastX128,
            uint256 feeGrowthInside1LastX128,
            uint128 tokensOwed0,
            uint128 tokensOwed1
        );

    function tokenByIndex(uint256 index) external view returns (uint256);

    function totalSupply() external view returns (uint256);
}


interface IUniswapV3Factory {
    function getPool(
        address tokenA,
        address tokenB,
        uint24 fee
    ) external view returns (address pool);
}

First, we use totalSupply to get the current number of positions, total position — burned position;
Then, we use the last tokenByIndex to get the total positions, recorded as total;
Finally, we call the positions method, starting from 1 (Uniswap v3’s tokenId starts from 1) and traverse until total; for each successfully returned result, call the getPool method of the Uniswap v3 factory to get the pool address

The full code is as follows:

pragma solidity 0.8.24;

    function getV3Pools(
        address factory,
        address positionManager,
        uint from,
        uint to
    ) public view returns (address[] memory pools) {
        {
            uint256 total = INonfungiblePositionManager(positionManager)
                .totalSupply();
            uint256 tokens = INonfungiblePositionManager(positionManager)
                .tokenByIndex(total - 1);
            if (from == 0) {
                from = 1;
            }
            if (to == 0 || to > tokens) {
                to = tokens;
            }
        }

        uint poolCount = 0;
        for (uint i = from; i <= to; ++i) {
            try
                INonfungiblePositionManager(positionManager).positions(i)
            returns (
                uint96,
                address,
                address,
                address,
                uint24,
                int24,
                int24,
                uint128,
                uint256,
                uint256,
                uint128,
                uint128
            ) {
                ++poolCount;
            } catch {}
        }

        pools = new address[](poolCount);
        if (poolCount == 0) {
            return pools;
        }

        for (uint i = from; i <= to; ++i) {
            try
                INonfungiblePositionManager(positionManager).positions(i)
            returns (
                uint96,
                address,
                address token0,
                address token1,
                uint24 fee,
                int24,
                int24,
                uint128,
                uint256,
                uint256,
                uint128,
                uint128
            ) {
                pools[--poolCount] = IUniswapV3Factory(factory).getPool(
                    token0,
                    token1,
                    fee
                );
            } catch {}
        }
    }

Due to the limitations of solidity, this code will report an error when compiled

stack too deep

We need to configure the viaIR option for the compiler to enable successful compilation:

solidity: {
    compilers: [{
        version: '0.8.24',
        settings: {  
          viaIR: true,
          optimizer: {
            enabled: true,
            runs: 20000,
          },
        },
      }
  ]
}

When we call the method getV3Pools, the step should less than 20,000,

When we call the getV3Pools method, the parameter step should be less than 20,000, otherwise out of gas may occur.

English version: https://medium.com/@guotie/the-inherent-flaw-of-uniswap-lp-asymmetry-in-profit-and-loss-fc7c2d173c2f

当我们对uniswap LP进行深入分析之后，我们发现了LP的惊人事实：那就是LP很难盈利，无论是USD本位还是币本位。

TL;DR
uniswap LP最根本的缺陷在于，相同币价涨幅与跌幅时，LP在上涨时的盈利和下跌时的亏损不对等。

为简单证明，我们以ETH/USDC为例来说明。

假如如下：
1. 现在ETH/USDC的价格是2000
2. 我们的初始资金是2000USDC
3. 我们提供流动性ETH和USDC的比例为1:1
4. 我们使用uniswap v3，价格范围为上下10%，即[1800, 2222]

我们的初始资产为2000USDC，LP的初始资产为：0.5ETH + 1000USDC

那么，存在以下几种可能：
1. 币价上涨超过10%，我们LP资产全部变为USDC
2. 币价下跌超过10%，我们LP资产全部变为ETH
3. 币价在[1800, 2222]之间波动

我们先来分析前两种情况。

币价超过2222

当币价高于2222时，我们的资产全部兑换为USDC，数量为：2053

那么，以USDC计价，我们的收益为：
(2053–2000)/2000=2.65%

币价低于1800

当币价低于1800时，我们的资产全部兑换为ETH，数量为1.026584

那么，以USDC计价，我们的损失为：
(2000–1800 * 1.026584)/2000 = 7.6%

通过上面的计算，我们可以发现，当币价上涨11%时我们的收益为2.65%，当币价下跌10%时，我们的损失为7.6%

1. LP降低了收益，同时也减少了亏损
2. LP在币价上涨时的收益与币价下跌时的亏损不平衡，上涨11%时，收益2.65%；而币价下跌10%时，亏损7.6%

无常损失

虽然有人可能会说，上面的亏损只是暂时的，当价格回到区间后，亏损就会

币本位

事实上，以币本位来计算不会影响结论，只是币价上涨时亏损加大，而币价下跌时盈利小。

非对等比例LP

上述分析基于token x 和token y的比例为1:1情况下，LP的收益和损失。那么，如果我们提供流动性时，x和y的比例不对等时，对收益和损失有什么影响呢？

让我们把上面的特例通用化。

首先，假设我们提供流动性时，当前价格在我们的价格区间内。如果不在，我们提供的流动性不会赚取任何手续费收益，因此暂不讨论。

当前价格为price current，记为pc
价格区间为price low, price high， 记为[pl, ph]
交易对为tokenx/tokeny
初始资产全部是token y，总量记为T。

为了开始提供流动性，我们需要把我们R比例的token y兑换为token x，这里R>0 && R<1。

事实上，当我们的价格区间和总资产确定后，R是确定的。

uniswap v3流动性变量五元组：
1. 当前价格， price current
2. 价格区间， price low，price high
3. token数量，amountX, amountY

上述5个变量，可以通过任意4个计算出第五个。

由于：
x = L * [sqrt(ph) — sqrt(pc)] / [sqrt(pc) * sqrt(ph)]
y = L * [sqrt(pc) — sqrt(pl)]

两式相除：
x/y = [sqrt(ph) — sqrt(pc)]/{[sqrt(pc) — sqrt(pl)] * [sqrt(pc) * sqrt(ph)]}

x = RT/pc
y = (1-R)T

代入，得到：
R/(1-R) = pc * [sqrt(ph) — sqrt(pc)]/{[sqrt(pc) — sqrt(pl)] * [sqrt(pc) * sqrt(ph)]}

上述公式中，pc，ph，pl均为已知，因此，可以求解R

当价格变化后，假设新的价格为price new，记为pn，假设price new仍然在价格区间内。此时，由于L不变，可以求解出token x的数量xn和token y的数量 yn

xn = L * [sqrt(ph) — sqrt(pn)] / [sqrt(pn) * sqrt(ph)]
yn = L * [sqrt(pn) — sqrt(pl)]

因此，可以根据以上公式计算在[pl, ph] 区间下的各种价格的盈利和亏损，然后与币价的涨跌幅对比。

总结

很多人没有意识到uniswap LP的天生缺陷，就是相同币价涨幅与跌幅时，币价上涨时的盈利与币价下跌时的亏损的不对等。

Chinese version: https://medium.com/@guotie/uniswap-lp-%E7%9A%84%E5%A4%A9%E7%94%9F%E7%BC%BA%E9%99%B7-%E7%9B%88%E4%BA%8F%E4%B8%8D%E5%AF%B9%E7%AD%89-2739ebcc882d

After conducting a thorough analysis of Uniswap Liquidity Providers (LP), we have uncovered a remarkable fact: LP faces challenges in achieving profitability, whether it be in USD terms or token terms.

TL;DR The fundamental flaw of Uniswap LP lies in the asymmetry of profit during price increases and losses during price decreases when the price change is the same.

To illustrate this, let’s consider the example of ETH/USDC.

Assuming the following:

1. The current price of ETH/USDC is 2000.
2. Our initial capital is 2000 USDC.
3. We provide liquidity in a 1:1 ratio of ETH to USDC.
4. We use Uniswap v3 with a price range of ±10%, i.e., [1800, 2222].

Our initial assets are 2000 USDC, and the LP’s initial assets are 0.5 ETH + 1000 USDC.

There are several possible scenarios:

1. If the coin price rises by more than 10%, our LP assets will be entirely converted to USDC.
2. If the coin price falls by more than 10%, our LP assets will be entirely converted to ETH.
3. If the coin price fluctuates within [1800, 2222].

Let’s analyze the first two scenarios.

Price Exceeds 2222

When the coin price is higher than 2222, our assets are entirely converted to USDC, with a quantity of 2053.

So, in terms of USDC, our profit is: (2053–2000)/2000 = 2.65%.

Price Falls Below 1800

When the coin price is lower than 1800, our assets are entirely converted to ETH, with a quantity of 1.026584.

So, in terms of USDC, our loss is: (2000–1800 * 1.026584)/2000 = 7.6%.

Through the above calculations, we find that when the coin price rises by 11%, our profit is 2.65%, and when the coin price falls by 10%, our loss is 7.6%.

1. LP reduces profits but also mitigates losses.
2. LP’s profit during coin price increases and losses during coin price decreases are imbalanced: a rise of 11% results in a profit of 2.65%, while a fall of 10% leads to a loss of 7.6%.

Impermanent Loss

Some may argue that the losses mentioned above are temporary, and they will be recovered when the price returns to the range.

Token-based Perspective

In fact, calculating in token terms does not alter the conclusion. It merely accentuates the increased loss during coin price increases and diminished profit during coin price decreases.

Non-equivalent LP Ratios

The above analysis is based on a 1:1 ratio of token x and token y. So, what happens to profits and losses if the ratio of x and y is not equal when providing liquidity?

Let’s generalize the above example.

Firstly, assuming we provide liquidity with the current price within our price range. If not, the liquidity provided won’t earn any fee income, so we won’t discuss it for now.

The current price is denoted as price current, [pl, ph] represents the price range, and the trading pair is token x/token y. The initial assets are entirely in token y, with a total quantity of T.

To initiate liquidity provision, we need to exchange an R ratio of token y for token x, where R > 0 and R < 1.

In reality, once our price range and total assets are determined, R is fixed.

Uniswap v3 liquidity variables include:

1. Current price, price current.
2. Price range, [price low, price high].
3. Token quantities, amountX, amountY.

Any four of the above five variables can be used to calculate the fifth.

Considering:
x = L * [sqrt(ph) — sqrt(pc)] / [sqrt(pc) * sqrt(ph)]
y = L * [sqrt(pc) — sqrt(pl)]

Dividing the two equations:：
x/y = [sqrt(ph) — sqrt(pc)]/{[sqrt(pc) — sqrt(pl)] * [sqrt(pc) * sqrt(ph)]}

Substituting
x = RT/pc
y = (1-R)T

We get:：
R/(1-R) = pc * [sqrt(ph) — sqrt(pc)]/{[sqrt(pc) — sqrt(pl)] * [sqrt(pc) * sqrt(ph)]}

In this formula, pc, ph, and pl are known, so R can be solved.

After a price change, assuming a new price, price new (pn), remains within the price range, and L remains constant, we can solve for the quantities of token x (xn) and token y (yn).

xn = L * [sqrt(ph) — sqrt(pn)] / [sqrt(pn) * sqrt(ph)]
yn = L * [sqrt(pn) — sqrt(pl)]

Therefore, based on the above formulas, we can calculate the profit and loss at various prices within the [pl, ph] range and compare them with the percentage changes in coin prices.

Conclusion

Many people are not aware of the inherent flaw in Uniswap LP, which is the asymmetry of profits during coin price increases.

JSON Web Token (JWT) is an open standard (RFC 7519) that defines a compact and self-contained way for securely transmitting information between parties as a JSON object. This information can be verified and trusted because it is digitally signed. JWTs can be signed using a secret (with the HMAC algorithm) or a public/private key pair using RSA or ECDSA.

Make JWT more safe

secret for every Account

In some best practice of JWT, they just say we need an universe secret for every account signature, which mostly from an envirment varible. But the secret is so fundemental, is it enough safe that a global secret for all account? Nobody care it, nobody discuss it, nobody mention it.

We use different salt to hash account password for different account, why we use same secret for all account? The JWT is JUST as important as user’s password!

In my opinion, we should use different secret for every account, just like password salt.

If we use different secret for every account, we should save the secret in server side, DB or redis. Of course, this will slow down the JWT validate flow, but we could save the secret in server’s memory cache after server start up.

save & validate signature in server side

JWT is mostly about how to verify the JWT token is valid, by the signature. In most scene, this is great. But in some case, for example, we want kick off a special user, JWT can do nothing.

So, we could save the JWT signature in the server, then we could verify the JWT twice:

• first, verify the signature;
• second, check the signature in server DB or redis, if exists, the JWT is valid; or else invalid

By this method, we can kick off user or force user re-login.

Also, there are some tricks, we don’t need to save all JWT payload in the server, for example, we can just save the userId and JWT signature in the server side.

JWT for anonymous or visitors

Sometime we want give better user expirence for the anonymous or visitors, we can use JWT to record visitor’s information. For example, the user’s information:

name
IP address
first visit time
location(optional)

use these information, we could track visitors and provide good expirence.

Question

If we use JWT this way, why we use JWT instead of session? One of the most benefit of JWT is the client can get many information from JWT, even they have not connect to the server.

Since the 2019 covid-19 epidemic, various deglobalization thoughts and regulations have emerged; after the Ukraine war, deglobalization reflections in the financial sector have begun to appear, can the dollar still be trusted? Can financial institutions in neutral countries still be trusted? Behind these trust crises, it shows that decentralized BTC and ETH will be the right direction for human development in the future.

We are at the crossroads of a great transformation.

About power

Before talking about stablecoins, we need to talk about power.

The current regulations on crypto are all illusions, and the essence is a power struggle. The characteristics of power determine that power is always self-reinforcing and self-expanding. Most of the current power is in the hands of politicians and the rich; therefore, we can see that the power of each government is constantly expanding, and at the same time, wealth is becoming more and more concentrated, and the proportion of wealth of the rich in each country is constantly increasing. rise.

With the penetration of the blockchain into finance and economy, part of the power will inevitably be transferred to the chain and to the code. This is unbearable for the current power owners, and they will do everything possible to prevent them as much as possible. This transfer of power.

Let’s take a look at this example of the Ukrainian war. Since the Ukraine war, various agencies have been asked by the US to sanction Russian entities, individuals. The major crypto exchanges are no exception, the most obvious being binance. Several U.S. politicians named cex and binance, asking them to be more proactive in imposing sanctions on Russian entities and individuals. Binance CEO cz said that compared with hundreds of banks in Europe, the assets of Russian users managed by Binance are less than 0.3% of the bank’s assets, but American politicians have been staring at Binance and asked Binance to sanction Russian users. Does binance have more influence than those hundreds of banks? Obviously not.

There are two reasons.
First, cex is a subversion of the financial field. For a long time, the financial field has been licensed to operate, thus ensuring the monopoly position and income of practitioners, and cex has broken this monopoly to some extent, which has always been a thorn in the eyes of regulators; as the largest cex, binance, Naturally bear the brunt.

Second, the assets of cex can be easily transferred to the chain, making it impossible to be sanctioned; while the assets of banks can only be transferred between banks, no matter which bank they are transferred to, they cannot avoid being sanctioned;

The blockchain challenges the country’s financial system and coinage rights. Therefore, neither China, nor the United States, nor other governments are willing to see the development and growth of the blockchain. After several rounds of crackdowns, China basically wiped out the domestic exchanges and mining industries; during the same period, although Facebook made a lot of explanations, made a lot of preparations, and attracted many traditional financial institutions, the United States did not hesitate to stop it. The idea of ​​facebook issuing a stablecoin; Russia has been restricting the use of BTC before the Ukraine war, only allowing BTC to be mined to earn foreign exchange.

If the governments of various countries are monolithic, it is estimated that the use of BTC and ETH has already been banned by law. However, every country in the world has conflicts of interest, and different countries have different demands, which gives the blockchain industry development opportunities.

The United States, as a global hegemon, can harvest the world through currency issuance; other big countries, the government can harvest their own countries by issuing legal currency; the worst is some small countries, which basically have no monetary autonomy and can only be harvested, so we see, Salgado first used BTC as the national reserve currency, and then South American countries followed suit to study this policy. Now that Russia has been sanctioned and kicked out of the swift system, its attitude towards BTC has changed 180 degrees, and it has even been willing to accept BTC as payment for crude oil and natural gas.

The chaotic world promotes the development of crypto. Ukraine has accepted crypto donations from the very beginning, and has also issued NFTs. Now Russia is discussing accepting BTC for the purchase of crude oil and natural gas. These government actions have greatly enhanced the consensus of crypto. This poses a challenge to the current global dollar-based monetary system. Since crypto does not require trust, it cannot be controlled by anyone, any organization, or any country, and it exceeds national sovereignty. Therefore, it will inevitably win the final victory.

In the process of issuing fiat currency, the government obtains a hidden benefit called seigniorage. Among the various challenges that blockchain poses to governments, the challenge of minting rights is the greatest. BTC and ETH are more of an asset attribute, while the influence of stablecoins will involve payment, circulation, liquidation, and penetrate into all aspects of the economy and finance. It has brought huge benefits to the government, and no government will easily give up this power, which is determined by the nature of power. Therefore, we can see that the United States has especially strengthened the supervision of stablecoins in the past two years.

The chart below is a graph of the U.S. government’s liabilities from 1990 to 2020. Among more than 200 countries in the world, the United States is a relatively restrained government, but despite this, the US government’s debt is still accelerating. It is conceivable how much wealth the people of other countries have been plundered by inflation.

Paypal is a great company. Since 1998, Paypal has defeated countless competitors from a team of several people to become the current giant, and profoundly changed the payment industry; however, Paypal has not fully realized its original vision — — — Save most of the world’s people from inflation. Today, even Americans have begun to suffer from inflation under the circumstance that the currency is constantly over-issued.

100 years ago, the food we ate and the houses we lived in were much cheaper than now, and of course our income was much lower than now. In the process of the government’s continuous issuance of fiat currency, due to the timeliness of currency flow, everyone gets different benefits, and the government obtains additional benefits from seigniorage; Most of the people are victims of inflation and become poorer and poorer in the process of over-issue of money.

This is not that Paypal is not good enough, not great enough; it is essentially that Paypal cannot do this; at the same time, no individual, any organization, or any government can do it. Seigniorage is the source of inflation. The corruption of power and the greed of human nature cannot be changed. In the face of the huge temptation of seigniorage, power cannot restrain itself forever, and the currency will continue to be issued. Therefore, the final outcome of any credit currency in the world is collapse. From ancient times to the present , without exception.

OK, we are about to get to the point of stablecoins. Decentralized algorithmic stablecoins must be used if inflation is to be prevented from exploiting the general public.

Join Coinmonks Telegram Channel and Youtube Channel learn about crypto trading and investing

Also, Read

• BlockFi vs Celsius | Hodlnaut Review | KuCoin Review
• Bitsgap review | Quadency Review | Bitbns Review
• Crypto Copy Trading Platforms | Coinmama Review
• Crypto exchanges in India | Bitcoin Savings Account
• OKEx vs KuCoin | Celsius Alternatives | How to Buy VeChain

A little thought about stablecoins (1) was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.

Why this?

Because react-native is on the wrong way.

First, performance, react-native waste time to use JIT to raise performance. This is the most big mistake. It should focus on wasm, not JIT.

Second, typescript. I think it should use typescript totally.

React-native will great again, typescript has big ecosym than flutter/dart, but the time window is not so long.

The transaction fee of `uniswap` is derived from the identity of `x * y = K`. In a specific transaction scenario, such as a loopback transaction, our transaction cost can be far lower than the rated fee .

What is a loopback transaction

The loopback transaction is a transaction in a transaction pair `tokenA/tokenB`, first swap`tokenA` to get `tokenB`, and then immediately swap the obtained `tokenB` back to `tokenA`.

The standard rate of `uniswap v2` is 0.3%, then the cost of loopback transaction is 0.6%, this cost is quite high. If we are just to brush the transaction volume, we need an effective way to reduce Handling fees, loopback transactions are a very effective way.

Theoretical Derivation

The following is our detailed derivation process. Assumptions are as follows:

* dx: the number of tokenA entered
* r0: the reserve quantity of tokenA
* r1: The reserve quantity of tokenB
* dy: the amount of the first tokenA -> tokenB swap
* ex: the second swap tokenB -> the number of tokenA

According to the formula of uniswap, the calculation is as follows:

dy = dx*997*r1/(1000*r0 + dx*997)

R1 = r1-dy
R0 = r0 + dx

ex = dy*997*R0/(1000*R1 + dy*997)

Substituting dy, after simplification, we can get:

ex = 997*997*dx*(r0+dx) / (1000*1000*r0 + 997*997*dx)

Divide by dx at the same time:

ex/dx = 997*997*(r0+dx) / (1000*1000*r0 + 997*997*dx)

Since ex is our tokenA quantity at the end of the final loopback transaction, dx is our tokenA input quantity, and 1-ex/dx is our handling fee ratio.

It can be seen from the above formula that the final loopback transaction ex is only related to the input dx and the `reserve` of `tokenA`, and the higher the ratio of the input number `dx` to `tokenA reserve`, the final result is ` The closer the ex/dx` is to 1, the less the fee is paid.

Code calculation

The test code is as follows:

Filename: loopbackSwap.js

const BigNumber = require(‘ethers’).BigNumber

const e18 = BigNumber.from(‘1000000000000000000’)

const getAmountOut = (amountIn, r0, r1) => {
const amountInWithFee = amountIn.mul(997)
 , numerator = amountInWithFee.mul(r1)
 , denominator = r0.mul(1000).add(amountInWithFee);

return numerator.div(denominator)
}

const getAmountBack = (amtIn, r0, r1, printable = false) => {
const out = getAmountOut(amtIn, r0, r1)

r0 = r0.add(amtIn)
r1 = r1.sub(out)

const dx = getAmountOut(out, r1, r0)
if (printable) {
console.info(‘swap x->y: out=%s r0=%s r1=%s backx=%s’,
out.toString(), r0.toString(), r1.toString(), dx.toString())
}
return {amtInter: out, amtOut: dx}
}

function loopbackSwap() {
const reserveA = BigNumber.from(1000000).mul(e18)
 , reserveB = BigNumber.from(2000000).mul(e18)
 , ratio = (multor) => reserveA.mul(multor).div(1000)

let amts = [
1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 3000, 5000, 10000]

for (let amt of amts) {
let amtIn = ratio(amt)
let {amtOut} = getAmountBack(amtIn, reserveA, reserveB)
console.info(‘dx/reserve=%s amtOut/amtIn=%s’, amt/1000, amtOut.mul(10000).div(amtIn).toNumber()/10000)
}
}

loopbackSwap()

run the scripts:

npx hardhat run loopbackSwap.js
dx/reserve=0.001 amtOut/amtIn=0.994
dx/reserve=0.002 amtOut/amtIn=0.994
dx/reserve=0.005 amtOut/amtIn=0.994
dx/reserve=0.01 amtOut/amtIn=0.994
dx/reserve=0.02 amtOut/amtIn=0.9941
dx/reserve=0.05 amtOut/amtIn=0.9942
dx/reserve=0.1 amtOut/amtIn=0.9945
dx/reserve=0.2 amtOut/amtIn=0.995
dx/reserve=0.5 amtOut/amtIn=0.9959
dx/reserve=1 amtOut/amtIn=0.9969
dx/reserve=2 amtOut/amtIn=0.9979
dx/reserve=3 amtOut/amtIn=0.9984
dx/reserve=5 amtOut/amtIn=0.9989
dx/reserve=10 amtOut/amtIn=0.9994

It can be seen from the results that when dx/reserve exceeds 1, the handling fee rate drops rapidly, and when dx/reserve=10, the handling fee is only 6/10000, incredible!

As a result, lightning loans can be used to lend a large amount of funds from the borrowing pool at a lower interest rate, and then perform loopback transactions. In some exchanges where transactions are mining, mining can be reduced in this way Handling fee, arbitrage profit.

Actual combat

We can write a contract to execute our loopback transaction.

It should be noted that we cannot directly set the `path` parameter of `uniswap router` to `[tokenA, tokenB, tokenA]` for loopback transactions, but must be divided into two swaps, the first is `[tokenA, tokenB] `, then `[tokenB, tokenA]`.

The sample code is as follows:

/// @dev swapLoopback swap tokenA to tokenB, then swap tokenB to tokenA
/// @param _router uniswap-like router
/// @param reward the reward token
/// @param amountIn amount in
/// @param amountOutMin just set to 0
/// @param path [tokenA, tokenB]
function swapLoopback(
address _router, // router
address reward, // reward token
uint amountIn,
uint amountOutMin,
address[] memory path
)
public
onlyOwner {
address tokenIn = path[0];
uint tokenInitial = IERC20(tokenIn).balanceOf(address(this));

_approve(IERC20(tokenIn), address(_router));
// solhint-disable-next-line
uint256 ts = block.timestamp + 60;
uint[] memory amounts = IUniswapRouter(_router).swapExactTokensForTokens(amountIn, amountOutMin, path, address(this), ts);

path[0] = path[1];
path[1] = tokenIn;
// console.log(“amounts:”, amounts[1]);
_approve(IERC20(path[0]), address(_router));
amounts = IUniswapRouter(_router).swapExactTokensForTokens(amounts[1], amountOutMin, path, address(this), ts);

// other arbitrage code with reward..
reward;
}

About me: I’m an solidity developer, dive deeply in AAVE, uniswap, Compound, 1inch, etc, I am looking for a solidity develop job, My blog: https://tiege.dev