@novastera-oss/nitro-metamask 0.3.2 → 0.4.1

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

@@ -4,6 +4,18 @@ import Foundation
 
 final class HybridNitroMetamask: HybridNitroMetamaskSpec {
   private let sdk = MetaMaskSDK.shared
+  
+  // Configurable dapp URL - stored for consistency with Android
+  // iOS SDK handles deep linking automatically via Info.plist
+  private var dappUrl: String? = nil
+  
+  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")
+  }
 
   func connect() -> Promise<ConnectResult> {
     // Use Promise.async with Swift async/await for best practice in Nitro modules
@@ -42,7 +54,7 @@ final class HybridNitroMetamask: HybridNitroMetamaskSpec {
         
         return ConnectResult(
           address: address,
-          chainId: Double(chainIdInt)
+          chainId: Int64(chainIdInt)
         )
         
       case .failure(let error):
@@ -93,4 +105,98 @@ final class HybridNitroMetamask: HybridNitroMetamaskSpec {
       }
     }
   }
+
+  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: connectAndSign(message:) convenience method
+    // Reference: https://github.com/MetaMask/metamask-ios-sdk
+    return Promise.async {
+      // 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
+      ]
+      
+      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: "Failed to retrieve address after connectSign"]
+          )
+        }
+        
+        guard let chainIdHex = self.sdk.chainId, !chainIdHex.isEmpty else {
+          throw NSError(
+            domain: "MetamaskConnector",
+            code: -1,
+            userInfo: [NSLocalizedDescriptionKey: "Failed to retrieve chainId after connectSign"]
+          )
+        }
+        
+        // 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 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,13 +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 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 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, deepLinkScheme?: string): void;
     connect(): Promise<ConnectResult>;
     signMessage(message: string): 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,OAAO,IAAI,OAAO,CAAC,aAAa,CAAC,CAAA;IACjC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CAC9C"}
+{"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,22 @@
 
 // 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 {
 
@@ -48,6 +58,10 @@ namespace margelo::nitro::nitrometamask {
   
 
   // Methods
+  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");
     auto __result = method(_javaPart);
@@ -80,5 +94,53 @@ namespace margelo::nitro::nitrometamask {
       return __promise;
     }();
   }
+  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<ConnectSignResult>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        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);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
 
 } // namespace margelo::nitro::nitrometamask

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

@@ -54,8 +54,12 @@ namespace margelo::nitro::nitrometamask {
 
   public:
     // Methods
+    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<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

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

@@ -0,0 +1,69 @@
+///
+/// JVariant_NullType_Long.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 <variant>
+
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <NitroModules/JNull.hpp>
+
+namespace margelo::nitro::nitrometamask {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_Long".
+   */
+  class JVariant_NullType_Long: public jni::JavaClass<JVariant_NullType_Long> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrometamask/Variant_NullType_Long;";
+
+    static jni::local_ref<JVariant_NullType_Long> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Long(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_Long> create_1(int64_t value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Long(int64_t)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_Long> fromCpp(const std::variant<nitro::NullType, int64_t>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        case 1: return create_1(std::get<1>(variant));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<nitro::NullType, int64_t> toCpp() const;
+  };
+
+  namespace JVariant_NullType_Long_impl {
+    class First final: public jni::JavaClass<First, JVariant_NullType_Long> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrometamask/Variant_NullType_Long$First;";
+    
+      [[nodiscard]] jni::local_ref<JNull> getValue() const {
+        static const auto field = javaClassStatic()->getField<JNull>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second final: public jni::JavaClass<Second, JVariant_NullType_Long> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrometamask/Variant_NullType_Long$Second;";
+    
+      [[nodiscard]] int64_t getValue() const {
+        static const auto field = javaClassStatic()->getField<int64_t>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_Long_impl
+} // namespace margelo::nitro::nitrometamask

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

@@ -0,0 +1,26 @@
+///
+/// JVariant_NullType_String.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_String.hpp"
+
+namespace margelo::nitro::nitrometamask {
+  /**
+   * Converts JVariant_NullType_String to std::variant<nitro::NullType, std::string>
+   */
+  std::variant<nitro::NullType, std::string> JVariant_NullType_String::toCpp() const {
+    if (isInstanceOf(JVariant_NullType_String_impl::First::javaClassStatic())) {
+      // It's a `nitro::NullType`
+      auto jniValue = static_cast<const JVariant_NullType_String_impl::First*>(this)->getValue();
+      return nitro::null;
+    } else if (isInstanceOf(JVariant_NullType_String_impl::Second::javaClassStatic())) {
+      // It's a `std::string`
+      auto jniValue = static_cast<const JVariant_NullType_String_impl::Second*>(this)->getValue();
+      return jniValue->toStdString();
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::nitrometamask