Barkswap Contracts & Integration Documentation #

┌──────────────────────────────────────────────────────────────────────────┐
│                        USER INTERFACES                                   │
│              (Frontend / Scripts / External Integrators)                  │
├────────────┬──────────────┬────────────────┬────────────────────────────┤
│            │              │                │                            │
│   SWAP     │  LIQUIDITY   │    FARMING     │    GOVERNANCE (ve3,3)      │
│            │              │                │                            │
│ SwapRouter │ NFTPosition  │ FarmingCenter  │  VotingEscrow  VoterV4    │
│ QuoterV2   │   Manager    │ EternalFarming │  Minter        Gauges     │
│            │              │                │  RewardsDist   Bribes     │
├────────────┴──────────────┴────────────────┴────────────────────────────┤
│                        ALGEBRA CORE                                      │
│                                                                          │
│  AlgebraFactory ──► AlgebraPool (concentrated liquidity, dynamic fees)   │
│  AlgebraPoolDeployer    CommunityVault    BasePluginV1Factory            │
├──────────────────────────────────────────────────────────────────────────┤
│                      PLUGIN LAYER                                        │
│  DynamicFeePlugin │ VolatilityOracle │ FarmingProxy │ SlidingFee         │
└──────────────────────────────────────────────────────────────────────────┘

// IAlgebraFactory
function createPool(
    address tokenA,
    address tokenB,
    bytes calldata data    // Plugin initialization data (can be empty: "0x")
) external returns (address pool);

// IAlgebraPool
function initialize(uint160 initialPrice) external;

// IPoolInitializer (on NonfungiblePositionManager)
function createAndInitializePoolIfNecessary(
    address token0,       // Must be sorted: token0 < token1
    address token1,
    address deployer,     // address(0) for standard pools
    uint160 sqrtPriceX96,
    bytes calldata data   // Plugin init data
) external payable returns (address pool);

// Safe method (checks reentrancy lock)
function safelyGetStateOfAMM() external view returns (
    uint160 sqrtPrice,       // Current sqrt price Q64.96
    int24   tick,            // Current tick
    uint16  lastFee,         // Current fee in 1e-6 (e.g., 500 = 0.05%)
    uint8   pluginConfig,    // Active plugin hooks bitmap
    uint128 activeLiquidity, // In-range liquidity
    int24   nextTick,        // Next initialized tick
    int24   previousTick     // Previous initialized tick
);

// Raw global state (caller must verify reentrancy lock)
function globalState() external view returns (
    uint160 price,
    int24   tick,
    uint16  lastFee,
    uint8   pluginConfig,
    uint16  communityFee,    // Community fee in 1e-3 (e.g., 100 = 10%)
    bool    unlocked         // Must be true for safe reads
);

// Get existing pool by token pair
function poolByPair(address tokenA, address tokenB) external view returns (address pool);

// Compute pool address deterministically (no on-chain call needed)
function computePoolAddress(address token0, address token1) external view returns (address pool);

function swap(
    address recipient,       // Address to receive output tokens
    bool    zeroToOne,       // true = token0 → token1, false = token1 → token0
    int256  amountRequired,  // Positive = exact input, Negative = exact output
    uint160 limitSqrtPrice,  // Price limit (MIN_SQRT_RATIO+1 or MAX_SQRT_RATIO-1)
    bytes   calldata data    // Passed to algebraSwapCallback
) external returns (int256 amount0, int256 amount1);

function algebraSwapCallback(
    int256 amount0Delta,  // Positive = you owe the pool this much token0
    int256 amount1Delta,  // Positive = you owe the pool this much token1
    bytes calldata data
) external;

function mint(
    address leftoversRecipient,  // Receives surplus tokens
    address recipient,           // Position owner
    int24   bottomTick,          // Lower tick boundary
    int24   topTick,             // Upper tick boundary
    uint128 liquidityDesired,    // Amount of liquidity to add
    bytes   calldata data        // Passed to algebraMintCallback
) external returns (uint256 amount0, uint256 amount1, uint128 liquidityActual);

function burn(
    int24   bottomTick,
    int24   topTick,
    uint128 amount,       // Liquidity to remove
    bytes   calldata data // Passed to plugin
) external returns (uint256 amount0, uint256 amount1);

function collect(
    address recipient,
    int24   bottomTick,
    int24   topTick,
    uint128 amount0Requested,
    uint128 amount1Requested
) external returns (uint128 amount0, uint128 amount1);

function flash(
    address recipient,
    uint256 amount0,
    uint256 amount1,
    bytes   calldata data  // Passed to algebraFlashCallback
) external;

function algebraFlashCallback(
    uint256 fee0,   // Fee owed in token0
    uint256 fee1,   // Fee owed in token1
    bytes calldata data
) external;

