// 1. Setup SDK and tokens
import { CurrencyAmount, Token, Percent } from '@uniswap/sdk-core';
import { Pool, Route, Trade } from '@uniswap/v4-sdk';

// 2. Get pool state from PoolManager
const poolState = await poolManager.getPool(...);

// 3. Create trade with slippage protection
const slippageTolerance = new Percent(50, 10000); // 0.5%
const minimumAmountOut = trade.minimumAmountOut(slippageTolerance);

// 4. Execute with deadline
const deadline = Math.floor(Date.now() / 1000) + 60 * 20; // 20 min

// Add liquidity with concentrated range
INonfungiblePositionManager.MintParams memory params =
    INonfungiblePositionManager.MintParams({
        token0: token0,
        token1: token1,
        fee: 3000,  // 0.3%
        tickLower: -887220,
        tickUpper: 887220,
        amount0Desired: amount0,
        amount1Desired: amount1,
        amount0Min: amount0 * 95 / 100,  // Slippage protection
        amount1Min: amount1 * 95 / 100,
        recipient: msg.sender,
        deadline: deadline
    });

positionManager.mint(params);

// 1. Extend BaseHook
contract MyHook is BaseHook {
    constructor(IPoolManager _poolManager) BaseHook(_poolManager) {}

    // 2. Declare permissions
    function getHookPermissions() public pure override
        returns (Hooks.Permissions memory) {
        return Hooks.Permissions({
            beforeSwap: true,
            afterSwap: true,
            // ... other permissions
        });
    }

    // 3. Implement hook logic
    function beforeSwap(...) external override returns (...) {
        // Custom logic
        return (this.beforeSwap.selector, BeforeSwapDelta.ZERO, dynamicFee);
    }
}

from subgraph_query import UniswapSubgraph

subgraph = UniswapSubgraph()

# Get pool data
pool = subgraph.get_pool("0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640")
print(f"TVL: ${pool['totalValueLockedUSD']}")

# Track recent swaps
swaps = subgraph.get_recent_swaps(pool_address, limit=100)

# User positions
positions = subgraph.get_user_positions(user_address)

// Pool identified by PoolKey
PoolKey memory key = PoolKey({
    currency0: token0,
    currency1: token1,
    fee: 3000,
    tickSpacing: 60,
    hooks: IHooks(hookAddress)
});

poolManager.initialize(key, sqrtPriceX96);

// Concentrated range: 1 ETH = $1800-$2200
int24 tickLower = getTickAtPrice(1800);
int24 tickUpper = getTickAtPrice(2200);

positionManager.mint(token0, token1, fee, tickLower, tickUpper, ...);

npm install @uniswap/v4-sdk @uniswap/v4-core @uniswap/v4-periphery
npm install @uniswap/sdk-core ethers

npm install @uniswap/v3-sdk @uniswap/v3-core @uniswap/v3-periphery

# TypeScript
npm install graphql graphql-request

# Python
pip install requests

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {MyHook} from "../src/MyHook.sol";

contract MyHookTest is Test {
    PoolManager poolManager;
    MyHook hook;

    function setUp() public {
        poolManager = new PoolManager(500000);
        hook = new MyHook(poolManager);
    }

    function testSwapTriggersHook() public {
        // Initialize pool with hook
        PoolKey memory key = PoolKey({...});
        poolManager.initialize(key, SQRT_PRICE_1_1);

        // Execute swap
        poolManager.swap(key, params, hookData);

        // Verify hook was called
        assertEq(hook.swapCount(), 1);
    }
}

import { expect } from 'chai';
import { Trade, Route } from '@uniswap/v4-sdk';

describe('Swap Integration', () => {
  it('should calculate correct minimum output', async () => {
    const slippage = new Percent(50, 10000);
    const minOut = trade.minimumAmountOut(slippage);

    expect(minOut.lessThan(trade.outputAmount)).to.be.true;
  });
});

User: "How do I use the new v4 SDK hook features?"
→ Use Context7: resolve-library-id("@uniswap/v4-sdk")
→ Then query-docs with specific hook questions
→ Apply security patterns from security.md