Legacy Fee Claims

const clanker = new LegacyCreatorFees({ wallet, publicClient });

// v2/v3/v3.1 - simple!
await clanker.claimLegacyCreatorFees({ token: '0x...', version: 3.1 });

// v0/v1 - need locker info
await clanker.claimLegacyCreatorFees({
  token: '0x...',
  version: 1,
  lockerParams: { locker: '0x...', positionId: 123n, recipient: '0x...' }
});

new LegacyCreatorFees(config?): LegacyCreatorFees;

claimLegacyCreatorFees(input): Promise<
  | {
  error: undefined;
  txHash: `0x${string}`;
}
  | {
  error: ClankerError;
  txHash: undefined;
}>;

claimLegacyCreatorFeesSimulate(input, account?): Promise<
  | SimulateContractReturnType<Abi | readonly unknown[], string, readonly unknown[], Chain | undefined, undefined, undefined, undefined, readonly [never], undefined>
  | {
  error: ClankerError;
}>;

getClaimLegacyCreatorFeesTransaction(input): LegacyClaimTransactionConfig;

getMetaLockerClaimTransaction(locker, positionId): LegacyClaimTransactionConfig;

new LegacyFeeClaims(config?): LegacyFeeClaims;

getClaimLegacyFeesTransaction(args): Promise<LegacyClaimTx>;

getLegacyClaimableFees(opts): Promise<LegacyClaimableFees>;

getTokenCreator(token): Promise<`0x${string}`>;

getTokenCreatorRoot(): Promise<`0x${string}`>;

initializeTokenCreator(token): Promise<
  | {
  error: undefined;
  txHash: `0x${string}`;
}
  | {
  error: ClankerError;
  txHash: undefined;
}>;

initializeTokenCreatorSimulate(token, account?): Promise<any>;

tokenCreatorTransfer(safe): Promise<
  | {
  error: undefined;
  txHash: `0x${string}`;
}
  | {
  error: ClankerError;
  txHash: undefined;
}>;

tokenCreatorTransferSimulate(safe, account?): Promise<any>;

updateTokenCreator(token): Promise<
  | {
  error: undefined;
  txHash: `0x${string}`;
}
  | {
  error: ClankerError;
  txHash: undefined;
}>;

updateTokenCreatorSimulate(token, account?): Promise<any>;

type ClaimLegacyCreatorFeesInput = 
  | {
  token: `0x${string}`;
  version: 2 | 3 | 3.1;
}
  | {
  lockerParams: LockerParams;
  token: `0x${string}`;
  version: 0 | 1;
};

{
  token: `0x${string}`;
  version: 2 | 3 | 3.1;
}

{
  lockerParams: LockerParams;
  token: `0x${string}`;
  version: 0 | 1;
}

type LegacyClaimableFees = {
  amount0: bigint;
  amount1: bigint;
  positionOwner: `0x${string}`;
  token0: `0x${string}`;
  token1: `0x${string}`;
};

type LegacyClaimArgs = {
  chainId: number;
  factory?: `0x${string}`;
  locker?: `0x${string}`;
  positionId?: bigint;
  recipient?: `0x${string}`;
  token: `0x${string}`;
  tokenType?: LegacyTokenType;
  walletAddress?: `0x${string}`;
};

type LegacyClaimFeesInput = LegacyClaimArgs;

type LegacyClaimFeesTransaction = LegacyClaimTx;

type LegacyClaimTransactionConfig = {
  abi: Abi;
  address: `0x${string}`;
  args: readonly unknown[];
  functionName: string;
};

type LegacyClaimTx = {
  data: `0x${string}`;
  kind: LegacyClaimTxKind;
  to: `0x${string}`;
  value?: bigint;
};

type LegacyClaimTxKind = 
  | "factory.claimRewards"
  | "locker.collectFees"
  | "metaLocker.collectFees";

type LegacyTokenType = "proxy" | "clanker" | "clanker_v2" | "clanker_v3" | "clanker_v3_1";

type LegacyVersion = 0 | 1 | 2 | 3 | 3.1;

type LockerParams = {
  locker: `0x${string}`;
  positionId: bigint;
  recipient: `0x${string}`;
};

const BASE_CHAIN_ID: 8453;

const CLANKER_FACTORIES_BASE: {
  clanker_v0: "0x250c9FB2b411B48273f69879007803790A6AeA47";
  clanker_v1: "0x9B84fcE5Dcd9a38d2D01d5D72373F6b6b067c3e1";
  clanker_v2: "0x732560fa1d1A76350b1A500155BA978031B53833";
  clanker_v3: "0x375C15db32D28cEcdcAB5C03Ab889bf15cbD2c5E";
  clanker_v3_1: "0x2A787b2362021cC3eEa3C24C4748a6cD5B687382";
  clanker_v3_presale: "0x71cDc0bDF30F5601fb0ac80Cf1d20B771342C035";
};