struct ExactInputSingleParams {
    address tokenIn;
    address tokenOut;
    address deployer;          // address(0) for standard pools
    address recipient;
    uint256 deadline;          // block.timestamp deadline
    uint256 amountIn;
    uint256 amountOutMinimum;  // Slippage protection
    uint160 limitSqrtPrice;    // 0 for no limit
}

function exactInputSingle(ExactInputSingleParams calldata params)
    external payable returns (uint256 amountOut);

struct ExactInputParams {
    bytes   path;              // Encoded path: tokenIn + deployer + tokenOut [+ deployer + tokenN ...]
    address recipient;
    uint256 deadline;
    uint256 amountIn;
    uint256 amountOutMinimum;
}

function exactInput(ExactInputParams calldata params)
    external payable returns (uint256 amountOut);

struct ExactOutputSingleParams {
    address tokenIn;
    address tokenOut;
    address deployer;          // address(0) for standard pools
    address recipient;
    uint256 deadline;
    uint256 amountOut;         // Desired output amount
    uint256 amountInMaximum;   // Max input (slippage protection)
    uint160 limitSqrtPrice;
}

function exactOutputSingle(ExactOutputSingleParams calldata params)
    external payable returns (uint256 amountIn);

struct ExactOutputParams {
    bytes   path;              // Encoded path (REVERSED order)
    address recipient;
    uint256 deadline;
    uint256 amountOut;
    uint256 amountInMaximum;
}

function exactOutput(ExactOutputParams calldata params)
    external payable returns (uint256 amountIn);

function exactInputSingleSupportingFeeOnTransferTokens(
    ExactInputSingleParams calldata params
) external payable returns (uint256 amountOut);

struct QuoteExactInputSingleParams {
    address tokenIn;
    address tokenOut;
    address deployer;       // address(0) for standard pools
    uint256 amountIn;
    uint160 limitSqrtPrice; // 0 for no limit
}

function quoteExactInputSingle(QuoteExactInputSingleParams memory params)
    external returns (
        uint256 amountOut,
        uint256 amountIn,
        uint160 sqrtPriceX96After,
        uint32  initializedTicksCrossed,
        uint256 gasEstimate,
        uint16  fee
    );

function quoteExactInput(bytes memory path, uint256 amountInRequired)
    external returns (
        uint256[] memory amountOutList,
        uint256[] memory amountInList,
        uint160[] memory sqrtPriceX96AfterList,
        uint32[]  memory initializedTicksCrossedList,
        uint256 gasEstimate,
        uint16[]  memory feeList
    );

struct QuoteExactOutputSingleParams {
    address tokenIn;
    address tokenOut;
    address deployer;
    uint256 amount;          // Desired output
    uint160 limitSqrtPrice;
}

function quoteExactOutputSingle(QuoteExactOutputSingleParams memory params)
    external returns (
        uint256 amountOut,
        uint256 amountIn,
        uint160 sqrtPriceX96After,
        uint32  initializedTicksCrossed,
        uint256 gasEstimate,
        uint16  fee
    );

struct MintParams {
    address token0;          // Must be sorted: token0 < token1
    address token1;
    address deployer;        // address(0) for standard pools
    int24   tickLower;       // Must be multiple of tickSpacing
    int24   tickUpper;       // Must be multiple of tickSpacing
    uint256 amount0Desired;
    uint256 amount1Desired;
    uint256 amount0Min;      // Slippage protection
    uint256 amount1Min;      // Slippage protection
    address recipient;
    uint256 deadline;
}

function mint(MintParams calldata params) external payable
    returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);

struct IncreaseLiquidityParams {
    uint256 tokenId;
    uint256 amount0Desired;
    uint256 amount1Desired;
    uint256 amount0Min;
    uint256 amount1Min;
    uint256 deadline;
}

function increaseLiquidity(IncreaseLiquidityParams calldata params) external payable
    returns (uint128 liquidity, uint256 amount0, uint256 amount1);

struct DecreaseLiquidityParams {
    uint256 tokenId;
    uint128 liquidity;       // Amount of liquidity to remove
    uint256 amount0Min;
    uint256 amount1Min;
    uint256 deadline;
}

function decreaseLiquidity(DecreaseLiquidityParams calldata params) external payable
    returns (uint256 amount0, uint256 amount1);

struct CollectParams {
    uint256 tokenId;
    address recipient;
    uint128 amount0Max;      // Use type(uint128).max to collect all
    uint128 amount1Max;
}

function collect(CollectParams calldata params) external payable
    returns (uint256 amount0, uint256 amount1);

function positions(uint256 tokenId) external view returns (
    uint88  nonce,
    address operator,
    address token0,
    address token1,
    address deployer,
    int24   tickLower,
    int24   tickUpper,
    uint128 liquidity,
    uint256 feeGrowthInside0LastX128,
    uint256 feeGrowthInside1LastX128,
    uint128 tokensOwed0,
    uint128 tokensOwed1
);

