如何通过代码查看 uniswap v3 某个 LP 的 未 claim 收入

在Uniswap V3中，流动性提供者（LP）的未领取收入（称为“未实现的费用”）可以通过与Uniswap V3的智能合约交互来查看。以下是如何通过代码查看某个LP的未领取收入的基本步骤：

1. 安装和设置Web3提供者（如Infura）和Web3.js或ethers.js库。
2. 使用Uniswap V3的NonfungiblePositionManager合约地址和ABI。
3. 使用LP的tokenId来获取流动性位置的信息。
4. 使用positions函数查询LP的特定位置信息，这将返回流动性提供者的未领取费用。

下面是使用JavaScript (ethers.js) 的示例代码：

首先，需要安装ethers.js库：

npm install ethers

然后，可以使用以下代码来获取未领取的收入：

const { ethers } = require('ethers');

// 连接到以太坊网络（这里使用的是主网）
const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_INFURA_API_KEY');

// Uniswap V3 NonfungiblePositionManager 合约地址和ABI
const NonfungiblePositionManagerAddress = '0xC36442b4a4522E871399CD717aBDD847Ab11FE88';
const NonfungiblePositionManagerABI = [
  // 需要从Uniswap V3的官方文档或者合约源码里获取完整的ABI
  "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)"
];

// 创建合约实例
const positionManager = new ethers.Contract(NonfungiblePositionManagerAddress, NonfungiblePositionManagerABI, provider);

// LP的tokenId
const tokenId = 'YOUR_LP_TOKEN_ID';

async function getUnclaimedFees() {
  // 调用positions函数获取LP信息
  const position = await positionManager.positions(tokenId);

  // 未领取的费用在tokensOwed0和tokensOwed1中
  const unclaimedFeesToken0 = position.tokensOwed0;
  const unclaimedFeesToken1 = position.tokensOwed1;

  console.log(`未领取的费用: Token0: ${unclaimedFeesToken0.toString()}, Token1: ${unclaimedFeesToken1.toString()}`);
}

getUnclaimedFees().catch(console.error);

请注意，这只是一个基本的示例，实际的实现可能还需要考虑其他因素，如价格滑点、交易费率变化等。同时，上述代码中需要填写你自己的Infura API密钥和LP的tokenId。

在运行上述代码之前，请确保你已经从Uniswap V3的GitHub仓库或Etherscan上获取了NonfungiblePositionManager合约的完整ABI，并将其粘贴到代码的相应位置。此外，你还需要确保提供了正确的tokenId，以获取特定LP的未领取收入信息。

对不起，出现这个错误通常是因为在使用 ethers.js 时，你可能没有正确地引入 JsonRpcProvider 类或者 ethers.js 的其他相关部分。请确保你已经正确地安装了 ethers.js 库，并且按照下面的步骤来引入 JsonRpcProvider。

首先，确保你已经正确地安装了 ethers.js：

npm install ethers

然后，在你的代码中，你应该这样引用 ethers.js：

const ethers = require('ethers');

或者，如果你正在使用 ES6 或 TypeScript，可以使用 import 语句：

import { ethers } from 'ethers';

之后，使用 ethers.providers.JsonRpcProvider 来创建一个新的 JSON RPC 提供者实例：

const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_INFURA_API_KEY');

请确保你的代码包含了正确的引用，并且你的 Infura API key 是有效的。如果你仍然遇到问题，请检查你的 Node.js 环境是否正确设置，并且 ethers.js 库是否已经被成功安装。

如果你已经按照上述步骤操作，但仍然遇到问题，可能需要检查你的 Node.js 版本是否支持 import 语法（如果你在使用 import），或者你可能需要配置一个编译步骤（如使用 Babel）来允许使用 ES6 语法。在某些情况下，错误可能是由于缺少环境配置或者与其他库的冲突造成的。

Uniswap V3 的 positions 方法返回的是与特定流动性位置相关的信息。这些返回值包括了关于流动性提供者位置和累积的费用等详细信息。下面是对这些返回值的解释：