const ClankerClaimRewardsAbi: readonly [{
  inputs: readonly [{
     name: "token";
     type: "address";
  }];
  name: "claimRewards";
  outputs: readonly [];
  stateMutability: "nonpayable";
  type: "function";
}];

const ClankerTokenDeployerAbi: readonly [{
  inputs: readonly [];
  name: "deployer";
  outputs: readonly [{
     name: "";
     type: "address";
  }];
  stateMutability: "view";
  type: "function";
}];

const EXPECTED_MERKLE_ROOT: "0xa7dcc91a2136ef1b3c708dbab901cbeb075f6df5cf5987494fedc340c57f7025";

const LEGACY_FACTORIES: {
  0: "0x250c9FB2b411B48273f69879007803790A6AeA47";
  1: "0x9B84fcE5Dcd9a38d2D01d5D72373F6b6b067c3e1";
  2: "0x732560fa1d1A76350b1A500155BA978031B53833";
  3: "0x375C15db32D28cEcdcAB5C03Ab889bf15cbD2c5E";
  3.1: "0x2A787b2362021cC3eEa3C24C4748a6cD5B687382";
};

const LEGACY_FEE_CLAIMS_ADDRESS: "0x10F4485d6f90239B72c6A5eaD2F2320993D285E4";

const LockerCollectFeesAbi: readonly [{
  inputs: readonly [{
     name: "_recipient";
     type: "address";
   }, {
     name: "_tokenId";
     type: "uint256";
  }];
  name: "collectFees";
  outputs: readonly [];
  stateMutability: "nonpayable";
  type: "function";
}];

const MetaLockerCollectFeesAbi: readonly [{
  inputs: readonly [{
     name: "_tokenId";
     type: "uint256";
  }];
  name: "collectFees";
  outputs: readonly [];
  stateMutability: "nonpayable";
  type: "function";
}];

const NonfungiblePositionManagerCollectAbi: readonly [{
  inputs: readonly [{
     components: readonly [{
        name: "tokenId";
        type: "uint256";
      }, {
        name: "recipient";
        type: "address";
      }, {
        name: "amount0Max";
        type: "uint128";
      }, {
        name: "amount1Max";
        type: "uint128";
     }];
     name: "params";
     type: "tuple";
  }];
  name: "collect";
  outputs: readonly [{
     name: "amount0";
     type: "uint256";
   }, {
     name: "amount1";
     type: "uint256";
  }];
  stateMutability: "payable";
  type: "function";
}];

const NonfungiblePositionManagerOwnerOfAbi: readonly [{
  inputs: readonly [{
     name: "tokenId";
     type: "uint256";
  }];
  name: "ownerOf";
  outputs: readonly [{
     name: "";
     type: "address";
  }];
  stateMutability: "view";
  type: "function";
}];

const NonfungiblePositionManagerPositionsAbi: readonly [{
  inputs: readonly [{
     name: "tokenId";
     type: "uint256";
  }];
  name: "positions";
  outputs: readonly [{
     name: "nonce";
     type: "uint96";
   }, {
     name: "operator";
     type: "address";
   }, {
     name: "token0";
     type: "address";
   }, {
     name: "token1";
     type: "address";
   }, {
     name: "fee";
     type: "uint24";
   }, {
     name: "tickLower";
     type: "int24";
   }, {
     name: "tickUpper";
     type: "int24";
   }, {
     name: "liquidity";
     type: "uint128";
   }, {
     name: "feeGrowthInside0LastX128";
     type: "uint256";
   }, {
     name: "feeGrowthInside1LastX128";
     type: "uint256";
   }, {
     name: "tokensOwed0";
     type: "uint128";
   }, {
     name: "tokensOwed1";
     type: "uint128";
  }];
  stateMutability: "view";
  type: "function";
}];

const UNISWAP_V3_BASE: {
  factory: "0x33128a8fC17869897dcE68Ed026d694621f6FDfD";
  nonfungiblePositionManager: "0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1";
  weth: "0x4200000000000000000000000000000000000006";
};

function getClaimLegacyCreatorFeesTransaction(input): LegacyClaimTransactionConfig;

// v3.1 token - simple
const tx = getClaimLegacyCreatorFeesTransaction({
  token: '0x...',
  version: 3.1
});

// v1 token - need locker info
const tx = getClaimLegacyCreatorFeesTransaction({
  token: '0x...',
  version: 1,
  lockerParams: { locker: '0x...', positionId: 123n, recipient: '0x...' }
});

await walletClient.writeContract(tx);

function getClaimLegacyFeesTransaction(publicClient, args): Promise<LegacyClaimTx>;

function getLegacyClaimableFees(publicClient, opts): Promise<LegacyClaimableFees>;

function getTokenCreatorMerkleProof(entries, targetToken): MerkleProofResult | null;

function parseTokenCreatorCSV(csvContent): TokenCreatorEntry[];