@solana-mobile/seed-vault-lib 0.1.0 → 0.2.0

package/android/src/main/java/com/solanamobile/seedvault/reactnative/SolanaMobileSeedVaultLibModule.kt

@@ -5,12 +5,13 @@ import android.content.Intent;
 import android.database.ContentObserver
 import android.net.Uri
 import android.os.Bundle
+import android.os.CountDownTimer
 import android.os.Handler
+import android.util.Base64
 import android.util.Log
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.solanamobile.seedvault.*
-import kotlinx.serialization.Serializable
 import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.builtins.serializer
 import kotlinx.serialization.json.Json
@@ -37,12 +38,22 @@ class SolanaMobileSeedVaultLibModule(val reactContext: ReactApplicationContext)
             }
         }
 
+    private var activityResultTimeout: Long? = DEFAULT_ACTIVITY_RESULT_TIMEOUT_MS
+
     init {
         reactContext.addActivityEventListener(mActivityEventListener)
 
         observeSeedVaultContentChanges()
     }
 
+    @ReactMethod
+    fun setActivtyResultTimeout(timeout: Long) {
+        activityResultTimeout = 
+            if (timeout > MINIMUM_ACTIVITY_RESULT_TIMEOUT_MS) timeout 
+            else if (timeout == 0L) null 
+            else MINIMUM_ACTIVITY_RESULT_TIMEOUT_MS
+    }
+
     @ReactMethod
     fun isSeedVaultAvailable(allowSimulated: Boolean = false, promise: Promise) {
         val seedVaultAvailable = SeedVault.isAvailable(reactContext, allowSimulated)
@@ -122,24 +133,87 @@ class SolanaMobileSeedVaultLibModule(val reactContext: ReactApplicationContext)
     }
 
     @ReactMethod