1. nonce: 用于追踪流动性位置的修改次数，每次修改位置时，nonce 会增加。这个值也可以用于某些操作，比如在调用increaseLiquidity或decreaseLiquidity方法时。

2. operator: 流动性位置的操作员地址，它有权限管理这个位置。操作员可以是位置所有者自己或者被授权的其他地址。

3. token0: 流动性位置中的第一个代币的地址（按地址排序，较小的地址）。

4. token1: 流动性位置中的第二个代币的地址（按地址排序，较大的地址）。

5. fee: 流动性位置的费率，表示每笔交易的手续费比率。Uniswap V3 支持多种费率，如 0.05%，0.3%，1% 等。

6. tickLower: 流动性位置的下限价位刻度。Uniswap V3 使用价位刻度来定义流动性的范围，每个刻度代表一个特定的价格。

7. tickUpper: 流动性位置的上限价位刻度。这个值高于 tickLower，共同界定了一个价格区间，流动性提供者仅在该区间内赚取交易费。

8. liquidity: 流动性位置的流动性数量，它是一个关键的参数，用来计算位置的价值和交易时产生的费用。

9. feeGrowthInside0LastX128: 从流动性位置上次收取费用以来，token0 的每单位流动性累积的费用增长量，使用一个固定的点数格式存储。

10. feeGrowthInside1LastX128: 从流动性位置上次收取费用以来，token1 的每单位流动性累积的费用增长量，使用一个固定的点数格式存储。

11. tokensOwed0: 未领取的 token0 费用。这是流动性提供者根据其提供的流动性和累积的交易费用，尚未领取的 token0 数量。

12. tokensOwed1: 未领取的 token1 费用。这是流动性提供者根据其提供的流动性和累积的交易费用，尚未领取的 token1 数量。

这些信息对于流动性提供者来说是非常重要的，因为它们提供了关于流动性位置的详细情况和经济收益的洞察。通过调用 positions 方法并传入特定的 tokenId，你可以获取这些信息。如果你是流动性提供者，你可以通过读取这些值来追踪你的投资和潜在收益。

如果你在 Uniswap V3 的智能合约中通过调用 positions 方法得到的 tokensOwed0 和 tokensOwed1 的值为0，但在 Uniswap 的用户界面（UI）中却看到了非零的未领取费用，可能是由于以下原因：

1. 数据同步延迟：
   用户界面可能会有缓存或者延迟更新的情况，而智能合约中的数据是实时的。如果你刚刚发起了一笔交易或者有其他更新，UI 可能还没有反映这些变化。

2. 合约状态未更新：
   在 Uniswap V3 中，未领取的费用并不会自动更新到 tokensOwed0 和 tokensOwed1。这些值只会在某个交互发生时更新，例如当你增加或减少流动性、收集费用，或者其他引发状态变更的操作时。因此，如果自上次交互以来有交易发生在你的流动性范围内，但你尚未与合约进行交互来触发更新，那么 tokensOwed0 和 tokensOwed1 将不会反映这些新的费用。

3. 未领取费用计算方式：
   Uniswap V3 UI 可能会使用一种动态计算的方式来显示未领取的费用，它可能会考虑当前的价格和流动性范围内的交易活动来估算未领取的费用，而不是直接显示合约中的 tokensOwed0 和 tokensOwed1。

为了更新 tokensOwed0 和 tokensOwed1 的值，你需要与合约进行交互，例如执行以下操作之一：

• 调用 collect 函数来收集你的未领取费用。
• 调整你的流动性位置，例如通过增加或减少流动性。

这些操作将会触发合约的内部逻辑，计算并更新你的未领取费用。

如果你确信应该有未领取的费用，但合约返回的值为0，你应该检查是否正确地调用了合约方法，并确认是否使用了正确的 tokenId。如果一切都正确无误，而问题仍然存在，可能需要进一步的调试或者与 Uniswap 的技术支持联系以解决这个问题。

非常高兴听到你已经成功地看到了 tokensOwed0 的更新！