function burn(uint256 tokenId) external payable;
// Requires: liquidity == 0 AND tokensOwed0 == 0 AND tokensOwed1 == 0

function approveForFarming(
    uint256 tokenId,
    bool    approve,
    address farmingAddress  // Must match the connected farming center
) external payable;

[tokenAddress (20 bytes)][deployerAddress (20 bytes)][tokenAddress (20 bytes)]...

0x + addressA (20 bytes) + deployer1 (20 bytes) + addressB (20 bytes) + deployer2 (20 bytes) + addressC (20 bytes)

const path = ethers.solidityPacked(
    ['address', 'address', 'address', 'address', 'address'],
    [tokenA, ethers.ZeroAddress, tokenB, ethers.ZeroAddress, tokenC]
);

pool = CREATE2(
    0xFF,
    poolDeployer,                                    // 0xeb4E9b84990C7c07D5205D35647A29de1B33dE7e
    keccak256(abi.encode(token0, token1)),           // salt (for standard pools)
    POOL_INIT_CODE_HASH                              // from PoolAddress.sol
)

// JavaScript computation
const { ethers } = require('ethers');

function computePoolAddress(poolDeployer, token0, token1) {
    // Ensure token0 < token1
    if (token0.toLowerCase() > token1.toLowerCase()) {
        [token0, token1] = [token1, token0];
    }
    const salt = ethers.keccak256(
        ethers.AbiCoder.defaultAbiCoder().encode(['address', 'address'], [token0, token1])
    );
    return ethers.getCreate2Address(
        poolDeployer,
        salt,
        '0xa18736c3ee97fe3c96c9428c0cc2a9116facec18e84f95f9da30543f8238a782'
    );
}

// AlgebraOracleV1TWAP lens contract
function getAverageTick(address pool, uint32 period) external view returns (int24 averageTick);

struct IncentiveKey {
    IERC20Minimal rewardToken;        // Main reward token
    IERC20Minimal bonusRewardToken;   // Bonus reward token
    IAlgebraPool  pool;               // Target Algebra pool
    uint256       nonce;              // Incentive nonce (increments per pool)
}

struct IncentiveParams {
    uint128 reward;                // Total main reward tokens
    uint128 bonusReward;           // Total bonus reward tokens
    uint128 rewardRate;            // Main reward per second
    uint128 bonusRewardRate;       // Bonus reward per second
    uint24  minimalPositionWidth;  // Min tick range (tickUpper - tickLower)
}

function createEternalFarming(
    IncentiveKey memory key,
    IncentiveParams memory params,
    address plugin               // Pool's plugin address
) external returns (address virtualPool);

function enterFarming(IncentiveKey memory key, uint256 tokenId) external;

function exitFarming(IncentiveKey memory key, uint256 tokenId) external;

function collectRewards(IncentiveKey memory key, uint256 tokenId)
    external returns (uint256 reward, uint256 bonusReward);

function claimReward(
    IERC20Minimal rewardToken,
    address to,
    uint256 amountRequested    // 0 = claim all
) external returns (uint256 rewardBalanceBefore);

Step 1: Mint LP position via NonfungiblePositionManager.mint()
           ↓
Step 2: Approve NFT for farming
        NonfungiblePositionManager.approveForFarming(tokenId, true, farmingCenterAddress)
           ↓
Step 3: Enter farming
        FarmingCenter.enterFarming(incentiveKey, tokenId)
           ↓
Step 4: Accrue rewards over time...
           ↓
Step 5: Collect accrued rewards
        FarmingCenter.collectRewards(incentiveKey, tokenId)
           ↓
Step 6: Claim reward tokens to wallet
        FarmingCenter.claimReward(rewardToken, recipientAddress, 0)
           ↓
Step 7: (Optional) Exit farming
        FarmingCenter.exitFarming(incentiveKey, tokenId)
           ↓
Step 8: (Optional) Decrease liquidity / burn NFT

function create_lock_for(
    uint256 _value,           // Amount of BARK to lock
    uint256 _lock_duration,   // Duration in seconds (max 2 years)
    address _to               // Recipient of the veNFT
) external returns (uint256 tokenId);

function increase_amount(uint256 _tokenId, uint256 _value) external;

function increase_unlock_time(uint256 _tokenId, uint256 _lock_duration) external;

function withdraw(uint256 _tokenId) external;
// Requires: block.timestamp >= locked[_tokenId].end

function merge(uint256 _from, uint256 _to) external;
// Combines lock amounts; uses the later expiry

function balanceOfNFT(uint256 _tokenId) external view returns (uint256);
// Returns current voting power of the veNFT

function locked(uint256 _tokenId) external view returns (int128 amount, uint256 end);
// Returns the locked amount and unlock timestamp

