@solana-mobile/mobile-wallet-adapter-protocol 2.0.1 → 2.1.0-alpha1

package/android/build.gradle

@@ -8,7 +8,7 @@ buildscript {
   }
 
   dependencies {
-    classpath 'com.android.tools.build:gradle:7.4.2'
+    classpath 'com.android.tools.build:gradle:8.2.1'
     // noinspection DifferentKotlinGradleVersion
     classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   }
@@ -132,9 +132,9 @@ def kotlin_version = getExtOrDefault('kotlinVersion')
 dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"  // From node_modules
-  implementation "com.solanamobile:mobile-wallet-adapter-clientlib:1.1.0"
+  implementation "com.solanamobile:mobile-wallet-adapter-clientlib:2.0.0"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.1"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
 }
 
 if (isNewArchitectureEnabled()) {

package/android/src/main/java/com/solanamobile/mobilewalletadapter/reactnative/SolanaMobileWalletAdapterModule.kt

@@ -10,6 +10,7 @@ import com.solana.mobilewalletadapter.clientlib.protocol.JsonRpc20Client
 import com.solana.mobilewalletadapter.clientlib.protocol.MobileWalletAdapterClient
 import com.solana.mobilewalletadapter.clientlib.scenario.LocalAssociationIntentCreator
 import com.solana.mobilewalletadapter.clientlib.scenario.LocalAssociationScenario
+import com.solana.mobilewalletadapter.common.protocol.SessionProperties.ProtocolVersion
 import com.solanamobile.mobilewalletadapter.reactnative.JSONSerializationUtils.convertJsonToMap
 import com.solanamobile.mobilewalletadapter.reactnative.JSONSerializationUtils.convertMapToJson
 import kotlinx.coroutines.*
@@ -38,9 +39,9 @@ class SolanaMobileWalletAdapterModule(reactContext: ReactApplicationContext) :
         // Used to ensure that you can't start more than one session at a time.
         private val mutex: Mutex = Mutex()
         private var sessionState: SessionState? = null
+        private var associationResultCallback: ((Int) -> Unit)? = null
     }
 
-    private val mActivityEventCallbacks = mutableMapOf<Int, (Int, Intent?) -> (Unit)>()
     private val mActivityEventListener: ActivityEventListener =
         object : BaseActivityEventListener() {
             override fun onActivityResult(
@@ -49,10 +50,8 @@ class SolanaMobileWalletAdapterModule(reactContext: ReactApplicationContext) :
                 resultCode: Int,
                 data: Intent?
             ) {
-                mActivityEventCallbacks[requestCode]?.let { callback ->
-                    callback(resultCode, data)
-                    mActivityEventCallbacks.remove(requestCode)
-                }
+                if (requestCode == REQUEST_LOCAL_ASSOCIATION) 
+                    associationResultCallback?.invoke(resultCode)
             }
         }
 
@@ -78,7 +77,7 @@ class SolanaMobileWalletAdapterModule(reactContext: ReactApplicationContext) :
                 localAssociation.port,
                 localAssociation.session
             )
-            launchIntent(intent, REQUEST_LOCAL_ASSOCIATION) { resultCode, _ ->
+            associationResultCallback = { resultCode ->
                 if (resultCode == Activity.RESULT_CANCELED) {
                     Log.d(name, "Local association cancelled by user, ending session")
                     promise.reject("Session not established: Local association cancelled by user", 
@@ -86,10 +85,18 @@ class SolanaMobileWalletAdapterModule(reactContext: ReactApplicationContext) :
                     localAssociation.close()
                 }
             }
+            currentActivity?.startActivityForResult(intent, REQUEST_LOCAL_ASSOCIATION)
+                ?: throw NullPointerException("Could not find a current activity from which to launch a local association")
             val client =
                 localAssociation.start().get(ASSOCIATION_TIMEOUT_MS.toLong(), TimeUnit.MILLISECONDS)
             sessionState = SessionState(client, localAssociation)
-            promise.resolve(true)
+            val sessionPropertiesMap: WritableMap = WritableNativeMap()
+            sessionPropertiesMap.putString("protocol_version", 
+                when (localAssociation.session.sessionProperties.protocolVersion) {
+                    ProtocolVersion.LEGACY -> "legacy"
+                    ProtocolVersion.V1 -> "v1"
+                })
+            promise.resolve(sessionPropertiesMap)
         } catch (e: ActivityNotFoundException) {
             Log.e(name, "Found no installed wallet that supports the mobile wallet protocol", e)
             cleanup()
@@ -129,6 +136,8 @@ class SolanaMobileWalletAdapterModule(reactContext: ReactApplicationContext) :
                 val userInfo = Arguments.createMap()
                 userInfo.putInt("jsonRpcErrorCode", cause.code)
                 promise.reject("JSON_RPC_ERROR", cause, userInfo)
+            } else if (cause is TimeoutException) {
+                promise.reject("Timed out waiting for response", e)
             } else {
                 throw e
             }
@@ -159,16 +168,9 @@ class SolanaMobileWalletAdapterModule(reactContext: ReactApplicationContext) :
         }
     } ?: throw NullPointerException("Tried to end a session without an active session")
 
