Add integration tests for BOLT12 and pathfinding APIs

Author: BitcoinZavior

example/integration_test/new_apis_test.dart

@@ -117,6 +117,161 @@ void main() {
       debugPrint("Custom preimage API test completed successfully!");
       await aliceNode.stop();
     });
+
+    testWidgets('bolt12_route_parameters_api_test', (WidgetTester tester) async {
+      await ensureFrbInitialized();
+
+      debugPrint("Testing RouteParametersConfig and BOLT12 API availability...");
+
+      // Test RouteParametersConfig creation
+      final routeParams = ldk.RouteParametersConfig(
+        maxTotalCltvExpiryDelta: 1008,
+        maxPathCount: 3,
+        maxChannelSaturationPowerOfHalf: 2,
+      );
+      debugPrint("RouteParametersConfig created: maxPathCount=${routeParams.maxPathCount}");
+      expect(routeParams.maxTotalCltvExpiryDelta, equals(1008));
+      expect(routeParams.maxPathCount, equals(3));
+      expect(routeParams.maxChannelSaturationPowerOfHalf, equals(2));
+
+      // Create a node to verify bolt12Payment() API exists
+      final config = await initLdkConfig(
+          'bolt12_api', const ldk.SocketAddress.hostname(addr: "0.0.0.0", port: 3019));
+      final nodeBuilder = ldk.Builder.fromConfig(config: config)
+          .setEntropyBip39Mnemonic(
+              mnemonic: ldk.Mnemonic(
+                  seedPhrase:
+                      "replace force spring cruise nothing select glass erupt medal raise consider pull"))
+          .setChainSourceEsplora(
+              esploraServerUrl: esploraUrl, syncConfig: esploraConfig);
+      final node = await nodeBuilder.build();
+      await node.start();
+      
+      // Sync wallets
+      debugPrint("Syncing wallets...");
+      await node.syncWallets();
+      debugPrint("Sync complete");
+
+      // Verify the bolt12Payment handler exists
+      final bolt12Handler = await node.bolt12Payment();
+      debugPrint("Bolt12Payment handler obtained successfully");
+
+      // Test creating a BOLT12 offer
+      // BOLT12 offer creation requires the node to have announced itself to the network
+      // For a fresh node without channels, this may fail
+      try {
+        final offer = await bolt12Handler.receive(
+          amountMsat: BigInt.from(500000),
+          description: "Test BOLT12 offer",
+        );
+        debugPrint("BOLT12 offer created successfully: ${offer.s}");
+        expect(offer.s.isNotEmpty, true);
+      } catch (e) {
+        // OfferCreationFailed is expected for a node without any channels or network presence
+        debugPrint("bolt12Payment.receive() - expected for fresh node without channels: $e");
+        
+        // Still verify the receiveVariableAmountUnsafe API exists
+        debugPrint("Verifying receiveVariableAmountUnsafe API exists...");
+        try {
+          await bolt12Handler.receiveVariableAmountUnsafe(description: "Variable amount test");
+        } catch (e2) {
+          debugPrint("receiveVariableAmountUnsafe API verified (same expected error): $e2");
+        }
+      }
+
+      debugPrint("BOLT12 RouteParametersConfig API test completed successfully!");
+      await node.stop();
+    });
+
+    testWidgets('pathfinding_scores_test', (WidgetTester tester) async {
+      await ensureFrbInitialized();
+
+      final config = await initLdkConfig(
+          'pathfinding', const ldk.SocketAddress.hostname(addr: "0.0.0.0", port: 3011));
+      debugPrint("Creating node for pathfinding scores test...");
+      final nodeBuilder = ldk.Builder.fromConfig(config: config)
+          .setEntropyBip39Mnemonic(
+              mnemonic: ldk.Mnemonic(
+                  seedPhrase:
+                      "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"))
+          .setChainSourceEsplora(
+              esploraServerUrl: esploraUrl, syncConfig: esploraConfig);
+      final node = await nodeBuilder.build();
+      await node.start();
+      
+      // Sync wallets to initialize persistence
+      debugPrint("Syncing wallets...");
+      await node.syncWallets();
+      debugPrint("Sync complete");
+
+      debugPrint("Testing pathfinding scores API...");
+
+      // Test exporting pathfinding scores
+      debugPrint("Testing exportPathfindingScores()...");
+      try {
+        final scores = await node.exportPathfindingScores();
+        debugPrint("Exported pathfinding scores: ${scores.length} bytes");
+        expect(scores, isNotNull);
+        // For a fresh node with no routing data, the scores might be empty or minimal
+        debugPrint("Pathfinding scores export successful!");
+      } catch (e) {
+        // persistenceFailed can happen on a fresh node with no routing data
+        debugPrint("exportPathfindingScores() returned error (expected for fresh node): $e");
+      }
+
+      await node.stop();
+      debugPrint("Pathfinding scores test completed!");
+    });
+
+    testWidgets('bolt12_async_receive_test', (WidgetTester tester) async {
+      await ensureFrbInitialized();
+
+      final config = await initLdkConfig(
+          'async_receive', const ldk.SocketAddress.hostname(addr: "0.0.0.0", port: 3012));
+      debugPrint("Creating node for async receive test...");
+      final nodeBuilder = ldk.Builder.fromConfig(config: config)
+          .setEntropyBip39Mnemonic(
+              mnemonic: ldk.Mnemonic(
+                  seedPhrase:
+                      "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"))
+          .setChainSourceEsplora(
+              esploraServerUrl: esploraUrl, syncConfig: esploraConfig);
+      final node = await nodeBuilder.build();
+      await node.start();
+      
+      // Sync wallets
+      debugPrint("Syncing wallets...");
+      await node.syncWallets();
+      debugPrint("Sync complete");
+
+      debugPrint("Testing BOLT12 receiveAsync API...");
+
+      // receiveAsyncUnsafe is for async payments (BOLT12 static invoices)
+      // This requires setting up paths to a static invoice server first
+      // Without that setup, it's expected to fail with offerCreationFailed
+      final bolt12Handler = await node.bolt12Payment();
+      debugPrint("Bolt12Payment handler obtained successfully");
+      
+      try {
+        final asyncOffer = await bolt12Handler.receiveAsyncUnsafe();
+        debugPrint("Async offer created: ${asyncOffer.s}");
+        expect(asyncOffer.s.isNotEmpty, true);
+      } catch (e) {
+        // Expected: offerCreationFailed because we haven't set up
+        // paths to a static invoice server via setPathsToStaticInvoiceServerUnsafe
+        debugPrint("receiveAsyncUnsafe() - expected error without static invoice server setup: $e");
+        
+        // Verify the setPathsToStaticInvoiceServerUnsafe API exists
+        debugPrint("Verifying setPathsToStaticInvoiceServerUnsafe API exists...");
+        // This would need real BlindedMessagePath objects to work
+        // For now, just verify the method exists on the handler
+        expect(bolt12Handler.setPathsToStaticInvoiceServerUnsafe, isNotNull);
+        debugPrint("setPathsToStaticInvoiceServerUnsafe API verified!");
+      }
+
+      await node.stop();
+      debugPrint("BOLT12 async receive test completed!");
+    });
   });
 }