mapping(address => uint256) public weights;              // pool → total vote weight
mapping(uint256 => uint256) public usedWeights;          // veNFT → total weight used
mapping(uint256 => mapping(address => uint256)) public votes;  // veNFT → pool → weight
uint256 public totalWeight;                              // Global total
mapping(uint256 => uint256) public lastVoted;            // veNFT → last vote timestamp

function vote(
    uint256   _tokenId,   // veNFT token ID
    address[] _poolVote,  // Array of pool addresses
    uint256[] _weights    // Array of weights (sum ≤ 10000, where 10000 = 100%)
) external;

function reset(uint256 _tokenId) external;

function poke(uint256 _tokenId) external;
// Recasts existing votes with current veNFT voting power
// (e.g., after power decay or after locking more tokens)

function createGauge(address _pool) external
    returns (address _gauge, address _internalBribe, address _externalBribe);

function claimRewards(address[] memory _gauges) external;
// Claims earned emissions from gauges

function claimBribes(
    address[] memory _bribes,
    address[][] memory _tokens,
    uint256 _tokenId
) external;

function getPoolVote(uint256 _tokenId) external view returns (address[] memory);
function getVotes(uint256 _tokenId, address _pool) external view returns (uint256);
function getPoolWeight(address _pool) external view returns (uint256);
function getTotalWeight() external view returns (uint256);
function poolsLength() external view returns (uint256);
function pools(uint256 index) external view returns (address);
function gauges(address pool) external view returns (address gauge);
function internalBribes(address gauge) external view returns (address);
function externalBribes(address gauge) external view returns (address);
function isAlive(address gauge) external view returns (bool);
function isWhitelisted(address pool) external view returns (bool);

function deposit(uint256 tokenId) external;
// Transfers NFT to gauge; starts earning rewards

function withdraw(uint256 tokenId) external;

function getReward(address account, address[] memory tokens) external;

function claimFees() external returns (uint256 claimed0, uint256 claimed1);

function earned(address token, address account) external view returns (uint256);

// On Bribe contract
function getRewardForOwner(uint256 tokenId, address[] memory tokens) external;

function update_period() external returns (uint256 period);
// Mints new BARK and distributes to Voter for gauge allocation

function active_period() external view returns (uint256);    // Current epoch start
function weekly_emission() external view returns (uint256);  // Current weekly emission
function circulating_supply() external view returns (uint256);

function claim(uint256 _tokenId) external returns (uint256);
// Claims accumulated rebase for a veNFT

function claimable(uint256 _tokenId) external view returns (uint256);
// View pending rebase amount

User                         SwapRouter                    AlgebraPool
  │                              │                              │
  │ approve(router, amount)      │                              │
  │──────────────────────────►   │                              │
  │                              │                              │
  │ exactInputSingle({           │                              │
  │   tokenIn, tokenOut,         │                              │
  │   deployer: 0x0,             │                              │
  │   recipient: user,           │                              │
  │   deadline,                  │                              │
  │   amountIn,                  │                              │
  │   amountOutMinimum,          │                              │
  │   limitSqrtPrice: 0          │                              │
  │ })                           │                              │
  │─────────────────────────────►│                              │
  │                              │  swap(recipient, ...)        │
  │                              │─────────────────────────────►│
  │                              │  algebraSwapCallback(...)    │
  │                              │◄─────────────────────────────│
  │                              │  transferFrom(user, pool)    │
  │                              │─────────────────────────────►│
  │                              │                              │
  │◄─── amountOut tokens ────────│◄─────────────────────────────│

1. ADD LIQUIDITY
   User → approve token0 & token1 for NonfungiblePositionManager
   User → NonfungiblePositionManager.mint({token0, token1, tickLower, tickUpper, amounts...})
   User ← receives LP NFT (tokenId)

2. FARM LP POSITION
   User → NonfungiblePositionManager.approveForFarming(tokenId, true, farmingCenter)
   User → FarmingCenter.enterFarming(incentiveKey, tokenId)
   ...time passes, farming rewards accrue...
   User → FarmingCenter.collectRewards(incentiveKey, tokenId)
   User → FarmingCenter.claimReward(rewardToken, userAddress, 0)

3. LOCK BARK FOR veNFT
   User → BARK.approve(votingEscrow, amount)
   User → VotingEscrow.create_lock_for(amount, 2_years, userAddress)
   User ← receives veNFT (veTokenId)

4. VOTE ON POOLS
   User → VoterV4.vote(veTokenId, [pool1, pool2], [6000, 4000])
   (Votes persist across epochs — no need to re-vote!)

5. EARN BRIBES + REBASES
   ...next epoch...
   User → VoterV4.claimBribes([bribeContracts], [[tokens]], veTokenId)
   User → RewardsDistributor.claim(veTokenId)