-    private fun launchIntent(intent: Intent, requestCode: Int, callback: (Int, Intent?) -> (Unit)) {
-        mActivityEventCallbacks[requestCode] = callback
-        currentActivity?.startActivityForResult(intent, REQUEST_LOCAL_ASSOCIATION) ?: run {
-            mActivityEventCallbacks.remove(requestCode)
-            throw NullPointerException("Could not find a current activity from which to launch a local association")
-        }
-    }
-
     private fun cleanup() {
         sessionState = null
+        associationResultCallback = null
         if (mutex.isLocked) {
             mutex.unlock()
         }

package/lib/cjs/index.browser.js

@@ -2,6 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var walletStandardUtil = require('@solana/wallet-standard-util');
+
 // Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
 const SolanaMobileWalletAdapterErrorCode = {
     ERROR_ASSOCIATION_PORT_OUT_OF_RANGE: 'ERROR_ASSOCIATION_PORT_OUT_OF_RANGE',
@@ -10,6 +12,7 @@ const SolanaMobileWalletAdapterErrorCode = {
     ERROR_SESSION_CLOSED: 'ERROR_SESSION_CLOSED',
     ERROR_SESSION_TIMEOUT: 'ERROR_SESSION_TIMEOUT',
     ERROR_WALLET_NOT_FOUND: 'ERROR_WALLET_NOT_FOUND',
+    ERROR_INVALID_PROTOCOL_VERSION: 'ERROR_INVALID_PROTOCOL_VERSION',
 };
 class SolanaMobileWalletAdapterError extends Error {
     constructor(...args) {
@@ -77,6 +80,175 @@ function createHelloReq(ecdhPublicKey, associationKeypairPrivateKey) {
     });
 }
 
+function encode(input) {
+    return window.btoa(input);
+}
+
+function createSIWSMessage(payload) {
+    return walletStandardUtil.createSignInMessageText(payload);
+}
+function createSIWSMessageBase64(payload) {
+    return encode(createSIWSMessage(payload));
+}
+
+// optional features
+const SolanaSignTransactions = 'solana:signTransactions';
+const SolanaCloneAuthorization = 'solana:cloneAuthorization';
+const SolanaSignInWithSolana = 'solana:signInWithSolana';
+
+/**
+ * Creates a {@link MobileWallet} proxy that handles backwards compatibility and API to RPC conversion.
+ *
+ * @param protocolVersion the protocol version in use for this session/request
+ * @param protocolRequestHandler callback function that handles sending the RPC request to the wallet endpoint.
+ * @returns a {@link MobileWallet} proxy
+ */
+function createMobileWalletProxy(protocolVersion, protocolRequestHandler) {
+    return new Proxy({}, {
+        get(target, p) {
+            if (target[p] == null) {
+                target[p] = function (inputParams) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const { method, params } = handleMobileWalletRequest(p, inputParams, protocolVersion);
+                        const result = yield protocolRequestHandler(method, params);
+                        // if the request tried to sign in but the wallet did not return a sign in result, fallback on message signing
+                        if (method === 'authorize' && params.sign_in_payload && !result.sign_in_result) {
+                            result['sign_in_result'] = yield signInFallback(params.sign_in_payload, result, protocolRequestHandler);
+                        }
+                        return handleMobileWalletResponse(p, result, protocolVersion);
+                    });
+                };
+            }
+            return target[p];
+        },
+        defineProperty() {
+            return false;
+        },
+        deleteProperty() {
+            return false;
+        },
+    });
+}
+/**
+ * Handles all {@link MobileWallet} API requests and determines the correct MWA RPC method and params to call.
+ * This handles backwards compatibility, based on the provided @protocolVersion.
+ *
+ * @param methodName the name of {@link MobileWallet} method that was called
+ * @param methodParams the parameters that were passed to the method
+ * @param protocolVersion the protocol version in use for this session/request
+ * @returns the RPC request method and params that should be sent to the wallet endpoint
+ */
+function handleMobileWalletRequest(methodName, methodParams, protocolVersion) {
+    let params = methodParams;
+    let method = methodName
+        .toString()
+        .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
+        .toLowerCase();
+    switch (methodName) {
+        case 'authorize': {
+            let { chain } = params;
+            if (protocolVersion === 'legacy') {
+                switch (chain) {
+                    case 'solana:testnet': {
+                        chain = 'testnet';
+                        break;
+                    }
+                    case 'solana:devnet': {
+                        chain = 'devnet';
+                        break;
+                    }
+                    case 'solana:mainnet': {
+                        chain = 'mainnet-beta';
+                        break;
+                    }
+                    default: {
+                        chain = params.cluster;
+                    }
+                }
+                params.cluster = chain;
+            }
+            else {
+                switch (chain) {
+                    case 'testnet':
+                    case 'devnet': {
+                        chain = `solana:${chain}`;
+                        break;
+                    }
+                    case 'mainnet-beta': {
+                        chain = 'solana:mainnet';
+                        break;
+                    }
+                }
+                params.chain = chain;
+            }
+        }
+        case 'reauthorize': {
+            const { auth_token, identity } = params;
+            if (auth_token) {
+                switch (protocolVersion) {
+                    case 'legacy': {
+                        method = 'reauthorize';
+                        params = { auth_token: auth_token, identity: identity };
+                        break;
+                    }
+                    default: {
+                        method = 'authorize';
+                        break;
+                    }
+                }
+            }
+            break;
+        }
+    }
+    return { method, params };
+}
+/**
+ * Handles all {@link MobileWallet} API responses and modifies the response for backwards compatibility, if needed
+ *
+ * @param method the {@link MobileWallet} method that was called
+ * @param response the original response that was returned by the method call
+ * @param protocolVersion the protocol version in use for this session/request
+ * @returns the possibly modified response
+ */
+function handleMobileWalletResponse(method, response, protocolVersion) {
+    switch (method) {
+        case 'getCapabilities': {
+            const capabilities = response;
+            switch (protocolVersion) {
+                case 'legacy': {
+                    const features = [SolanaSignTransactions];
+                    if (capabilities.supports_clone_authorization === true) {
+                        features.push(SolanaCloneAuthorization);
+                    }
+                    return Object.assign(Object.assign({}, capabilities), { features: features });
+                }
+                case 'v1': {
+                    return Object.assign(Object.assign({}, capabilities), { supports_sign_and_send_transactions: true, supports_clone_authorization: capabilities.features.includes(SolanaCloneAuthorization) });
+                }
+            }
+        }
+    }
+    return response;
+}
+function signInFallback(signInPayload, authorizationResult, protocolRequestHandler) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const domain = (_a = signInPayload.domain) !== null && _a !== void 0 ? _a : window.location.host;
+        const address = authorizationResult.accounts[0].address;
+        const siwsMessage = createSIWSMessageBase64(Object.assign(Object.assign({}, signInPayload), { domain, address }));
+        const signMessageResult = yield protocolRequestHandler('sign_messages', {
+            addresses: [address],
+            payloads: [siwsMessage]
+        });
+        const signInResult = {
+            address: address,
+            signed_message: siwsMessage,
+            signature: signMessageResult.signed_payloads[0].slice(siwsMessage.length)
+        };
+        return signInResult;
+    });
+}
+
 const SEQUENCE_NUMBER_BYTES = 4;
 function createSequenceNumberVector(sequenceNumber) {
     if (sequenceNumber >= 4294967296) {
@@ -88,29 +260,11 @@ function createSequenceNumberVector(sequenceNumber) {
     return new Uint8Array(byteArray);
 }
 
-function generateAssociationKeypair() {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield crypto.subtle.generateKey({
-            name: 'ECDSA',
-            namedCurve: 'P-256',
-        }, false /* extractable */, ['sign'] /* keyUsages */);
-    });
-}
-
-function generateECDHKeypair() {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield crypto.subtle.generateKey({
-            name: 'ECDH',
-            namedCurve: 'P-256',
-        }, false /* extractable */, ['deriveKey', 'deriveBits'] /* keyUsages */);
-    });
-}
-
 const INITIALIZATION_VECTOR_BYTES = 12;