当你增加流动性到 Uniswap V3 的池子中时，智能合约会计算自上次交互以来的交易活动，并更新你的未领取费用。这就解释了为什么在你执行了增加流动性操作后，tokensOwed0 和 tokensOwed1 的值得到了更新。

这是一个重要的提醒，对于流动性提供者来说，与 Uniswap V3 智能合约的交互不仅限于增加或减少流动性，还包括定期地收集未领取的费用。定期收集费用可以减少潜在的损失风险，例如在代币价格剧烈波动时。

如果你打算继续提供流动性并管理你的投资，以下是一些可能会对你有用的提示：

• 定期监控：监控你的流动性位置和累积的费用，以及市场的波动情况，以便做出及时的决策。
• 自动化脚本：如果你有编程经验，可以编写脚本来自动化监控和收集费用的过程。
• 风险管理：了解提供流动性的风险，比如临时损失（impermanent loss），并制定相应的策略来管理这些风险。
• 更新知识：Uniswap 和其他去中心化金融（DeFi）平台不断发展，持续更新你的知识以了解最新的功能和最佳实践。

最后，始终确保你了解与 DeFi 协议交互的相关风险，并且在必要时咨询专业的金融顾问。

要在不与 Uniswap V3 合约直接交互的情况下计算未领取的费用，你需要使用某些链外（off-chain）的数据和方法。下面是一个基本的计算流程，并且给出了相应的 JavaScript 代码示例，使用了 ethers.js 来与以太坊区块链进行交互。

首先，我们需要获取以下数据：

1. 当前的 feeGrowthGlobal0X128 和 feeGrowthGlobal1X128 值。
2. 你上次交互时的 feeGrowthInside0LastX128 和 feeGrowthInside1LastX128 值。
3. 你的流动性位置的 liquidity 值。

然后，我们可以使用以下公式来计算未领取的费用：

未领取的费用 token0 = (feeGrowthGlobal0X128 - feeGrowthInside0LastX128) * liquidity / 2^128
未领取的费用 token1 = (feeGrowthGlobal1X128 - feeGrowthInside1LastX128) * liquidity / 2^128

以下是代码示例：

const { ethers } = require('ethers');

// 设置你的提供者（可以是 Infura, Alchemy, 或者其他）
const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_INFURA_API_KEY');

// Uniswap V3 池子合约的地址和 ABI
const poolAddress = 'YOUR_POOL_ADDRESS';
const poolABI = [
  // 你需要从 Uniswap 的文档或 Etherscan 获取完整的 ABI
  "function feeGrowthGlobal0X128() external view returns (uint256)",
  "function feeGrowthGlobal1X128() external view returns (uint256)"
];

// 创建合约实例
const poolContract = new ethers.Contract(poolAddress, poolABI, provider);

// 你需要知道你的流动性提供者的信息
const liquidity = YOUR_LIQUIDITY; // 你的流动性值
const feeGrowthInside0LastX128 = YOUR_LAST_FEE_GROWTH_INSIDE0; // 上次交互时的 feeGrowthInside0LastX128
const feeGrowthInside1LastX128 = YOUR_LAST_FEE_GROWTH_INSIDE1; // 上次交互时的 feeGrowthInside1LastX128

async function calculateUnclaimedFees() {
  const feeGrowthGlobal0X128 = await poolContract.feeGrowthGlobal0X128();
  const feeGrowthGlobal1X128 = await poolContract.feeGrowthGlobal1X128();

  const unclaimedFeesToken0 = (feeGrowthGlobal0X128.sub(feeGrowthInside0LastX128)).mul(liquidity).div(ethers.BigNumber.from(2).pow(128));
  const unclaimedFeesToken1 = (feeGrowthGlobal1X128.sub(feeGrowthInside1LastX128)).mul(liquidity).div(ethers.BigNumber.from(2).pow(128));

  console.log(`未领取的费用: Token0: ${ethers.utils.formatUnits(unclaimedFeesToken0, 'wei')}, Token1: ${ethers.utils.formatUnits(unclaimedFeesToken1, 'wei')}`);
}

calculateUnclaimedFees().catch(console.error);