Every 7 days:
  ┌──────────────────────────────────────────────────────────────┐
  │ 1. Minter.update_period()                                    │
  │    → Mints weekly BARK emission                              │
  │    → Sends to Voter.updateClaimable(amount)                  │
  │                                                              │
  │ 2. Voter calculates gauge shares based on vote weights       │
  │    → claimable[gauge] += amount × poolWeight / totalWeight   │
  │                                                              │
  │ 3. Voter.distribute([gauges])                                │
  │    → Sends BARK to each gauge via notifyRewardAmount()       │
  │                                                              │
  │ 4. RewardsDistributor receives rebase allocation             │
  │    → veNFT holders can claim()                               │
  └──────────────────────────────────────────────────────────────┘

import { ethers } from 'ethers';

// Network Configuration
const DOGEOS_TESTNET = {
    chainId: 6281971,
    name: 'DogeOS Testnet',
    rpcUrl: 'https://rpc.testnet.dogeos.com',
};

const provider = new ethers.JsonRpcProvider(DOGEOS_TESTNET.rpcUrl);
const signer = new ethers.Wallet(PRIVATE_KEY, provider);

// Contract Addresses
const ADDRESSES = {
    factory:            '0x099F459D81ce99aD3eCE1Ca2c77d9869883d2457',
    poolDeployer:       '0xeb4E9b84990C7c07D5205D35647A29de1B33dE7e',
    swapRouter:         '0x77147f436cE9739D2A54Ffe428DBe02b90c0205e',
    positionManager:    '0x4Bb4A5CF44028519908D6B4A90C570fEaA8c9a07',
    quoterV2:           '0xcEF56157baaB2Fe9D16ccF0eB4a9Df354380257D',
    eternalFarming:     '0xccdF60E4EfE4fB84183595Ad897E30a9ED4042EA',
    farmingCenter:      '0xc3BfA70A15556A01D35Fca03D8905A2afB7A5DbC',
    veToken:            '0xB4e0150c0CF27Aa0005BA494B17322a3e2554E4d',
    votingEscrow:       '0xC7457Ba36B06C891cf094EDc9d3e2eeB1c624bb5',
    voter:              '0xDb036a6C675b775e260F685d6634b70A4C9136b9',
    minter:             '0x4270CE6Cae2f730fceD7c21aD6BE135977E18aA2',
    rewardsDistributor: '0x7f06c051934930257f2F4312fB74b4027d4E62B1',
    wrappedNative:      '0xF6BDB158A5ddF77F1B83bC9074F6a472c58D78aE',
};

const SWAP_ROUTER_ABI = [
    'function exactInputSingle((address tokenIn, address tokenOut, address deployer, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 limitSqrtPrice)) external payable returns (uint256 amountOut)',
    'function exactInput((bytes path, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum)) external payable returns (uint256 amountOut)',
];

const ERC20_ABI = [
    'function approve(address spender, uint256 amount) external returns (bool)',
    'function balanceOf(address account) external view returns (uint256)',
    'function decimals() external view returns (uint8)',
];

async function swapExactInput(tokenIn, tokenOut, amountIn) {
    const router = new ethers.Contract(ADDRESSES.swapRouter, SWAP_ROUTER_ABI, signer);
    const token = new ethers.Contract(tokenIn, ERC20_ABI, signer);

    // Step 1: Approve router
    const approveTx = await token.approve(ADDRESSES.swapRouter, amountIn);
    await approveTx.wait();

    // Step 2: Get quote (optional but recommended)
    const quotedOut = await getQuote(tokenIn, tokenOut, amountIn);
    const minOut = quotedOut * 99n / 100n; // 1% slippage

    // Step 3: Execute swap
    const deadline = Math.floor(Date.now() / 1000) + 600; // 10 min
    const tx = await router.exactInputSingle({
        tokenIn,
        tokenOut,
        deployer: ethers.ZeroAddress,  // Standard pool
        recipient: signer.address,
        deadline,
        amountIn,
        amountOutMinimum: minOut,
        limitSqrtPrice: 0n,            // No price limit
    });

    const receipt = await tx.wait();
    console.log('Swap executed:', receipt.hash);
    return receipt;
}

// Multi-hop swap: tokenA → tokenB → tokenC
async function swapMultiHop(tokenA, tokenB, tokenC, amountIn) {
    const router = new ethers.Contract(ADDRESSES.swapRouter, SWAP_ROUTER_ABI, signer);

    const path = ethers.solidityPacked(
        ['address', 'address', 'address', 'address', 'address'],
        [tokenA, ethers.ZeroAddress, tokenB, ethers.ZeroAddress, tokenC]
    );

    const tx = await router.exactInput({
        path,
        recipient: signer.address,
        deadline: Math.floor(Date.now() / 1000) + 600,
        amountIn,
        amountOutMinimum: 0n, // Replace with actual slippage check!
    });

    return await tx.wait();
}