-function encryptJsonRpcMessage(jsonRpcMessage, sharedSecret) {
+const ENCODED_PUBLIC_KEY_LENGTH_BYTES = 65;
+function encryptMessage(plaintext, sequenceNumber, sharedSecret) {
     return __awaiter(this, void 0, void 0, function* () {
-        const plaintext = JSON.stringify(jsonRpcMessage);
-        const sequenceNumberVector = createSequenceNumberVector(jsonRpcMessage.id);
+        const sequenceNumberVector = createSequenceNumberVector(sequenceNumber);
         const initializationVector = new Uint8Array(INITIALIZATION_VECTOR_BYTES);
         crypto.getRandomValues(initializationVector);
         const ciphertext = yield crypto.subtle.encrypt(getAlgorithmParams(sequenceNumberVector, initializationVector), sharedSecret, new TextEncoder().encode(plaintext));
@@ -121,18 +275,14 @@ function encryptJsonRpcMessage(jsonRpcMessage, sharedSecret) {
         return response;
     });
 }
-function decryptJsonRpcMessage(message, sharedSecret) {
+function decryptMessage(message, sharedSecret) {
     return __awaiter(this, void 0, void 0, function* () {
         const sequenceNumberVector = message.slice(0, SEQUENCE_NUMBER_BYTES);
         const initializationVector = message.slice(SEQUENCE_NUMBER_BYTES, SEQUENCE_NUMBER_BYTES + INITIALIZATION_VECTOR_BYTES);
         const ciphertext = message.slice(SEQUENCE_NUMBER_BYTES + INITIALIZATION_VECTOR_BYTES);
         const plaintextBuffer = yield crypto.subtle.decrypt(getAlgorithmParams(sequenceNumberVector, initializationVector), sharedSecret, ciphertext);
         const plaintext = getUtf8Decoder().decode(plaintextBuffer);
-        const jsonRpcMessage = JSON.parse(plaintext);
-        if (Object.hasOwnProperty.call(jsonRpcMessage, 'error')) {
-            throw new SolanaMobileWalletAdapterProtocolError(jsonRpcMessage.id, jsonRpcMessage.error.code, jsonRpcMessage.error.message);
-        }
-        return jsonRpcMessage;
+        return plaintext;
     });
 }
 function getAlgorithmParams(sequenceNumber, initializationVector) {
@@ -151,12 +301,48 @@ function getUtf8Decoder() {
     return _utf8Decoder;
 }
 
+function generateAssociationKeypair() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield crypto.subtle.generateKey({
+            name: 'ECDSA',
+            namedCurve: 'P-256',
+        }, false /* extractable */, ['sign'] /* keyUsages */);
+    });
+}
+
+function generateECDHKeypair() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield crypto.subtle.generateKey({
+            name: 'ECDH',
+            namedCurve: 'P-256',
+        }, false /* extractable */, ['deriveKey', 'deriveBits'] /* keyUsages */);
+    });
+}
+
+function encryptJsonRpcMessage(jsonRpcMessage, sharedSecret) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const plaintext = JSON.stringify(jsonRpcMessage);
+        const sequenceNumber = jsonRpcMessage.id;
+        return encryptMessage(plaintext, sequenceNumber, sharedSecret);
+    });
+}
+function decryptJsonRpcMessage(message, sharedSecret) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const plaintext = yield decryptMessage(message, sharedSecret);
+        const jsonRpcMessage = JSON.parse(plaintext);
+        if (Object.hasOwnProperty.call(jsonRpcMessage, 'error')) {
+            throw new SolanaMobileWalletAdapterProtocolError(jsonRpcMessage.id, jsonRpcMessage.error.code, jsonRpcMessage.error.message);
+        }
+        return jsonRpcMessage;
+    });
+}
+
 function parseHelloRsp(payloadBuffer, // The X9.62-encoded wallet endpoint ephemeral ECDH public keypoint.
 associationPublicKey, ecdhPrivateKey) {
     return __awaiter(this, void 0, void 0, function* () {
         const [associationPublicKeyBuffer, walletPublicKey] = yield Promise.all([
             crypto.subtle.exportKey('raw', associationPublicKey),
-            crypto.subtle.importKey('raw', payloadBuffer, { name: 'ECDH', namedCurve: 'P-256' }, false /* extractable */, [] /* keyUsages */),
+            crypto.subtle.importKey('raw', payloadBuffer.slice(0, ENCODED_PUBLIC_KEY_LENGTH_BYTES), { name: 'ECDH', namedCurve: 'P-256' }, false /* extractable */, [] /* keyUsages */),
         ]);
         const sharedSecret = yield crypto.subtle.deriveBits({ name: 'ECDH', public: walletPublicKey }, ecdhPrivateKey, 256);
         const ecdhSecretKey = yield crypto.subtle.importKey('raw', sharedSecret, 'HKDF', false /* extractable */, ['deriveKey'] /* keyUsages */);
@@ -170,6 +356,31 @@ associationPublicKey, ecdhPrivateKey) {
     });
 }
 
