[nato-uniswap-v3] Add NATO Uniswap V3 strategy

src/strategies/strategies/nato-uniswap-v3/README.md

@@ -0,0 +1,37 @@
+# NATO Uniswap V3 Strategy
+
+This strategy calculates voting power based on Uniswap V3 LP positions that include the NATO token.
+
+## Parameters
+
+- **tokenAddress**: NATO token contract address  
+- **poolAddress**: Uniswap V3 pool address (NATO/WETH)  
+- **feeTier**: Uniswap V3 pool fee tier (e.g. `10000` for 1%)  
+- **positionManager**: Uniswap V3 NFT Position Manager contract address  
+- **network**: Target chain (e.g. `"base"`)
+
+## Example
+
+```json
+[
+  {
+    "name": "Nato example",
+    "strategy": {
+      "name": "nato-uniswap-v3",
+      "params": {
+        "tokenAddress": "0xd968196fa6977c4e58f2af5ac01c655ea8332d22",
+        "poolAddress": "0x02623e0e65a1d8537f6235512839e2f7b76c7a12",
+        "feeTier": 10000,
+        "positionManager": "0x03a520b32c04bf3beef7beb72e919cf822ed34f1",
+        "network": "base"
+      }
+    },
+    "network": "base",
+    "addresses": [
+      "0x4019fc024a385c6eb2ba17a43b286615f11c4ef4",
+      "0x07a1f6fc8923c5ebd4e4ddae89ac97629856a0f",
+      "0x38c0039247a31f399bae65e953612125cb88268"
+    ],
+    "snapshot": 12222222
+  }
+]

src/strategies/strategies/nato-uniswap-v3/examples.json

@@ -0,0 +1,21 @@
+[
+  {
+    "name": "Nato example",
+    "strategy": {
+      "name": "nato-uniswap-v3",
+      "params": {
+        "tokenAddress": "0xd968196fa6977c4e58f2af5ac01c655ea8332d22",
+        "poolAddress": "0x02623e0e65A1D8537f6235512839E2f7b76C7A12",
+        "feeTier": 10000,
+        "positionManager": "0x03a520b32c04bf3beef7beb72e919cf822ed34f1"
+      }
+    },
+    "network": "base",
+    "addresses": [
+      "0x4019FC024a385c6Eb2bA17a43B286615f11C4EF4",
+      "0x07a1f6fc89223c5ebD4e4ddaE89Ac97629856A0f",
+      "0x38C0039247A31F3939baE65e953612125cB88268"
+    ],
+    "snapshot": 12222222
+  }
+]

src/strategies/strategies/nato-uniswap-v3/index.ts

@@ -0,0 +1,189 @@
+import { getAddress } from '@ethersproject/address';
+import { formatUnits } from '@ethersproject/units';
+import { Multicaller } from '../../utils';
+
+const POSITION_MANAGER_ABI = [
+  'function balanceOf(address owner) view returns (uint256)',
+  'function tokenOfOwnerByIndex(address owner, uint256 index) view returns (uint256)',
+  'function positions(uint256 tokenId) 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 POOL_ABI = [
+  'function slot0() view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)'
+];
+
+function getAmount1ForLiquidity(
+  sqrtLower: number,
+  sqrtUpper: number,
+  sqrtPriceCurrent: bigint,
+  liquidity: bigint
+): bigint {
+  const lower = BigInt(sqrtLower);
+  const upper = BigInt(sqrtUpper);
+  const current = BigInt(sqrtPriceCurrent);
+  const L = BigInt(liquidity);
+
+  if (current <= lower) return 0n;
+  if (current < upper) {
+    return (L * (current - lower)) / 2n ** 96n;
+  }
+  return (L * (upper - lower)) / 2n ** 96n;
+}
+
+export const strategy = async (
+  _space: string,
+  _network: string,
+  _provider: any,
+  addresses: string[],
+  options: any,
+  snapshot: number | 'latest'
+) => {
+  const results: Record<string, number> = {};
+  const blockTag = typeof snapshot === 'number' ? snapshot : 'latest';
+
+  // slot0
+  const poolCaller = new Multicaller(_network, _provider, POOL_ABI, {
+    blockTag
+  });
+  poolCaller.call('slot0', options.poolAddress, 'slot0', []);
+  const poolRes = await poolCaller.execute();
+  const slot0Arr = poolRes.slot0 as any[];
+  if (!slot0Arr || !slot0Arr[0])
+    throw new Error('❌ Failed to fetch slot0() from pool');
+  const sqrtPriceX96 = BigInt(slot0Arr[0]);
+
+  // balanceOf
+  const balancesCaller = new Multicaller(
+    _network,
+    _provider,
+    POSITION_MANAGER_ABI,
+    { blockTag }
+  );
+  addresses.forEach(addr => {
+    const addrChecksum = getAddress(addr);
+    balancesCaller.call(
+      `${addrChecksum}.balance`,
+      options.positionManager,
+      'balanceOf',
+      [addrChecksum]
+    );
+  });
+  const balancesRes = (await balancesCaller.execute()) as Record<
+    string,
+    { balance: any }
+  >;
+
+  // tokenOfOwnerByIndex
+  const tokensCaller = new Multicaller(
+    _network,
+    _provider,
+    POSITION_MANAGER_ABI,
+    { blockTag }
+  );
+  Object.entries(balancesRes).forEach(([addrChecksum, { balance }]) => {
+    const count = balance ? parseInt(balance.toString()) : 0;
+    for (let i = 0; i < count; i++) {
+      tokensCaller.call(
+        `${addrChecksum}.tokenIds.${i}`,
+        options.positionManager,
+        'tokenOfOwnerByIndex',
+        [addrChecksum, i]
+      );
+    }
+  });
+  const tokensRes = (await tokensCaller.execute()) as Record<
+    string,
+    { tokenIds: Record<string, any> }
+  >;
+
+  // positions
+  const positionsCaller = new Multicaller(
+    _network,
+    _provider,
+    POSITION_MANAGER_ABI,
+    { blockTag }
+  );
+  Object.values(tokensRes).forEach((entry: any) => {
+    if (!entry?.tokenIds) return;
+    Object.values(entry.tokenIds).forEach((tokenId: any) => {
+      if (tokenId !== undefined) {
+        positionsCaller.call(
+          `${tokenId}`,
+          options.positionManager,
+          'positions',
+          [tokenId.toString()]
+        );
+      }
+    });
+  });
+  const positionsRes = (await positionsCaller.execute()) as Record<
+    string,
+    any[]
+  >;
+
+  // aggregate
+  for (const addrRaw of addresses) {
+    const addrChecksum = getAddress(addrRaw);
+    const balBN = balancesRes[addrChecksum]?.balance;
+    const bal = balBN ? parseInt(balBN.toString()) : 0;
+    if (!bal) {
+      results[addrChecksum] = 0;
+      continue;
+    }
+
+    const tokenIdsObj = (tokensRes[addrChecksum]?.tokenIds || {}) as Record<
+      string,
+      any
+    >;
+    const tokenIds = Object.values(tokenIdsObj)
+      .map((v: any) => v?.toString())
+      .filter(Boolean);
+
+    let total = 0n;
+    for (const tokenId of tokenIds) {
+      const pos = positionsRes[tokenId];
+      if (!pos) continue;
+
+      const [
+        ,
+        ,
+        ,
+        token1,
+        fee,
+        tickLower,
+        tickUpper,
+        liquidity,
+        ,
+        ,
+        ,
+        tokensOwed1
+      ] = pos;
+
+      if (
+        String(token1).toLowerCase() !==
+          String(options.tokenAddress).toLowerCase() ||
+        Number(fee) !== Number(options.feeTier)
+      )
+        continue;
+
+      const sqrtLower = Math.floor(
+        Math.sqrt(Math.pow(1.0001, Number(tickLower))) * 2 ** 96
+      );
+      const sqrtUpper = Math.floor(
+        Math.sqrt(Math.pow(1.0001, Number(tickUpper))) * 2 ** 96
+      );
+
+      const amount1 = getAmount1ForLiquidity(
+        sqrtLower,
+        sqrtUpper,
+        sqrtPriceX96,
+        BigInt(liquidity)
+      );
+      total += amount1 + BigInt(tokensOwed1);
+    }
+
+    results[addrChecksum] = parseFloat(formatUnits(total.toString(), 18));
+  }
+
+  return results;
+};

src/strategies/strategies/nato-uniswap-v3/schema.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "NATO Uniswap V3 Strategy",
+  "type": "object",
+  "properties": {
+    "tokenAddress": {
+      "type": "string",
+      "title": "NATO Token Address",
+      "default": "0xd968196fa6977c4e58f2af5ac01c655ea8332d22"
+    },
+    "poolAddress": {
+      "type": "string",
+      "title": "Uniswap V3 Pool Address",
+      "default": "0x02623e0e65a1d8537f6235512839e2f7b76c7a12"
+    },
+    "feeTier": {
+      "type": "number",
+      "title": "Fee Tier (Uniswap V3)",
+      "default": 10000
+    },
+    "positionManager": {
+      "type": "string",
+      "title": "Uniswap V3 Position Manager Address",
+      "default": "0x03a520b32c04bf3beef7beb72e919cf822ed34f1"
+    },
+    "network": {
+      "type": "string",
+      "title": "Network",
+      "default": "base"
+    }
+  },
+  "required": [
+    "tokenAddress",
+    "poolAddress",
+    "feeTier",
+    "positionManager",
+    "network"
+  ]
+}

test/strategies/unit/strategy.test.ts

@@ -103,6 +103,13 @@
     });
 
     it('Should take less than 10 sec. to resolve', () => {
+      // guard: avoid null timing assertion in CI
+      if (getScoresTime == null || Number.isNaN(getScoresTime)) {
+        throw new Error('getScoresTime is null/NaN - strategy did not return a timing value');
+      }
+      if (typeof getScoresTime !== 'number') {
+        throw new Error(`getScoresTime is not a number (got ${typeof getScoresTime})`);
+      }
       expect(getScoresTime).toBeLessThanOrEqual(10000);
     });
 
@@ -198,9 +205,7 @@
 );
 
 (moreArg ? describe.each(examples) : describe.skip.each(examples))(
-  `\nTest strategy "${strategy}" with example index $index (with ${
-    moreArg || 500
-  } addresses)`,
+  `\nTest strategy "${strategy}" with example index $index (with ${moreArg || 500} addresses)`,
   // @ts-ignore
   ({ example }) => {
     let scoresMore: any = null;
@@ -220,9 +225,14 @@
       await new Promise(r => setTimeout(r, 500));
     });
 
-    it(`Should take less than 20 sec. to resolve with ${
-      moreArg || 500
-    } addresses`, () => {
+    it(`Should take less than 20 sec. to resolve with ${moreArg || 500} addresses`, () => {
+      // guard: avoid null timing assertion in CI
+      if (getScoresTimeMore == null || Number.isNaN(getScoresTimeMore)) {
+        throw new Error('getScoresTimeMore is null/NaN - strategy did not return a timing value');
+      }
+      if (typeof getScoresTimeMore !== 'number') {
+        throw new Error(`getScoresTimeMore is not a number (got ${typeof getScoresTimeMore})`);
+      }
       expect(getScoresTimeMore).toBeLessThanOrEqual(20000);
     });
   }
@@ -289,7 +299,7 @@
     expect(githubUser.message).not.toEqual('Not Found');
   });
   it('Version in strategy should be a valid string', async () => {
-    const version = snapshot.strategies[strategy].author;
+    const version = snapshot.strategies[strategy].version;
     expect(typeof version).toBe('string');
   });
 });