Singleton-like pattern for a project
If you need to wrap SomeClass, make your wrapper an abstraction:

public interface ISomeClassWrapper
{
    // expose the methods and properties you want to wrap
}


Then everywhere it's needed in the code, replace static method calls like this:

public void DoSomething()
{
    SomeClass.Xyz();
}


With something like this:

public class MyOtherClass
{
    private readonly ISomeClassWrapper _wrapper;

    public MyOtherClass(ISomeClassWrapper wrapper)
    {
        _wrapper = wrapper;
    }

    public void DoSomething()
    {
        _wrapper.Xyz();
    }
}


Now, if you're worried about how many instances of SomeClassWrapper (which implements ISomeClassWrapper but MyOtherClass doesn't need to know that), don't instantiate it. ever.

How do you ensure there's only 1 instance of it?

When you've replaced SomeClass.Xyz(); with _wrapper.Xyz();, you've done several things:


MyOtherClass is now decoupled from SomeClass, and even from SomeClassWrapper.
The ISomeClassWrapper dependency is now statically declared as such, so just by looking at MyOtherClass's constructor you know it needs an implementation for ISomeClassWrapper to carry out its tasks.
You can now provide a fake/mock implementation of ISomeClassWrapper, and write a test for DoSomething() without worrying about side-effects in code that you have no control over.
The code that's responsible for providing the ISomeClassWrapper instance/implementation, is also responsible for passing everyone that wants an ISomeClassWrapper instance, the same instance. Most IoC containers can do this very, very easily.