+function parseSessionProps(message, sharedSecret) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const plaintext = yield decryptMessage(message, sharedSecret);
+        const jsonProperties = JSON.parse(plaintext);
+        let protocolVersion = 'legacy';
+        if (Object.hasOwnProperty.call(jsonProperties, 'v')) {
+            switch (jsonProperties.v) {
+                case 1:
+                case '1':
+                case 'v1':
+                    protocolVersion = 'v1';
+                    break;
+                case 'legacy':
+                    protocolVersion = 'legacy';
+                    break;
+                default:
+                    throw new SolanaMobileWalletAdapterError(SolanaMobileWalletAdapterErrorCode.ERROR_INVALID_PROTOCOL_VERSION, `Unknown/unsupported protocol version: ${jsonProperties.v}`);
+            }
+        }
+        return ({
+            protocol_version: protocolVersion
+        });
+    });
+}
+
 function getRandomAssociationPort() {
     return assertAssociationPort(49152 + Math.floor(Math.random() * (65535 - 49152 + 1)));
 }
@@ -226,7 +437,7 @@ function getIntentURL(methodPathname, intentUrlBase) {
             [...getPathParts(baseUrl.pathname), ...getPathParts(methodPathname)].join('/');
     return new URL(pathname, baseUrl);
 }
-function getAssociateAndroidIntentURL(associationPublicKey, putativePort, associationURLBase) {
+function getAssociateAndroidIntentURL(associationPublicKey, putativePort, associationURLBase, protocolVersions = ['v1']) {
     return __awaiter(this, void 0, void 0, function* () {
         const associationPort = assertAssociationPort(putativePort);
         const exportedKey = yield crypto.subtle.exportKey('raw', associationPublicKey);
@@ -234,6 +445,9 @@ function getAssociateAndroidIntentURL(associationPublicKey, putativePort, associ
         const url = getIntentURL('v1/associate/local', associationURLBase);
         url.searchParams.set('association', getStringWithURLUnsafeCharactersReplaced(encodedKey));
         url.searchParams.set('port', `${associationPort}`);
+        protocolVersions.forEach((version) => {
+            url.searchParams.set('v', version);
+        });
         return url;
     });
 }
@@ -438,59 +652,51 @@ function transact(callback, config) {
                         break;
                     case 'hello_req_sent': {
                         const sharedSecret = yield parseHelloRsp(responseBuffer, state.associationPublicKey, state.ecdhPrivateKey);
-                        state = { __type: 'connected', sharedSecret };
-                        const wallet = new Proxy({}, {
-                            get(target, p) {
-                                if (target[p] == null) {
-                                    const method = p
-                                        .toString()
-                                        .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
-                                        .toLowerCase();
-                                    target[p] = function (params) {
-                                        return __awaiter(this, void 0, void 0, function* () {
-                                            const id = nextJsonRpcMessageId++;
-                                            socket.send(yield encryptJsonRpcMessage({
-                                                id,
-                                                jsonrpc: '2.0',
-                                                method,
-                                                params: params !== null && params !== void 0 ? params : {},
-                                            }, sharedSecret));
-                                            return new Promise((resolve, reject) => {
-                                                jsonRpcResponsePromises[id] = {
-                                                    resolve(result) {
-                                                        switch (p) {
-                                                            case 'authorize':
-                                                            case 'reauthorize': {
-                                                                const { wallet_uri_base } = result;
-                                                                if (wallet_uri_base != null) {
-                                                                    try {
-                                                                        assertSecureEndpointSpecificURI(wallet_uri_base);
-                                                                    }
-                                                                    catch (e) {
-                                                                        reject(e);
-                                                                        return;
-                                                                    }
-                                                                }
-                                                                break;
-                                                            }
-                                                        }
-                                                        resolve(result);
-                                                    },
-                                                    reject,
-                                                };
-                                            });
-                                        });
-                                    };
+                        const sessionPropertiesBuffer = responseBuffer.slice(ENCODED_PUBLIC_KEY_LENGTH_BYTES);
+                        const sessionProperties = sessionPropertiesBuffer.byteLength !== 0
+                            ? yield (() => __awaiter(this, void 0, void 0, function* () {
+                                const sequenceNumberVector = sessionPropertiesBuffer.slice(0, SEQUENCE_NUMBER_BYTES);
+                                const sequenceNumber = getSequenceNumberFromByteArray(sequenceNumberVector);
+                                if (sequenceNumber !== (lastKnownInboundSequenceNumber + 1)) {
+                                    throw new Error('Encrypted message has invalid sequence number');
                                 }
-                                return target[p];
-                            },
-                            defineProperty() {
-                                return false;
-                            },
-                            deleteProperty() {
-                                return false;
-                            },
-                        });
+                                lastKnownInboundSequenceNumber = sequenceNumber;
+                                return parseSessionProps(sessionPropertiesBuffer, sharedSecret);
+                            }))() : { protocol_version: 'legacy' };
+                        state = { __type: 'connected', sharedSecret, sessionProperties };
+                        const wallet = createMobileWalletProxy(sessionProperties.protocol_version, (method, params) => __awaiter(this, void 0, void 0, function* () {
+                            const id = nextJsonRpcMessageId++;
+                            socket.send(yield encryptJsonRpcMessage({
+                                id,
+                                jsonrpc: '2.0',
+                                method,
+                                params: params !== null && params !== void 0 ? params : {},
+                            }, sharedSecret));
+                            return new Promise((resolve, reject) => {
+                                jsonRpcResponsePromises[id] = {
+                                    resolve(result) {
+                                        switch (method) {
+                                            case 'authorize':
+                                            case 'reauthorize': {
+                                                const { wallet_uri_base } = result;
+                                                if (wallet_uri_base != null) {
+                                                    try {
+                                                        assertSecureEndpointSpecificURI(wallet_uri_base);
+                                                    }
+                                                    catch (e) {
+                                                        reject(e);
+                                                        return;
+                                                    }
+                                                }
+                                                break;
+                                            }
+                                        }
+                                        resolve(result);
+                                    },
+                                    reject,
+                                };
+                            });
+                        }));
                         try {
                             resolve(yield callback(wallet));
                         }
@@ -533,8 +739,11 @@ function transact(callback, config) {
     });
 }
 
+exports.SolanaCloneAuthorization = SolanaCloneAuthorization;
 exports.SolanaMobileWalletAdapterError = SolanaMobileWalletAdapterError;
 exports.SolanaMobileWalletAdapterErrorCode = SolanaMobileWalletAdapterErrorCode;
 exports.SolanaMobileWalletAdapterProtocolError = SolanaMobileWalletAdapterProtocolError;
 exports.SolanaMobileWalletAdapterProtocolErrorCode = SolanaMobileWalletAdapterProtocolErrorCode;
+exports.SolanaSignInWithSolana = SolanaSignInWithSolana;
+exports.SolanaSignTransactions = SolanaSignTransactions;
 exports.transact = transact;