请确保替换 YOUR_INFURA_API_KEY、YOUR_POOL_ADDRESS、YOUR_LIQUIDITY、YOUR_LAST_FEE_GROWTH_INSIDE0 和 YOUR_LAST_FEE_GROWTH_INSIDE1 为你自己的值。这段代码将会计算并输出未领取的 Token0 和 Token1 的费用。

需要注意的是，这个代码只是一个示例，你可能需要根据你的具体情况进行调整。此外，为了确保准确性，你需要有当前和上次交互时的准确数据。如果你不确定如何获取这些数据，你可能需要通过 Uniswap V3 的子图（subgraph）或其他数据源来获取。

在 Uniswap V3 中，feeGrowthInside0LastX128 是一个与流动性提供者（LP）的位置相关的值，它用于计算流动性提供者在其提供的流动性范围内所累积的交易费用（对于 token0）。这个值是一个重要的会计指标，用于确保流动性提供者能够正确地领取其应得的费用。

让我们详细解释一下这个术语和它的含义：

• feeGrowthInside：这部分表示在特定的价格区间内（即流动性提供者设置的价格范围内），每单位流动性累积的交易费用增长量。

• 0：这个数字表示我们正在讨论的是第一个代币（在 Uniswap V3 中，代币对是按照它们的地址排序的，所以 token0 是地址较小的代币）。

• LastX128：这表示这个值是用一个 128 位的定点数格式存储的。X128 表示该数值被放大了 2^128 倍，这样做是为了在智能合约中保持数值的精度和避免浮点数的使用，因为以太坊虚拟机 (EVM) 不支持浮点数。

• Last：这表示的是上一次该值被记录的时间点。每次流动性提供者或其代表的操作员与池子进行交互时（比如增加或减少流动性、或者领取费用），这个值就会更新。

具体来说，当一个交易发生在流动性提供者的价格区间内时，交易费用会根据交易的大小和设置的费率被收取，并按比例分配给该价格区间内的所有流动性提供者。这种费用的累积是连续的，feeGrowthInside0LastX128 就是用来追踪每单位流动性所应得费用的增长的。当流动性提供者想要收集他们的费用时，智能合约会使用当前的 feeGrowthInside0X128 值减去上次收集时的 feeGrowthInside0LastX128，以此来计算流动性提供者在此期间赚取的费用。这个计算结果再乘以流动性提供者提供的流动性数量，就得到了他们应领取的 token0 的总量。

在 Uniswap V3 中，feeGrowthGlobal0X128 是一个累计计数器，它追踪了自池子创建以来，每单位流动性累积的 token0 的全局交易费用增长量。这个值是用于计算流动性提供者在任何时刻都应得的交易费的关键参数之一。

下面详细解释这个术语：

• feeGrowthGlobal：这部分代表全局累积的费用增长量，即不仅仅是某个特定的流动性提供者的位置，而是整个池子的。

• 0：这个数字指的是第一个代币（token0），这是按照代币的地址排序的，token0 是地址较小的代币。

• X128：这表示该数值被放大了 2^128 倍，使用一个固定的点数格式存储。这种放大是为了保持智能合约计算的精度，在以太坊的智能合约内不支持浮点数操作，因此通常使用整数运算来模拟定点数运算。

• Global：这意味着这个值是针对整个池子的，而不是针对个别流动性提供者的。它是一个汇总值，包括了所有流动性提供者所应获得的费用。

当一个交易在 Uniswap V3 的池子中发生时，一定比例的交易额会作为费用被收取。这些费用会按照交易发生时的流动性比例分配给所有流动性提供者。feeGrowthGlobal0X128 会持续增长，以反映每单位流动性累积的全局费用。流动性提供者实际能够领取的费用金额取决于他们流动性的大小以及他们流动性所在的价格范围。

因此，feeGrowthGlobal0X128 是一个不断增长的值，它代表了单位流动性累积的全球交易费用（对于 token0）。当流动性提供者想要领取他们的费用时，会使用他们的位置的 feeGrowthInside0LastX128 值与当前的 feeGrowthGlobal0X128 值进行比较，以确定在他们的位置的价格范围内实际累积的费用量。