const POSITION_MANAGER_ABI = [
    'function mint((address token0, address token1, address deployer, int24 tickLower, int24 tickUpper, uint256 amount0Desired, uint256 amount1Desired, uint256 amount0Min, uint256 amount1Min, address recipient, uint256 deadline)) external payable returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1)',
    'function createAndInitializePoolIfNecessary(address token0, address token1, address deployer, uint160 sqrtPriceX96, bytes data) external payable returns (address pool)',
    'function positions(uint256 tokenId) external view returns (uint88 nonce, address operator, address token0, address token1, address deployer, int24 tickLower, int24 tickUpper, uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, uint128 tokensOwed0, uint128 tokensOwed1)',
];

async function addLiquidity(token0, token1, amount0, amount1, tickLower, tickUpper) {
    // Ensure token0 < token1
    if (token0.toLowerCase() > token1.toLowerCase()) {
        [token0, token1] = [token1, token0];
        [amount0, amount1] = [amount1, amount0];
    }

    const pm = new ethers.Contract(ADDRESSES.positionManager, POSITION_MANAGER_ABI, signer);
    const t0 = new ethers.Contract(token0, ERC20_ABI, signer);
    const t1 = new ethers.Contract(token1, ERC20_ABI, signer);

    // Approve
    await (await t0.approve(ADDRESSES.positionManager, amount0)).wait();
    await (await t1.approve(ADDRESSES.positionManager, amount1)).wait();

    // Mint position
    const tx = await pm.mint({
        token0,
        token1,
        deployer: ethers.ZeroAddress,
        tickLower,
        tickUpper,
        amount0Desired: amount0,
        amount1Desired: amount1,
        amount0Min: 0n,  // Replace with slippage-adjusted value
        amount1Min: 0n,  // Replace with slippage-adjusted value
        recipient: signer.address,
        deadline: Math.floor(Date.now() / 1000) + 600,
    });

    const receipt = await tx.wait();

    // Parse tokenId from IncreaseLiquidity event
    const iface = new ethers.Interface([
        'event IncreaseLiquidity(uint256 indexed tokenId, uint128 liquidityDesired, uint128 actualLiquidity, uint256 amount0, uint256 amount1, address pool)',
    ]);
    const log = receipt.logs.find(l => {
        try { return iface.parseLog(l) !== null; } catch { return false; }
    });
    const parsed = iface.parseLog(log);
    console.log('NFT Token ID:', parsed.args.tokenId.toString());
    return parsed.args.tokenId;
}

const PM_ABI_EXTENDED = [
    ...POSITION_MANAGER_ABI,
    'function decreaseLiquidity((uint256 tokenId, uint128 liquidity, uint256 amount0Min, uint256 amount1Min, uint256 deadline)) external payable returns (uint256 amount0, uint256 amount1)',
    'function collect((uint256 tokenId, address recipient, uint128 amount0Max, uint128 amount1Max)) external payable returns (uint256 amount0, uint256 amount1)',
    'function burn(uint256 tokenId) external payable',
];

async function removeLiquidity(tokenId, liquidityToRemove) {
    const pm = new ethers.Contract(ADDRESSES.positionManager, PM_ABI_EXTENDED, signer);

    // Step 1: Decrease liquidity
    const decreaseTx = await pm.decreaseLiquidity({
        tokenId,
        liquidity: liquidityToRemove,
        amount0Min: 0n,
        amount1Min: 0n,
        deadline: Math.floor(Date.now() / 1000) + 600,
    });
    await decreaseTx.wait();

    // Step 2: Collect tokens + fees
    const collectTx = await pm.collect({
        tokenId,
        recipient: signer.address,
        amount0Max: ethers.MaxUint256 >> 128n,  // type(uint128).max
        amount1Max: ethers.MaxUint256 >> 128n,
    });
    await collectTx.wait();

    // Step 3: (Optional) Burn empty NFT
    // Only if liquidity == 0 and no tokens owed
    // await pm.burn(tokenId);
}

const FARMING_CENTER_ABI = [
    'function enterFarming((address rewardToken, address bonusRewardToken, address pool, uint256 nonce) key, uint256 tokenId) external',
    'function exitFarming((address rewardToken, address bonusRewardToken, address pool, uint256 nonce) key, uint256 tokenId) external',
    'function collectRewards((address rewardToken, address bonusRewardToken, address pool, uint256 nonce) key, uint256 tokenId) external returns (uint256 reward, uint256 bonusReward)',
    'function claimReward(address rewardToken, address to, uint256 amountRequested) external returns (uint256 rewardBalanceBefore)',
];

const NFT_PM_FARMING_ABI = [
    'function approveForFarming(uint256 tokenId, bool approve, address farmingAddress) external payable',
];

