标签: uniswap

我正在查看uniswap 文档，其中说明了这个示例：

\n

在 WETH / USDC 池中查找 WETH 价格的示例，其中\nWETH 是 token0，USDC 是 token1：

\n

您有一个 oracle 读数，显示 tickCumulative 返回为\n[70_000, 1_070_000]，观察之间的经过时间为\n10 秒。

\n

我们可以通过累加器值的差值 (1_070_000 - 70_000 = 1_000_000) 并除以经过的时间 (1_000_000 / 10 = 100_000) 来得出此间隔内的平均刻度。

\n

当价格变动读数为 100_000 时，我们可以通过将当前价格变动用作公式 p(i) = 1.0001**i 中的 i 来求出代币 1 (USDC)\n 以代币 0 (WETH) 表示的值（参见公式 p(i) = 1.0001**i 中的 6.1）白皮书）。

\n

1.0001**100_000 \xe2\x89\x85 22015.5 USDC / WETH

\n

WETH 的价格不是 22015.50 美元。我想也许他们只是用了一个简单数字的例子。所以我决定尝试一下USDC/WETH 矿池白皮书中的示例

调用 …

我在将其导入到我的 TypeScript React 项目中时遇到问题。

import { SwapWidget } from '@uniswap/widgets';

编译时出现此错误yarn build：

Can't import the named export 'SwapWidget' (imported as 'SwapWidget') from default-exporting module (only default export is available)

这是库中的声明@uniswap\widgets：

Can't import the named export 'SwapWidget' (imported as 'SwapWidget') from default-exporting module (only default export is available)

ts-config.js:

declare type SwapWidgetProps = SwapProps & WidgetProps;
declare function SwapWidget(props: SwapWidgetProps): JSX.Element;

export { SUPPORTED_LOCALES, SwapWidget };

我正在尝试创建 v3 uniswap 池的实例。我正在使用安全帽和孟买测试网的分支。

当我尝试创建池实例时：

const poolExample = new Pool(
  TokenA,
  TokenB,
  immutables.fee,
  state.sqrtPriceX96.toString(),
  state.liquidity.toString(),
  state.tick
);

我收到以下错误：

Error: Invariant failed: PRICE_BOUNDS

堆栈是：

Error: Invariant failed: PRICE_BOUNDS
  at invariant (node_modules/tiny-invariant/dist/tiny-invariant.cjs.js:14:11)
  at new Pool (node_modules/@uniswap/v3-sdk/src/entities/pool.ts:71:5)
  at Context.<anonymous> (test/Uniswap-test.js:134:25)
  at processTicksAndRejections (node:internal/process/task_queues:96:5)

有关追踪错误根源的任何提示吗？

池的参数具有以下值：

fee : 3000
state.sqrtPriceX96 : 0
state.liquidity: 0
state.tick: 0

我想计算 Uniswap v3 中特定池中锁定的总价值。我无法为此使用子图 API。

我可以使用 uniswapV3pool 合约函数获取当前流动性/范围内流动性：

in_range_liquidity = uniswapV3pool_contract.functions.liquidity().call()

我得到了流动性的结果10608850786221311055。我是否需要对其进行处理才能获得美元价值或其他值？

最后，这只是当前的流动性，我需要总锁定价值，其中包括池中的活跃和不活跃流动性。

我正在编写一个自动化测试套件，需要针对 Uniswap v2 风格的自动做市商测试功能：进行掉期并使用不同的订单路由。因此，需要部署路由器。

是否有任何现有示例说明如何在 Brownie 中部署可测试的 Uniswap v2 风格交换？因为 Brownie 是智能合约开发者中的少数，那么 Truffle 或 Hardhat 有没有例子呢？

我也在探索使用主网分叉的选项，但我不确定此操作是否太昂贵（慢）而无法用于单元测试。

我正在查看 uniswap 代码，试图理解代码，其中大部分内容都非常清楚，但我确实有一些问题。

在这个函数中：

