use source generator to define all the interop functions

Author: zone117x

Secp256k1.Net.SourceGenerator/InteropGenerator.cs

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <IsRoslynComponent>true</IsRoslynComponent>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.8.0" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" PrivateAssets="all">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="System.Text.Json" Version="8.0.5" PrivateAssets="all" GeneratePathProperty="true" />
+  </ItemGroup>
+
+</Project>

Secp256k1.Net.SourceGenerator/Secp256k1.Net.SourceGenerator.csproj

@@ -388,7 +388,7 @@ public void NativeLibResolveLoadClose()
             try
             {
                 File.Copy(origLibPath, tempLibPath, overwrite: true);
-                var libPtr = LoadLibNative.LoadLib(tempLibPath);
+                var libPtr = LoadLibNative.LoadLibrary(tempLibPath, out var _);
                 LoadLibNative.CloseLibrary(libPtr);
             }
             finally
@@ -435,7 +435,7 @@ public void NativeLibResolveWithExtraSearchPaths()
                 Assert.AreEqual(tempLibPath, resolvedPath, "Library should be resolved from ExtraNativeLibSearchPaths");
 
                 // Actually load the library to prove it works
-                var libPtr = LoadLibNative.LoadLib(resolvedPath);
+                var libPtr = LoadLibNative.LoadLibrary(resolvedPath, out var _);
                 Assert.AreNotEqual(IntPtr.Zero, libPtr, "Library should load successfully");
                 LoadLibNative.CloseLibrary(libPtr);
             }
@@ -454,9 +454,8 @@ public void NativeLibLoadFailure()
         {
             var exception = Assert.ThrowsException<Exception>(() =>
             {
-                LoadLibNative.LoadLib("invalid_lib_test_123456");
+                LoadLibNative.LoadLibrary("invalid_lib_test_123456", out var _);
             });
-            StringAssert.Contains(exception.Message, "loading failed");
         }
 
         [TestMethod]
@@ -467,19 +466,22 @@ public void NativeLibCloseFailure()
             {
                 LoadLibNative.CloseLibrary(new IntPtr(int.MaxValue));
             });
-            StringAssert.Contains(exception.Message, "closing failed");
         }
 
         [TestMethod]
         public void NativeLibSymbolLoadFailure()
         {
             var libPath = LibPathResolver.Resolve(Secp256k1.LIB);
-            var libPtr = LoadLibNative.LoadLib(libPath);
-            var exception = Assert.ThrowsException<Exception>(() =>
+            var libPtr = LoadLibNative.LoadLibrary(libPath, out var _);
+            try
             {
-                LoadLibNative.GetDelegate<Action>(libPtr, "invalid_symbol_name_test_123456");
-            });
-            StringAssert.Contains(exception.Message, "symbol failed");
+                LoadLibNative.GetSymbolPointer(libPtr, "invalid_symbol_name_test_123456");
+                Assert.Fail("Expected an exception");
+            }
+            catch (Exception ex) when (ex is not AssertFailedException)
+            {
+                // success - any exception was thrown
+            }
         }
 
         [TestMethod]

Secp256k1.Net.Test/Tests.cs

@@ -5,6 +5,8 @@ namespace Secp256k1Net.DynamicLinking
 {
     static class DynamicLinkingMacOS
     {
+        public const int RTLD_NOW = 2;
+
         const string LIBDL = "libdl";
 
         [DllImport(LIBDL)]

Secp256k1.Net/DynamicLinking/DynamicLinkingMacOS.cs

@@ -9,12 +9,61 @@ namespace Secp256k1Net
 {
     internal static class LoadLibNative
     {
+
+#if NET8_0_OR_GREATER
+        /// <summary>
+        /// Loads the native library using modern .NET NativeLibrary APIs.
+        /// Tries standard resolution first, then falls back to LibPathResolver.
+        /// </summary>
+        /// <param name="libName">The library name (e.g., "secp256k1").</param>
+        /// <param name="libPath">Output parameter that receives the resolved library path.</param>
+        /// <returns>The handle to the loaded library.</returns>
+        public static IntPtr LoadLibrary(string libName, out string libPath)
+        {
+            var assembly = typeof(Secp256k1).Assembly;
+            // Try standard resolution first (works for RID-specific builds and NativeAOT)
+            if (NativeLibrary.TryLoad(libName, assembly,
+                DllImportSearchPath.AssemblyDirectory | DllImportSearchPath.ApplicationDirectory,
+                out var handle))
+            {
+                libPath = libName;
+                return handle;
+            }
+
+            // Also try with lib prefix for Unix
+            var libPrefixedName = "lib" + libName;
+            if (NativeLibrary.TryLoad(libPrefixedName, assembly,
+                DllImportSearchPath.AssemblyDirectory | DllImportSearchPath.ApplicationDirectory,
+                out handle))
+            {
+                libPath = libPrefixedName;
+                return handle;
+            }
+
+            // Fallback: use LibPathResolver for comprehensive path probing
+            libPath = LibPathResolver.Resolve(libName);
+            return NativeLibrary.Load(libPath);
+        }
+
+        public static void CloseLibrary(IntPtr lib)
+        {
+            NativeLibrary.Free(lib);
+        }
+
+        public static IntPtr GetSymbolPointer(IntPtr libPtr, string symbolName)
+        {
+            return NativeLibrary.GetExport(libPtr, symbolName);
+        }
+
+#else
+
         static readonly bool IsWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
         static readonly bool IsMacOS = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
         static readonly bool IsLinux = RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
 
-        public static IntPtr LoadLib(string libPath)
+        public static IntPtr LoadLibrary(string libName, out string libPath)
         {
+            libPath = LibPathResolver.Resolve(libName);
             IntPtr libPtr;
 
             if (IsWindows)
@@ -27,8 +76,7 @@ public static IntPtr LoadLib(string libPath)
             }
             else if (IsMacOS)
             {
-                const int RTLD_NOW = 2;
-                libPtr = DynamicLinkingMacOS.dlopen(libPath, RTLD_NOW);
+                libPtr = DynamicLinkingMacOS.dlopen(libPath, DynamicLinkingMacOS.RTLD_NOW);
             }
             else
             {
@@ -143,5 +191,6 @@ public static TDelegate GetDelegate<TDelegate>(IntPtr libPtr, string symbolName,
             var functionPtr = pointerDereferenceFunc.Invoke(ptr);
             return Marshal.GetDelegateForFunctionPointer<TDelegate>(functionPtr);
         }
+#endif
     }
 }