在 Uniswap V3 中，流动性提供者只能在他们提供流动性的特定价格区间内赚取费用。这意味着他们的收益是依据交易发生在他们流动性范围（由 tickLower 和 tickUpper 界定）内的情况而变化的。feeGrowthGlobal0X128 代表全局的费用增长，包括了所有价格范围内的费用，但并不是所有这些费用都属于特定流动性提供者。因此，为了准确计算一个流动性提供者应得的费用，需要使用 feeGrowthInside0LastX128 来表示该流动性提供者的特定价格区间内的费用增长。

以下是为什么需要比较 feeGrowthInside0LastX128 和 feeGrowthGlobal0X128 值来计算领取费用的原因：

1. 区间限定的费用累积：流动性提供者只赚取其设定价格区间内的交易费用。feeGrowthGlobal0X128 包含了池子中所有价格区间的累积费用，而流动性提供者只对其价格区间内的部分有权益。

2. 精确计算：通过比较全局累积值（feeGrowthGlobal0X128）和流动性提供者上次领取费用时所在价格区间的累积值（feeGrowthInside0LastX128），可以精确计算出该提供者新增的未领取费用。

3. 避免重复领取：更新 feeGrowthInside0LastX128 确保流动性提供者不会领取超过他们所赚取的费用。在他们每次领取费用之后，feeGrowthInside0LastX128 会更新为当时的全局累积值，以便下次计算始终基于最新的未领取费用。

4. 合约状态同步：每当流动性提供者与池子合约进行交互（如增加或减少流动性、领取费用等），合约会自动更新 feeGrowthInside0LastX128。这样做是为了保证合约的状态与流动性提供者所应领取的费用保持同步。

简而言之，使用 feeGrowthInside0LastX128 与 feeGrowthGlobal0X128 的比较是为了根据流动性提供者特定的价格区间来计算他们在某段时间内应得的精确交易费用。这种计算方法确保了流动性提供者获得公平的费用分配，并且保持了智能合约状态的一致性和准确性。

是的，在Uniswap V3中，你可以通过调用流动性池的NonfungiblePositionManager合约中的positions函数，并传递你的NFT代表的流动性提供者位置的tokenId，来获取包括feeGrowthInside0LastX128在内的多个与你的流动性位置相关的参数。positions函数返回的信息中包含了你上次交互时记录的feeGrowthInside0LastX128值。

以下是如何从NonfungiblePositionManager合约获取特定流动性位置信息的简要示例代码：

const ethers = require('ethers');

// 初始化你的Web3提供者
const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_INFURA_API_KEY');

// Uniswap V3 NonfungiblePositionManager 合约地址和ABI
const NonfungiblePositionManagerAddress = '0xC36442b4a4522E871399CD717aBDD847Ab11FE88';
const NonfungiblePositionManagerABI = [
  // ...包含positions方法的完整ABI
];

// 创建合约实例
const positionManager = new ethers.Contract(NonfungiblePositionManagerAddress, NonfungiblePositionManagerABI, provider);

// LP的tokenId
const tokenId = 'YOUR_LP_TOKEN_ID';

async function getPositionDetails(tokenId) {
  const position = await positionManager.positions(tokenId);
  // position对象包含了你的流动性位置的详细信息，包括feeGrowthInside0LastX128
  console.log(position);
  // 输出特定的值
  console.log(`feeGrowthInside0LastX128: ${position.feeGrowthInside0LastX128}`);
}

getPositionDetails(tokenId).catch(console.error);

在运行上述代码之前，请确保你已经从Uniswap V3的GitHub仓库或Etherscan上获取了NonfungiblePositionManager合约的完整ABI，并将其粘贴到代码的相应位置。此外，你还需要确保提供了正确的tokenId，以获取特定流动性提供者位置的信息。

