@novastera-oss/nitro-metamask 0.3.3 → 0.4.2

package/app.plugin.js

@@ -0,0 +1,121 @@
+const { withAppDelegate } = require('@expo/config-plugins');
+
+const withMetamaskAppDelegate = (config) => {
+  return withAppDelegate(config, (config) => {
+    const { modResults } = config;
+    
+    // Check if AppDelegate is Swift
+    if (modResults.language === 'swift') {
+      // Check if the method already exists
+      if (modResults.contents.includes('MetaMaskSDK.shared.handleUrl')) {
+        return config;
+      }
+      
+      // Add import if not present
+      if (!modResults.contents.includes('import MetaMaskSDK')) {
+        // Find the last import statement and add after it
+        const importRegex = /^import\s+.*$/gm;
+        const imports = modResults.contents.match(importRegex);
+        if (imports && imports.length > 0) {
+          const lastImport = imports[imports.length - 1];
+          const lastImportIndex = modResults.contents.lastIndexOf(lastImport);
+          modResults.contents = 
+            modResults.contents.slice(0, lastImportIndex + lastImport.length) +
+            '\nimport MetaMaskSDK' +
+            modResults.contents.slice(lastImportIndex + lastImport.length);
+        } else {
+          // No imports found, add at the top after the first line
+          const firstLineIndex = modResults.contents.indexOf('\n');
+          modResults.contents = 
+            modResults.contents.slice(0, firstLineIndex + 1) +
+            'import MetaMaskSDK\n' +
+            modResults.contents.slice(firstLineIndex + 1);
+        }
+      }
+      
+      // Add the deep link handler method
+      const deepLinkHandler = `
+  // Handle deep links from MetaMask wallet
+  // MetaMask returns to the app via deep link after signing/connecting
+  // Added by @novastera-oss/nitro-metamask config plugin
+  func application(
+    _ app: UIApplication,
+    open url: URL,
+    options: [UIApplication.OpenURLOptionsKey: Any] = [:]
+  ) -> Bool {
+    // Check if this is a MetaMask deep link (host="mmsdk")
+    if let components = URLComponents(url: url, resolvingAgainstBaseURL: true),
+       components.host == "mmsdk" {
+      // Handle MetaMask deep link return
+      MetaMaskSDK.shared.handleUrl(url)
+      return true
+    }
+    
+    // Handle other deep links (e.g., React Native Linking)
+    return false
+  }`;
+      
+      // Insert before the last closing brace of the AppDelegate class
+      // Try to find the closing brace of the class before @end or end of file
+      const classEndPattern = /(\s+)\}(?=\s*(?:@end|$))/;
+      const match = modResults.contents.match(classEndPattern);
+      if (match) {
+        const indent = match[1];
+        const insertIndex = match.index;
+        modResults.contents = 
+          modResults.contents.slice(0, insertIndex) +
+          deepLinkHandler.replace(/^  /gm, indent) +
+          '\n' + indent + '}' +
+          modResults.contents.slice(insertIndex + match[0].length);
+      } else {
+        // Fallback: append before @end
+        modResults.contents = modResults.contents.replace(
+          /^(@end|}$)/m,
+          deepLinkHandler + '\n$1'
+        );
+      }
+    } else if (modResults.language === 'objc') {
+      // Handle Objective-C AppDelegate
+      if (modResults.contents.includes('MetaMaskSDK')) {
+        return config;
+      }
+      
+      // Add import
+      if (!modResults.contents.includes('#import <MetaMaskSDK/MetaMaskSDK.h>')) {
+        const importRegex = /^#import\s+.*$/gm;
+        const imports = modResults.contents.match(importRegex);
+        if (imports && imports.length > 0) {
+          const lastImport = imports[imports.length - 1];
+          const lastImportIndex = modResults.contents.lastIndexOf(lastImport);
+          modResults.contents = 
+            modResults.contents.slice(0, lastImportIndex + lastImport.length) +
+            '\n#import <MetaMaskSDK/MetaMaskSDK.h>' +
+            modResults.contents.slice(lastImportIndex + lastImport.length);
+        }
+      }
+      
+      const objcHandler = `
+- (BOOL)application:(UIApplication *)app openURL:(NSURL *)url options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options {
+  // Check if this is a MetaMask deep link (host="mmsdk")
+  NSURLComponents *components = [NSURLComponents componentsWithURL:url resolvingAgainstBaseURL:YES];
+  if ([components.host isEqualToString:@"mmsdk"]) {
+    // Handle MetaMask deep link return
+    [[MetaMaskSDK sharedInstance] handleUrl:url];
+    return YES;
+  }
+  
+  // Handle other deep links
+  return NO;
+}`;
+      
+      modResults.contents = modResults.contents.replace(
+        /^(@end|}$)/m,
+        objcHandler + '\n$1'
+      );
+    }
+    
+    return config;
+  });
+};
+
+module.exports = withMetamaskAppDelegate;