async function stakeFarm(tokenId, incentiveKey) {
    const pm = new ethers.Contract(ADDRESSES.positionManager, NFT_PM_FARMING_ABI, signer);
    const fc = new ethers.Contract(ADDRESSES.farmingCenter, FARMING_CENTER_ABI, signer);

    // Step 1: Approve for farming
    await (await pm.approveForFarming(tokenId, true, ADDRESSES.farmingCenter)).wait();

    // Step 2: Enter farming
    await (await fc.enterFarming(incentiveKey, tokenId)).wait();
    console.log('Staked in farm');
}

async function collectAndClaimFarmRewards(tokenId, incentiveKey) {
    const fc = new ethers.Contract(ADDRESSES.farmingCenter, FARMING_CENTER_ABI, signer);

    // Step 1: Collect (accrue rewards internally)
    const collectTx = await fc.collectRewards(incentiveKey, tokenId);
    const receipt = await collectTx.wait();
    console.log('Rewards collected');

    // Step 2: Claim reward tokens to wallet
    await (await fc.claimReward(
        incentiveKey.rewardToken,
        signer.address,
        0n  // 0 = claim all
    )).wait();

    // Step 3: Claim bonus reward tokens (if any)
    if (incentiveKey.bonusRewardToken !== ethers.ZeroAddress) {
        await (await fc.claimReward(
            incentiveKey.bonusRewardToken,
            signer.address,
            0n
        )).wait();
    }
}

async function unstakeFarm(tokenId, incentiveKey) {
    const fc = new ethers.Contract(ADDRESSES.farmingCenter, FARMING_CENTER_ABI, signer);

    // Collect final rewards then exit
    await collectAndClaimFarmRewards(tokenId, incentiveKey);
    await (await fc.exitFarming(incentiveKey, tokenId)).wait();
    console.log('Exited farm');
}

const VOTING_ESCROW_ABI = [
    'function create_lock_for(uint256 _value, uint256 _lock_duration, address _to) external returns (uint256)',
    'function increase_amount(uint256 _tokenId, uint256 _value) external',
    'function increase_unlock_time(uint256 _tokenId, uint256 _lock_duration) external',
    'function withdraw(uint256 _tokenId) external',
    'function balanceOfNFT(uint256 _tokenId) external view returns (uint256)',
    'function locked(uint256 _tokenId) external view returns (int128 amount, uint256 end)',
    'function merge(uint256 _from, uint256 _to) external',
];

const VOTER_ABI = [
    'function vote(uint256 _tokenId, address[] _poolVote, uint256[] _weights) external',
    'function reset(uint256 _tokenId) external',
    'function poke(uint256 _tokenId) external',
    'function claimBribes(address[] _bribes, address[][] _tokens, uint256 _tokenId) external',
    'function getPoolVote(uint256 _tokenId) external view returns (address[])',
    'function getPoolWeight(address _pool) external view returns (uint256)',
    'function getTotalWeight() external view returns (uint256)',
    'function gauges(address pool) external view returns (address)',
    'function internalBribes(address gauge) external view returns (address)',
    'function externalBribes(address gauge) external view returns (address)',
];

// Lock BARK tokens for 2 years and get veNFT
async function lockBark(amount) {
    const bark = new ethers.Contract(ADDRESSES.veToken, ERC20_ABI, signer);
    const ve = new ethers.Contract(ADDRESSES.votingEscrow, VOTING_ESCROW_ABI, signer);

    // Approve
    await (await bark.approve(ADDRESSES.votingEscrow, amount)).wait();

    // Lock for 2 years (max)
    const TWO_YEARS = 2 * 365 * 24 * 60 * 60;
    const tx = await ve.create_lock_for(amount, TWO_YEARS, signer.address);
    const receipt = await tx.wait();

    // Parse veNFT token ID from Transfer event
    const iface = new ethers.Interface([
        'event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)',
    ]);
    const log = receipt.logs.find(l => {
        try {
            const p = iface.parseLog(l);
            return p && p.args.from === ethers.ZeroAddress;
        } catch { return false; }
    });
    const veTokenId = iface.parseLog(log).args.tokenId;
    console.log('veNFT minted:', veTokenId.toString());
    return veTokenId;
}

// Vote on pools with veNFT
async function voteOnPools(veTokenId, pools, weights) {
    const voter = new ethers.Contract(ADDRESSES.voter, VOTER_ABI, signer);

    // weights are in basis points out of 10000
    // e.g., [6000, 4000] = 60% pool1, 40% pool2
    const tx = await voter.vote(veTokenId, pools, weights);
    await tx.wait();
    console.log('Voted successfully');
}

// Example: Vote 60% on pool1, 40% on pool2
// await voteOnPools(veTokenId, [pool1Address, pool2Address], [6000, 4000]);