这个feeGrowthInside0LastX128值是在流动性提供者上次与池子进行交互（如提供或移除流动性、收取费用等）时记录的。当你再次与池子交互时（如收取累积的费用），合约将使用这个值来计算自上次交互以来你应获得的费用。

是的，feeGrowthGlobal0X128 是一个针对 Uniswap V3 中特定池子（特定代币对和费率组合）的全局值，对于该池子中的所有流动性提供者（LP）都是相同的。这个值表示自该池子创建以来，每单位流动性累积的 token0 的全球交易费用增长量。

在 Uniswap V3 中，每个池子都有其独立的 feeGrowthGlobal0X128 和 feeGrowthGlobal1X128 值，这些值分别追踪每单位流动性对于 token0 和 token1 累积的全球交易费用增长。这些全球费用增长值会随着交易的执行而不断增加，并且按照池子中的流动性在特定时间点上的分布进行累积。

当一个交易在池子中发生时，交易费用会根据池子的费率从交易额中扣除，并按比例分配给流动性提供者。这个分配是基于流动性提供者的流动性在价格范围内的分布。feeGrowthGlobal0X128 会更新以反映在整个池子范围内的每单位流动性分摊到的交易费用。

然而，流动性提供者实际能够领取的费用取决于他们在特定价格范围内的流动性分布，这就是为什么需要计算 feeGrowthInsideLastX128 的值。这个值根据流动性提供者的价格区间（由 tickLower 和 tickUpper 界定）来计算他们范围内的每单位流动性累积的费用增长量，从而确保流动性提供者只领取他们应得的费用部分。

总而言之，feeGrowthGlobal0X128 是池子级别的全局值，对于池子中的所有流动性提供者都是一样的，但实际领取的费用还需要结合流动性提供者的具体流动性位置来计算。

feeGrowthInside0LastX128 是 Uniswap V3 智能合约中用来跟踪流动性提供者（LP）特定价格区间内累积的交易费用的值。它是通过一系列复杂的计算得出的，主要基于全局费用增长和该价格区间内的交易活动。这个值关键地影响了流动性提供者能够收集的费用。

以下是概述该值是如何计算的：

1. 全局费用增长：当在池子中发生交易时，根据交易大小和池子的费率，一定比例的交易额会被作为费用收取。这些费用会被累加到全局费用增长（feeGrowthGlobal0X128 和 feeGrowthGlobal1X128）中。

2. 价格区间：流动性提供者设置的流动性是在特定的价格区间内（由tickLower和tickUpper界定）。只有当当前价格处于这个区间时，该流动性才活跃，并能够收集费用。

3. 计算区间内费用增长：每当价格穿过一个价格刻度（tick），就会更新该刻度的累积费用增长值。这使得智能合约能够为特定价格区间计算累积的费用增长。

4. 更新feeGrowthInside0LastX128：当流动性提供者与池子进行交互（如增加或减少流动性、领取费用等）时，智能合约会计算并更新他们的价格区间内的累积费用增长（feeGrowthInside0LastX128）。这是通过取全局费用增长值（feeGrowthGlobal0X128）并减去价格区间外的费用增长来完成的。

5. 存储精度：为了保持智能合约计算的精度，feeGrowthInside0LastX128（以及其他相关的费用增长值）被放大了2^128倍，使用定点数格式存储。

整个计算过程涉及到对智能合约中多个变量的管理，如全局费用增长、各个刻度的累积费用增长、以及特定价格区间内的费用增长。Uniswap V3 的智能合约代码负责处理所有这些复杂的计算，以确保每个流动性提供者能够正确地领取到他们应得的交易费用。

要了解feeGrowthInside0LastX128的精确计算方法，可以查看 Uniswap V3 的智能合约源代码，特别是与费用计算和流动性管理相关的部分，比如UniswapV3Pool合约。在实践中，大多数用户不需要手动进行这些计算，因为这些都由智能合约自动处理。

在 Uniswap V3 中，feeGrowthInside0LastX128 是指在某个特定流动性提供者的价格区间内，每单位流动性累积的 token0 的交易费用增长量。这个值是用来计算流动性提供者自上次交互（例如增加流动性、领取费用）以来赚取的费用的。