-    fun authorizeNewSeed() {
+    fun requestAuthorizeNewSeed() {
+        Log.d(TAG, "Requesting authorization for a new seed...")
+        val intent = Wallet.authorizeSeed(WalletContractV1.PURPOSE_SIGN_SOLANA_TRANSACTION)
+        reactContext.currentActivity?.startActivityForResult(intent, REQUEST_AUTHORIZE_SEED_ACCESS)
+    }
+
+    @ReactMethod
+    fun authorizeNewSeed(promise: Promise) {
         Log.d(TAG, "Requesting authorization for a new seed...")
         val intent = Wallet.authorizeSeed(WalletContractV1.PURPOSE_SIGN_SOLANA_TRANSACTION)
-        reactContext.currentActivity?.startActivityForResult(intent, REQUEST_AUTHORIZE_SEED_ACCESS);
+        registerForActivityResult(intent, REQUEST_AUTHORIZE_SEED_ACCESS) { resultCode, data -> 
+            try {
+                val authToken = Wallet.onAuthorizeSeedResult(resultCode, data)
+                Log.d(TAG, "Seed authorized, AuthToken=$authToken")
+                
+                promise.resolve(
+                    Arguments.createMap().apply {
+                        putString("authToken", authToken.toString())
+                    }
+                )
+            } catch (e: Wallet.ActionFailedException) {
+                Log.e(TAG, "Seed authorization failed", e)
+                promise.reject(e)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun requestCreateNewSeed() {
+        Log.d(TAG, "Requesting creation of a new seed...")
+        val intent = Wallet.createSeed(WalletContractV1.PURPOSE_SIGN_SOLANA_TRANSACTION)
+        reactContext.currentActivity?.startActivityForResult(intent, REQUEST_CREATE_NEW_SEED)
     }
 
     @ReactMethod
-    fun createNewSeed() {
+    fun createNewSeed(promise: Promise) {
         Log.d(TAG, "Requesting creation of a new seed...")
         val intent = Wallet.createSeed(WalletContractV1.PURPOSE_SIGN_SOLANA_TRANSACTION)
-        reactContext.currentActivity?.startActivityForResult(intent, REQUEST_CREATE_NEW_SEED);
+        registerForActivityResult(intent, REQUEST_CREATE_NEW_SEED) { resultCode, data -> 
+            try {
+                val authToken = Wallet.onCreateSeedResult(resultCode, data)
+                Log.d(TAG, "Seed created, AuthToken=$authToken")
+                
+                promise.resolve(
+                    Arguments.createMap().apply {
+                        putString("authToken", authToken.toString())
+                    }
+                )
+            } catch (e: Wallet.ActionFailedException) {
+                Log.e(TAG, "Seed creation failed", e)
+                promise.reject(e)
+            }
+        }
     }
 
     @ReactMethod
-    fun importExistingSeed() {
+    fun requestImportExistingSeed() {
         Log.d(TAG, "Requesting import of an existing seed...")
         val intent = Wallet.importSeed(WalletContractV1.PURPOSE_SIGN_SOLANA_TRANSACTION)
-        reactContext.currentActivity?.startActivityForResult(intent, REQUEST_IMPORT_EXISTING_SEED);
+        reactContext.currentActivity?.startActivityForResult(intent, REQUEST_IMPORT_EXISTING_SEED)
+    }
+
+    @ReactMethod
+    fun importExistingSeed(promise: Promise) {
+        Log.d(TAG, "Requesting import of an existing seed...")
+        val intent = Wallet.importSeed(WalletContractV1.PURPOSE_SIGN_SOLANA_TRANSACTION)
+        registerForActivityResult(intent, REQUEST_IMPORT_EXISTING_SEED) { resultCode, data -> 
+            try {
+                val authToken = Wallet.onImportSeedResult(resultCode, data)
+                Log.d(TAG, "Seed imported, AuthToken=$authToken")
+                
+                promise.resolve(
+                    Arguments.createMap().apply {
+                        putString("authToken", authToken.toString())
+                    }
+                )
+            } catch (e: Wallet.ActionFailedException) {
+                Log.e(TAG, "Seed import failed", e)
+                promise.reject(e)
+            }
+        }
     }
 
     @ReactMethod
@@ -155,37 +229,146 @@ class SolanaMobileSeedVaultLibModule(val reactContext: ReactApplicationContext)
     }
 
     @ReactMethod
-    fun signMessage(authToken: String, derivationPath: String, message: ReadableArray) {
-        signMessages(authToken, listOf(SigningRequest(message.toByteArray(), arrayListOf(Uri.parse(derivationPath)))))
+    fun requestSignMessage(authToken: String, derivationPath: String, message: ReadableArray) {
+        requestSignMessages(authToken, listOf(SigningRequest(message.toByteArray(), arrayListOf(Uri.parse(derivationPath)))))
     }
 
     @ReactMethod
-    fun signMessages(authToken: String, signingRequestsJson: String) {
+    fun requestSignMessages(authToken: String, signingRequestsJson: String) {
         val signingRequests: List<SigningRequest> = json.decodeFromString(ListSerializer(SigningRequestSerializer), signingRequestsJson)
-        signMessages(authToken, signingRequests)
+        requestSignMessages(authToken, signingRequests)
     }
 
-    private fun signMessages(authToken: String, signingRequests: List<SigningRequest>) {
+    private fun requestSignMessages(authToken: String, signingRequests: List<SigningRequest>) {
         Log.d(TAG, "Requesting provided messages to be signed...")
         val intent = Wallet.signMessages(authToken.toLong(), ArrayList(signingRequests))
         reactContext.currentActivity?.startActivityForResult(intent, REQUEST_SIGN_MESSAGES);
     }
 
     @ReactMethod
-    fun signTransaction(authToken: String, derivationPath: String, transaction: ReadableArray) {
-        signTransactions(authToken, listOf(SigningRequest(transaction.toByteArray(), arrayListOf(Uri.parse(derivationPath)))))
+    fun signMessage(authToken: String, derivationPath: String, message: String, promise: Promise) {
+        val messageBytes = Base64.decode(message, Base64.DEFAULT);
+        signMessagesAsync(authToken, listOf(SigningRequest(messageBytes, arrayListOf(Uri.parse(derivationPath))))) { result, error ->
+            result?.let { promise.resolve(Arguments.makeNativeMap(Arguments.toBundle(result.getMap(0)))) } 
+            ?: promise.reject(error ?: Error("An unkown error occurred"))
+        }
     }
 
     @ReactMethod
-    fun signTransactions(authToken: String, signingRequestsJson: String) {
+    fun signMessages(authToken: String, signingRequests: ReadableArray, promise: Promise) {
+        val signingRequests: List<SigningRequest> = json.decodeFromJsonElement(ListSerializer(SigningRequestSerializer), signingRequests.toJson())
+        signMessagesAsync(authToken, signingRequests) { result, error ->
+            result?.let { promise.resolve(result) } ?: promise.reject(error ?: Error("An unkown error occurred"))
+        }
+    }
+
+    private fun signMessagesAsync(authToken: String, signingRequests: List<SigningRequest>, callback: (result: ReadableArray?, error: Throwable?) -> Unit) {
+        Log.d(TAG, "Requesting provided messages to be signed...")
+        val intent = Wallet.signMessages(authToken.toLong(), ArrayList(signingRequests))
+        registerForActivityResult(intent, REQUEST_SIGN_MESSAGES) { resultCode, data ->
+            try {
+                val result = Wallet.onSignMessagesResult(resultCode, data)
+                Log.d(TAG, "Message signed: signatures=$result")
+
+                callback(
+                    Arguments.makeNativeArray(result.map { response ->
+                        Arguments.createMap().apply {
+                            putArray("signatures", Arguments.makeNativeArray(response.signatures.map { Base64.encodeToString(it, Base64.NO_WRAP) }))
+                            putArray("resolvedDerivationPaths", Arguments.makeNativeArray(response.resolvedDerivationPaths.map { it.toString() }))
+                        }
+                    }), null
+                )
+            } catch (e: Wallet.ActionFailedException) {
+                Log.e(TAG, "Message signing failed", e)
+                callback(null, e)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun requestSignTransaction(authToken: String, derivationPath: String, transaction: ReadableArray) {
+        requestSignTransactions(authToken, listOf(SigningRequest(transaction.toByteArray(), arrayListOf(Uri.parse(derivationPath)))))
+    }
+
+    @ReactMethod
+    fun requestSignTransactions(authToken: String, signingRequestsJson: String) {
         val signingRequests: List<SigningRequest> = json.decodeFromString(ListSerializer(SigningRequestSerializer), signingRequestsJson)
-        signTransactions(authToken, signingRequests)
+        requestSignTransactions(authToken, signingRequests)
+    }
+
+    private fun requestSignTransactions(authToken: String, signingRequests: List<SigningRequest>) {
+        Log.d(TAG, "Requesting provided transactions to be signed...")
+        val intent = Wallet.signTransactions(authToken.toLong(), ArrayList(signingRequests))
+        reactContext.currentActivity?.startActivityForResult(intent, REQUEST_SIGN_TRANSACTIONS)
+    }
+
+    @ReactMethod
+    fun signTransaction(authToken: String, derivationPath: String, transaction: String, promise: Promise) {
+        val txBytes = Base64.decode(transaction, Base64.DEFAULT);
+        signTransactionsAsync(authToken, listOf(SigningRequest(txBytes, arrayListOf(Uri.parse(derivationPath))))) { result, error ->
+            result?.let { promise.resolve(Arguments.makeNativeMap(Arguments.toBundle(result.getMap(0)))) } 
+            ?: promise.reject(error ?: Error("An unkown error occurred"))
+        }
+    }
+
+    @ReactMethod
+    fun signTransactions(authToken: String, signingRequests: ReadableArray, promise: Promise) {
+        val signingRequests: List<SigningRequest> = json.decodeFromJsonElement(ListSerializer(SigningRequestSerializer), signingRequests.toJson())
+        signTransactionsAsync(authToken, signingRequests) { result, error ->
+            result?.let { promise.resolve(result) } ?: promise.reject(error ?: Error("An unkown error occurred"))
+        }
     }
 
-    private fun signTransactions(authToken: String, signingRequests: List<SigningRequest>) {
+    private fun signTransactionsAsync(authToken: String, signingRequests: List<SigningRequest>, callback: (result: ReadableArray?, error: Throwable?) -> Unit) {
         Log.d(TAG, "Requesting provided transactions to be signed...")
         val intent = Wallet.signTransactions(authToken.toLong(), ArrayList(signingRequests))
-        reactContext.currentActivity?.startActivityForResult(intent, REQUEST_SIGN_TRANSACTIONS);
+        registerForActivityResult(intent, REQUEST_SIGN_TRANSACTIONS) { resultCode, data ->
+            try {
+                val result = Wallet.onSignTransactionsResult(resultCode, data)
+                Log.d(TAG, "Transactions signed: signatures=$result")
+
+                callback(
+                    Arguments.makeNativeArray(result.map { response ->
+                        Arguments.createMap().apply {
+                            putArray("signatures", Arguments.makeNativeArray(response.signatures.map { Base64.encodeToString(it, Base64.NO_WRAP) }))
+                            putArray("resolvedDerivationPaths", Arguments.makeNativeArray(response.resolvedDerivationPaths.map { it.toString() }))
+                        }
+                    }), null
+                )
+            } catch (e: Wallet.ActionFailedException) {
+                Log.e(TAG, "Transaction signing failed", e)
+                callback(null, e)
+            }
+        }
+    }
+
+    private fun registerForActivityResult(intent: Intent, requestCode: Int, callback: (resultCode: Int, data: Intent?) -> Unit) {
+        val timeout = activityResultTimeout?.let { timeout ->
+            object : CountDownTimer(timeout, timeout) {
+                override fun onTick(millisUntilFinished: Long) {}
+                override fun onFinish() {
+                    reactContext.currentActivity?.finishActivity(requestCode)
+                }
+            }
+        }
+
+        reactContext.addActivityEventListener(object : BaseActivityEventListener() {
+            override fun onActivityResult(
+                activity: Activity?,
+                receivedRequestCode: Int,
+                resultCode: Int,
+                data: Intent?
+            ) {
+                if (receivedRequestCode == requestCode) {
+                    reactContext.removeActivityEventListener(this)
+                    callback(resultCode, data)
+                    timeout?.cancel()
+                }
+            }
+        })
+        
+        reactContext.currentActivity?.startActivityForResult(intent, requestCode)
+        timeout?.start()
     }
 
     @ReactMethod
@@ -204,6 +387,49 @@ class SolanaMobileSeedVaultLibModule(val reactContext: ReactApplicationContext)
         reactContext.currentActivity?.startActivityForResult(intent, REQUEST_GET_PUBLIC_KEYS);
     }
 
+    @ReactMethod
+    fun getPublicKey(authToken: String, derivationPath: String, promise: Promise) {
+        getPublicKeysAsync(authToken, Arguments.createArray().apply {
+            pushString(derivationPath)
+        }) { result, error ->
+            result?.let { promise.resolve(Arguments.makeNativeMap(Arguments.toBundle(result.getMap(0)))) } 
+            ?: promise.reject(error ?: Error("An unkown error occurred"))
+        }
+    }
+
+    @ReactMethod
+    fun getPublicKeys(authToken: String, derivationPaths: ReadableArray, promise: Promise) {
+        getPublicKeysAsync(authToken, derivationPaths) { result, error ->
+            result?.let { promise.resolve(result) } ?: promise.reject(error ?: Error("An unkown error occurred"))
+        }
+    }
+
+    private fun getPublicKeysAsync(authToken: String, derivationPaths: ReadableArray, callback: (result: ReadableArray?, error: Throwable?) -> Unit) {
+        Log.d(TAG, "Requesting public keys for provided derviation paths...")
+        val intent = Wallet.requestPublicKeys(authToken.toLong(), Arguments.toList(derivationPaths)?.mapNotNull {
+            (it as? String)?.let { uriString -> Uri.parse(uriString) }
+        } as ArrayList ?: arrayListOf())
+        registerForActivityResult(intent, REQUEST_GET_PUBLIC_KEYS) { resultCode, data ->
+            try {
+                val result = Wallet.onRequestPublicKeysResult(resultCode, data)
+                Log.d(TAG, "Public key retrieved: publicKey=$result")
+
+                callback(
+                    Arguments.makeNativeArray(result.map { response ->
+                        Arguments.createMap().apply {
+                            putArray("publicKey", response.publicKey.toWritableArray())
+                            putString("publicKeyEncoded", response.publicKeyEncoded)
+                            putString("resolvedDerviationPath", response.resolvedDerivationPath.toString())
+                        }
+                    }), null
+                )
+            } catch (e: Wallet.ActionFailedException) {
+                Log.e(TAG, "Public Key retrieval failed", e)
+                callback(null, e)
+            }
+        }
+    }
+
     private fun sendEvent(reactContext: ReactContext, eventName: String, params: WritableMap? = null) {
         reactContext
             .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
@@ -313,80 +539,7 @@ class SolanaMobileSeedVaultLibModule(val reactContext: ReactApplicationContext)
         private const val REQUEST_SIGN_MESSAGES = 4
         private const val REQUEST_GET_PUBLIC_KEYS = 5
         private const val KEY_PENDING_EVENT = "pendingEvent"
+        private const val DEFAULT_ACTIVITY_RESULT_TIMEOUT_MS = 300000L
+        private const val MINIMUM_ACTIVITY_RESULT_TIMEOUT_MS = 30000L
     }
-}
-
-interface RNWritable {
-    fun toWritableMap(): WritableMap
-}
-
-data class Account(
-    @WalletContractV1.AccountId val id: Long,
-    val name: String,
-    val derivationPath: Uri,
-    val publicKeyEncoded: String
-) : RNWritable {
-    override fun toWritableMap() = Arguments.createMap().apply {
-        putString("id", "$id")
-        putString("name", name)
-        putString("derivationPath", "$derivationPath")
-        putString("publicKeyEncoded", publicKeyEncoded)
-    }
-}
-
-data class Seed(
-    @WalletContractV1.AuthToken val authToken: Long,
-    val name: String,
-    @WalletContractV1.Purpose val purpose: Int,
-    // val accounts: List<Account> = listOf()
-) : RNWritable {
-    override fun toWritableMap() = Arguments.createMap().apply {
-        putString("authToken", "$authToken")
-        putString("name", name)
-        putInt("purpose", purpose)
-    }
-}
-
-fun List<RNWritable>.toWritableArray() = Arguments.createArray().apply {
-    forEach { writable ->
-        pushMap(writable.toWritableMap())
-    }
-}
-
-@Serializable
-sealed interface SeedVaultEvent {
-    sealed class SeedEvent(val authToken: Long) : SeedVaultEvent
-    class SeedAuthorized(authToken: Long) : SeedEvent(authToken)
-    class NewSeedCreated(authToken: Long) : SeedEvent(authToken)
-    class ExistingSeedImported(authToken: Long) : SeedEvent(authToken)
-
-    data class PayloadsSigned(val result: List<SigningResponse>) : SeedVaultEvent
-
-    data class PublicKeysEvent(val result: List<PublicKeyResponse>) : SeedVaultEvent
-}
-
-internal fun SeedVaultEvent.toWritableMap() : WritableMap = Arguments.createMap().apply {
-    putString("__type", this@toWritableMap::class.simpleName)
-    when (this@toWritableMap) {
-        is SeedVaultEvent.SeedEvent -> {
-            putString("authToken", authToken.toString())
-        }
-        is SeedVaultEvent.PayloadsSigned -> {
-            putArray("result", Arguments.makeNativeArray(result.map { response ->
-                Arguments.createMap().apply {
-                    putArray("signatures", Arguments.makeNativeArray(response.signatures.map { it.toWritableArray() }))
-                    putArray("resolvedDerivationPaths", Arguments.makeNativeArray(response.resolvedDerivationPaths.map { it.toString() }))
-                }
-            }))
-        }
-        is SeedVaultEvent.PublicKeysEvent -> {
-            putArray("result", Arguments.makeNativeArray(result.map { response ->
-                Arguments.createMap().apply {
-                    putArray("publicKey", response.publicKey.toWritableArray())
-                    putString("publicKeyEncoded", response.publicKeyEncoded)
-                    putString("resolvedDerviationPath", response.resolvedDerivationPath.toString())
-                }
-            }))
-        }
-    }
-}
+}

package/lib/esm/index.js

@@ -0,0 +1,111 @@
+import { useRef, useEffect } from 'react';
+import { Platform, NativeModules, PermissionsAndroid, NativeEventEmitter } from 'react-native';
+
+// EVENTS
+// Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
+const SeedVaultEventType = {
+    AuthorizeSeedAccess: "SeedAuthorized",
+    CreateNewSeed: "NewSeedCreated",
+    ImportExistingSeed: "ExistingSeedImported",
+    PayloadsSigned: "PayloadsSigned",
+    GetPublicKeys: "PublicKeysEvent",
+    ContentChange: "SeedVaultContentChange"
+};
+
+const SeedPurpose = {
+    SignSolanaTransaction: 0,
+};
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+const LINKING_ERROR = `The package 'solana-mobile-seed-vault-lib' doesn't seem to be linked. Make sure: \n\n` +
+    '- You rebuilt the app after installing the package\n' +
+    '- If you are using Lerna workspaces\n' +
+    '  - You have added `@solana-mobile/seed-vault-lib` as an explicit dependency, and\n' +
+    '  - You have added `@solana-mobile/seed-vault-lib` to the `nohoist` section of your package.json\n' +
+    '- You are not using Expo managed workflow\n';
+const SolanaMobileSeedVaultLib = Platform.OS === 'android' && NativeModules.SolanaMobileSeedVaultLib
+    ? NativeModules.SolanaMobileSeedVaultLib
+    : new Proxy({}, {
+        get() {
+            throw new Error(Platform.OS !== 'android'
+                ? 'The package `solana-mobile-seed-vault-lib` is only compatible with React Native Android'
+                : LINKING_ERROR);
+        },
+    });
+const SeedVaultPermissionAndroid = 'com.solanamobile.seedvault.ACCESS_SEED_VAULT';
+const checkSeedVaultPermission = () => __awaiter(void 0, void 0, void 0, function* () {
+    const granted = yield PermissionsAndroid.check(SeedVaultPermissionAndroid);
+    if (!granted) {
+        throw new Error('You do not have permission to access Seed Vault. You must request permission to use Seed Vault.');
+    }
+});
+const checkIsSeedVaultAvailable = (allowSimulated = false) => __awaiter(void 0, void 0, void 0, function* () {
+    const seedVaultAvailable = yield SolanaMobileSeedVaultLib.isSeedVaultAvailable(allowSimulated);
+    if (!seedVaultAvailable) {
+        throw new Error(allowSimulated
+            ? 'Seed Vault is not available on this device, please install the Seed Vault Simulator'
+            : 'Seed Vault is not available on this device');
+    }
+});
+const SEED_VAULT_EVENT_BRIDGE_NAME = 'SeedVaultEventBridge';
+function useSeedVault(handleSeedVaultEvent, handleContentChange) {
+    const seedVaultEventHandler = useRef(handleSeedVaultEvent);
+    const contentChangeHandler = useRef(handleContentChange);
+    useEffect(() => {
+        seedVaultEventHandler.current = handleSeedVaultEvent;
+        contentChangeHandler.current = handleContentChange;
+    });
+    checkIsSeedVaultAvailable(true);
+    checkSeedVaultPermission();
+    // Start native event listener
+    useEffect(() => {
+        const seedVaultEventEmitter = new NativeEventEmitter();
+        const listener = seedVaultEventEmitter.addListener(SEED_VAULT_EVENT_BRIDGE_NAME, (nativeEvent) => {
+            if (isContentChangeEvent(nativeEvent)) {
+                contentChangeHandler.current(nativeEvent);
+            }
+            else if (isSeedVaultEvent(nativeEvent)) {
+                seedVaultEventHandler.current(nativeEvent);
+            }
+            else {
+                console.warn('Unexpected native event type');
+            }
+        });
+        return () => {
+            listener.remove();
+        };
+    }, []);
+}
+function isSeedVaultEvent(nativeEvent) {
+    return Object.values(SeedVaultEventType).includes(nativeEvent.__type);
+}
+function isContentChangeEvent(nativeEvent) {
+    return nativeEvent.__type == SeedVaultEventType.ContentChange;
+}
+const SeedVault = SolanaMobileSeedVaultLib;
+
+export { SeedPurpose, SeedVault, SeedVaultEventType, SeedVaultPermissionAndroid, useSeedVault };

package/lib/esm/index.native.js

@@ -12,6 +12,10 @@ const SeedVaultEventType = {
     ContentChange: "SeedVaultContentChange"
 };
 
+const SeedPurpose = {
+    SignSolanaTransaction: 0,
+};
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -83,10 +87,8 @@ function useSeedVault(handleSeedVaultEvent, handleContentChange) {
         const listener = seedVaultEventEmitter.addListener(SEED_VAULT_EVENT_BRIDGE_NAME, (nativeEvent) => {
             if (isContentChangeEvent(nativeEvent)) {
                 contentChangeHandler.current(nativeEvent);
-                handleContentChange(nativeEvent);
             }
             else if (isSeedVaultEvent(nativeEvent)) {
-                handleSeedVaultEvent(nativeEvent);
                 seedVaultEventHandler.current(nativeEvent);
             }
             else {
@@ -104,5 +106,6 @@ function isSeedVaultEvent(nativeEvent) {
 function isContentChangeEvent(nativeEvent) {
     return nativeEvent.__type == SeedVaultEventType.ContentChange;
 }
+const SeedVault = SolanaMobileSeedVaultLib;
 
-export { SeedVaultEventType, SeedVaultPermissionAndroid, useSeedVault };
+export { SeedPurpose, SeedVault, SeedVaultEventType, SeedVaultPermissionAndroid, useSeedVault };