package/ios/HybridNitroMetamask.swift

@@ -9,9 +9,10 @@ final class HybridNitroMetamask: HybridNitroMetamaskSpec {
   // iOS SDK handles deep linking automatically via Info.plist
   private var dappUrl: String? = nil
   
-  func configure(dappUrl: String?) {
+  func configure(dappUrl: String?, deepLinkScheme: String?) {
     // iOS SDK handles deep linking automatically via Info.plist
     // Store the URL for consistency with Android implementation
+    // deepLinkScheme is ignored on iOS as it's handled automatically
     self.dappUrl = dappUrl
     NSLog("NitroMetamask: configure: Dapp URL set to \(dappUrl ?? "default"). Deep link handled automatically via Info.plist")
   }
@@ -53,7 +54,7 @@ final class HybridNitroMetamask: HybridNitroMetamaskSpec {
         
         return ConnectResult(
           address: address,
-          chainId: Double(chainIdInt)
+          chainId: Int64(chainIdInt)
         )
         
       case .failure(let error):
@@ -105,136 +106,96 @@ final class HybridNitroMetamask: HybridNitroMetamaskSpec {
     }
   }
 
-  func connectSign(nonce: String, exp: Int64) -> Promise<String> {
+  func connectSign(nonce: String, exp: Int64) -> Promise<ConnectSignResult> {
     // Use Promise.async with Swift async/await for best practice in Nitro modules
     // Reference: https://nitro.margelo.com/docs/types/promises
-    // Based on MetaMask iOS SDK: connect and sign in one call
+    // Based on MetaMask iOS SDK: connectAndSign(message:) convenience method
     // Reference: https://github.com/MetaMask/metamask-ios-sdk
     return Promise.async {
-      // First, ensure we're connected
-      var address = self.sdk.account
-      var chainIdHex = self.sdk.chainId
+      // Construct JSON message with only nonce and exp
+      // We don't include address or chainID - just encrypt nonce and exp
+      let messageDict: [String: Any] = [
+        "nonce": nonce,
+        "exp": exp
+      ]
       
-      // If not connected, connect first
-      if address == nil || address?.isEmpty == true || chainIdHex == nil || chainIdHex?.isEmpty == true {
-        let connectResult = try await self.sdk.connect()
-        
-        switch connectResult {
-        case .success:
-          address = self.sdk.account
-          chainIdHex = self.sdk.chainId
-          
-          guard let account = address, !account.isEmpty else {
-            throw NSError(
-              domain: "MetamaskConnector",
-              code: -1,
-              userInfo: [NSLocalizedDescriptionKey: "MetaMask SDK returned no address after connection"]
-            )
-          }
-          
-          guard let chainId = chainIdHex, !chainId.isEmpty,
-                let chainIdInt = Int(chainId.replacingOccurrences(of: "0x", with: ""), radix: 16) else {
-            throw NSError(
-              domain: "MetamaskConnector",
-              code: -1,
-              userInfo: [NSLocalizedDescriptionKey: "Invalid chainId format"]
-            )
-          }
-          
-          // Construct JSON message
-          let messageDict: [String: Any] = [
-            "address": account,
-            "chainID": chainIdInt,
-            "nonce": nonce,
-            "exp": exp
-          ]
-          
-          guard let jsonData = try? JSONSerialization.data(withJSONObject: messageDict),
-                let message = String(data: jsonData, encoding: .utf8) else {
-            throw NSError(
-              domain: "MetamaskConnector",
-              code: -1,
-              userInfo: [NSLocalizedDescriptionKey: "Failed to create JSON message"]
-            )
-          }
-          
-          // Create EthereumRequest for personal_sign
-          let params: [String] = [account, message]
-          let request = EthereumRequest(
-            method: .personalSign,
-            params: params
-          )
-          
-          // Make the request using the SDK's async request method
-          let result = try await self.sdk.request(request)
-          
-          // Extract signature from response
-          if let signature = result as? String {
-            return signature
-          } else if let dict = result as? [String: Any], let sig = dict["signature"] as? String ?? dict["result"] as? String {
-            return sig
-          } else {
-            throw NSError(
-              domain: "MetamaskConnector",
-              code: -1,
-              userInfo: [NSLocalizedDescriptionKey: "Invalid signature response format"]
-            )
-          }
-          
-        case .failure(let error):
-          throw error
-        }
-      } else {
-        // Already connected, construct message and sign
-        guard let account = address, !account.isEmpty,
-              let chainId = chainIdHex, !chainId.isEmpty,
-              let chainIdInt = Int(chainId.replacingOccurrences(of: "0x", with: ""), radix: 16) else {
+      guard let jsonData = try? JSONSerialization.data(withJSONObject: messageDict),
+            let message = String(data: jsonData, encoding: .utf8) else {
+        throw NSError(
+          domain: "MetamaskConnector",
+          code: -1,
+          userInfo: [NSLocalizedDescriptionKey: "Failed to create JSON message"]
+        )
+      }
+      
+      NSLog("NitroMetamask: connectSign: Constructed message with nonce and exp: \(message)")
+      
+      // Use the SDK's connectAndSign convenience method - it will connect if needed and sign the message
+      // This is the recommended approach per MetaMask iOS SDK documentation
+      // Reference: https://github.com/MetaMask/metamask-ios-sdk
+      let connectSignResult = try await self.sdk.connectAndSign(message: message)
+      
+      switch connectSignResult {
+      case .success(let signature):
+        // After connectSign completes, get the address and chainId from the SDK
+        guard let address = self.sdk.account, !address.isEmpty else {
           throw NSError(
             domain: "MetamaskConnector",
             code: -1,
-            userInfo: [NSLocalizedDescriptionKey: "Invalid connection state"]
+            userInfo: [NSLocalizedDescriptionKey: "Failed to retrieve address after connectSign"]
           )
         }
         
-        // Construct JSON message
-        let messageDict: [String: Any] = [
-          "address": account,
-          "chainID": chainIdInt,
-          "nonce": nonce,
-          "exp": Int64(exp)
-        ]
-        
-        guard let jsonData = try? JSONSerialization.data(withJSONObject: messageDict),
-              let message = String(data: jsonData, encoding: .utf8) else {
+        guard let chainIdHex = self.sdk.chainId, !chainIdHex.isEmpty else {
           throw NSError(
             domain: "MetamaskConnector",
             code: -1,
-            userInfo: [NSLocalizedDescriptionKey: "Failed to create JSON message"]
+            userInfo: [NSLocalizedDescriptionKey: "Failed to retrieve chainId after connectSign"]
           )
         }
         
-        // Create EthereumRequest for personal_sign
-        let params: [String] = [account, message]
-        let request = EthereumRequest(
-          method: .personalSign,
-          params: params
-        )
-        
-        // Make the request using the SDK's async request method
-        let result = try await self.sdk.request(request)
-        
-        // Extract signature from response
-        if let signature = result as? String {
-          return signature
-        } else if let dict = result as? [String: Any], let sig = dict["signature"] as? String ?? dict["result"] as? String {
-          return sig
-        } else {
+        // Parse chainId from hex string (e.g., "0x1") to Int64
+        guard let chainId = Int64(chainIdHex.replacingOccurrences(of: "0x", with: ""), radix: 16) else {
           throw NSError(
             domain: "MetamaskConnector",
             code: -1,
-            userInfo: [NSLocalizedDescriptionKey: "Invalid signature response format"]
+            userInfo: [NSLocalizedDescriptionKey: "Invalid chainId format: \(chainIdHex)"]
           )
         }
+        
+        NSLog("NitroMetamask: connectSign: Signature received successfully, address=\(address), chainId=\(chainId)")
+        
+        // Return ConnectSignResult with signature, address, and chainId
+        return ConnectSignResult(signature: signature, address: address, chainId: chainId)
+        
+      case .failure(let error):
+        throw error
+      }
+    }
+  }
+
+  func getAddress() -> Promise<Variant_NullType_String> {
+    return Promise.async {
+      if let account = self.sdk.account, !account.isEmpty {
+        return Variant_NullType_String.second(account)
+      } else {
+        return Variant_NullType_String.first(NullType())
+      }
+    }
+  }
+
+  func getChainId() -> Promise<Variant_NullType_Int64> {
+    return Promise.async {
+      guard let chainIdHex = self.sdk.chainId, !chainIdHex.isEmpty else {
+        return Variant_NullType_Int64.first(NullType())
+      }
+      
+      // Parse chainId from hex string (e.g., "0x1") to Int64 (bigint maps to Int64 in Swift)
+      if let chainIdInt = Int64(chainIdHex.replacingOccurrences(of: "0x", with: ""), radix: 16) {
+        return Variant_NullType_Int64.second(chainIdInt)
+      } else {
+        NSLog("NitroMetamask: Invalid chainId format: \(chainIdHex)")
+        return Variant_NullType_Int64.first(NullType())
       }
     }
   }

package/lib/typescript/src/specs/nitro-metamask.nitro.d.ts

@@ -1,23 +1,48 @@
 import { type HybridObject } from 'react-native-nitro-modules';
 export interface ConnectResult {
     address: string;
-    chainId: number;
+    chainId: bigint;
+}
+export interface ConnectSignResult {
+    signature: string;
+    address: string;
+    chainId: bigint;
 }
 export interface NitroMetamask extends HybridObject<{
     ios: 'swift';
     android: 'kotlin';
 }> {
     /**
-     * Configure the dapp URL for MetaMask SDK validation.
-     * This URL is only used for SDK validation - the deep link return is handled automatically via AndroidManifest.xml.
+     * Configure the dapp URL and deep link scheme for MetaMask SDK.
      *
      * @param dappUrl - A valid HTTP/HTTPS URL (e.g., "https://yourdomain.com").
      *                  If not provided, defaults to "https://novastera.com".
-     *                  This is separate from the deep link scheme which is auto-detected from your manifest.
+     *                  This is used for SDK validation.
+     * @param deepLinkScheme - The deep link scheme from your AndroidManifest.xml (e.g., "nitrometamask").
+     *                         If not provided, the library will attempt to auto-detect it.
+     *                         This is used to return to your app after MetaMask operations.
      */
-    configure(dappUrl?: string): void;
+    configure(dappUrl?: string, deepLinkScheme?: string): void;
     connect(): Promise<ConnectResult>;
     signMessage(message: string): Promise<string>;
-    connectSign(nonce: string, exp: bigint): Promise<string>;
+    /**
+     * Connect to MetaMask (if not already connected) and sign a message containing nonce and expiration.
+     * Returns the signature along with the address and chainId that were used to sign.
+     *
+     * @param nonce - A unique nonce for this signing request
+     * @param exp - Expiration timestamp (as bigint)
+     * @returns Promise resolving to ConnectSignResult containing signature, address, and chainId
+     */
+    connectSign(nonce: string, exp: bigint): Promise<ConnectSignResult>;
+    /**
+     * Get the currently connected wallet address.
+     * Returns null if not connected.
+     */
+    getAddress(): Promise<string | null>;
+    /**
+     * Get the current chain ID.
+     * Returns null if not connected.
+     */
+    getChainId(): Promise<bigint | null>;
 }
 //# sourceMappingURL=nitro-metamask.nitro.d.ts.map

package/lib/typescript/src/specs/nitro-metamask.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nitro-metamask.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/nitro-metamask.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,aAAc,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACtF;;;;;;;OAOG;IACH,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,OAAO,IAAI,OAAO,CAAC,aAAa,CAAC,CAAA;IACjC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAC7C,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CACzD"}
+{"version":3,"file":"nitro-metamask.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/nitro-metamask.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,aAAc,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACtF;;;;;;;;;OASG;IACH,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1D,OAAO,IAAI,OAAO,CAAC,aAAa,CAAC,CAAA;IACjC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAC7C;;;;;;;OAOG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAA;IACnE;;;OAGG;IACH,UAAU,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IACpC;;;OAGG;IACH,UAAU,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;CACrC"}

package/nitrogen/generated/android/NitroMetamask+autolinking.cmake

@@ -36,6 +36,8 @@ target_sources(
   ../nitrogen/generated/shared/c++/HybridNitroMetamaskSpec.cpp
   # Android-specific Nitrogen C++ sources
   ../nitrogen/generated/android/c++/JHybridNitroMetamaskSpec.cpp
+  ../nitrogen/generated/android/c++/JVariant_NullType_String.cpp
+  ../nitrogen/generated/android/c++/JVariant_NullType_Long.cpp
 )
 
 # From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake

package/nitrogen/generated/android/c++/JConnectResult.hpp

@@ -33,8 +33,8 @@ namespace margelo::nitro::nitrometamask {
       static const auto clazz = javaClassStatic();
       static const auto fieldAddress = clazz->getField<jni::JString>("address");
       jni::local_ref<jni::JString> address = this->getFieldValue(fieldAddress);
-      static const auto fieldChainId = clazz->getField<double>("chainId");
-      double chainId = this->getFieldValue(fieldChainId);
+      static const auto fieldChainId = clazz->getField<int64_t>("chainId");
+      int64_t chainId = this->getFieldValue(fieldChainId);
       return ConnectResult(
         address->toStdString(),
         chainId
@@ -47,7 +47,7 @@ namespace margelo::nitro::nitrometamask {
      */
     [[maybe_unused]]
     static jni::local_ref<JConnectResult::javaobject> fromCpp(const ConnectResult& value) {
-      using JSignature = JConnectResult(jni::alias_ref<jni::JString>, double);
+      using JSignature = JConnectResult(jni::alias_ref<jni::JString>, int64_t);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(

package/nitrogen/generated/android/c++/JConnectSignResult.hpp

@@ -0,0 +1,65 @@
+///
+/// JConnectSignResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ConnectSignResult.hpp"
+
+#include <string>
+
+namespace margelo::nitro::nitrometamask {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ConnectSignResult" and the the Kotlin data class "ConnectSignResult".
+   */
+  struct JConnectSignResult final: public jni::JavaClass<JConnectSignResult> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrometamask/ConnectSignResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ConnectSignResult by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ConnectSignResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldSignature = clazz->getField<jni::JString>("signature");
+      jni::local_ref<jni::JString> signature = this->getFieldValue(fieldSignature);
+      static const auto fieldAddress = clazz->getField<jni::JString>("address");
+      jni::local_ref<jni::JString> address = this->getFieldValue(fieldAddress);
+      static const auto fieldChainId = clazz->getField<int64_t>("chainId");
+      int64_t chainId = this->getFieldValue(fieldChainId);
+      return ConnectSignResult(
+        signature->toStdString(),
+        address->toStdString(),
+        chainId
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JConnectSignResult::javaobject> fromCpp(const ConnectSignResult& value) {
+      using JSignature = JConnectSignResult(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, int64_t);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.signature),
+        jni::make_jstring(value.address),
+        value.chainId
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrometamask

package/nitrogen/generated/android/c++/JHybridNitroMetamaskSpec.cpp

@@ -9,12 +9,21 @@
 
 // Forward declaration of `ConnectResult` to properly resolve imports.
 namespace margelo::nitro::nitrometamask { struct ConnectResult; }
+// Forward declaration of `ConnectSignResult` to properly resolve imports.
+namespace margelo::nitro::nitrometamask { struct ConnectSignResult; }
 
 #include "ConnectResult.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
 #include "JConnectResult.hpp"
 #include <string>
+#include "ConnectSignResult.hpp"
+#include "JConnectSignResult.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include "JVariant_NullType_String.hpp"
+#include <NitroModules/JNull.hpp>
+#include "JVariant_NullType_Long.hpp"
 #include <optional>
 
 namespace margelo::nitro::nitrometamask {
@@ -49,9 +58,9 @@ namespace margelo::nitro::nitrometamask {
   
 
   // Methods
-  void JHybridNitroMetamaskSpec::configure(const std::optional<std::string>& dappUrl) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* dappUrl */)>("configure");
-    method(_javaPart, dappUrl.has_value() ? jni::make_jstring(dappUrl.value()) : nullptr);
+  void JHybridNitroMetamaskSpec::configure(const std::optional<std::string>& dappUrl, const std::optional<std::string>& deepLinkScheme) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* dappUrl */, jni::alias_ref<jni::JString> /* deepLinkScheme */)>("configure");
+    method(_javaPart, dappUrl.has_value() ? jni::make_jstring(dappUrl.value()) : nullptr, deepLinkScheme.has_value() ? jni::make_jstring(deepLinkScheme.value()) : nullptr);
   }
   std::shared_ptr<Promise<ConnectResult>> JHybridNitroMetamaskSpec::connect() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("connect");
@@ -85,14 +94,46 @@ namespace margelo::nitro::nitrometamask {
       return __promise;
     }();
   }
-  std::shared_ptr<Promise<std::string>> JHybridNitroMetamaskSpec::connectSign(const std::string& nonce, int64_t exp) {
+  std::shared_ptr<Promise<ConnectSignResult>> JHybridNitroMetamaskSpec::connectSign(const std::string& nonce, int64_t exp) {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* nonce */, int64_t /* exp */)>("connectSign");
     auto __result = method(_javaPart, jni::make_jstring(nonce), exp);
     return [&]() {
-      auto __promise = Promise<std::string>::create();
+      auto __promise = Promise<ConnectSignResult>::create();
       __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
-        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
-        __promise->resolve(__result->toStdString());
+        auto __result = jni::static_ref_cast<JConnectSignResult>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>> JHybridNitroMetamaskSpec::getAddress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getAddress");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::variant<nitro::NullType, std::string>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JVariant_NullType_String>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::variant<nitro::NullType, int64_t>>> JHybridNitroMetamaskSpec::getChainId() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getChainId");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::variant<nitro::NullType, int64_t>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JVariant_NullType_Long>(__boxedResult);
+        __promise->resolve(__result->toCpp());
       });
       __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
         jni::JniException __jniError(__throwable);

package/nitrogen/generated/android/c++/JHybridNitroMetamaskSpec.hpp

@@ -54,10 +54,12 @@ namespace margelo::nitro::nitrometamask {
 
   public:
     // Methods
-    void configure(const std::optional<std::string>& dappUrl) override;
+    void configure(const std::optional<std::string>& dappUrl, const std::optional<std::string>& deepLinkScheme) override;
     std::shared_ptr<Promise<ConnectResult>> connect() override;
     std::shared_ptr<Promise<std::string>> signMessage(const std::string& message) override;
-    std::shared_ptr<Promise<std::string>> connectSign(const std::string& nonce, int64_t exp) override;
+    std::shared_ptr<Promise<ConnectSignResult>> connectSign(const std::string& nonce, int64_t exp) override;
+    std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>> getAddress() override;
+    std::shared_ptr<Promise<std::variant<nitro::NullType, int64_t>>> getChainId() override;
 
   private:
     friend HybridBase;

package/nitrogen/generated/android/c++/JVariant_NullType_Long.cpp

@@ -0,0 +1,26 @@
+///
+/// JVariant_NullType_Long.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JVariant_NullType_Long.hpp"
+
+namespace margelo::nitro::nitrometamask {
+  /**
+   * Converts JVariant_NullType_Long to std::variant<nitro::NullType, int64_t>
+   */
+  std::variant<nitro::NullType, int64_t> JVariant_NullType_Long::toCpp() const {
+    if (isInstanceOf(JVariant_NullType_Long_impl::First::javaClassStatic())) {
+      // It's a `nitro::NullType`
+      auto jniValue = static_cast<const JVariant_NullType_Long_impl::First*>(this)->getValue();
+      return nitro::null;
+    } else if (isInstanceOf(JVariant_NullType_Long_impl::Second::javaClassStatic())) {
+      // It's a `int64_t`
+      auto jniValue = static_cast<const JVariant_NullType_Long_impl::Second*>(this)->getValue();
+      return jniValue;
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::nitrometamask