const REWARDS_DISTRIBUTOR_ABI = [
    'function claim(uint256 _tokenId) external returns (uint256)',
    'function claimable(uint256 _tokenId) external view returns (uint256)',
];

const GAUGE_ABI = [
    'function getReward(address account, address[] tokens) external',
    'function earned(address token, address account) external view returns (uint256)',
    'function deposit(uint256 tokenId) external',
    'function withdraw(uint256 tokenId) external',
];

// Claim ve rebase
async function claimRebase(veTokenId) {
    const rd = new ethers.Contract(ADDRESSES.rewardsDistributor, REWARDS_DISTRIBUTOR_ABI, signer);

    const pending = await rd.claimable(veTokenId);
    console.log('Pending rebase:', ethers.formatEther(pending));

    if (pending > 0n) {
        const tx = await rd.claim(veTokenId);
        await tx.wait();
        console.log('Rebase claimed');
    }
}

// Claim bribe rewards for a veNFT
async function claimAllBribes(veTokenId, poolAddresses) {
    const voter = new ethers.Contract(ADDRESSES.voter, VOTER_ABI, signer);

    // Build arrays of bribe addresses and reward tokens
    const bribes = [];
    const tokens = [];

    for (const pool of poolAddresses) {
        const gauge = await voter.gauges(pool);
        if (gauge === ethers.ZeroAddress) continue;

        const intBribe = await voter.internalBribes(gauge);
        const extBribe = await voter.externalBribes(gauge);

        // Internal bribe (trading fees)
        bribes.push(intBribe);
        tokens.push([/* list of reward token addresses for this bribe */]);

        // External bribe (third-party incentives)
        bribes.push(extBribe);
        tokens.push([/* list of reward token addresses for this bribe */]);
    }

    if (bribes.length > 0) {
        const tx = await voter.claimBribes(bribes, tokens, veTokenId);
        await tx.wait();
        console.log('Bribes claimed');
    }
}

// Claim gauge emissions (for staked LP positions)
async function claimGaugeRewards(gaugeAddress, rewardTokens) {
    const gauge = new ethers.Contract(gaugeAddress, GAUGE_ABI, signer);

    // Check earned
    for (const token of rewardTokens) {
        const earned = await gauge.earned(token, signer.address);
        console.log(`Earned ${token}: ${ethers.formatEther(earned)}`);
    }

    // Claim
    const tx = await gauge.getReward(signer.address, rewardTokens);
    await tx.wait();
    console.log('Gauge rewards claimed');
}

event Initialize(uint160 price, int24 tick);
event Mint(address sender, address indexed owner, int24 indexed bottomTick, int24 indexed topTick, uint128 liquidityAmount, uint256 amount0, uint256 amount1);
event Burn(address indexed owner, int24 indexed bottomTick, int24 indexed topTick, uint128 liquidityAmount, uint256 amount0, uint256 amount1, uint24 pluginFee);
event Swap(address indexed sender, address indexed recipient, int256 amount0, int256 amount1, uint160 price, uint128 liquidity, int24 tick, uint24 overrideFee, uint24 pluginFee);
event Collect(address indexed owner, address recipient, int24 indexed bottomTick, int24 indexed topTick, uint128 amount0, uint128 amount1);
event Flash(address indexed sender, address indexed recipient, uint256 amount0, uint256 amount1, uint256 paid0, uint256 paid1);
event Fee(uint16 fee);
event CommunityFee(uint16 communityFeeNew);
event TickSpacing(int24 newTickSpacing);
event Plugin(address newPluginAddress);

event IncreaseLiquidity(uint256 indexed tokenId, uint128 liquidityDesired, uint128 actualLiquidity, uint256 amount0, uint256 amount1, address pool);
event DecreaseLiquidity(uint256 indexed tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
event Collect(uint256 indexed tokenId, address recipient, uint256 amount0, uint256 amount1);

event FarmEntered(uint256 indexed tokenId, bytes32 indexed incentiveId, uint128 liquidity);
event FarmEnded(uint256 indexed tokenId, bytes32 indexed incentiveId, address indexed rewardAddress, address bonusRewardToken, address owner, uint256 reward, uint256 bonusReward);
event RewardsCollected(uint256 tokenId, bytes32 incentiveId, uint256 rewardAmount, uint256 bonusRewardAmount);
event RewardClaimed(address indexed to, uint256 reward, address indexed rewardAddress, address indexed owner);

event GaugeCreated(address indexed gauge, address creator, address internalBribe, address externalBribe, address indexed pool);
event Voted(address indexed voter, uint256 indexed tokenId, address[] pools, uint256[] weights);
event DistributeReward(address indexed sender, address indexed gauge, uint256 amount);
event Whitelisted(address indexed pool);
event Blacklisted(address indexed pool);