这个值的计算涉及到几个步骤，其中包括确定流动性提供者的价格区间，并且基于该区间内交易活动来更新费用增长值。以下是计算feeGrowthInside0LastX128的概念性解释，以及如何通过智能合约代码来执行这些操作。

原理说明：

1. 全局费用增长：当在 Uniswap V3 池中发生交易时，一定比例的交易额会作为费用被收取，并且这个费用会被加到全局的费用增长计数器（feeGrowthGlobal0X128）中。

2. 价格刻度（Ticks）：Uniswap V3 使用价格刻度系统来管理价格区间。每个刻度代表一个特定的价格点，刻度之间的区间可以被流动性提供者选择来提供流动性。

3. 计算区间内费用增长：为了计算某个区间内的费用增长，合约需要考虑该区间内的交易活动。每当价格穿过刻度时，合约会更新刻度的费用增长值。

4. 更新feeGrowthInside0LastX128：流动性提供者与池子交互时（例如提供流动性或领取费用），合约会计算特定价格区间内的费用增长。这是通过获取全局费用增长值，并减去区间外的费用增长来完成的。

5. 存储精度：为了保持智能合约计算的精度，所有的费用增长值（包括feeGrowthInside0LastX128）都以 2^128 放大的定点数格式存储。

代码实现：

请注意，以下代码不是实际的智能合约代码，而是概念性的伪代码，用于说明原理。在实际的 Uniswap V3 智能合约中，这些计算会更加复杂，并且会考虑到价格穿过刻度时的事件和流动性的变化。

function updateFeeGrowthInside(uint256 tokenId) external {
    // 获取流动性位置，价格区间和上次的feeGrowthInside0LastX128
    Position memory position = positions[tokenId];
    
    // 计算当前区间内的费用增长
    uint256 feeGrowthInside0 = getFeeGrowthInside(position.tickLower, position.tickUpper);
    
    // 更新 position 的 feeGrowthInside0LastX128
    position.feeGrowthInside0LastX128 = feeGrowthInside0;
    
    // 存储更新后的位置信息
    positions[tokenId] = position;
}

function getFeeGrowthInside(int24 tickLower, int24 tickUpper) private view returns (uint256 feeGrowthInside0) {
    // 从全局费用增长中减去区间外的费用增长
    uint256 feeGrowthGlobal0 = feeGrowthGlobal0X128;
    uint256 feeGrowthOutsideLower0 = getFeeGrowthOutside(tickLower);
    uint256 feeGrowthOutsideUpper0 = getFeeGrowthOutside(tickUpper);
    
    feeGrowthInside0 = feeGrowthGlobal0 - feeGrowthOutsideLower0 - feeGrowthOutsideUpper0;
    return feeGrowthInside0;
}

function getFeeGrowthOutside(int24 tick) private view returns (uint256 feeGrowthOutside0) {
    // 基于 tick 的状态计算区间外的费用增长
    // ...
    return feeGrowthOutside0;
}

实际 Uniswap V3 的合约实现会更加复杂，它会考虑到在价格变动时各个刻度之间的流动性变化、虚拟的流动性参数以及其他因素。 若要查看具体的合约实现，应该直接参考 Uniswap V3 的官方智能合约源代码。

了解这些计算的细节通常对于大多数流动性提供者来说并不必要，因为这些都是由 Uniswap V3 的智能合约自动处理的。然而，对于那些想要深入理解协议工作原理的开发者来说，学习合约代码会非常有益。

在 Uniswap V3 中，poolAddress 指的是特定代币对和费率组合的流动性池合约地址。每个流动性池都有它自己的合约地址，该地址用于管理该池子的所有交互，包括交易、流动性的添加和移除、费用的累积和分配等。

流动性池合约（通常称为UniswapV3Pool合约）负责处理代币间交易的核心逻辑，并且维护与该池子相关的状态，如当前价格、流动性、费用增长等数据。feeGrowthGlobal0X128 和 feeGrowthGlobal1X128 函数是该合约的两个公共视图（view）函数，它们分别返回代币 token0 和 token1 的全球费用增长值。