function createPair(address tokenA, address tokenB) external returns (address pair) {
    require(tokenA != tokenB, 'UniswapV2: IDENTICAL_ADDRESSES');
    (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
    require(token0 != address(0), 'UniswapV2: ZERO_ADDRESS');
    require(getPair[token0][token1] == address(0), 'UniswapV2: PAIR_EXISTS'); // single check is sufficient
    bytes memory bytecode = type(UniswapV2Pair).creationCode;
    bytes32 salt = keccak256(abi.encodePacked(token0, token1));
    assembly {
        pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
    }
    IUniswapV2Pair(pair).initialize(token0, token1);
    getPair[token0][token1] = pair;
    getPair[token1][token0] = pair; // populate mapping in …

我正在处理safeTransferETHUniswap V2 路由器合约中的辅助函数的一个奇怪问题。

swapExactTokensForETH我正在尝试使用Uniswap V2 路由器提供的功能将合约持有的代币交换为 Ether 。（函数代码位于Uniswap 的 github 上的 router1 中）。被调用的函数是：

function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        override
        ensure(deadline)
        returns (uint[] memory amounts)
    {
        require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH');
        amounts = UniswapV2Library.getAmountsOut(factory, amountIn, path);
        require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
        TransferHelper.safeTransferFrom(path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]);
        _swap(amounts, path, address(this));
        IWETH(WETH).withdraw(amounts[amounts.length - 1]);
        TransferHelper.safeTransferETH(to, amounts[amounts.length - 1]);
    }

此代码中唯一引发错误的部分是函数TransferHelper.safeTransferETH，即：

function safeTransferETH(address to, …

我用来IUniswapV3PoolState.slot0返回 sqrtPriceX96 并在 Uniswap V3 中勾选不同的货币对。对于 ETH/DAI 来说，结果非常合理，但对于 ETH/USDT 和 ETH/USDC 来说，结果却截然不同。

这不是因为代币的顺序，而是价格的最终结果（在考虑平方根和 Q96 后）相差 10^(-12)。所以我会得到 ETH/DAI 大约 3200 美元，而 ETH/USDT 和 ETH/USDC 会得到 3200*10^(-12) 美元。我有什么遗漏的吗？谢谢你！

我正在尝试在 uniswap unsing Hardhat 的主网分支上交换代币，但出现此错误：Error: Transaction reverted without a reason string。我真的不知道为什么。

这是我的交换函数：

    function swap(address router, address _tokenIn, address _tokenOut, uint _amount) public {
        IERC20(router).approve(router, _amount);
        address[] memory path;
        path = new address[](2);
        path[0] = _tokenIn;
        path[1] = _tokenOut;
        uint deadline = block.timestamp + 300;  
        IUniswapV2Router(router).swapExactTokensForTokens(_amount, 1, path, address(this), deadline);  
}

这是一个简单的函数，应该可以工作。我就是这样称呼它的：

await arb.swap(
    uniAddress,
    wethAddress,
    daiAddress,
    ethers.utils.parseEther('0.5')
);

感谢您的解答！

另外，我拨打的地址只是为了验证它们是否正确，但我很确定它们是：

const wethAddress = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
const daiAddress = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
const uniAddress = '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D';

我正在创建一种代币，当在流动性池上出售时，它会收取费用并燃烧一定数量的代币。

假设我有一个接收地址，我如何检查它是否是流动性池？

我想我也许可以使用这个： https: //docs.uniswap.org/protocol/V2/reference/smart-contracts/pair-erc-20但是我不确定哪个功能可以工作或者是否有其他方法。

人们可以使用UniSwap Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D)和交换代币UniSwap Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f)

但有什么不同呢？为什么存在两个交换代币的合约？

我看到上面有很多旧的tx UniSwap Factory，看起来UniSwap Factory活跃度并不高UniSwap Router，是否意味着UniSwap Router有新技术要取代UniSwap Factory？

我正在尝试基于此Solidity 示例，使用 python、web3 和 eth-abi 库计算（离线，即没有 http 请求）Uniswap 对的地址。

address factory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address token0 = 0xCAFE000000000000000000000000000000000000; // change me!
address token1 = 0xF00D000000000000000000000000000000000000; // change me!

address pair = address(uint(keccak256(abi.encodePacked(
  hex'ff',
  factory,
  keccak256(abi.encodePacked(token0, token1)),
  hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));

有一些想法：

hexadem_ ='0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
hexadem_1 = 0xff
abiEncoded_1 = encode_abi_packed(['address', 'address'], (  token_0, token_1 ))
salt_ = web3.Web3.solidityKeccak(['bytes'], ['0x' +abiEncoded_1.hex()])
abiEncoded_2 = encode_abi_packed(['bytes', 'address', 'bytes32'], (bytes(hexadem_1), factory, salt_))
resPair = web3.Web3.solidityKeccak(['bytes','bytes'], ['0x' +abiEncoded_2.hex(), hexadem_])

有人可以建议我，出了什么问题，应该考虑哪种方式？