要找到特定流动性池的合约地址，你可以：

1. 访问 Uniswap V3 官方界面，选择你感兴趣的代币对，并在交易或池子界面中找到该流动性池的详细信息。
2. 使用 Uniswap V3 的工厂合约，通过传入代币对的地址和费率，调用 getPool 函数来获取池子的合约地址。
3. 通过 Etherscan 或其他区块链浏览器，在 Uniswap V3 的工厂合约页面上查找已经创建的流动性池地址。

一旦你得到了流动性池的合约地址，你就可以使用这个地址和相关的 ABI 来与池子合约进行交互，获取所需的信息，如全球费用增长值等。记住，每个流动性池的合约地址都是唯一的，对应于一个特定的代币对和费率。

在代码中，poolAddress 应该被替换为你想要查询的具体流动性池的合约地址。例如：

const poolAddress = '0x8ad599c3a0ff1de082011efddc58f1908eb6e6d8'; // 示例地址，ETH/USDT 0.3% 池子

这个地址是通过 Uniswap V3 Factory 合约创建的，并且每个代币对和费率组合都会有一个独立的地址。这些地址在 Uniswap V3 的工厂合约中是公开可查的，你可以通过调用工厂合约的 getPool 方法来查询特定代币对和费率组合对应的池子地址。

错误信息 "TypeError: feeGrowthGlobal0X128.sub is not a function" 表明你正在尝试在一个不是 BigNumber 类型的变量上调用 sub 方法。在 ethers.js 库中，BigNumber 是一个用于处理大数和安全进行数学运算的类。sub 方法是 BigNumber 实例的一个方法，用于执行减法运算。

如果你在调用一个合约方法，比如 feeGrowthGlobal0X128，并期望它返回一个 BigNumber，但实际上并没有返回预期的类型，就可能出现这个错误。通常，这种情况是因为合约方法的调用不正确或者数据没有被正确处理。

下面是一个示例代码，展示如何正确地使用 ethers.js 调用合约方法并使用 BigNumber 的 sub 方法：

const { ethers } = require('ethers');

// 初始化Web3提供者
const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_INFURA_API_KEY');

// Uniswap V3 池子合约的地址和 ABI
const poolContractAddress = 'YOUR_POOL_CONTRACT_ADDRESS';
const poolContractABI = [
  // 从 Uniswap 的文档或 Etherscan 获取完整的 ABI
  "function feeGrowthGlobal0X128() external view returns (uint256)"
  // 其他必要的合约方法ABI...
];

// 创建合约实例
const poolContract = new ethers.Contract(poolContractAddress, poolContractABI, provider);

async function getFeeGrowthGlobal0X128() {
  // 调用合约方法
  const feeGrowthGlobal0X128 = await poolContract.feeGrowthGlobal0X128();

  // 确保返回值是 BigNumber 类型
  if (!ethers.BigNumber.isBigNumber(feeGrowthGlobal0X128)) {
    console.error('The returned value is not a BigNumber.');
    return;
  }

  // 使用 BigNumber 的方法进行减法运算
  const someValueToSubtract = ethers.BigNumber.from('1000000000000000000'); // 示例值（1 ETH）
  const result = feeGrowthGlobal0X128.sub(someValueToSubtract);

  console.log(result.toString()); // 输出结果
}

getFeeGrowthGlobal0X128().catch(console.error);

请确保您替换了 YOUR_INFURA_API_KEY 和 YOUR_POOL_CONTRACT_ADDRESS 以及相关的 ABI。如果 feeGrowthGlobal0X128() 调用正确返回了 BigNumber 对象，你就可以使用 sub() 等方法进行数学运算。

如果你在使用合约对象调用方法时遇到了这种类型错误，建议检查以下几点：

1. 确保你使用的是最新版本的 ethers.js 库。
2. 确保你正确地从合约中获取了数据，并且数据的类型是 BigNumber。
3. 如果你在使用 TypeScript，确保你的类型定义是正确的。